@skillpet/circuit 0.5.0

package/dist/logic/timing.js

@@ -0,0 +1,791 @@
+import { Element } from "../element.js";
+import { Segment, SegmentPoly, SegmentText } from "../segment.js";
+import { linspace } from "../geometry/util.js";
+import { Point } from "../geometry/point.js";
+import { bbox } from "../types.js";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function stateLevel(state) {
+    return state
+        .replace(/[2-9]|=|x/g, "V")
+        .replace(/u/g, "1")
+        .replace(/d/g, "0")
+        .replace(/[nN]/g, "1")
+        .replace(/[pP]/g, "0")
+        .replace(/[lL]/g, "0")
+        .replace(/[hH]/g, "1");
+}
+function flattenSignals(signals) {
+    const result = [];
+    for (const item of signals) {
+        if (typeof item === "string")
+            continue;
+        if (Array.isArray(item)) {
+            result.push(...flattenSignals(item));
+        }
+        else if (typeof item === "object" && item !== null) {
+            result.push(item);
+        }
+    }
+    return result;
+}
+function expcurve(height) {
+    const xs = linspace(0, 1, 10);
+    const ys = xs.map((v) => height * Math.exp(-v * 6));
+    return { xs, ys };
+}
+// ---------------------------------------------------------------------------
+// Doublesigmoid — break/split marker used in timing waveforms
+// ---------------------------------------------------------------------------
+class Doublesigmoid {
+    y0;
+    height;
+    curve1x;
+    curve2x;
+    extend;
+    rate = 25;
+    constructor(x0, y0, y1, extend = 0.1, gap = 0.2) {
+        this.y0 = y0;
+        this.extend = extend;
+        this.height = y1 - y0;
+        this.curve1x = x0 - gap * this.height / 2;
+        this.curve2x = x0 + gap * this.height / 2;
+    }
+    curve(side) {
+        const fullh = this.height * (1 + this.extend * 2);
+        const drop = this.height * this.extend;
+        const sigx = linspace(-0.15, 0.15);
+        const sigy = sigx.map((x) => 1 / (1 + Math.exp(-x * this.rate)) * fullh - drop);
+        const cx = side === "left" ? this.curve1x : this.curve2x;
+        return {
+            xs: sigx.map((x) => x + cx),
+            ys: sigy.map((y) => y + this.y0),
+        };
+    }
+}
+function getSplitSegments(x0, y0, y1) {
+    const sig = new Doublesigmoid(x0, y0, y1);
+    const left = sig.curve("left");
+    const right = sig.curve("right");
+    const leftPts = left.xs.map((x, i) => [x, left.ys[i]]);
+    const rightPts = right.xs.map((x, i) => [x, right.ys[i]]);
+    return [
+        new Segment(leftPts, { lw: 1, zorder: 3 }),
+        new Segment(rightPts, { lw: 1, zorder: 3 }),
+        new SegmentPoly([...leftPts, ...[...rightPts].reverse()], {
+            zorder: 3,
+            color: "none",
+            fill: "white",
+            lw: 1,
+            closed: false,
+        }),
+    ];
+}
+// ---------------------------------------------------------------------------
+// Wave section classes — each renders one character of a wave string
+// ---------------------------------------------------------------------------
+class Wave0 {
+    params;
+    x0;
+    xend;
+    y0;
+    y1;
+    y1_prev;
+    pstate;
+    nstate;
+    plevel;
+    rise;
+    xrise;
+    xrisehalf;
+    yhalf;
+    xcenter;
+    xtext;
+    kwargs;
+    constructor(params) {
+        this.params = params;
+        this.x0 = params.x0;
+        this.xend = params.xend;
+        this.y0 = params.y0;
+        this.y1 = params.y1;
+        this.y1_prev = params.y1_prev;
+        this.pstate = params.pstate;
+        this.nstate = params.nstate;
+        this.plevel = params.plevel;
+        this.rise = params.rise;
+        this.xrise = this.x0 + this.rise;
+        this.xrisehalf = this.x0 + this.rise / 2;
+        this.yhalf = (this.y0 + this.y1) / 2;
+        this.xcenter = (this.x0 + this.xend) / 2;
+        this.xtext = this.xcenter + this.rise / 2;
+        this.kwargs = params.kwargs;
+    }
+    vertsIn() {
+        const m = {
+            "-": [[this.x0, this.y0]],
+            "|": [[this.x0, this.y0]],
+            "0": [
+                [this.x0, this.y0],
+                [this.xrisehalf, this.yhalf],
+                [this.xrise, this.y0],
+            ],
+            "1": [
+                [this.x0, this.y1],
+                [this.xrise, this.y0],
+            ],
+            "z": [
+                [this.x0, this.yhalf],
+                [this.xrisehalf, this.y0],
+            ],
+            "V": [[this.xrise, this.y0]],
+        };
+        return m[this.plevel] ?? [];
+    }
+    vertsOut() {
+        return [[this.xend, this.y0]];
+    }
+    segments() {
+        const verts = [...this.vertsIn(), ...this.vertsOut()];
+        return [new Segment(verts, this.kwargs)];
+    }
+}
+class WaveL extends Wave0 {
+    vertsIn() {
+        if ("pP".includes(this.params.pstate)) {
+            return [[this.x0, this.y0]];
+        }
+        return [
+            [this.x0, this.y1],
+            [this.x0, this.y0],
+        ];
+    }
+    segments() {
+        const segs = super.segments();
+        if (this.params.state === "L") {
+            const alength = 0.25;
+            const awidth = 0.12;
+            segs.push(new Segment([
+                [this.x0, this.yhalf + alength / 2],
+                [this.x0, this.yhalf - alength / 2],
+            ], { arrow: "->", arrowwidth: awidth, arrowlength: alength }));
+        }
+        return segs;
+    }
+}
+class Wave1 extends Wave0 {
+    vertsIn() {
+        const m = {
+            "-": [[this.x0, this.y1]],
+            "h": [[this.x0, this.y1]],
+            "H": [[this.x0, this.y1]],
+            "l": [[this.x0, this.y1]],
+            "L": [[this.x0, this.y1]],
+            "0": [
+                [this.x0, this.y0],
+                [this.xrise, this.y1],
+            ],
+            "1": this.y1_prev !== this.y1
+                ? [
+                    [this.x0, this.y1_prev],
+                    [this.xrise, this.y1],
+                ]
+                : [
+                    [this.x0, this.y1],
+                    [this.xrisehalf, this.yhalf],
+                    [this.xrise, this.y1],
+                ],
+            "z": [
+                [this.x0, this.yhalf],
+                [this.xrisehalf, this.y1],
+            ],
+            "V": [[this.xrise, this.y1]],
+        };
+        return m[this.plevel] ?? [];
+    }
+    vertsOut() {
+        return [[this.xend, this.y1]];
+    }
+}
+class WaveH extends Wave1 {
+    vertsIn() {
+        if ("nN".includes(this.params.pstate)) {
+            return [[this.x0, this.y1]];
+        }
+        return [
+            [this.x0, this.y0],
+            [this.x0, this.y1],
+        ];
+    }
+    segments() {
+        const segs = super.segments();
+        if (this.params.state === "H") {
+            const alength = 0.25;
+            const awidth = 0.12;
+            segs.push(new Segment([
+                [this.x0, this.yhalf - alength / 2],
+                [this.x0, this.yhalf + alength / 2],
+            ], { arrow: "->", arrowwidth: awidth, arrowlength: alength }));
+        }
+        return segs;
+    }
+}
+class Wavez extends Wave0 {
+    vertsIn() {
+        const { xs: xcurve, ys: yexp } = expcurve((this.y1 - this.y0) / 2);
+        const ycurve = yexp.map((yc) => this.yhalf + yc);
+        const ycurveflip = yexp.map((yc) => this.yhalf - yc);
+        const xc = xcurve.map((x) => this.x0 + x * this.rise * 6);
+        const m = {
+            "-": [[this.x0, this.yhalf]],
+            "0": xc.map((x, i) => [x, ycurveflip[i]]),
+            "1": xc.map((x, i) => [x, ycurve[i]]),
+            "z": [[this.x0, this.yhalf]],
+            "V": [[this.xrise + this.rise, this.yhalf]],
+        };
+        return m[this.plevel] ?? [];
+    }
+    vertsOut() {
+        return [[this.xend, this.yhalf]];
+    }
+}
+class WaveV extends Wave0 {
+    vertsIn() {
+        const m = {
+            "-": [
+                [this.x0, this.y1],
+                [this.x0, this.y0],
+            ],
+            "|": [
+                [this.x0, this.y1],
+                [this.x0, this.y0],
+            ],
+            "0": [
+                [this.xrise, this.y1],
+                [this.x0, this.y0],
+            ],
+            "1": [
+                [this.x0, this.y1],
+                [this.xrise, this.y0],
+            ],
+            "z": [
+                [this.xrise, this.y1],
+                [this.xrisehalf, this.yhalf],
+                [this.xrise, this.y0],
+            ],
+            "V": [
+                [this.xrise, this.y1],
+                [this.xrisehalf, this.yhalf],
+                [this.xrise, this.y0],
+            ],
+        };
+        return m[this.plevel] ?? [];
+    }
+    vertsOut() {
+        const nstate = "=23456789x".includes(this.nstate) ? "V" : this.nstate;
+        const m = {
+            "0": [
+                [this.xend + this.rise, this.y0],
+                [this.xend, this.y1],
+            ],
+            "L": [
+                [this.xend, this.y0],
+                [this.xend, this.y1],
+            ],
+            "l": [
+                [this.xend, this.y0],
+                [this.xend, this.y1],
+            ],
+            "1": [
+                [this.xend, this.y0],
+                [this.xend + this.rise, this.y1],
+            ],
+            "H": [
+                [this.xend, this.y0],
+                [this.xend, this.y1],
+            ],
+            "h": [
+                [this.xend, this.y0],
+                [this.xend, this.y1],
+            ],
+            "z": [
+                [this.xend, this.y0],
+                [this.xend, this.y1],
+            ],
+            "V": [
+                [this.xend, this.y0],
+                [this.xend + this.rise / 2, this.yhalf],
+                [this.xend, this.y1],
+            ],
+            "-": [
+                [this.xend, this.y0],
+                [this.xend, this.y1],
+            ],
+            "n": [
+                [this.xend, this.y0],
+                [this.xend, this.y1],
+            ],
+            "p": [
+                [this.xend, this.y0],
+                [this.xend, this.y1],
+            ],
+            "N": [
+                [this.xend, this.y0],
+                [this.xend, this.y1],
+            ],
+            "P": [
+                [this.xend, this.y0],
+                [this.xend, this.y1],
+            ],
+        };
+        return m[nstate] ?? [];
+    }
+    fillOpts() {
+        const colorMap = {
+            "3": "#feffc2",
+            "4": "#ffe2ba",
+            "5": "#abd9ff",
+            "6": "#bdfbff",
+            "7": "#bdffcb",
+            "8": "#e3a5fa",
+            "9": "#f7b7bd",
+        };
+        return {
+            fill: colorMap[this.params.state],
+            hatch: this.params.state === "x",
+        };
+    }
+    segments() {
+        const { fill, hatch } = this.fillOpts();
+        const segs = [];
+        const pOpen = "-|".includes(this.pstate);
+        const nOpen = "-|".includes(this.nstate);
+        if (pOpen && nOpen) {
+            segs.push(new Segment([
+                [this.x0, this.y0],
+                [this.xend, this.y0],
+            ], this.kwargs));
+            segs.push(new Segment([
+                [this.x0, this.y1],
+                [this.xend, this.y1],
+            ], this.kwargs));
+            segs.push(new SegmentPoly([
+                [this.x0, this.y0],
+                [this.xend, this.y0],
+                [this.xend, this.y1],
+                [this.x0, this.y1],
+            ], { color: "none", fill, hatch }));
+        }
+        else if (pOpen) {
+            segs.push(new SegmentPoly([[this.x0, this.y0], ...this.vertsOut(), [this.x0, this.y1]], { closed: false, fill, hatch, ...this.kwargs }));
+        }
+        else if (nOpen) {
+            segs.push(new SegmentPoly([[this.xend, this.y1], ...this.vertsIn(), [this.xend, this.y0]], { closed: false, fill, hatch, ...this.kwargs }));
+        }
+        else {
+            segs.push(new SegmentPoly([...this.vertsIn(), ...this.vertsOut()], {
+                fill,
+                hatch,
+                ...this.kwargs,
+            }));
+        }
+        if (this.params.data.length > 0 && this.params.state !== "x") {
+            segs.push(new SegmentText([this.xtext, this.yhalf], this.params.data[0], {
+                color: this.params.datacolor,
+                fontsize: 11,
+                align: ["center", "center"],
+            }));
+            this.params.data.shift();
+        }
+        return segs;
+    }
+}
+class WaveU extends Wave1 {
+    vertsIn() {
+        const { xs: xcurve, ys: yexp } = expcurve(this.y1 - this.y0);
+        const xc = xcurve.map((x) => this.x0 + x * this.rise * 6);
+        const ycurvef = yexp.map((yc) => this.y1 - yc);
+        const ycurvehf = yexp.map((yc) => this.y1 - yc / 2);
+        const m = {
+            "-": [[this.x0, this.y1]],
+            "0": xc.map((x, i) => [x, ycurvef[i]]),
+            "1": [[this.x0, this.y1]],
+            "z": xc.map((x, i) => [x, ycurvehf[i]]),
+            "V": [[this.xrise, this.y1]],
+        };
+        return m[this.plevel] ?? [];
+    }
+    segments() {
+        const verts = this.vertsIn();
+        return [
+            new Segment(verts, this.kwargs),
+            new Segment([verts[verts.length - 1], [this.xend, this.y1]], {
+                ...this.kwargs,
+                ls: ":",
+            }),
+        ];
+    }
+}
+class WaveD extends Wave0 {
+    vertsIn() {
+        const { xs: xcurve, ys: yexp } = expcurve(this.y1 - this.y0);
+        const xc = xcurve.map((x) => this.x0 + x * this.rise * 6);
+        const ycurve = yexp.map((yc) => this.y0 + yc);
+        const ycurveh = yexp.map((yc) => this.y0 + yc / 2);
+        const m = {
+            "-": [[this.x0, this.y0]],
+            "0": [[this.x0, this.y0]],
+            "1": xc.map((x, i) => [x, ycurve[i]]),
+            "z": xc.map((x, i) => [x, ycurveh[i]]),
+            "V": [[this.x0, this.y0]],
+        };
+        return m[this.plevel] ?? [];
+    }
+    segments() {
+        const verts = this.vertsIn();
+        return [
+            new Segment(verts, this.kwargs),
+            new Segment([verts[verts.length - 1], [this.xend, this.y0]], {
+                ...this.kwargs,
+                ls: ":",
+            }),
+        ];
+    }
+}
+class WaveClk extends Wave0 {
+    vertsIn() {
+        const state = this.params.state;
+        const period = this.params.period;
+        let yh = this.y1;
+        let yl = this.y0;
+        if ("nN".includes(state)) {
+            [yh, yl] = [yl, yh];
+        }
+        const verts = [];
+        for (let p = 0; p < this.params.periods; p++) {
+            verts.push([this.x0 + period * p, yl], [this.x0 + period * p, yh], [this.x0 + period * p + period / 2, yh], [this.x0 + period * p + period / 2, yl]);
+        }
+        if (("nN".includes(state) && "lL".includes(this.params.pstate)) ||
+            ("pP".includes(state) && "hH".includes(this.params.pstate))) {
+            return verts.slice(1);
+        }
+        return verts;
+    }
+    vertsOut() {
+        const yl = "nN".includes(this.params.state) ? this.y1 : this.y0;
+        return [[this.xend, yl]];
+    }
+    segments() {
+        const segs = super.segments();
+        if ("NP".includes(this.params.state)) {
+            const period = this.params.period;
+            const alength = 0.25;
+            const awidth = 0.12;
+            let yhead = this.yhalf - alength / 2;
+            let ytail = this.yhalf + alength / 2;
+            if (this.params.state === "P") {
+                [yhead, ytail] = [ytail, yhead];
+            }
+            for (let p = 0; p < this.params.periods; p++) {
+                const xc = this.x0 + period * p;
+                segs.push(new Segment([
+                    [xc, ytail],
+                    [xc, yhead],
+                ], {
+                    arrow: "->",
+                    arrowwidth: awidth,
+                    arrowlength: alength,
+                    ...this.kwargs,
+                }));
+            }
+        }
+        return segs;
+    }
+}
+// ---------------------------------------------------------------------------
+// Wave class lookup
+// ---------------------------------------------------------------------------
+const WAVE_LOOKUP = {
+    "0": Wave0,
+    "1": Wave1,
+    H: WaveH,
+    h: WaveH,
+    L: WaveL,
+    l: WaveL,
+    z: Wavez,
+    u: WaveU,
+    d: WaveD,
+    n: WaveClk,
+    p: WaveClk,
+    N: WaveClk,
+    P: WaveClk,
+};
+// ---------------------------------------------------------------------------
+// TimingDiagram
+// ---------------------------------------------------------------------------
+export class TimingDiagram extends Element {
+    waveData;
+    yheight;
+    ygap;
+    risetime;
+    _fontSize;
+    namecolor;
+    datacolor;
+    gridcolor;
+    tickcolor;
+    edgecolor;
+    hscale;
+    showGrid;
+    constructor(waved, userParams = {}) {
+        super(userParams);
+        this.waveData = waved;
+        this.yheight = userParams.yheight ?? 0.5;
+        this.ygap = userParams.ygap ?? 0.3;
+        this.risetime = userParams.risetime ?? 0.15;
+        this._fontSize = userParams.fontsize ?? 12;
+        this.namecolor = userParams.namecolor ?? "blue";
+        this.datacolor = userParams.datacolor;
+        this.gridcolor = userParams.gridcolor ?? "#DDDDDD";
+        this.tickcolor = userParams.tickcolor ?? "#888888";
+        this.edgecolor = userParams.edgecolor ?? "blue";
+        this.showGrid = userParams.grid ?? true;
+        const signals = this.waveData.signal ?? [];
+        const signalsFlat = flattenSignals(signals);
+        const config = this.waveData.config ?? {};
+        this.hscale = config.hscale ?? 1;
+        const head = this.waveData.head ?? {};
+        const foot = this.waveData.foot ?? {};
+        const height = (this.yheight + this.ygap) * signalsFlat.length;
+        let periods = 0;
+        for (const w of signalsFlat) {
+            periods = Math.max(periods, (w.wave ?? "").length);
+        }
+        if (this.showGrid) {
+            this._drawGrid(periods, height);
+        }
+        const clipBox = bbox(0, this.yheight + 0.05, periods * this.yheight * 2 * this.hscale, -height);
+        let y0 = 0;
+        for (const signal of signalsFlat) {
+            this._drawName(signal.name ?? "", y0);
+            this._drawWave(signal, y0, clipBox);
+            y0 -= this.yheight + this.ygap;
+        }
+        this._drawEdges(signalsFlat);
+        this._drawHeadFoot(head, foot, periods, y0);
+        this.anchors.topleft = [0, 0];
+    }
+    _drawGrid(periods, height) {
+        for (let p = 0; p <= periods; p++) {
+            const x = p * 2 * this.yheight * this.hscale;
+            this.segments.push(new Segment([
+                [x, this.yheight + this.ygap / 2],
+                [x, this.yheight - height],
+            ], { ls: ":", lw: 1, color: this.gridcolor, zorder: 0 }));
+        }
+    }
+    _drawName(name, y0) {
+        if (!name)
+            return;
+        const textpad = 0.2;
+        this.segments.push(new SegmentText([-textpad, y0], name, {
+            align: ["right", "bottom"],
+            fontsize: this._fontSize,
+            color: this.namecolor,
+        }));
+    }
+    _drawWave(signal, y0, clip) {
+        const wave = signal.wave ?? "";
+        if (!wave)
+            return;
+        const phase = signal.phase ?? 0;
+        let level = signal.level ?? "0";
+        const waverise = signal.risetime ?? this.risetime;
+        const wavekwargs = {
+            color: signal.color ?? undefined,
+            lw: signal.lw ?? 1,
+            clip,
+        };
+        const data = signal.data
+            ? Array.isArray(signal.data)
+                ? [...signal.data]
+                : signal.data.split(" ")
+            : [];
+        if (level.length === 1) {
+            level = level.repeat(wave.length);
+        }
+        else if (level.length < wave.length) {
+            level += level[level.length - 1].repeat(wave.length - level.length);
+        }
+        const period = 2 * this.yheight * (signal.period ?? 1) * this.hscale;
+        let signalHeight = this.yheight;
+        let i = 0;
+        let pstate = "-";
+        let y1_prev = y0 + signalHeight;
+        let x = -period * phase;
+        while (i < wave.length) {
+            const state = wave[i];
+            const splits = [];
+            let pcount = 1;
+            const lvl = parseInt(level[i], 10);
+            if (!isNaN(lvl) && lvl > 0) {
+                signalHeight = (lvl / 10) * this.yheight;
+            }
+            if (signalHeight === 0)
+                signalHeight = this.yheight;
+            let k = i + 1;
+            while (k < wave.length && (wave[k] === "|" || wave[k] === ".")) {
+                if (wave[k] === "|")
+                    splits.push(pcount);
+                pcount++;
+                k++;
+            }
+            const nstate = k < wave.length ? wave[k] : "-";
+            const y1 = y0 + signalHeight;
+            const xend = x + pcount * period;
+            const params = {
+                state,
+                pstate,
+                nstate,
+                plevel: stateLevel(pstate),
+                nlevel: stateLevel(nstate),
+                periods: pcount,
+                period,
+                x0: x,
+                xend,
+                y0,
+                y1,
+                y1_prev,
+                rise: waverise,
+                data,
+                datacolor: this.datacolor,
+                kwargs: wavekwargs,
+            };
+            const WaveCls = WAVE_LOOKUP[state] ?? WaveV;
+            this.segments.push(...new WaveCls(params).segments());
+            for (const split of splits) {
+                this.segments.push(...getSplitSegments(x + (split + 1) * period - period / 2, y0, y1));
+            }
+            pstate = state;
+            y1_prev = y1;
+            x += pcount * period;
+            i = k;
+        }
+    }
+    _drawEdges(signalsFlat) {
+        const edges = this.waveData.edge ?? [];
+        if (edges.length === 0)
+            return;
+        const period = 2 * this.yheight * this.hscale;
+        for (let edgeStr of edges) {
+            let label = "";
+            if (edgeStr.includes(" ")) {
+                const idx = edgeStr.indexOf(" ");
+                label = edgeStr.slice(idx + 1);
+                edgeStr = edgeStr.slice(0, idx);
+            }
+            const styleMatch = edgeStr.match(/\{(.*?)\}/);
+            let edgeColor = this.edgecolor;
+            if (styleMatch) {
+                const parts = styleMatch[1].split(",");
+                edgeColor = parts[0] || edgeColor;
+                edgeStr = edgeStr.replace(/\{.*?\}/, "");
+            }
+            let arrow;
+            if (edgeStr.includes("<") && edgeStr.includes(">"))
+                arrow = "<>";
+            else if (edgeStr.includes("<"))
+                arrow = "<";
+            else if (edgeStr.includes(">"))
+                arrow = ">";
+            const nodeRefs = edgeStr.match(/\[(.+?)\]/g);
+            if (nodeRefs && nodeRefs.length === 2) {
+                const endpoints = [];
+                for (const ref of nodeRefs) {
+                    const inner = ref.slice(1, -1);
+                    const colonIdx = inner.indexOf(":");
+                    const waveNumStr = inner.slice(0, colonIdx);
+                    const timeStr = inner.slice(colonIdx + 1);
+                    const waveNum = parseInt(waveNumStr.replace(/[^0-9]/g, ""), 10);
+                    const time = parseFloat(timeStr);
+                    let ofst = this.yheight / 2;
+                    if (waveNumStr.includes("^"))
+                        ofst = this.yheight + 0.2;
+                    else if (waveNumStr.includes("v"))
+                        ofst = -0.2;
+                    const sigPhase = signalsFlat[waveNum]?.phase ?? 0;
+                    const nodex = time * period - period * sigPhase;
+                    const nodey = -waveNum * (this.yheight + this.ygap) + ofst;
+                    endpoints.push([nodex, nodey]);
+                }
+                if (endpoints.length === 2) {
+                    this.segments.push(new Segment(endpoints, {
+                        lw: 1,
+                        color: edgeColor,
+                        arrow,
+                        zorder: 3,
+                    }));
+                    if (label) {
+                        const cx = (endpoints[0][0] + endpoints[1][0]) / 2;
+                        const cy = (endpoints[0][1] + endpoints[1][1]) / 2;
+                        this.segments.push(new SegmentText([cx, cy], label, {
+                            fontsize: 8,
+                            color: edgeColor,
+                            align: ["center", "center"],
+                            zorder: 4,
+                        }));
+                    }
+                }
+            }
+            else if (edgeStr.length >= 3) {
+                const first = edgeStr[0];
+                const last = edgeStr[edgeStr.length - 1];
+                const anchorStart = this.anchors[`node_${first}`];
+                const anchorEnd = this.anchors[`node_${last}`];
+                if (anchorStart && anchorEnd) {
+                    const toXY = (a) => a instanceof Point ? [a.x, a.y] : [a[0], a[1]];
+                    const p0 = toXY(anchorStart);
+                    const pn = toXY(anchorEnd);
+                    this.segments.push(new Segment([p0, pn], { lw: 1, color: edgeColor, arrow, zorder: 3 }));
+                    if (label) {
+                        const cx = (p0[0] + pn[0]) / 2;
+                        const cy = (p0[1] + pn[1]) / 2;
+                        this.segments.push(new SegmentText([cx, cy], label, {
+                            fontsize: 8,
+                            color: edgeColor,
+                            align: ["center", "center"],
+                            zorder: 4,
+                        }));
+                    }
+                }
+            }
+        }
+    }
+    _drawHeadFoot(head, foot, periods, yBottom) {
+        if (head.tick !== undefined || head.tock !== undefined) {
+            const tk = (head.tick ?? head.tock ?? 0);
+            const every = head.every ?? 1;
+            const startx = head.tick !== undefined ? 0 : this.hscale / 2;
+            for (let p = 0; p < periods; p += every) {
+                const x = (startx + p * this.hscale) * 2 * this.yheight;
+                this.segments.push(new SegmentText([x, this.yheight + this.ygap], String(tk + p), {
+                    color: this.tickcolor,
+                    fontsize: this._fontSize,
+                    align: ["center", "bottom"],
+                }));
+            }
+        }
+        if (foot.tick !== undefined || foot.tock !== undefined) {
+            const tk = (foot.tick ?? foot.tock ?? 0);
+            const every = foot.every ?? 1;
+            const startx = foot.tick !== undefined ? 0 : this.hscale / 2;
+            for (let p = 0; p < periods; p += every) {
+                const x = (startx + p * this.hscale) * 2 * this.yheight;
+                this.segments.push(new SegmentText([x, yBottom + this.yheight], String(tk + p), {
+                    color: this.tickcolor,
+                    fontsize: this._fontSize,
+                    align: ["center", "top"],
+                }));
+            }
+        }
+    }
+}
+//# sourceMappingURL=timing.js.map