smithkit 0.1.1 → 0.2.0

package/dist/lib/draw/SmithData.js

@@ -1,366 +0,0 @@
-import { SmithGroup } from './SmithGroup.js';
-import { line } from 'd3';
-import { SmithMarker } from './SmithMarker.js';
-export class SmithData {
-    data;
-    color;
-    transform;
-    fgContainer;
-    scaler;
-    markerDragHandler;
-    markerContainer;
-    style;
-    viewportScale = 1;
-    destroyed = false;
-    visible = true;
-    pendingEvents = new Map();
-    group;
-    markersCount = 0;
-    markers = [];
-    handler = null;
-    constructor(data, color, transform, fgContainer, scaler, markerDragHandler, markerContainer = fgContainer, style = {}) {
-        this.data = data;
-        this.color = color;
-        this.transform = transform;
-        this.fgContainer = fgContainer;
-        this.scaler = scaler;
-        this.markerDragHandler = markerDragHandler;
-        this.markerContainer = markerContainer;
-        this.style = {
-            mode: style.mode ?? 'points',
-            lineWidth: style.lineWidth ?? 2,
-            pointRadius: style.pointRadius ?? 2,
-        };
-        this.data = this.copySamples(data);
-        this.group = this.drawTrace(this.data);
-        this.group.attr('pointer-events', 'none');
-        this.fgContainer.append(this.group);
-        this.zoomDataPoints();
-    }
-    drawTrace(data) {
-        const group = new SmithGroup({
-            stroke: 'none',
-            strokeWidth: 'none',
-            fill: this.color,
-        });
-        group.attr('data-role', 'samples');
-        group.attr('data-mode', this.style.mode);
-        if (this.style.mode !== 'points') {
-            const path = line()
-                .x((sample) => this.scaler.x(sample.reflectionCoefficient[0]))
-                .y((sample) => this.scaler.y(sample.reflectionCoefficient[1]));
-            group.Element.append('path')
-                .attr('class', 'trace-line')
-                .attr('d', path(data))
-                .attr('fill', 'none')
-                .attr('stroke', this.color)
-                .attr('stroke-width', this.style.lineWidth)
-                .attr('vector-effect', 'non-scaling-stroke')
-                .attr('stroke-linejoin', 'round')
-                .attr('stroke-linecap', 'round');
-        }
-        if (this.style.mode !== 'line') {
-            this.renderPoints(group, data);
-        }
-        return group;
-    }
-    renderPoints(group, data) {
-        let visible = data;
-        if (data.length > 5000) {
-            const cells = new Set();
-            const cellSize = Math.max(0.5, this.style.pointRadius) / this.viewportScale;
-            const extent = this.scaler.x(1);
-            const margin = this.style.pointRadius / this.viewportScale;
-            visible = data.filter((sample) => {
-                const x = this.scaler.x(sample.reflectionCoefficient[0]) * this.transform.k + this.transform.x;
-                const y = this.scaler.y(sample.reflectionCoefficient[1]) * this.transform.k + this.transform.y;
-                if (x < -margin || y < -margin || x > extent + margin || y > extent + margin) {
-                    return false;
-                }
-                const cell = `${Math.floor(x / cellSize)},${Math.floor(y / cellSize)}`;
-                if (cells.has(cell)) {
-                    return false;
-                }
-                cells.add(cell);
-                return true;
-            });
-        }
-        group.Element.selectAll('circle')
-            .data(visible)
-            .join('circle')
-            .attr('cx', (sample) => this.scaler.x(sample.reflectionCoefficient[0]))
-            .attr('cy', (sample) => this.scaler.y(sample.reflectionCoefficient[1]))
-            .attr('r', this.style.pointRadius / (this.transform.k * this.viewportScale));
-    }
-    setViewportScale(scale) {
-        if (scale === this.viewportScale || !Number.isFinite(scale) || scale <= 0) {
-            return;
-        }
-        this.viewportScale = scale;
-        this.zoomDataPoints();
-    }
-    zoom(transform) {
-        if (this.destroyed) {
-            return;
-        }
-        this.transform = transform;
-        this.zoomDataPoints();
-        this.zoomAllMarkers();
-    }
-    zoomDataPoints() {
-        const k = this.transform.k;
-        if (this.style.mode === 'line') {
-            return;
-        }
-        if (this.data.length > 5000) {
-            this.renderPoints(this.group, this.data);
-        }
-        else {
-            this.group.Element.selectAll('circle').attr('r', this.style.pointRadius / (k * this.viewportScale));
-        }
-    }
-    zoomAllMarkers() {
-        const k = this.transform.k;
-        for (const marker of this.markers) {
-            const entry = marker.selectedPoint;
-            if (entry) {
-                marker.marker.zoom(k);
-            }
-        }
-    }
-    addMarker(sampleIndex = 0) {
-        if (this.destroyed) {
-            throw new Error('This dataset has been removed.');
-        }
-        this.validateSampleIndex(sampleIndex);
-        const markerIndex = this.markersCount++;
-        const marker = new SmithMarker(markerIndex + 1, this.color, (dragging) => this.markerDragHandler?.(marker, dragging));
-        const markerDesc = {
-            marker,
-            selectedPoint: this.data[sampleIndex],
-            number: markerIndex + 1,
-        };
-        this.markers.push(markerDesc);
-        marker.Element.attr('data-role', 'marker');
-        this.markerContainer.append(marker);
-        marker.setDragHandler((mp) => {
-            const dp = this.findClosestPointTo(this.scaler.pointInvert(mp));
-            if (markerDesc.selectedPoint === dp) {
-                return;
-            }
-            markerDesc.selectedPoint = dp;
-            marker.move(this.scaler.point(dp.reflectionCoefficient));
-            marker.zoom(this.transform.k);
-            this.notifyMarker(markerDesc);
-        });
-        marker.zoom(this.transform.k);
-        marker.show();
-        marker.move(this.scaler.point(markerDesc.selectedPoint.reflectionCoefficient));
-        marker.Element.style('display', () => (this.visible ? null : 'none'));
-        this.notifyMarker(markerDesc);
-        return this.markers.length - 1;
-    }
-    removeMarker(index) {
-        const entry = this.markers[index];
-        if (!entry) {
-            return false;
-        }
-        clearTimeout(this.pendingEvents.get(entry));
-        this.pendingEvents.delete(entry);
-        entry.marker.destroy();
-        this.markers.splice(index, 1);
-        return true;
-    }
-    setMarkerSample(index, sampleIndex) {
-        const entry = this.markers[index];
-        if (!entry) {
-            return false;
-        }
-        this.validateSampleIndex(sampleIndex);
-        entry.selectedPoint = this.data[sampleIndex];
-        entry.marker.move(this.scaler.point(entry.selectedPoint.reflectionCoefficient));
-        this.notifyMarker(entry);
-        return true;
-    }
-    setMarkerFrequency(index, frequencyHz) {
-        if (!this.markers[index]) {
-            return false;
-        }
-        if (!Number.isFinite(frequencyHz) || frequencyHz < 0) {
-            throw new RangeError('Marker frequency must be finite and non-negative.');
-        }
-        return this.setMarkerSample(index, this.nearestFrequencyIndex(frequencyHz));
-    }
-    nearestFrequencyIndex(frequencyHz) {
-        let closest = 0;
-        let distance = Math.abs(this.data[0].frequencyHz - frequencyHz);
-        for (let i = 1; i < this.data.length; i++) {
-            const nextDistance = Math.abs(this.data[i].frequencyHz - frequencyHz);
-            if (nextDistance < distance) {
-                closest = i;
-                distance = nextDistance;
-            }
-        }
-        return closest;
-    }
-    validateSampleIndex(index) {
-        if (!Number.isInteger(index) || index < 0 || index >= this.data.length) {
-            throw new RangeError('Sample index is outside this trace.');
-        }
-    }
-    get Samples() {
-        return this.data;
-    }
-    get SampleCount() {
-        return this.data.length;
-    }
-    get Color() {
-        return this.color;
-    }
-    get Visible() {
-        return this.visible;
-    }
-    markerSampleIndex(index) {
-        const entry = this.markers[index];
-        return entry ? this.data.indexOf(entry.selectedPoint) : -1;
-    }
-    setColor(color) {
-        this.color = color;
-        this.group.attr('fill', color);
-        this.group.Element.select('.trace-line').attr('stroke', color);
-        this.markers.forEach(({ marker }) => marker.setColor(color));
-    }
-    get Style() {
-        return { ...this.style };
-    }
-    setStyle(options) {
-        const next = {
-            mode: options.mode ?? this.style.mode,
-            lineWidth: options.lineWidth ?? this.style.lineWidth,
-            pointRadius: options.pointRadius ?? this.style.pointRadius,
-        };
-        if (next.mode === this.style.mode &&
-            next.lineWidth === this.style.lineWidth &&
-            next.pointRadius === this.style.pointRadius) {
-            return;
-        }
-        const modeChanged = next.mode !== this.style.mode;
-        this.style = next;
-        if (modeChanged) {
-            this.redraw();
-        }
-        else {
-            this.group.Element.select('.trace-line').attr('stroke-width', next.lineWidth);
-            this.zoomDataPoints();
-        }
-    }
-    redraw() {
-        const group = this.drawTrace(this.data).attr('pointer-events', 'none');
-        // Replace in place to retain trace ordering beneath the separate marker layer.
-        this.group.Node.replaceWith(group.Node);
-        this.group = group;
-        this.group.Element.style('display', () => (this.visible ? null : 'none'));
-    }
-    setVisible(visible) {
-        this.visible = visible;
-        this.group.Element.style('display', () => (visible ? null : 'none'));
-        this.markers.forEach(({ marker }) => {
-            if (!visible) {
-                marker.cancelDrag();
-            }
-            marker.Element.style('display', () => (visible ? null : 'none'));
-        });
-    }
-    copySamples(values) {
-        if (!values.length ||
-            values.some(({ frequencyHz, reflectionCoefficient }) => !Number.isFinite(frequencyHz) ||
-                frequencyHz < 0 ||
-                reflectionCoefficient.length !== 2 ||
-                !reflectionCoefficient.every(Number.isFinite))) {
-            throw new RangeError('A dataset requires samples with a non-negative finite frequency and two finite coordinates.');
-        }
-        return values.map(({ frequencyHz, reflectionCoefficient }) => ({
-            frequencyHz,
-            reflectionCoefficient: [reflectionCoefficient[0], reflectionCoefficient[1]],
-        }));
-    }
-    notifyMarker(entry) {
-        if (this.pendingEvents.has(entry)) {
-            return;
-        }
-        const timer = setTimeout(() => {
-            this.pendingEvents.delete(entry);
-            const index = this.markers.indexOf(entry);
-            if (!this.destroyed && index >= 0) {
-                this.handler?.(index, entry.selectedPoint);
-            }
-        }, 0);
-        this.pendingEvents.set(entry, timer);
-    }
-    cancelEvents() {
-        this.pendingEvents.forEach((timer) => clearTimeout(timer));
-        this.pendingEvents.clear();
-    }
-    update(values, strategy = 'frequency') {
-        if (this.destroyed) {
-            throw new Error('This dataset has been removed.');
-        }
-        const samples = this.copySamples(values);
-        const selectedIndices = this.markers.map((entry) => this.data.indexOf(entry.selectedPoint));
-        this.cancelEvents();
-        this.data = samples;
-        const group = this.drawTrace(samples).attr('pointer-events', 'none');
-        this.group.Element.remove();
-        this.group = group;
-        this.group.Element.style('display', () => (this.visible ? null : 'none'));
-        this.fgContainer.append(group);
-        this.zoomDataPoints();
-        this.markers.forEach((entry, index) => {
-            if (strategy === 'sample-index') {
-                entry.selectedPoint = samples[Math.min(selectedIndices[index], samples.length - 1)];
-            }
-            else if (strategy === 'reflection') {
-                entry.selectedPoint = this.findClosestPointTo(entry.selectedPoint.reflectionCoefficient);
-            }
-            else {
-                entry.selectedPoint = samples[this.nearestFrequencyIndex(entry.selectedPoint.frequencyHz)];
-            }
-            entry.marker.move(this.scaler.point(entry.selectedPoint.reflectionCoefficient));
-            this.notifyMarker(entry);
-        });
-    }
-    destroy() {
-        if (this.destroyed) {
-            return;
-        }
-        this.destroyed = true;
-        this.cancelEvents();
-        this.handler = null;
-        this.markers.forEach(({ marker }) => marker.destroy());
-        this.markers = [];
-        this.markerDragHandler = undefined;
-        this.data = [];
-        this.group.Element.remove();
-    }
-    getMarker(index) {
-        return this.markers[index];
-    }
-    get Markers() {
-        return this.markers.slice();
-    }
-    setMarkerMoveHandler(handler) {
-        this.handler = handler;
-    }
-    findClosestPointTo(p) {
-        const dist = (p1, p2) => {
-            const xd = p1[0] - p2[0];
-            const yd = p1[1] - p2[1];
-            return Math.hypot(xd, yd);
-        };
-        return this.data.reduce((prev, curr) => {
-            const d1 = dist(p, prev.reflectionCoefficient);
-            const d2 = dist(p, curr.reflectionCoefficient);
-            return d1 <= d2 ? prev : curr;
-        });
-    }
-}

package/dist/lib/draw/SmithMarker.js

@@ -1,122 +0,0 @@
-import * as d3 from 'd3';
-import { MouseGesture } from './MouseGesture.js';
-import { SmithShape } from './SmithShape.js';
-export class SmithMarker extends SmithShape {
-    dragStateHandler;
-    size = 18;
-    mouseGesture = new MouseGesture();
-    activeDrags = new Set();
-    destroyed = false;
-    triangle;
-    inner;
-    text;
-    rc = [0, 0];
-    dragHandler = null;
-    constructor(marker, color, dragStateHandler = null) {
-        super(d3.select(document.createElementNS('http://www.w3.org/2000/svg', 'g')));
-        this.dragStateHandler = dragStateHandler;
-        const g = this.Element.style('cursor', 'var(--smithkit-marker-cursor, grab)');
-        this.triangle = g
-            .append('polygon')
-            .attr('stroke', 'none')
-            .attr('fill', 'gray')
-            .attr('transform', 'translate(0,0)');
-        this.inner = g
-            .append('polygon')
-            .attr('stroke', 'none')
-            .attr('fill', color)
-            .attr('transform', 'translate(0,0)');
-        this.text = g
-            .append('text')
-            .attr('pointer-events', 'none')
-            .attr('transform', 'translate(0,0)')
-            .attr('font-family', 'Verdana')
-            .attr('font-weight', 'normal')
-            .attr('text-anchor', 'middle')
-            .attr('dominant-baseline', 'middle')
-            .attr('x', '0')
-            .attr('y', '0')
-            .attr('fill', 'white')
-            .text(marker.toString());
-        this.zoom(1);
-        const drag = d3
-            .drag()
-            .on('start', (event) => {
-            if (this.destroyed) {
-                return;
-            }
-            this.mouseGesture.capture(event.sourceEvent, 'drag');
-            const wasIdle = this.activeDrags.size === 0;
-            this.activeDrags.add(event.identifier);
-            if (wasIdle) {
-                this.dragStateHandler?.(true);
-            }
-        })
-            .on('drag', (event) => this.onDrag(event))
-            .on('end', (event) => {
-            if (this.activeDrags.delete(event.identifier) && this.activeDrags.size === 0) {
-                this.dragStateHandler?.(false);
-            }
-        });
-        this.triangle.call(drag);
-        this.inner.call(drag);
-    }
-    destroy() {
-        if (this.destroyed) {
-            return;
-        }
-        this.destroyed = true;
-        this.dragHandler = null;
-        this.cancelDrag();
-        this.dragStateHandler = null;
-        this.Element.selectAll('*').on('.drag', null).interrupt();
-        this.Element.remove();
-    }
-    cancelDrag() {
-        if (this.activeDrags.size > 0) {
-            this.activeDrags.clear();
-            this.dragStateHandler?.(false);
-        }
-        this.mouseGesture.destroy();
-    }
-    setColor(color) {
-        this.inner.attr('fill', color);
-    }
-    onDrag(event) {
-        if (this.dragHandler) {
-            this.dragHandler([event.x, event.y]);
-        }
-    }
-    get Position() {
-        return this.rc;
-    }
-    move(p) {
-        this.rc = p;
-        this.triangle.attr('transform', `translate(${p[0]},${p[1]})`);
-        this.inner.attr('transform', `translate(${p[0]},${p[1]})`);
-        this.text.attr('x', `${p[0]}`).attr('y', `${p[1]}`);
-    }
-    zoom(k) {
-        const size = this.size / k;
-        const h = size / 12;
-        const dy = -size / 1.6;
-        const fs = size / 1.8;
-        // calculate inner triangle
-        const alpha = Math.atan(1 / 2);
-        const beta = Math.PI / 2 - alpha;
-        const x = h / Math.sin(alpha);
-        const y = h / Math.sin(beta) + h / Math.tan(beta);
-        this.triangle.attr('points', `0,0 ${size / 2},${-size} ${-size / 2},${-size}`);
-        this.inner.attr('points', `0,${-x} ${size / 2 - y},${-size + h} ${-size / 2 + y},${-size + h}`);
-        this.text.attr('font-size', `${fs}`).attr('dy', `${dy}`);
-    }
-    show() {
-        this.Element.attr('opacity', null);
-    }
-    hide() {
-        this.Element.attr('opacity', '0');
-    }
-    setDragHandler(handler) {
-        this.dragHandler = handler;
-    }
-}

package/dist/lib/formatting.d.ts

@@ -1,7 +0,0 @@
-import type { Complex } from './complex/Complex.js';
-/** Format with three significant digits and an SI prefix; includes spacing before the unit. */
-export declare function formatNumber(value: number): string;
-/** Format Cartesian components to decimalPlaces fractional digits. */
-export declare function formatComplex(value: Complex, unit?: string, decimalPlaces?: number): string;
-/** Format magnitude and phase in degrees to decimalPlaces fractional digits. */
-export declare function formatComplexPolar(value: Complex, unit?: string, decimalPlaces?: number): string;

package/dist/lib/formatting.js

@@ -1,16 +0,0 @@
-import { format } from 'd3';
-/** Format with three significant digits and an SI prefix; includes spacing before the unit. */
-export function formatNumber(value) {
-    const formatted = format('.3~s')(value);
-    return Number.isFinite(value) && /[a-zA-Zµ]$/.test(formatted)
-        ? formatted.replace(/([a-zA-Zµ])$/, ' $1')
-        : formatted + ' ';
-}
-/** Format Cartesian components to decimalPlaces fractional digits. */
-export function formatComplex(value, unit = '', decimalPlaces = 3) {
-    return `${value.toString(decimalPlaces)} ${unit === '' ? '' : `[${unit}]`}`;
-}
-/** Format magnitude and phase in degrees to decimalPlaces fractional digits. */
-export function formatComplexPolar(value, unit = '', decimalPlaces = 3) {
-    return `${value.abs().toFixed(decimalPlaces)} ${unit} ∠${((value.arg() * 180) / Math.PI).toFixed(decimalPlaces)}°`;
-}

package/dist/lib/grid/definitions.d.ts

@@ -1,3 +0,0 @@
-import type { SmithTicksData } from './types.js';
-/** Build fresh definitions so callers cannot mutate another chart's grid. */
-export declare function createGridDefinitions(): SmithTicksData;

package/dist/lib/grid/definitions.js

@@ -1,123 +0,0 @@
-function resistanceArcs(bands) {
-    return bands.flatMap(([values, from, to, largeArc]) => values.map((value) => [
-        value,
-        [
-            [from, from < 0 ? 1 : 0],
-            [to, to < 0 ? 1 : 0],
-        ],
-        [largeArc, from > to],
-    ]));
-}
-function reactanceArcs(bands) {
-    return bands.flatMap(([values, outer, inner]) => values.flatMap((value) => [
-        [
-            value,
-            [
-                [outer, 1],
-                [inner, 1],
-            ],
-            [false, false],
-        ],
-        [
-            -value,
-            [
-                [outer, 0],
-                [inner, 0],
-            ],
-            [false, true],
-        ],
-    ]));
-}
-const resistanceMajor = [
-    [[0.05, 0.15], 0.2, -0.2, false],
-    [[0.1, 0.3, 0.5, 0.7, 0.9], 2, -2, true],
-    [[0.2, 0.4, 0.6, 0.8, 1.2, 1.4, 1.6, 1.8], 5, -5, true],
-    [[1, 3, 5], 10, -10, true],
-    [[2, 4], 20, -20, true],
-    [[20], 50, -50, true],
-];
-const resistanceMinor = [
-    [[0.02, 0.04, 0.06, 0.08, 0.12, 0.14, 0.16, 0.18], 0.2, 0.5, false],
-    [[0.02, 0.04, 0.06, 0.08, 0.12, 0.14, 0.16, 0.18], -0.2, -0.5, false],
-    [[0.05, 0.15, 0.25, 0.35, 0.45], 0.5, 1, false],
-    [[0.05, 0.15, 0.25, 0.35, 0.45], -0.5, -1, false],
-    [
-        [
-            0.01, 0.02, 0.03, 0.04, 0.06, 0.07, 0.08, 0.09, 0.11, 0.12, 0.13, 0.14, 0.16, 0.17, 0.18,
-            0.19,
-        ],
-        0.2,
-        -0.2,
-        false,
-    ],
-    [[0.22, 0.24, 0.26, 0.28, 0.32, 0.34, 0.36, 0.38, 0.42, 0.44, 0.46, 0.48], 0.5, -0.5, false],
-    [[0.55, 0.65, 0.75, 0.85, 0.95], 2, -2, true],
-    [[1.1, 1.3, 1.5, 1.7, 1.9], 2, -2, false],
-    [[2.2, 2.4, 2.6, 2.8, 3.2, 3.4, 3.6, 3.8], 5, -5, true],
-    [[4.2, 4.4, 4.6, 4.8], 5, -5, false],
-    [[6, 8, 12, 14, 16, 18], 20, -20, true],
-    [[7, 9], 10, -10, true],
-    [[30, 40], 50, -50, true],
-];
-const reactanceMajor = [
-    [[0.05, 0.15], 0.2, 0],
-    [[0.1, 0.3, 0.5, 0.7, 0.9], 2, 0],
-    [[0.2, 0.4, 0.6, 0.8, 1.2, 1.4, 1.6, 1.8], 5, 0],
-    [[1, 3, 5], 10, 0],
-    [[2, 4, 10], 20, 0],
-    [[20], 50, 0],
-];
-const reactanceMinor = [
-    [
-        [
-            0.01, 0.02, 0.03, 0.04, 0.06, 0.07, 0.08, 0.09, 0.11, 0.12, 0.13, 0.14, 0.16, 0.17, 0.18,
-            0.19,
-        ],
-        0.2,
-        0,
-    ],
-    [[0.02, 0.04, 0.06, 0.08, 0.12, 0.14, 0.16, 0.18], 0.5, 0.2],
-    [[0.22, 0.24, 0.26, 0.28, 0.32, 0.34, 0.36, 0.38, 0.42, 0.44, 0.46, 0.48], 0.5, 0],
-    [[0.05, 0.15, 0.25, 0.35, 0.45], 1, 0.5],
-    [[0.55, 0.65, 0.75, 0.85, 0.95], 1, 0],
-    [[1.1, 1.3, 1.5, 1.7, 1.9], 2, 0],
-    [[2.2, 2.4, 2.6, 2.8, 3.2, 3.4, 3.6, 3.8, 4.2, 4.4, 4.6, 4.8], 5, 0],
-    [[6, 8, 14, 16, 18], 20, 0],
-    [[7, 9], 10, 0],
-    [[12, 30, 40], 50, 0],
-];
-/** Build fresh definitions so callers cannot mutate another chart's grid. */
-export function createGridDefinitions() {
-    return {
-        resistance: {
-            major: { lines: [], circles: [10, 50], arcs: resistanceArcs(resistanceMajor) },
-            minor: { lines: [], circles: [], arcs: resistanceArcs(resistanceMinor) },
-        },
-        reactance: {
-            major: {
-                lines: [{ p1: [-1, 0], p2: [1, 0] }],
-                circles: [],
-                arcs: [
-                    ...reactanceArcs(reactanceMajor),
-                    [
-                        50,
-                        [
-                            [0, 0],
-                            [0, 1],
-                        ],
-                        [false, false],
-                    ],
-                    [
-                        -50,
-                        [
-                            [0, 1],
-                            [0, 0],
-                        ],
-                        [false, true],
-                    ],
-                ],
-            },
-            minor: { lines: [], circles: [], arcs: reactanceArcs(reactanceMinor) },
-        },
-    };
-}

package/dist/lib/grid/geometry.d.ts

@@ -1,20 +0,0 @@
-import type { TickDefRequired } from '../arcs/Tick.js';
-import type { SmithTicksShapes } from './types.js';
-import type { Point } from '../shapes/Point.js';
-export type GridKind = 'resistance' | 'reactance' | 'conductance' | 'susceptance';
-export type GridArc = [Point, Point, number, boolean, boolean];
-/** Normalized geometry only: no DOM, D3, or pixel coordinates. */
-export declare function gridGeometry(kind: GridKind, data: SmithTicksShapes): {
-    lines: import("../shapes/Line.js").Line[];
-    circles: import("../shapes/Circle.js").Circle[];
-    arcs: GridArc[];
-};
-export declare function gridLabel(kind: GridKind, definition: TickDefRequired): {
-    point: [number, number];
-    text: string;
-    rotate: number;
-    dx: number;
-    dy: number;
-    textAnchor: string;
-    dominantBaseline: string;
-};