smithkit 0.1.1 → 0.3.0

package/dist/lib/grid/GridLabels.js

@@ -0,0 +1,45 @@
+import { Tick } from './Tick.js';
+export class GridLabels {
+    constructor() { }
+    static values = [
+        0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1, 1.2, 1.4, 1.6, 1.8, 2, 3, 4, 5, 10, 20, 50,
+    ];
+    static interiorValues = [0.2, 0.4, 0.6, 0.8, 1];
+    static resistance() {
+        const axis = [0, ...GridLabels.values].map((r) => new Tick({
+            point: { r, i: 0 },
+            dp: r === 0 || r >= 10 ? 0 : 1,
+            // Keep the zero inside the rim and clear of the opposite grid's high-value labels.
+            transform: { dx: r === 0 ? 0.02 : 0.005, dy: r === 0 ? 0.02 : -0.005 },
+            dominantBaseline: r === 0 ? 'hanging' : 'baseline',
+        }));
+        const interior = [1, -1].flatMap((i) => [...GridLabels.interiorValues].reverse().map((r) => new Tick({
+            point: { r, i },
+            dp: 1,
+            transform: { dx: i * 0.005, dy: -0.005, rotate: i < 0 ? 180 : 0 },
+            textAnchor: i < 0 ? 'end' : 'start',
+        })));
+        return [...axis, ...interior];
+    }
+    static reactance() {
+        return [1, -1].flatMap((sign) => [
+            ...GridLabels.interiorValues.map((i) => ({ r: 1, i: sign * i })),
+            ...GridLabels.values.map((i) => ({ r: 0, i: sign * i })),
+        ].map((point) => new Tick({
+            point,
+            dp: Math.abs(point.i) >= 10 ? 0 : 1,
+            transform: {
+                dx: -sign * 0.005,
+                dy: -0.005,
+                rotate: sign > 0
+                    ? point.r === 1 || point.i < 1
+                        ? 180
+                        : 0
+                    : point.r === 0 && point.i < -1
+                        ? 180
+                        : 0,
+            },
+            textAnchor: sign > 0 ? 'end' : 'start',
+        })));
+    }
+}

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

@@ -0,0 +1,13 @@
+import type { SmithGridLayer } from './SmithGridLayer.js';
+import type { GridDetail, GridLayer, GridStyle } from '../layers.js';
+import { LayerControl } from './LayerControl.js';
+/** Exposes grid controls without exposing the SVG renderer. */
+export declare class GridLayerControl extends LayerControl implements GridLayer {
+    private readonly layer;
+    private readonly changed;
+    constructor(layer: SmithGridLayer, assertAlive: () => void, changed: () => void);
+    setVisible(visible: boolean): void;
+    setLabelsVisible(visible: boolean): void;
+    setDetail(detail: GridDetail): void;
+    setStyle(style: Partial<GridStyle>): void;
+}

package/dist/lib/grid/GridLayerControl.js

@@ -0,0 +1,48 @@
+import { LayerControl } from './LayerControl.js';
+/** Exposes grid controls without exposing the SVG renderer. */
+export class GridLayerControl extends LayerControl {
+    layer;
+    changed;
+    constructor(layer, assertAlive, changed) {
+        super(assertAlive);
+        this.layer = layer;
+        this.changed = changed;
+    }
+    setVisible(visible) {
+        this.assertAlive();
+        this.layer.visibility(visible);
+        this.changed();
+    }
+    setLabelsVisible(visible) {
+        this.assertAlive();
+        this.layer.setLabelsVisible(visible);
+        this.changed();
+    }
+    setDetail(detail) {
+        this.assertAlive();
+        if (!['basic', 'standard', 'detailed'].includes(detail)) {
+            throw new RangeError('Grid detail must be basic, standard, or detailed.');
+        }
+        this.layer.setDetail(detail);
+        this.changed();
+    }
+    setStyle(style) {
+        this.assertAlive();
+        this.validateLengths(style, ['majorWidth', 'minorWidth', 'textFontSize']);
+        const properties = {
+            stroke: 'Stroke',
+            majorWidth: 'MajorWidth',
+            minorWidth: 'MinorWidth',
+            textColor: 'TextColor',
+            textFontFamily: 'TextFontFamily',
+            textFontSize: 'TextFontSize',
+        };
+        for (const key of Object.keys(properties)) {
+            const value = style[key];
+            if (value !== undefined) {
+                this.layer[properties[key]] = String(value);
+            }
+        }
+        this.changed();
+    }
+}

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

@@ -0,0 +1,6 @@
+/** Shared lifecycle and style validation for chart layer adapters. */
+export declare abstract class LayerControl {
+    protected readonly assertAlive: () => void;
+    protected constructor(assertAlive: () => void);
+    protected validateLengths<T>(style: T, keys: readonly (keyof T)[]): void;
+}

package/dist/lib/grid/LayerControl.js

@@ -0,0 +1,16 @@
+/** Shared lifecycle and style validation for chart layer adapters. */
+export class LayerControl {
+    assertAlive;
+    constructor(assertAlive) {
+        this.assertAlive = assertAlive;
+    }
+    validateLengths(style, keys) {
+        for (const key of keys) {
+            const value = style[key];
+            if (value !== undefined &&
+                (typeof value !== 'number' || !Number.isFinite(value) || value <= 0)) {
+                throw new RangeError(`${String(key)} must be a positive finite number.`);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,26 @@
+import { ConstCircles } from './ConstCircles.js';
+import { SmithGroup } from '../svg/SmithGroup.js';
+import type { SmithScaler } from '../svg/SmithScaler.js';
+import type { SmithTicksData } from './types.js';
+import { type GridKind } from './GridGeometry.js';
+import type { GridDetail } from '../layers.js';
+export interface GridLayerParams {
+    scaler: SmithScaler;
+    detail: GridDetail;
+    data: SmithTicksData;
+}
+/** SVG adapter shared by the four constant impedance/admittance layers. */
+export declare class SmithGridLayer extends ConstCircles {
+    private kind;
+    protected major: SmithGroup;
+    protected minor: SmithGroup;
+    protected texts: SmithGroup;
+    private readonly standardDefinitions;
+    private readonly basicDefinitions;
+    private detail;
+    constructor(params: GridLayerParams, kind: GridKind);
+    setLabelsVisible(visible: boolean): void;
+    setDetail(detail: GridDetail): void;
+    private static labelPriority;
+    private drawGrid;
+}

package/dist/lib/grid/SmithGridLayer.js

@@ -0,0 +1,95 @@
+import { ConstCircles } from './ConstCircles.js';
+import { SmithGroup } from '../svg/SmithGroup.js';
+import { SmithText } from '../svg/SmithText.js';
+import { GridGeometry } from './GridGeometry.js';
+import { GridDefinitions } from './GridDefinitions.js';
+import { GridLabels } from './GridLabels.js';
+/** SVG adapter shared by the four constant impedance/admittance layers. */
+export class SmithGridLayer extends ConstCircles {
+    kind;
+    major;
+    minor;
+    texts;
+    standardDefinitions;
+    basicDefinitions;
+    detail = 'detailed';
+    constructor(params, kind) {
+        super(params.scaler);
+        this.kind = kind;
+        const real = kind === 'resistance' || kind === 'conductance';
+        const definitions = params.data[real ? 'resistance' : 'reactance'];
+        this.standardDefinitions = definitions.major;
+        this.basicDefinitions = GridDefinitions.basic()[real ? 'resistance' : 'reactance'];
+        this.major = this.drawGrid(definitions.major, this.opts.majorWidth);
+        this.minor = this.drawGrid(definitions.minor, this.opts.minorWidth);
+        this.texts = new SmithGroup()
+            .attr('stroke', 'none')
+            .attr('font-size', this.opts.textFontSize)
+            .attr('font-family', this.opts.textFontFamily)
+            .attr('fill', this.opts.textColor);
+        for (const tick of real ? GridLabels.resistance() : GridLabels.reactance()) {
+            const label = GridGeometry.label(kind, tick.definition);
+            const text = new SmithText(this.scaler.point(label.point), label.text, {
+                rotate: label.rotate,
+                dx: this.scaler.r(label.dx).toString(),
+                dy: this.scaler.r(label.dy).toString(),
+                textAnchor: label.textAnchor,
+                dominantBaseline: label.dominantBaseline,
+            });
+            text.Element.attr('data-label-priority', SmithGridLayer.labelPriority(tick.definition.point.r, tick.definition.point.i));
+            const { r, i } = tick.definition.point;
+            const basic = real
+                ? i === 0 && (r === 0 || GridDefinitions.basicValues.includes(r))
+                : r === 0 && GridDefinitions.basicValues.includes(Math.abs(i));
+            text.Element.attr('data-basic-label', String(basic));
+            this.texts.append(text);
+        }
+        this.build();
+        this.setDetail(params.detail);
+    }
+    setLabelsVisible(visible) {
+        // Keep this separate from whole-layer opacity and detail-specific label filtering.
+        this.texts.attr('display', visible ? null : 'none');
+    }
+    setDetail(detail) {
+        if (detail === this.detail) {
+            return;
+        }
+        if ((detail === 'basic') !== (this.detail === 'basic')) {
+            this.major.Element.selectAll('*').remove();
+            this.drawGrid(detail === 'basic' ? this.basicDefinitions : this.standardDefinitions, this.opts.majorWidth, this.major);
+        }
+        if (detail === 'detailed') {
+            this.minor.show();
+        }
+        else {
+            this.minor.hide();
+        }
+        this.texts.Element.selectAll('[data-basic-label="false"]').attr('display', detail === 'basic' ? 'none' : null);
+        this.detail = detail;
+    }
+    static labelPriority(real, imaginary) {
+        const value = Math.abs(imaginary === 0 ? real : imaginary);
+        const importance = value === 0
+            ? 300
+            : value === 1
+                ? 100
+                : value === 50
+                    ? 90
+                    : [0.5, 2].includes(value)
+                        ? 80
+                        : [0.2, 5, 10].includes(value)
+                            ? 70
+                            : 40;
+        return importance + (imaginary === 0 ? 20 : real === 0 ? 10 : 0);
+    }
+    drawGrid(definitions, width, group = new SmithGroup()) {
+        const geometry = GridGeometry.shapes(this.kind, definitions);
+        this.drawShapes(group.Element, this.opts.stroke, width, {
+            lines: geometry.lines.map((line) => this.scaler.line(line)),
+            circles: geometry.circles.map((circle) => this.scaler.circle(circle)),
+            arcs: geometry.arcs.map((arc) => this.scaleArc(this.scaler, arc)),
+        });
+        return group;
+    }
+}

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

@@ -1,4 +1,4 @@
-import type { Line } from '../shapes/Line.js';
+import type { Line } from '../math/geometry.js';
 export declare enum SmithArcEntry {
     circle = 0,
     clipCircles = 1,

package/dist/lib/index.d.ts

@@ -1,16 +1,16 @@
 export { Smith, SmithEventType } from './Smith.js';
 export type { SmithEvent } from './Smith.js';
-export { Complex } from './complex/Complex.js';
+export { Complex } from './math/Complex.js';
 export type { TraceSamples, TraceSample } from './samples.js';
-export { parseTouchstone } from './io/touchstone.js';
-export type { TouchstoneData } from './io/touchstone.js';
+export { Touchstone } from './io/Touchstone.js';
+export type { TouchstoneData } from './io/Touchstone.js';
 export { SmithScales } from './scales/SmithScales.js';
-export { compareMarkerReadings } from './measurements.js';
+export { MarkerMeasurements } from './MarkerMeasurements.js';
 export type { TraceOptions, TraceUpdateOptions, MarkerSelectionStrategy, TraceStyle, TraceRenderMode, TraceInfo, MarkerInfo, MarkerSnapshot, MarkerComparison, } from './measurements.js';
-export { readReflection, reflectionToImpedance, impedanceToReflection, reflectionToAdmittance, admittanceToReflection, } from './rf.js';
-export type { SmithReading } from './rf.js';
-export type { GridStyle, CircleStyle, GridLayer, CircleLayer, ChartLayers, PeripheralScales, } from './layers.js';
-export { renormalizeReflection, renormalizeSamples } from './renormalization.js';
-export { formatNumber, formatComplex, formatComplexPolar } from './formatting.js';
-export { reactanceToComponent } from './components.js';
-export type { ReactiveComponent } from './components.js';
+export { RfCalculations } from './rf/RfCalculations.js';
+export type { SmithReading } from './rf/RfCalculations.js';
+export type { GridStyle, CircleStyle, GridLayer, GridDetail, CircleLayer, ChartLayers, PeripheralScales, } from './layers.js';
+export { SmithFormatter } from './SmithFormatter.js';
+export type { ReactiveComponent } from './rf/RfCalculations.js';
+export type { SmithAppearance, SmithTheme, SmithThemeOverrides } from './appearance/types.js';
+export type { MarkerLegendField, MarkerLegendOptions, ImageExportOptions, SmithImageExportOptions, ScaleImageExportOptions, ScaleExportReadout, } from './svg/export.js';

package/dist/lib/index.js

@@ -1,9 +1,7 @@
 export { Smith, SmithEventType } from './Smith.js';
-export { Complex } from './complex/Complex.js';
-export { parseTouchstone } from './io/touchstone.js';
+export { Complex } from './math/Complex.js';
+export { Touchstone } from './io/Touchstone.js';
 export { SmithScales } from './scales/SmithScales.js';
-export { compareMarkerReadings } from './measurements.js';
-export { readReflection, reflectionToImpedance, impedanceToReflection, reflectionToAdmittance, admittanceToReflection, } from './rf.js';
-export { renormalizeReflection, renormalizeSamples } from './renormalization.js';
-export { formatNumber, formatComplex, formatComplexPolar } from './formatting.js';
-export { reactanceToComponent } from './components.js';
+export { MarkerMeasurements } from './MarkerMeasurements.js';
+export { RfCalculations } from './rf/RfCalculations.js';
+export { SmithFormatter } from './SmithFormatter.js';

package/dist/lib/{draw → interaction}/SmithCursor.d.ts

@@ -1,25 +1,10 @@
-import { SmithGroup } from './SmithGroup.js';
-import { SmithScaler } from './SmithScaler.js';
-import { Complex } from '../complex/Complex.js';
-interface DrawOptions {
-    point: {
-        radius: number;
-        color: string;
-    };
-    impedance: {
-        width: number;
-        color: string;
-    };
-    admittance: {
-        width: number;
-        color: string;
-    };
-}
+import { SmithGroup } from '../svg/SmithGroup.js';
+import { SmithScaler } from '../svg/SmithScaler.js';
+import { Complex } from '../math/Complex.js';
 export declare class SmithCursor {
     private scaler;
     private epsilon;
     private pendingMove;
-    private drawingOpts;
     private calcs;
     private zClipCircle;
     private yClipCircle;
@@ -44,6 +29,4 @@ export declare class SmithCursor {
     hide(): void;
     private cancelPendingMove;
     setMoveHandler(handler: ((rc: Complex) => void) | null): void;
-    setDrawOptions(opts: DrawOptions): void;
 }
-export {};

package/dist/lib/{draw → interaction}/SmithCursor.js

@@ -1,18 +1,13 @@
-import { SmithGroup } from './SmithGroup.js';
-import { SmithCircle } from './SmithCircle.js';
-import { SmithLine } from './SmithLine.js';
-import { SmithArc } from './SmithArc.js';
-import { SmithConstantCircle } from '../SmithConstantCircle.js';
-import { Complex } from '../complex/Complex.js';
+import { SmithGroup } from '../svg/SmithGroup.js';
+import { SmithCircle } from '../svg/SmithCircle.js';
+import { SmithLine } from '../svg/SmithLine.js';
+import { SmithArc } from '../svg/SmithArc.js';
+import { SmithConstantCircle } from '../rf/SmithConstantCircle.js';
+import { Complex } from '../math/Complex.js';
 export class SmithCursor {
     scaler;
     epsilon = 1.5e-4;
     pendingMove;
-    drawingOpts = {
-        point: { radius: 5, color: 'red' },
-        impedance: { width: 1, color: 'red' },
-        admittance: { width: 1, color: 'green' },
-    };
     calcs = new SmithConstantCircle();
     zClipCircle = this.calcs.resistanceCircle(0);
     yClipCircle = this.calcs.conductanceCircle(0);
@@ -27,8 +22,8 @@ export class SmithCursor {
         this.group = new SmithGroup().attr('pointer-events', 'none');
         this.impedance = {
             group: new SmithGroup({
-                stroke: this.drawingOpts.impedance.color,
-                strokeWidth: this.drawingOpts.impedance.width.toString(),
+                stroke: 'var(--smithkit-cursor-impedanceColor)',
+                strokeWidth: 'var(--smithkit-cursor-lineWidth)',
                 fill: 'none',
             }),
             resistance: { circle: new SmithCircle({ p: [0, 0], r: 1 }) },
@@ -42,8 +37,8 @@ export class SmithCursor {
         this.impedance.reactance.line.nonScalingStroke();
         this.admittance = {
             group: new SmithGroup({
-                stroke: this.drawingOpts.admittance.color,
-                strokeWidth: this.drawingOpts.admittance.width.toString(),
+                stroke: 'var(--smithkit-cursor-admittanceColor)',
+                strokeWidth: 'var(--smithkit-cursor-lineWidth)',
                 fill: 'none',
             }),
             conductance: { circle: new SmithCircle({ p: [0, 0], r: 1 }) },
@@ -56,8 +51,8 @@ export class SmithCursor {
         this.admittance.susceptance.arc.nonScalingStroke();
         this.admittance.susceptance.line.nonScalingStroke();
         this.point = new SmithLine([0, 0], [0, 0], {
-            stroke: this.drawingOpts.point.color,
-            strokeWidth: this.drawingOpts.point.radius.toString(),
+            stroke: 'var(--smithkit-cursor-pointColor)',
+            strokeWidth: 'var(--smithkit-cursor-pointSize)',
             fill: 'none',
         });
         this.point.nonScalingStroke();
@@ -180,7 +175,4 @@ export class SmithCursor {
             this.cancelPendingMove();
         }
     }
-    setDrawOptions(opts) {
-        this.drawingOpts = opts;
-    }
 }

package/dist/lib/io/Touchstone.d.ts

@@ -0,0 +1,10 @@
+import type { TraceSamples } from '../samples.js';
+export interface TouchstoneData {
+    samples: TraceSamples;
+    referenceImpedanceOhms: number;
+}
+export declare class Touchstone {
+    private constructor();
+    /** Read one-port Touchstone 1.x data; frequencies in the result are always Hz. */
+    static parse(text: string): TouchstoneData;
+}

package/dist/lib/io/Touchstone.js

@@ -0,0 +1,75 @@
+export class Touchstone {
+    constructor() { }
+    /** Read one-port Touchstone 1.x data; frequencies in the result are always Hz. */
+    static parse(text) {
+        const units = { HZ: 1, KHZ: 1e3, MHZ: 1e6, GHZ: 1e9 };
+        let frequencyScale = 1e9;
+        let format = 'MA';
+        let referenceImpedanceOhms = 50;
+        let optionsSeen = false;
+        const samples = [];
+        for (const [index, raw] of text
+            .replace(/^\uFEFF/, '')
+            .split(/\r?\n/)
+            .entries()) {
+            const line = raw.split('!')[0].trim();
+            if (!line) {
+                continue;
+            }
+            const fail = (message) => {
+                throw new Error(`Line ${index + 1}: ${message}`);
+            };
+            if (line.startsWith('[')) {
+                fail('Only Touchstone 1.x one-port files (.s1p) are supported.');
+            }
+            if (line.startsWith('#')) {
+                if (optionsSeen || samples.length) {
+                    fail('The option line must appear once, before the data.');
+                }
+                optionsSeen = true;
+                const options = line.slice(1).trim().toUpperCase().split(/\s+/).filter(Boolean);
+                if (!options.length) {
+                    continue;
+                }
+                const [unit = 'GHZ', parameter = 'S', representation = 'MA', r = 'R', impedance = '50'] = options;
+                if (!(unit in units) ||
+                    parameter !== 'S' ||
+                    !['RI', 'MA', 'DB'].includes(representation) ||
+                    r !== 'R' ||
+                    options.length > 5) {
+                    fail('Expected: # Hz|kHz|MHz|GHz S RI|MA|DB R impedance.');
+                }
+                frequencyScale = units[unit];
+                format = representation;
+                referenceImpedanceOhms = Number(impedance);
+                if (!Number.isFinite(referenceImpedanceOhms) || referenceImpedanceOhms <= 0) {
+                    fail('Reference impedance must be positive.');
+                }
+                continue;
+            }
+            const fields = line.split(/\s+/).map(Number);
+            if (fields.length !== 3 || !fields.every(Number.isFinite)) {
+                fail('Expected frequency and two finite S11 components.');
+            }
+            const [frequency, a, b] = fields;
+            const frequencyHz = frequency * frequencyScale;
+            if (frequencyHz < 0 || !Number.isFinite(frequencyHz)) {
+                fail('Frequency must be finite and non-negative.');
+            }
+            if (format === 'MA' && a < 0) {
+                fail('Magnitude must be non-negative.');
+            }
+            const magnitude = format === 'DB' ? 10 ** (a / 20) : a;
+            const radians = (b * Math.PI) / 180;
+            const reflectionCoefficient = format === 'RI' ? [a, b] : [magnitude * Math.cos(radians), magnitude * Math.sin(radians)];
+            if (!reflectionCoefficient.every(Number.isFinite)) {
+                fail('S11 is outside the supported numeric range.');
+            }
+            samples.push({ frequencyHz, reflectionCoefficient });
+        }
+        if (!samples.length) {
+            throw new Error('The file contains no S11 samples.');
+        }
+        return { samples, referenceImpedanceOhms };
+    }
+}

package/dist/lib/layers.d.ts

@@ -1,7 +1,4 @@
-import type { ConstCircles } from './draw/ConstCircles.js';
-import type { ConstQCircles } from './draw/ConstQCircles.js';
-import type { ConstSwrCircles } from './draw/ConstSwrCircles.js';
-import type { Complex } from './complex/Complex.js';
+import type { Complex } from './math/Complex.js';
 export interface GridStyle {
     stroke: string;
     /** Non-scaling stroke width in CSS pixels. */
@@ -10,7 +7,7 @@ export interface GridStyle {
     minorWidth: number;
     textColor: string;
     textFontFamily: string;
-    /** Font size in SVG chart units; labels scale with chart geometry. */
+    /** Base font size in chart units; adaptive layout enforces a 9 CSS px minimum in the default view. */
     textFontSize: number;
 }
 export interface CircleStyle {
@@ -18,10 +15,14 @@ export interface CircleStyle {
     /** Non-scaling stroke width in CSS pixels. */
     strokeWidth: number;
 }
+export type GridDetail = 'basic' | 'standard' | 'detailed';
 /** Grid styling uses SVG user units, except non-scaling stroke widths in screen pixels. */
 export interface GridLayer {
     setVisible(visible: boolean): void;
-    setMinorVisible(visible: boolean): void;
+    /** Show or hide labels independently of grid lines. Default: true. */
+    setLabelsVisible(visible: boolean): void;
+    /** Default: detailed. Basic shows only the principal normalized values. */
+    setDetail(detail: GridDetail): void;
     setStyle(style: Partial<GridStyle>): void;
 }
 export interface CircleLayer {
@@ -43,6 +44,3 @@ export interface PeripheralScales {
     /** Pass null to clear the indicators. */
     update(reflectionCoefficient: Complex | null): void;
 }
-/** Keep renderer instances out of the public chart API. */
-export declare function gridLayer(layer: ConstCircles, assertAlive: () => void): GridLayer;
-export declare function circleLayer(layer: ConstQCircles | ConstSwrCircles, minimum: number, assertAlive: () => void): CircleLayer;

package/dist/lib/layers.js

@@ -1,73 +1 @@
-/** Keep renderer instances out of the public chart API. */
-export function gridLayer(layer, assertAlive) {
-    return {
-        setVisible(visible) {
-            assertAlive();
-            layer.visibility(visible);
-        },
-        setMinorVisible(visible) {
-            assertAlive();
-            layer.displayMinor(visible);
-        },
-        setStyle(style) {
-            assertAlive();
-            validateLengths(style, ['majorWidth', 'minorWidth', 'textFontSize']);
-            const properties = {
-                stroke: 'Stroke',
-                majorWidth: 'MajorWidth',
-                minorWidth: 'MinorWidth',
-                textColor: 'TextColor',
-                textFontFamily: 'TextFontFamily',
-                textFontSize: 'TextFontSize',
-            };
-            for (const key of Object.keys(properties)) {
-                const value = style[key];
-                if (value !== undefined) {
-                    layer[properties[key]] = String(value);
-                }
-            }
-        },
-    };
-}
-export function circleLayer(layer, minimum, assertAlive) {
-    const validate = (value) => {
-        if (!Number.isFinite(value) || value < minimum || value <= 0) {
-            throw new RangeError(`Circle value must be finite, positive, and at least ${minimum}.`);
-        }
-    };
-    return {
-        setVisible(visible) {
-            assertAlive();
-            layer.visibility(visible);
-        },
-        setStyle(style) {
-            assertAlive();
-            validateLengths(style, ['strokeWidth']);
-            if (style.stroke !== undefined) {
-                layer.Stroke = style.stroke;
-            }
-            if (style.strokeWidth !== undefined) {
-                layer.StrokeWidth = String(style.strokeWidth);
-            }
-        },
-        addValue(value) {
-            assertAlive();
-            validate(value);
-            layer.append(value);
-        },
-        removeValue(value) {
-            assertAlive();
-            validate(value);
-            layer.remove(value);
-        },
-    };
-}
-function validateLengths(style, keys) {
-    for (const key of keys) {
-        const value = style[key];
-        if (value !== undefined &&
-            (typeof value !== 'number' || !Number.isFinite(value) || value <= 0)) {
-            throw new RangeError(`${String(key)} must be a positive finite number.`);
-        }
-    }
-}
+export {};

package/dist/lib/{complex → math}/Complex.d.ts

@@ -126,5 +126,6 @@ export declare class Complex {
     static equals(z1: Complex, z2: Complex, epsilon?: number): boolean;
     static toPolar(z: Complex): [number, number];
     static toVector(z: Complex): [number, number];
+    /** Format Cartesian components with Number.toFixed(dp), defaulting to three decimal places. */
     static toString(z: Complex, dp?: number): string;
 }

package/dist/lib/{complex → math}/Complex.js

@@ -626,7 +626,7 @@ export class Complex {
     static toVector(z) {
         return [z.re, z.im];
     }
-    // TODO: format
+    /** Format Cartesian components with Number.toFixed(dp), defaulting to three decimal places. */
     static toString(z, dp = 3) {
         const re = z.re.toFixed(dp);
         const im = Math.abs(z.im).toFixed(dp);

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

@@ -0,0 +1,14 @@
+export type Point = [number, number];
+export interface Line {
+    p1: Point;
+    p2: Point;
+}
+export interface Circle {
+    p: Point;
+    r: number;
+}
+export interface Arc {
+    p1: Point;
+    p2: Point;
+    r: number;
+}

package/dist/lib/measurements.d.ts

@@ -1,5 +1,5 @@
-import { Complex } from './complex/Complex.js';
-import type { SmithReading } from './rf.js';
+import { Complex } from './math/Complex.js';
+import type { SmithReading } from './rf/RfCalculations.js';
 export type TraceRenderMode = 'points' | 'line' | 'both';
 export interface TraceStyle {
     mode: TraceRenderMode;
@@ -49,5 +49,3 @@ export interface MarkerComparison {
     /** Shortest signed B − A phase difference in [−180, 180); undefined at Γ = 0. */
     readonly phaseDeltaDegrees: number | undefined;
 }
-/** Compare B against A without a chart or browser. Frequencies must be finite and non-negative. */
-export declare function compareMarkerReadings(a: Pick<MarkerSnapshot, 'frequencyHz' | 'impedanceOhms' | 'reflectionCoefficient'>, b: Pick<MarkerSnapshot, 'frequencyHz' | 'impedanceOhms' | 'reflectionCoefficient'>): MarkerComparison;