@skillpet/circuit 0.5.0 → 0.5.2

package/dist/logic/timing.js

@@ -1,791 +0,0 @@
-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