smithkit 0.1.1 → 0.3.0

package/dist/lib/measurements.js

@@ -1,19 +1 @@
-/** Compare B against A without a chart or browser. Frequencies must be finite and non-negative. */
-export function compareMarkerReadings(a, b) {
-    if (![a.frequencyHz, b.frequencyHz].every((frequencyHz) => Number.isFinite(frequencyHz) && frequencyHz >= 0)) {
-        throw new RangeError('Marker frequencies must be finite and non-negative.');
-    }
-    const isFinite = (value) => Number.isFinite(value.re) && Number.isFinite(value.im);
-    const hasPhase = (gamma) => isFinite(gamma) && (gamma.re !== 0 || gamma.im !== 0);
-    const phaseDelta = hasPhase(a.reflectionCoefficient) && hasPhase(b.reflectionCoefficient)
-        ? ((b.reflectionCoefficient.arg() - a.reflectionCoefficient.arg()) * 180) / Math.PI
-        : undefined;
-    const impedanceDelta = a.impedanceOhms && b.impedanceOhms && isFinite(a.impedanceOhms) && isFinite(b.impedanceOhms)
-        ? b.impedanceOhms.sub(a.impedanceOhms)
-        : undefined;
-    return {
-        frequencyDeltaHz: b.frequencyHz - a.frequencyHz,
-        impedanceDeltaOhms: impedanceDelta && isFinite(impedanceDelta) ? impedanceDelta : undefined,
-        phaseDeltaDegrees: phaseDelta === undefined ? undefined : ((phaseDelta + 540) % 360) - 180,
-    };
-}
+export {};

package/dist/lib/rendering/SvgChartRenderer.d.ts

@@ -0,0 +1,66 @@
+import type { SmithTheme } from '../appearance/types.js';
+import { SmithData } from '../traces/SmithData.js';
+import type { SmithMarker } from '../traces/SmithMarker.js';
+import { TraceSamples } from '../samples.js';
+import { Complex } from '../math/Complex.js';
+import type { ChartLayers, PeripheralScales } from '../layers.js';
+import type { TraceStyle } from '../measurements.js';
+/** Internal SVG backend. Owns chart elements, view transforms, and SVG gestures. */
+export declare class SvgChartRenderer {
+    private onCursorChange;
+    private calcs;
+    private scalers;
+    private readonly defaultTransform;
+    private transform;
+    private zoomEnabled;
+    private applyingView;
+    private zoomBehavior;
+    private svg;
+    private resizeObserver;
+    private readonly labelLayout;
+    private container;
+    private dataContainer;
+    private markerContainer;
+    private reactanceAxis;
+    private constResistance;
+    private constReactance;
+    private constConductance;
+    private constSusceptance;
+    private constSwrCircles;
+    private constQCircles;
+    private cursor;
+    private peripheralScaleRenderer;
+    private readonly traces;
+    private destroyed;
+    private mouseGesture;
+    private markerDragging;
+    private cursorBeforeMarkerDrag;
+    readonly layers: ChartLayers;
+    readonly peripheralScales: PeripheralScales;
+    constructor(onCursorChange: ((position: Complex | undefined) => void) | null);
+    setTheme(theme: SmithTheme): void;
+    draw(target: string | HTMLElement): void;
+    /** Export the current mounted view as standalone SVG with its configured background. */
+    toSvg(): string;
+    /** Remove this chart and release its event handlers. Safe to call more than once. */
+    destroy(): void;
+    private updateViewportScale;
+    private assertAlive;
+    private createScalers;
+    private cursorMove;
+    setMarkerDragging(dragging: boolean): void;
+    hideCursor(): void;
+    private initCursor;
+    get cursorPosition(): Complex;
+    private initializeZoom;
+    /** Enable or disable wheel, double-click, and mouse/touch zoom/pan. Keeps the current view. */
+    setZoomEnabled(enabled: boolean): void;
+    private applyView;
+    resetView(): void;
+    private onZoom;
+    private cursorContainer;
+    private drawReactanceAxis;
+    /** Construct trace rendering without exposing chart containers or scalers to Smith. */
+    createTrace(values: TraceSamples, color: string, style: Partial<TraceStyle>, onMarkerDrag: (marker: SmithMarker, dragging: boolean) => void): SmithData;
+    removeTrace(trace: SmithData): void;
+}

package/dist/lib/rendering/SvgChartRenderer.js

@@ -0,0 +1,342 @@
+import { SvgTheme } from '../appearance/SvgTheme.js';
+import * as d3 from 'd3';
+import { MouseGesture } from '../interaction/MouseGesture.js';
+import { SmithSvg } from '../svg/SmithSvg.js';
+import { LabelLayout } from '../svg/LabelLayout.js';
+import { SvgExporter } from '../svg/SvgExporter.js';
+import { SmithGroup } from '../svg/SmithGroup.js';
+import { SmithCircle } from '../svg/SmithCircle.js';
+import { SmithData } from '../traces/SmithData.js';
+import { SmithCursor } from '../interaction/SmithCursor.js';
+import { ConstResistance } from '../grid/ConstResistance.js';
+import { ConstReactance } from '../grid/ConstReactance.js';
+import { ConstConductance } from '../grid/ConstConductance.js';
+import { ConstSusceptance } from '../grid/ConstSusceptance.js';
+import { ConstQCircles } from '../grid/ConstQCircles.js';
+import { ConstSwrCircles } from '../grid/ConstSwrCircles.js';
+import { SmithScaler } from '../svg/SmithScaler.js';
+import { SmithConstantCircle } from '../rf/SmithConstantCircle.js';
+import { GridDefinitions } from '../grid/GridDefinitions.js';
+import { Complex } from '../math/Complex.js';
+import { SmithPeripheralScales } from '../scales/SmithPeripheralScales.js';
+import { GridLayerControl } from '../grid/GridLayerControl.js';
+import { CircleLayerControl } from '../grid/CircleLayerControl.js';
+/** Internal SVG backend. Owns chart elements, view transforms, and SVG gestures. */
+export class SvgChartRenderer {
+    onCursorChange;
+    calcs = new SmithConstantCircle();
+    scalers;
+    defaultTransform = d3.zoomIdentity.translate(62.5, 62.5).scale(0.75);
+    transform = d3.zoomIdentity;
+    zoomEnabled = true;
+    applyingView = false;
+    zoomBehavior = d3.zoom();
+    svg;
+    resizeObserver;
+    labelLayout;
+    container;
+    dataContainer;
+    markerContainer;
+    reactanceAxis;
+    constResistance;
+    constReactance;
+    constConductance;
+    constSusceptance;
+    constSwrCircles;
+    constQCircles;
+    cursor;
+    peripheralScaleRenderer = new SmithPeripheralScales();
+    traces = new Set();
+    destroyed = false;
+    mouseGesture = new MouseGesture();
+    markerDragging = false;
+    cursorBeforeMarkerDrag = null;
+    layers;
+    peripheralScales;
+    constructor(onCursorChange) {
+        this.onCursorChange = onCursorChange;
+        const viewBoxSize = 500;
+        const gridData = GridDefinitions.create();
+        this.scalers = this.createScalers(viewBoxSize);
+        this.svg = new SmithSvg(viewBoxSize);
+        this.container = new SmithGroup();
+        this.constResistance = new ConstResistance({
+            data: gridData,
+            scaler: this.scalers.default,
+            detail: 'detailed',
+        });
+        this.constResistance.show();
+        this.constReactance = new ConstReactance({
+            data: gridData,
+            scaler: this.scalers.default,
+            detail: 'detailed',
+        });
+        this.constReactance.show();
+        this.constConductance = new ConstConductance({
+            data: gridData,
+            scaler: this.scalers.default,
+            detail: 'detailed',
+        });
+        this.constConductance.hide();
+        this.constSusceptance = new ConstSusceptance({
+            data: gridData,
+            scaler: this.scalers.default,
+            detail: 'detailed',
+        });
+        this.constSusceptance.hide();
+        this.constQCircles = new ConstQCircles(this.scalers.default);
+        this.constQCircles.hide();
+        this.constSwrCircles = new ConstSwrCircles(this.scalers.default);
+        this.constSwrCircles.hide();
+        this.cursor = this.initCursor();
+        const cursorContainer = this.cursorContainer();
+        this.reactanceAxis = this.drawReactanceAxis({
+            stroke: 'var(--smithkit-boundary-stroke)',
+            strokeWidth: 'var(--smithkit-boundary-width)',
+            fill: 'none',
+        });
+        this.dataContainer = new SmithGroup().attr('data-layer', 'samples');
+        this.markerContainer = new SmithGroup().attr('data-layer', 'markers');
+        // build chart
+        this.svg.append(this.container);
+        this.container.append(this.constConductance.draw().attr('data-layer', 'conductance'));
+        this.container.append(this.constSusceptance.draw().attr('data-layer', 'susceptance'));
+        this.container.append(this.constResistance.draw().attr('data-layer', 'resistance'));
+        this.container.append(this.constReactance.draw().attr('data-layer', 'reactance'));
+        this.container.append(this.constQCircles.draw());
+        this.container.append(this.constSwrCircles.draw());
+        this.container.append(this.peripheralScaleRenderer);
+        this.container.append(this.cursor.Group);
+        this.container.append(this.reactanceAxis);
+        this.container.append(cursorContainer);
+        this.container.append(this.dataContainer);
+        const labels = new SmithGroup().attr('data-layer', 'labels').attr('pointer-events', 'none');
+        for (const [name, layer] of [
+            ['conductance', this.constConductance],
+            ['susceptance', this.constSusceptance],
+            ['resistance', this.constResistance],
+            ['reactance', this.constReactance],
+        ]) {
+            labels.append(layer.labels.attr('data-label-layer', name));
+        }
+        labels.append(this.peripheralScaleRenderer.labels);
+        this.container.append(labels);
+        this.container.append(this.markerContainer);
+        this.labelLayout = new LabelLayout(this.svg.Node, labels.Node, this.defaultTransform);
+        const assertAlive = () => this.assertAlive();
+        this.layers = {
+            resistance: new GridLayerControl(this.constResistance, assertAlive, () => this.labelLayout.update(true)),
+            reactance: new GridLayerControl(this.constReactance, assertAlive, () => this.labelLayout.update(true)),
+            conductance: new GridLayerControl(this.constConductance, assertAlive, () => this.labelLayout.update(true)),
+            susceptance: new GridLayerControl(this.constSusceptance, assertAlive, () => this.labelLayout.update(true)),
+            q: new CircleLayerControl(this.constQCircles, 0, assertAlive),
+            vswr: new CircleLayerControl(this.constSwrCircles, 1, assertAlive),
+        };
+        this.peripheralScales = {
+            setVisible: (visible) => {
+                assertAlive();
+                if (visible) {
+                    this.peripheralScaleRenderer.show();
+                }
+                else {
+                    this.peripheralScaleRenderer.hide();
+                }
+                this.labelLayout.update(true);
+            },
+            update: (gamma) => {
+                assertAlive();
+                this.peripheralScaleRenderer.update(gamma);
+            },
+        };
+        this.initializeZoom();
+        this.resizeObserver = new ResizeObserver(() => this.updateViewportScale());
+        this.resizeObserver.observe(this.svg.Node);
+    }
+    setTheme(theme) {
+        this.assertAlive();
+        SvgTheme.apply(this.svg.Node, theme);
+        this.labelLayout.update(true);
+    }
+    draw(target) {
+        this.assertAlive();
+        const host = typeof target === 'string' ? document.querySelector(target) : target;
+        if (!host) {
+            throw new Error('Chart container was not found.');
+        }
+        host.appendChild(this.svg.Node);
+        this.updateViewportScale();
+    }
+    /** Export the current mounted view as standalone SVG with its configured background. */
+    toSvg() {
+        this.assertAlive();
+        return SvgExporter.chart(this.svg.Node);
+    }
+    /** Remove this chart and release its event handlers. Safe to call more than once. */
+    destroy() {
+        if (this.destroyed) {
+            return;
+        }
+        this.resizeObserver.disconnect();
+        this.traces.forEach((trace) => trace.destroy());
+        this.traces.clear();
+        this.destroyed = true;
+        this.cursor.setMoveHandler(null);
+        this.onCursorChange = null;
+        this.mouseGesture.destroy();
+        this.zoomBehavior.on('start', null).on('zoom', null);
+        this.svg.Element.interrupt().on('.zoom', null);
+        this.svg.Element.selectAll('*').interrupt().on('.smithkit', null).on('.drag', null);
+        this.svg.Element.remove();
+    }
+    updateViewportScale() {
+        if (this.destroyed) {
+            return;
+        }
+        const matrix = this.svg.Node.getScreenCTM();
+        if (matrix) {
+            const scale = Math.hypot(matrix.a, matrix.b);
+            this.traces.forEach((trace) => trace.setViewportScale(scale));
+        }
+        this.labelLayout.update();
+    }
+    assertAlive() {
+        if (this.destroyed) {
+            throw new Error('This Smith chart has been destroyed. Create a new instance.');
+        }
+    }
+    createScalers(size) {
+        const impedance = new SmithScaler(d3.scaleLinear().domain([-1, 1]).range([0, size]), d3.scaleLinear().domain([1, -1]).range([0, size]), d3
+            .scaleLinear()
+            .domain([0, 1])
+            .range([0, size / 2]));
+        const admittance = new SmithScaler(d3.scaleLinear().domain([1, -1]).range([0, size]), d3.scaleLinear().domain([-1, 1]).range([0, size]), d3
+            .scaleLinear()
+            .domain([0, 1])
+            .range([0, size / 2]));
+        return { default: impedance, impedance, admittance };
+    }
+    cursorMove(p) {
+        if (this.markerDragging) {
+            return;
+        }
+        this.cursor.Position = Complex.from(this.scalers.default.pointInvert(p));
+    }
+    setMarkerDragging(dragging) {
+        this.markerDragging = dragging;
+        if (dragging) {
+            this.cursorBeforeMarkerDrag = this.svg.Node.style.getPropertyValue('cursor') || null;
+            this.svg.Element.style('cursor', 'grabbing').style('--smithkit-marker-cursor', 'grabbing');
+            this.cursor.hide();
+        }
+        else {
+            this.svg.Element.style('cursor', () => this.cursorBeforeMarkerDrag).style('--smithkit-marker-cursor', null);
+            this.cursorBeforeMarkerDrag = null;
+        }
+    }
+    hideCursor() {
+        this.cursor.hide();
+    }
+    initCursor() {
+        const cursor = new SmithCursor(this.scalers.default);
+        cursor.Group.attr('class', 'smith-cursor');
+        cursor.setMoveHandler(() => {
+            this.onCursorChange?.(this.cursor.Position);
+        });
+        return cursor;
+    }
+    get cursorPosition() {
+        return this.cursor.Position;
+    }
+    initializeZoom() {
+        const zoom = this.zoomBehavior
+            .scaleExtent([0.6, 1000])
+            .filter((event) => this.zoomEnabled &&
+            !this.markerDragging &&
+            (!event.ctrlKey || event.type === 'wheel') &&
+            !event.button)
+            .on('start', (event) => {
+            if (event.sourceEvent) {
+                this.mouseGesture.capture(event.sourceEvent, 'zoom');
+            }
+        })
+            .on('zoom', (event) => {
+            if ((!this.zoomEnabled || this.markerDragging) && !this.applyingView) {
+                // An already active mouse/touch gesture still needs its normal end event.
+                // Restore D3's view through its public API while that gesture finishes.
+                this.applyView(this.transform);
+                return;
+            }
+            this.onZoom(event.transform);
+        });
+        this.svg.Element.call(zoom);
+        this.resetView();
+    }
+    /** Enable or disable wheel, double-click, and mouse/touch zoom/pan. Keeps the current view. */
+    setZoomEnabled(enabled) {
+        this.assertAlive();
+        if (typeof enabled !== 'boolean') {
+            throw new TypeError('Zoom enabled must be a boolean.');
+        }
+        if (this.zoomEnabled === enabled) {
+            return;
+        }
+        this.zoomEnabled = enabled;
+        if (!enabled) {
+            this.svg.Element.interrupt();
+        }
+    }
+    applyView(transform) {
+        this.applyingView = true;
+        try {
+            this.svg.Element.call(this.zoomBehavior.transform, transform);
+        }
+        finally {
+            this.applyingView = false;
+        }
+    }
+    resetView() {
+        this.assertAlive();
+        const transform = this.defaultTransform;
+        this.applyView(transform);
+    }
+    onZoom(transform) {
+        if (this.destroyed) {
+            return;
+        }
+        this.transform = transform;
+        this.container.Element.attr('transform', transform.toString());
+        this.traces.forEach((d) => d.zoom(transform));
+    }
+    cursorContainer() {
+        const shape = this.drawReactanceAxis({ fill: 'transparent', stroke: 'none' });
+        shape.Element.style('pointer-events', 'all')
+            .on('pointermove.smithkit', (event) => {
+            this.cursorMove(d3.pointer(event));
+        })
+            .on('pointerleave.smithkit', () => {
+            this.cursor.hide();
+            this.onCursorChange?.(undefined);
+        });
+        return shape;
+    }
+    drawReactanceAxis(opts) {
+        const c = this.calcs.resistanceCircle(0);
+        c.p[0] = this.scalers.default.x(c.p[0]);
+        c.p[1] = this.scalers.default.y(c.p[1]);
+        c.r = this.scalers.default.r(c.r);
+        return new SmithCircle(c, opts);
+    }
+    /** Construct trace rendering without exposing chart containers or scalers to Smith. */
+    createTrace(values, color, style, onMarkerDrag) {
+        this.assertAlive();
+        const trace = new SmithData(values, color, this.transform, this.dataContainer, this.scalers.default, onMarkerDrag, this.markerContainer, style);
+        this.traces.add(trace);
+        this.updateViewportScale();
+        return trace;
+    }
+    removeTrace(trace) {
+        // Release gestures while Smith can still resolve the marker's public snapshot.
+        trace.destroy();
+        this.traces.delete(trace);
+    }
+}

package/dist/lib/rf/RfCalculations.d.ts

@@ -0,0 +1,65 @@
+import type { TraceSamples } from '../samples.js';
+import { Complex } from '../math/Complex.js';
+/** Physical quantities derived from a voltage reflection coefficient Γ. */
+export interface SmithReading {
+    readonly reflectionCoefficient: Complex;
+    readonly impedanceOhms: Complex | undefined;
+    readonly admittanceSiemens: Complex | undefined;
+    readonly phaseDegrees: number | undefined;
+    readonly vswr: number | undefined;
+    readonly standingWaveRatioDb: number | undefined;
+    readonly returnLossDb: number;
+    readonly reflectionLossDb: number | undefined;
+    readonly attenuationDb: number | undefined;
+    readonly q: number | undefined;
+    readonly powerReflectionCoefficient: number;
+    readonly voltageReflectionCoefficientMagnitude: number;
+    readonly powerTransmissionCoefficient: number | undefined;
+    readonly voltageTransmissionCoefficientMagnitude: number;
+    readonly currentTransmissionCoefficientMagnitude: number;
+    readonly standingWavePeak: number | undefined;
+    readonly standingWaveLossCoefficient: number | undefined;
+}
+/** An ideal series component equivalent to a reactance at one frequency. */
+export type ReactiveComponent = {
+    readonly kind: 'inductor';
+    readonly inductanceHenries: number;
+} | {
+    readonly kind: 'capacitor';
+    readonly capacitanceFarads: number;
+};
+export declare class RfCalculations {
+    private constructor();
+    private static readonly calcs;
+    private static validateReference;
+    private static validateComplex;
+    private static finite;
+    /** Convert Γ to physical impedance in ohms; undefined at the open circuit Γ = 1. */
+    static reflectionToImpedance(gamma: Complex, referenceImpedanceOhms?: number): Complex | undefined;
+    /** Convert physical impedance in ohms to Γ. Undefined for a singular result. */
+    static impedanceToReflection(impedanceOhms: Complex, referenceImpedanceOhms?: number): Complex | undefined;
+    /** Convert Γ to physical admittance in siemens; undefined at the short circuit Γ = −1. */
+    static reflectionToAdmittance(gamma: Complex, referenceImpedanceOhms?: number): Complex | undefined;
+    /** Convert physical admittance in siemens to Γ. Undefined for a singular result. */
+    static admittanceToReflection(admittanceSiemens: Complex, referenceImpedanceOhms?: number): Complex | undefined;
+    /**
+     * Read Γ without a chart or DOM. Undefined means a singular or inapplicable quantity.
+     * Passive-load quantities are undefined outside |Γ| ≤ 1; exact infinite limits are retained.
+     * Attenuation assumes a fully reflecting termination and is half the return loss.
+     */
+    static readReflection(gamma: Complex, referenceImpedanceOhms?: number): SmithReading;
+    /**
+     * Change the positive real reference impedance of a voltage reflection coefficient.
+     * Preserves physical impedance, including exact open/short limits. A singular or
+     * unrepresentable result is undefined; non-finite inputs throw RangeError.
+     */
+    static renormalizeReflection(gamma: Complex, fromOhms: number, toOhms: number): Complex | undefined;
+    /** Copy and renormalize every sample; reject invalid/singular data without modifying the input. */
+    static renormalizeSamples(samples: TraceSamples, fromOhms: number, toOhms: number): TraceSamples;
+    /**
+     * Convert reactance in ohms at a frequency in Hz to an ideal series L or C.
+     * Zero frequency, zero reactance, or an unrepresentable component returns undefined.
+     * Non-finite reactance and negative/non-finite frequency throw RangeError.
+     */
+    static reactanceToComponent(reactanceOhms: number, frequencyHz: number): ReactiveComponent | undefined;
+}

package/dist/lib/rf/RfCalculations.js

@@ -0,0 +1,161 @@
+import { Complex } from '../math/Complex.js';
+import { SmithConstantCircle } from './SmithConstantCircle.js';
+export class RfCalculations {
+    constructor() { }
+    static calcs = new SmithConstantCircle();
+    static validateReference(referenceImpedanceOhms) {
+        if (!Number.isFinite(referenceImpedanceOhms) || referenceImpedanceOhms <= 0) {
+            throw new RangeError('Reference impedance must be positive and finite.');
+        }
+    }
+    static validateComplex(value) {
+        if (!Number.isFinite(value.re) || !Number.isFinite(value.im)) {
+            throw new RangeError('Complex components must be finite.');
+        }
+    }
+    static finite(value) {
+        return value && Number.isFinite(value.re) && Number.isFinite(value.im) ? value : undefined;
+    }
+    /** Convert Γ to physical impedance in ohms; undefined at the open circuit Γ = 1. */
+    static reflectionToImpedance(gamma, referenceImpedanceOhms = 50) {
+        RfCalculations.validateReference(referenceImpedanceOhms);
+        RfCalculations.validateComplex(gamma);
+        return RfCalculations.finite(RfCalculations.calcs.rflCoeffToImpedance(gamma)?.mul(referenceImpedanceOhms));
+    }
+    /** Convert physical impedance in ohms to Γ. Undefined for a singular result. */
+    static impedanceToReflection(impedanceOhms, referenceImpedanceOhms = 50) {
+        RfCalculations.validateReference(referenceImpedanceOhms);
+        RfCalculations.validateComplex(impedanceOhms);
+        return RfCalculations.finite(RfCalculations.calcs.impedanceToRflCoeff(impedanceOhms.div(referenceImpedanceOhms)));
+    }
+    /** Convert Γ to physical admittance in siemens; undefined at the short circuit Γ = −1. */
+    static reflectionToAdmittance(gamma, referenceImpedanceOhms = 50) {
+        RfCalculations.validateReference(referenceImpedanceOhms);
+        RfCalculations.validateComplex(gamma);
+        return RfCalculations.finite(RfCalculations.calcs.rflCoeffToAdmittance(gamma)?.div(referenceImpedanceOhms));
+    }
+    /** Convert physical admittance in siemens to Γ. Undefined for a singular result. */
+    static admittanceToReflection(admittanceSiemens, referenceImpedanceOhms = 50) {
+        RfCalculations.validateReference(referenceImpedanceOhms);
+        RfCalculations.validateComplex(admittanceSiemens);
+        return RfCalculations.finite(RfCalculations.calcs.admittanceToRflCoeff(admittanceSiemens.mul(referenceImpedanceOhms)));
+    }
+    /**
+     * Read Γ without a chart or DOM. Undefined means a singular or inapplicable quantity.
+     * Passive-load quantities are undefined outside |Γ| ≤ 1; exact infinite limits are retained.
+     * Attenuation assumes a fully reflecting termination and is half the return loss.
+     */
+    static readReflection(gamma, referenceImpedanceOhms = 50) {
+        const impedanceOhms = RfCalculations.reflectionToImpedance(gamma, referenceImpedanceOhms);
+        const admittanceSiemens = RfCalculations.reflectionToAdmittance(gamma, referenceImpedanceOhms);
+        const magnitude = gamma.abs();
+        const passive = magnitude <= 1;
+        const returnLossDb = -20 * Math.log10(magnitude);
+        const vswr = passive ? (1 + magnitude) / (1 - magnitude) : undefined;
+        return {
+            reflectionCoefficient: gamma,
+            impedanceOhms,
+            admittanceSiemens,
+            phaseDegrees: magnitude === 0 ? undefined : (gamma.arg() * 180) / Math.PI,
+            vswr,
+            standingWaveRatioDb: vswr === undefined ? undefined : 20 * Math.log10(vswr),
+            returnLossDb,
+            reflectionLossDb: passive ? (-10 / Math.LN10) * Math.log1p(-(magnitude ** 2)) : undefined,
+            attenuationDb: passive ? returnLossDb / 2 : undefined,
+            q: impedanceOhms && (impedanceOhms.re !== 0 || impedanceOhms.im !== 0)
+                ? Math.abs(impedanceOhms.im / impedanceOhms.re)
+                : undefined,
+            powerReflectionCoefficient: magnitude ** 2,
+            voltageReflectionCoefficientMagnitude: magnitude,
+            powerTransmissionCoefficient: passive ? 1 - magnitude ** 2 : undefined,
+            voltageTransmissionCoefficientMagnitude: gamma.add(1).abs(),
+            currentTransmissionCoefficientMagnitude: Complex.one().sub(gamma).abs(),
+            standingWavePeak: vswr === undefined ? undefined : Math.sqrt(vswr),
+            standingWaveLossCoefficient: passive
+                ? (1 + magnitude ** 2) / (1 - magnitude ** 2)
+                : undefined,
+        };
+    }
+    /**
+     * Change the positive real reference impedance of a voltage reflection coefficient.
+     * Preserves physical impedance, including exact open/short limits. A singular or
+     * unrepresentable result is undefined; non-finite inputs throw RangeError.
+     */
+    static renormalizeReflection(gamma, fromOhms, toOhms) {
+        RfCalculations.validateReference(fromOhms);
+        RfCalculations.validateReference(toOhms);
+        if (!Number.isFinite(gamma.re) || !Number.isFinite(gamma.im)) {
+            throw new RangeError('Reflection coefficient components must be finite.');
+        }
+        if (fromOhms === toOhms || (gamma.im === 0 && Math.abs(gamma.re) === 1)) {
+            return gamma;
+        }
+        // Γnew = (Γold + k) / (1 + k Γold). Scale references before summing.
+        const referenceScale = Math.max(fromOhms, toOhms);
+        const from = fromOhms / referenceScale;
+        const to = toOhms / referenceScale;
+        const k = (fromOhms - toOhms) / referenceScale / (from + to);
+        const scale = Math.max(1, Math.abs(gamma.re), Math.abs(gamma.im));
+        const x = gamma.re / scale;
+        const y = gamma.im / scale;
+        const inverseScale = 1 / scale;
+        const nr = x + k * inverseScale;
+        const dr = inverseScale + k * x;
+        const di = k * y;
+        const denominatorScale = Math.max(Math.abs(dr), Math.abs(di));
+        if (denominatorScale === 0) {
+            return;
+        }
+        const real = dr / denominatorScale;
+        const imaginary = di / denominatorScale;
+        const denominator = real ** 2 + imaginary ** 2;
+        const re = ((nr / denominatorScale) * real + (y / denominatorScale) * imaginary) / denominator;
+        // Analytic imaginary numerator avoids cancellation for very large finite Γ.
+        const im = (((1 - k) * (1 + k) * (y / denominatorScale)) / denominator) *
+            (inverseScale / denominatorScale);
+        return Number.isFinite(re) && Number.isFinite(im) ? Complex.from(re, im) : undefined;
+    }
+    /** Copy and renormalize every sample; reject invalid/singular data without modifying the input. */
+    static renormalizeSamples(samples, fromOhms, toOhms) {
+        RfCalculations.validateReference(fromOhms);
+        RfCalculations.validateReference(toOhms);
+        return samples.map((sample, index) => {
+            if (!Number.isFinite(sample.frequencyHz) ||
+                sample.frequencyHz < 0 ||
+                sample.reflectionCoefficient.length !== 2) {
+                throw new RangeError(`Invalid sample at index ${index}.`);
+            }
+            const gamma = RfCalculations.renormalizeReflection(Complex.from(...sample.reflectionCoefficient), fromOhms, toOhms);
+            if (!gamma) {
+                throw new RangeError(`Renormalization is singular or outside the numeric range at sample ${index}.`);
+            }
+            return { frequencyHz: sample.frequencyHz, reflectionCoefficient: gamma.toVector() };
+        });
+    }
+    /**
+     * Convert reactance in ohms at a frequency in Hz to an ideal series L or C.
+     * Zero frequency, zero reactance, or an unrepresentable component returns undefined.
+     * Non-finite reactance and negative/non-finite frequency throw RangeError.
+     */
+    static reactanceToComponent(reactanceOhms, frequencyHz) {
+        if (!Number.isFinite(reactanceOhms)) {
+            throw new RangeError('Reactance must be finite.');
+        }
+        if (!Number.isFinite(frequencyHz) || frequencyHz < 0) {
+            throw new RangeError('Frequency must be finite and non-negative.');
+        }
+        if (frequencyHz === 0 || reactanceOhms === 0) {
+            return;
+        }
+        // Compute in log space so intermediate products/quotients cannot overflow.
+        const logReactance = Math.log(Math.abs(reactanceOhms));
+        const logAngularFrequency = Math.log(2 * Math.PI) + Math.log(frequencyHz);
+        const value = Math.exp((reactanceOhms > 0 ? logReactance : -logReactance) - logAngularFrequency);
+        if (!Number.isFinite(value) || value === 0) {
+            return;
+        }
+        return reactanceOhms > 0
+            ? { kind: 'inductor', inductanceHenries: value }
+            : { kind: 'capacitor', capacitanceFarads: value };
+    }
+}

package/dist/lib/{SmithConstantCircle.d.ts → rf/SmithConstantCircle.d.ts}

@@ -1,6 +1,5 @@
-import { Circle } from './shapes/Circle.js';
-import { Point } from './shapes/Point.js';
-import { Complex } from './complex/Complex.js';
+import type { Circle, Point } from '../math/geometry.js';
+import { Complex } from '../math/Complex.js';
 export declare class SmithConstantCircle {
     Z0: number;
     constructor(Z0?: number);