smithkit 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,20 @@
+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;
+};

package/dist/lib/grid/geometry.js

@@ -0,0 +1,55 @@
+import { SmithConstantCircle } from '../SmithConstantCircle.js';
+import { Complex } from '../complex/Complex.js';
+const calcs = new SmithConstantCircle();
+const circles = {
+    resistance: (value) => calcs.resistanceCircle(value),
+    reactance: (value) => calcs.reactanceCircle(value),
+    conductance: (value) => calcs.conductanceCircle(value),
+    susceptance: (value) => calcs.susceptanceCircle(value),
+};
+const clipping = {
+    resistance: 'reactance',
+    reactance: 'resistance',
+    conductance: 'susceptance',
+    susceptance: 'conductance',
+};
+/** Normalized geometry only: no DOM, D3, or pixel coordinates. */
+export function gridGeometry(kind, data) {
+    const circle = circles[kind];
+    const clip = circles[clipping[kind]];
+    return {
+        lines: data.lines,
+        circles: data.circles.map(circle),
+        arcs: data.arcs.map(([value, limits, options]) => {
+            const c = circle(value);
+            const [a, b] = limits.map(([limit, index]) => calcs.circleCircleIntersection(c, clip(limit))[index]);
+            return [a, b, c.r, options[0], options[1]];
+        }),
+    };
+}
+export function gridLabel(kind, definition) {
+    const { point, transform, dp, textAnchor, dominantBaseline } = definition;
+    const admittance = kind === 'conductance' || kind === 'susceptance';
+    const real = kind === 'resistance' || kind === 'conductance';
+    const rc = admittance
+        ? calcs.admittanceToRflCoeff(Complex.from(point.r, point.i))
+        : calcs.impedanceToRflCoeff(Complex.from(point.r, point.i));
+    if (!rc) {
+        throw new Error('Invalid grid label coordinates.');
+    }
+    const value = real ? point.r : point.i;
+    const circle = circles[kind](value);
+    let rotate = -calcs.tangentToCircleAngle(circle, rc.toVector()) + transform.rotate;
+    if (admittance && rotate !== 90) {
+        rotate += 180;
+    }
+    return {
+        point: rc.toVector(),
+        text: value.toFixed(dp),
+        rotate,
+        dx: transform.dx,
+        dy: transform.dy,
+        textAnchor,
+        dominantBaseline,
+    };
+}

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

@@ -0,0 +1,3 @@
+import { Tick } from '../arcs/Tick.js';
+export declare function resistanceLabels(): Tick[];
+export declare function reactanceLabels(): Tick[];

package/dist/lib/grid/labels.js

@@ -0,0 +1,41 @@
+import { Tick } from '../arcs/Tick.js';
+const 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,
+];
+const interiorValues = [0.2, 0.4, 0.6, 0.8, 1];
+export function resistanceLabels() {
+    const axis = [0, ...values].map((r) => new Tick({
+        point: { r, i: 0 },
+        dp: r === 0 || r >= 10 ? 0 : 1,
+        transform: { dx: 0.005, dy: r === 0 ? 0.005 : -0.005 },
+        dominantBaseline: r === 0 ? 'hanging' : 'baseline',
+    }));
+    const interior = [1, -1].flatMap((i) => [...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];
+}
+export function reactanceLabels() {
+    return [1, -1].flatMap((sign) => [
+        ...interiorValues.map((i) => ({ r: 1, i: sign * i })),
+        ...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/types.d.ts

@@ -0,0 +1,30 @@
+import type { Line } from '../shapes/Line.js';
+export declare enum SmithArcEntry {
+    circle = 0,
+    clipCircles = 1,
+    arcOptions = 2
+}
+export type SmithArcDef = [number, [number, number][], [boolean, boolean]];
+export type SmithTickDef = [
+    number,
+    number,
+    {
+        dx?: string;
+        dy?: string;
+    }
+];
+export interface SmithTicksShapes {
+    lines: Line[];
+    circles: number[];
+    arcs: SmithArcDef[];
+}
+export interface SmithTicksData {
+    resistance: {
+        major: SmithTicksShapes;
+        minor: SmithTicksShapes;
+    };
+    reactance: {
+        major: SmithTicksShapes;
+        minor: SmithTicksShapes;
+    };
+}

package/dist/lib/grid/types.js

@@ -0,0 +1,6 @@
+export var SmithArcEntry;
+(function (SmithArcEntry) {
+    SmithArcEntry[SmithArcEntry["circle"] = 0] = "circle";
+    SmithArcEntry[SmithArcEntry["clipCircles"] = 1] = "clipCircles";
+    SmithArcEntry[SmithArcEntry["arcOptions"] = 2] = "arcOptions";
+})(SmithArcEntry || (SmithArcEntry = {}));

package/dist/lib/index.d.ts

@@ -0,0 +1,16 @@
+export { Smith, SmithEventType } from './Smith.js';
+export type { SmithEvent } from './Smith.js';
+export { Complex } from './complex/Complex.js';
+export type { TraceSamples, TraceSample } from './samples.js';
+export { parseTouchstone } from './io/touchstone.js';
+export type { TouchstoneData } from './io/touchstone.js';
+export { SmithScales } from './scales/SmithScales.js';
+export { compareMarkerReadings } from './measurements.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';

package/dist/lib/index.js

@@ -0,0 +1,9 @@
+export { Smith, SmithEventType } from './Smith.js';
+export { Complex } from './complex/Complex.js';
+export { parseTouchstone } 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';

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

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

package/dist/lib/io/touchstone.js

@@ -0,0 +1,72 @@
+/** Read one-port Touchstone 1.x data; frequencies in the result are always Hz. */
+export function parseTouchstone(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

@@ -0,0 +1,48 @@
+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';
+export interface GridStyle {
+    stroke: string;
+    /** Non-scaling stroke width in CSS pixels. */
+    majorWidth: number;
+    /** Non-scaling stroke width in CSS pixels. */
+    minorWidth: number;
+    textColor: string;
+    textFontFamily: string;
+    /** Font size in SVG chart units; labels scale with chart geometry. */
+    textFontSize: number;
+}
+export interface CircleStyle {
+    stroke: string;
+    /** Non-scaling stroke width in CSS pixels. */
+    strokeWidth: number;
+}
+/** 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;
+    setStyle(style: Partial<GridStyle>): void;
+}
+export interface CircleLayer {
+    setVisible(visible: boolean): void;
+    setStyle(style: Partial<CircleStyle>): void;
+    addValue(value: number): void;
+    removeValue(value: number): void;
+}
+export interface ChartLayers {
+    readonly resistance: GridLayer;
+    readonly reactance: GridLayer;
+    readonly conductance: GridLayer;
+    readonly susceptance: GridLayer;
+    readonly q: CircleLayer;
+    readonly vswr: CircleLayer;
+}
+export interface PeripheralScales {
+    setVisible(visible: boolean): void;
+    /** 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

@@ -0,0 +1,73 @@
+/** 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.`);
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+import { Complex } from '../complex/Complex.js';
+/** Finite complex quotient without squaring the denominator or overflowing its sum. */
+export declare function complexRatio(nr: number, ni: number, dr: number, di: number): Complex | undefined;

package/dist/lib/math/complexRatio.js

@@ -0,0 +1,30 @@
+import { Complex } from '../complex/Complex.js';
+/** Finite complex quotient without squaring the denominator or overflowing its sum. */
+export function complexRatio(nr, ni, dr, di) {
+    const scale = Math.max(Math.abs(nr), Math.abs(ni), Math.abs(dr), Math.abs(di));
+    if (!Number.isFinite(scale) || (dr === 0 && di === 0)) {
+        return;
+    }
+    nr /= scale;
+    ni /= scale;
+    dr /= scale;
+    di /= scale;
+    let re;
+    let im;
+    if (Math.abs(dr) >= Math.abs(di)) {
+        const ratio = di / dr;
+        const denominator = dr + di * ratio;
+        re = (nr + ni * ratio) / denominator;
+        im = (ni - nr * ratio) / denominator;
+    }
+    else {
+        const ratio = dr / di;
+        const denominator = di + dr * ratio;
+        re = (nr * ratio + ni) / denominator;
+        im = (ni * ratio - nr) / denominator;
+    }
+    if (!Number.isFinite(re) || !Number.isFinite(im)) {
+        return;
+    }
+    return Complex.from(re, im);
+}

package/dist/lib/measurements.d.ts

@@ -0,0 +1,53 @@
+import { Complex } from './complex/Complex.js';
+import type { SmithReading } from './rf.js';
+export type TraceRenderMode = 'points' | 'line' | 'both';
+export interface TraceStyle {
+    mode: TraceRenderMode;
+    /** Non-scaling SVG stroke width in CSS pixels. Default: 2. */
+    lineWidth: number;
+    /** Point radius in CSS pixels; remains constant under chart zoom and container resize. Default: 2. */
+    pointRadius: number;
+}
+export interface TraceOptions extends Partial<TraceStyle> {
+    name?: string;
+    /** A solid CSS color, such as '#2563eb' or 'orange'. */
+    color?: string;
+    visible?: boolean;
+}
+/** How markers select samples when a trace is replaced. */
+export type MarkerSelectionStrategy = 'frequency' | 'sample-index' | 'reflection';
+export interface TraceUpdateOptions {
+    /** Default: frequency. Ties select the earliest input sample; indices clamp to the new last sample. */
+    markerSelection?: MarkerSelectionStrategy;
+}
+export interface MarkerInfo {
+    readonly id: string;
+    /** Stable display number within the trace; removed numbers are not reused. */
+    readonly number: number;
+    readonly sampleIndex: number;
+}
+export interface TraceInfo extends Readonly<TraceStyle> {
+    readonly id: string;
+    readonly name: string;
+    readonly color: string;
+    readonly visible: boolean;
+    readonly sampleCount: number;
+    readonly markers: readonly MarkerInfo[];
+}
+/** A detached reading identified by stable, chart-local trace and marker IDs. */
+export interface MarkerSnapshot extends SmithReading {
+    readonly frequencyHz: number;
+    readonly traceId: string;
+    readonly markerId: string;
+    readonly markerNumber: number;
+    readonly sampleIndex: number;
+}
+export interface MarkerComparison {
+    readonly frequencyDeltaHz: number;
+    /** Undefined if either impedance is singular or non-finite. */
+    readonly impedanceDeltaOhms: Complex | undefined;
+    /** 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;

package/dist/lib/measurements.js

@@ -0,0 +1,19 @@
+/** 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,
+    };
+}

package/dist/lib/renormalization.d.ts

@@ -0,0 +1,10 @@
+import { Complex } from './complex/Complex.js';
+import type { TraceSamples } from './samples.js';
+/**
+ * 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.
+ */
+export declare function renormalizeReflection(gamma: Complex, fromOhms: number, toOhms: number): Complex | undefined;
+/** Copy and renormalize every sample; reject invalid/singular data without modifying the input. */
+export declare function renormalizeSamples(samples: TraceSamples, fromOhms: number, toOhms: number): TraceSamples;

package/dist/lib/renormalization.js

@@ -0,0 +1,62 @@
+import { Complex } from './complex/Complex.js';
+function validateReference(value) {
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new RangeError('Reference impedance must be positive and finite.');
+    }
+}
+/**
+ * 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.
+ */
+export function renormalizeReflection(gamma, fromOhms, toOhms) {
+    validateReference(fromOhms);
+    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. */
+export function renormalizeSamples(samples, fromOhms, toOhms) {
+    validateReference(fromOhms);
+    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 = 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() };
+    });
+}

package/dist/lib/rf.d.ts

@@ -0,0 +1,35 @@
+import { Complex } from './complex/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;
+}
+/** Convert Γ to physical impedance in ohms; undefined at the open circuit Γ = 1. */
+export declare function reflectionToImpedance(gamma: Complex, referenceImpedanceOhms?: number): Complex | undefined;
+/** Convert physical impedance in ohms to Γ. Undefined for a singular result. */
+export declare function impedanceToReflection(impedanceOhms: Complex, referenceImpedanceOhms?: number): Complex | undefined;
+/** Convert Γ to physical admittance in siemens; undefined at the short circuit Γ = −1. */
+export declare function reflectionToAdmittance(gamma: Complex, referenceImpedanceOhms?: number): Complex | undefined;
+/** Convert physical admittance in siemens to Γ. Undefined for a singular result. */
+export declare function 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.
+ */
+export declare function readReflection(gamma: Complex, referenceImpedanceOhms?: number): SmithReading;