smithkit 0.0.0-stage → 0.1.0

package/dist/lib/rf.js

@@ -0,0 +1,74 @@
+import { Complex } from './complex/Complex.js';
+import { SmithConstantCircle } from './SmithConstantCircle.js';
+const calcs = new SmithConstantCircle();
+function validateReference(referenceImpedanceOhms) {
+    if (!Number.isFinite(referenceImpedanceOhms) || referenceImpedanceOhms <= 0) {
+        throw new RangeError('Reference impedance must be positive and finite.');
+    }
+}
+function validateComplex(value) {
+    if (!Number.isFinite(value.re) || !Number.isFinite(value.im)) {
+        throw new RangeError('Complex components must be finite.');
+    }
+}
+function 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. */
+export function reflectionToImpedance(gamma, referenceImpedanceOhms = 50) {
+    validateReference(referenceImpedanceOhms);
+    validateComplex(gamma);
+    return finite(calcs.rflCoeffToImpedance(gamma)?.mul(referenceImpedanceOhms));
+}
+/** Convert physical impedance in ohms to Γ. Undefined for a singular result. */
+export function impedanceToReflection(impedanceOhms, referenceImpedanceOhms = 50) {
+    validateReference(referenceImpedanceOhms);
+    validateComplex(impedanceOhms);
+    return finite(calcs.impedanceToRflCoeff(impedanceOhms.div(referenceImpedanceOhms)));
+}
+/** Convert Γ to physical admittance in siemens; undefined at the short circuit Γ = −1. */
+export function reflectionToAdmittance(gamma, referenceImpedanceOhms = 50) {
+    validateReference(referenceImpedanceOhms);
+    validateComplex(gamma);
+    return finite(calcs.rflCoeffToAdmittance(gamma)?.div(referenceImpedanceOhms));
+}
+/** Convert physical admittance in siemens to Γ. Undefined for a singular result. */
+export function admittanceToReflection(admittanceSiemens, referenceImpedanceOhms = 50) {
+    validateReference(referenceImpedanceOhms);
+    validateComplex(admittanceSiemens);
+    return finite(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.
+ */
+export function readReflection(gamma, referenceImpedanceOhms = 50) {
+    const impedanceOhms = reflectionToImpedance(gamma, referenceImpedanceOhms);
+    const admittanceSiemens = 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,
+    };
+}

package/dist/lib/samples.d.ts

@@ -0,0 +1,6 @@
+/** One S11 sample. The reflection coefficient is [real, imaginary]. */
+export interface TraceSample {
+    readonly frequencyHz: number;
+    readonly reflectionCoefficient: readonly [number, number];
+}
+export type TraceSamples = readonly TraceSample[];

package/dist/lib/samples.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/scales/SmithPeripheralScales.d.ts

@@ -0,0 +1,10 @@
+import type { Complex } from '../complex/Complex.js';
+import { SmithGroup } from '../draw/SmithGroup.js';
+/** Peripheral rulers in the chart's 500-unit coordinate system. */
+export declare class SmithPeripheralScales extends SmithGroup {
+    private readonly scales;
+    private readonly axes;
+    constructor();
+    /** Connect to the same cursor or marker data as the independent parameter scales. */
+    update(gamma: Complex | null): void;
+}

package/dist/lib/scales/SmithPeripheralScales.js

@@ -0,0 +1,124 @@
+import { select, format } from 'd3';
+import { SmithGroup } from '../draw/SmithGroup.js';
+import { peripheralScales } from './peripheralScales.js';
+let nextScaleId = 0;
+const firstRadius = 250;
+const ringSpacing = 20;
+function point(radius, degrees) {
+    const angle = (degrees * Math.PI) / 180;
+    return [250 + radius * Math.cos(angle), 250 - radius * Math.sin(angle)];
+}
+/** Peripheral rulers in the chart's 500-unit coordinate system. */
+export class SmithPeripheralScales extends SmithGroup {
+    scales = peripheralScales();
+    axes = this.Element.attr('data-layer', 'peripheral-scales')
+        .attr('pointer-events', 'none')
+        .selectAll('g')
+        .data(this.scales)
+        .join('g')
+        .attr('data-scale', (scale) => scale.id)
+        .attr('role', 'img')
+        .attr('aria-label', (scale) => scale.title);
+    constructor() {
+        super();
+        this.axes.each(function (scale, index) {
+            const axis = select(this);
+            const radius = firstRadius + index * ringSpacing;
+            const captionAngle = scale.unit === 'λ' ? 180 : 0;
+            axis.append('title').text(scale.title);
+            axis
+                .append('circle')
+                .attr('cx', 250)
+                .attr('cy', 250)
+                .attr('r', radius)
+                .attr('fill', 'none')
+                .attr('stroke', '#475569')
+                .attr('stroke-width', 0.8)
+                .attr('vector-effect', 'non-scaling-stroke');
+            for (const value of scale.ticks) {
+                const angle = scale.angle(value);
+                const [x1, y1] = point(radius, angle);
+                const major = scale.major(value);
+                const [x2, y2] = point(radius - (major ? 4 : 2), angle);
+                axis
+                    .append('line')
+                    .attr('x1', x1)
+                    .attr('y1', y1)
+                    .attr('x2', x2)
+                    .attr('y2', y2)
+                    .attr('stroke', '#475569')
+                    .attr('stroke-width', major ? 0.8 : 0.5)
+                    .attr('vector-effect', 'non-scaling-stroke');
+                const captionDistance = Math.abs(((angle - captionAngle + 540) % 360) - 180);
+                if (major && captionDistance > 25) {
+                    const [x, y] = point(radius + 8, angle);
+                    const rotation = angle >= 0 ? 90 - angle : -90 - angle;
+                    axis
+                        .append('text')
+                        .attr('x', x)
+                        .attr('y', y)
+                        .attr('transform', `rotate(${rotation},${x},${y})`)
+                        .attr('text-anchor', 'middle')
+                        .attr('dominant-baseline', 'central')
+                        .attr('font-family', 'system-ui, sans-serif')
+                        .attr('font-size', 10.5)
+                        .attr('fill', '#334155')
+                        .text(scale.unit === 'λ' ? value.toFixed(2) : String(value));
+                }
+            }
+            // Reserve a label sector for the curved caption without masking the ruler or its ticks.
+            const captionRadius = radius + 5;
+            const start = point(captionRadius, captionAngle + 45);
+            const end = point(captionRadius, captionAngle - 45);
+            const pathId = `smithkit-peripheral-caption-${nextScaleId++}`;
+            axis
+                .append('defs')
+                .append('path')
+                .attr('id', pathId)
+                .attr('d', `M${start} A${captionRadius},${captionRadius} 0 0 1 ${end}`);
+            const caption = scale.unit === 'λ'
+                ? scale.id === 'wavelengths-generator'
+                    ? 'WAVELENGTHS TOWARD GENERATOR →'
+                    : '← WAVELENGTHS TOWARD LOAD'
+                : scale.title.toUpperCase();
+            axis
+                .append('text')
+                .attr('class', 'peripheral-caption')
+                .attr('text-anchor', 'middle')
+                .attr('font-family', 'system-ui, sans-serif')
+                .attr('font-size', 10.5)
+                .attr('font-weight', 500)
+                .attr('letter-spacing', 0.3)
+                .attr('fill', '#334155')
+                .append('textPath')
+                .attr('href', `#${pathId}`)
+                .attr('startOffset', '50%')
+                .text(caption);
+            axis
+                .append('circle')
+                .attr('class', 'peripheral-indicator')
+                .attr('r', 3)
+                .attr('visibility', 'hidden')
+                .attr('fill', '#dc2626')
+                .attr('stroke', 'white')
+                .attr('stroke-width', 1);
+        });
+    }
+    /** Connect to the same cursor or marker data as the independent parameter scales. */
+    update(gamma) {
+        const valid = gamma !== null && Number.isFinite(gamma.abs()) && gamma.abs() <= 1;
+        this.axes.each(function (scale, index) {
+            const value = valid ? scale.read(gamma) : null;
+            const axis = select(this);
+            const label = value === null ? scale.title : `${scale.title}: ${format('.4~g')(value)} ${scale.unit}`;
+            axis.attr('aria-label', label).select('title').text(label);
+            const dot = axis.select('.peripheral-indicator');
+            if (value === null) {
+                dot.attr('visibility', 'hidden').attr('data-value', null);
+                return;
+            }
+            const [x, y] = point(firstRadius + index * ringSpacing, scale.angle(value));
+            dot.attr('cx', x).attr('cy', y).attr('data-value', value).attr('visibility', null);
+        });
+    }
+}

package/dist/lib/scales/SmithScales.d.ts

@@ -0,0 +1,16 @@
+import type { Complex } from '../complex/Complex.js';
+/** Independent parameter scales. Connect update() to a chart's cursor events. */
+export declare class SmithScales {
+    private readonly scales;
+    private readonly container;
+    private destroyed;
+    private readonly start;
+    private readonly length;
+    private readonly axes;
+    constructor();
+    draw(target: string | HTMLElement): void;
+    /** Show a passive-load reflection coefficient, or hide indicators with null. */
+    update(gamma: Complex | null): void;
+    destroy(): void;
+    private assertAlive;
+}

package/dist/lib/scales/SmithScales.js

@@ -0,0 +1,134 @@
+import { select, format } from 'd3';
+import { radialScales } from './radialScales.js';
+/** Independent parameter scales. Connect update() to a chart's cursor events. */
+export class SmithScales {
+    scales = radialScales();
+    container = select(document.createElement('div'))
+        .attr('class', 'radial-scales')
+        .style('display', 'grid')
+        .style('grid-template-columns', 'repeat(auto-fit, minmax(min(100%, 300px), 1fr))')
+        .style('gap', '8px 20px');
+    destroyed = false;
+    start = 8;
+    length = 304;
+    axes = this.container
+        .selectAll('svg')
+        .data(this.scales)
+        .join('svg')
+        .attr('xmlns', 'http://www.w3.org/2000/svg')
+        .attr('viewBox', '0 0 320 60')
+        .attr('role', 'img')
+        .attr('aria-label', (scale) => scale.title)
+        .attr('data-scale', (scale) => scale.id)
+        .style('display', 'block')
+        .style('width', '100%')
+        .style('height', 'auto');
+    constructor() {
+        this.axes
+            .append('text')
+            .attr('x', this.start)
+            .attr('y', 12)
+            .attr('font-family', 'system-ui, sans-serif')
+            .attr('font-size', 12)
+            .attr('fill', '#334155')
+            .text((scale) => scale.title);
+        this.axes
+            .append('text')
+            .attr('class', 'scale-value')
+            .attr('x', this.start)
+            .attr('y', 25)
+            .attr('font-family', 'system-ui, sans-serif')
+            .attr('font-size', 11)
+            .attr('font-weight', 600)
+            .attr('fill', '#b42318')
+            .text('—');
+        this.axes
+            .append('line')
+            .attr('class', 'scale-axis')
+            .attr('x1', this.start)
+            .attr('x2', this.start + this.length)
+            .attr('y1', 36)
+            .attr('y2', 36)
+            .attr('stroke', '#64748b')
+            .attr('stroke-width', 1);
+        const start = this.start;
+        const length = this.length;
+        this.axes.each(function (scale) {
+            const ticks = select(this)
+                .selectAll('g')
+                .data(scale.values)
+                .join('g')
+                .attr('transform', (value) => `translate(${start + length * scale.position(value)},36)`);
+            ticks.append('line').attr('y2', 5).attr('stroke', '#64748b').attr('stroke-width', 1);
+            ticks
+                .append('text')
+                .attr('y', 17)
+                .attr('font-size', 10)
+                .attr('font-family', 'system-ui, sans-serif')
+                .attr('fill', '#334155')
+                .attr('text-anchor', (_, i) => i === 0 ? 'start' : i === scale.values.length - 1 ? 'end' : 'middle')
+                .text((value) => (value === Infinity ? '∞' : String(value)));
+        });
+        this.axes
+            .append('circle')
+            .attr('class', 'scale-indicator')
+            .attr('visibility', 'hidden')
+            .attr('cx', this.start)
+            .attr('cy', 36)
+            .attr('r', 4)
+            .attr('fill', '#dc2626')
+            .attr('stroke', 'white')
+            .attr('stroke-width', 1);
+        this.axes.append('title').text((scale) => scale.description ?? scale.title);
+    }
+    draw(target) {
+        this.assertAlive();
+        const host = typeof target === 'string' ? document.querySelector(target) : target;
+        if (!host) {
+            throw new Error('Scale container was not found.');
+        }
+        host.appendChild(this.container.node());
+    }
+    /** Show a passive-load reflection coefficient, or hide indicators with null. */
+    update(gamma) {
+        this.assertAlive();
+        const magnitude = gamma === null ? NaN : Math.hypot(gamma.re, gamma.im);
+        if (!gamma || !Number.isFinite(magnitude) || magnitude > 1) {
+            this.axes.select('circle').attr('visibility', 'hidden').attr('data-position', null);
+            this.axes.select('.scale-value').text('—');
+            this.axes.attr('aria-label', (scale) => `${scale.title}. ${scale.description ?? ''}`.trim());
+            this.axes.select('title').text((scale) => scale.description ?? scale.title);
+            return;
+        }
+        const start = this.start;
+        const length = this.length;
+        this.axes.each(function (scale) {
+            const value = scale.read(gamma);
+            const position = Math.max(0, Math.min(1, scale.position(value)));
+            const axis = select(this);
+            const number = value === Infinity ? '∞' : format('.4~g')(value);
+            const suffix = scale.unit === 'dB' ? ' dB' : scale.id === 'vswr' ? ' : 1' : '';
+            const readout = number + suffix;
+            const label = `${scale.title}: ${readout}${scale.description ? `. ${scale.description}` : ''}`;
+            axis.select('.scale-value').text(readout);
+            axis.attr('aria-label', label).select('title').text(label);
+            axis
+                .select('circle')
+                .attr('cx', start + position * length)
+                .attr('data-position', position)
+                .attr('visibility', null);
+        });
+    }
+    destroy() {
+        if (this.destroyed) {
+            return;
+        }
+        this.destroyed = true;
+        this.container.remove();
+    }
+    assertAlive() {
+        if (this.destroyed) {
+            throw new Error('These Smith scales have been destroyed. Create a new instance.');
+        }
+    }
+}

package/dist/lib/scales/peripheralScales.d.ts

@@ -0,0 +1,12 @@
+import type { Complex } from '../complex/Complex.js';
+export interface PeripheralScale {
+    id: string;
+    title: string;
+    unit: '°' | 'λ';
+    ticks: number[];
+    major: (value: number) => boolean;
+    angle: (value: number) => number;
+    read: (gamma: Complex) => number | null;
+}
+/** A full reflection-coefficient rotation represents half a wavelength along the line. */
+export declare function peripheralScales(): PeripheralScale[];

package/dist/lib/scales/peripheralScales.js

@@ -0,0 +1,49 @@
+function phase(gamma) {
+    return gamma.re === 0 && gamma.im === 0 ? null : (Math.atan2(gamma.im, gamma.re) * 180) / Math.PI;
+}
+/** A full reflection-coefficient rotation represents half a wavelength along the line. */
+export function peripheralScales() {
+    const wavelengths = (gamma, direction) => {
+        const degrees = phase(gamma);
+        return degrees === null ? null : (0.25 + (direction * degrees) / 720 + 0.5) % 0.5;
+    };
+    return [
+        {
+            id: 'transmission-phase',
+            title: 'Transmission phase · °',
+            unit: '°',
+            ticks: Array.from({ length: 179 }, (_, i) => -89 + i),
+            major: (v) => v % 5 === 0,
+            // Project from Γ = −1 to the perimeter, not from the chart center.
+            angle: (v) => 2 * v,
+            read: (gamma) => phase({ re: 1 + gamma.re, im: gamma.im }),
+        },
+        {
+            id: 'reflection-phase',
+            title: 'Reflection phase · °',
+            unit: '°',
+            ticks: Array.from({ length: 180 }, (_, i) => -178 + i * 2),
+            major: (v) => v % 10 === 0,
+            angle: (v) => v,
+            read: phase,
+        },
+        {
+            id: 'wavelengths-load',
+            title: 'Wavelengths → load',
+            unit: 'λ',
+            ticks: Array.from({ length: 250 }, (_, i) => i / 500),
+            major: (v) => Math.round(v * 500) % 5 === 0,
+            angle: (v) => 720 * v - 180,
+            read: (gamma) => wavelengths(gamma, 1),
+        },
+        {
+            id: 'wavelengths-generator',
+            title: 'Wavelengths → generator',
+            unit: 'λ',
+            ticks: Array.from({ length: 250 }, (_, i) => i / 500),
+            major: (v) => Math.round(v * 500) % 5 === 0,
+            angle: (v) => 180 - 720 * v,
+            read: (gamma) => wavelengths(gamma, -1),
+        },
+    ];
+}

package/dist/lib/scales/radialScales.d.ts

@@ -0,0 +1,12 @@
+import type { Complex } from '../complex/Complex.js';
+export interface RadialScale {
+    id: string;
+    title: string;
+    description?: string;
+    unit: 'dB' | 'ratio';
+    read: (gamma: Complex) => number;
+    values: number[];
+    position: (value: number) => number;
+}
+/** Normalized positions along each scale, from zero to one. */
+export declare function radialScales(): RadialScale[];

package/dist/lib/scales/radialScales.js

@@ -0,0 +1,109 @@
+import { SmithConstantCircle } from '../SmithConstantCircle.js';
+/** Normalized positions along each scale, from zero to one. */
+export function radialScales() {
+    const calcs = new SmithConstantCircle();
+    return [
+        {
+            id: 'vswr',
+            unit: 'ratio',
+            read: (gamma) => calcs.rflCoeffToSwr(gamma),
+            title: 'VSWR',
+            values: [1, 1.5, 2, 3, 5, 10, Infinity],
+            position: (v) => (v === Infinity ? 1 : calcs.swrToRflCoeffEOrI(v)),
+        },
+        {
+            id: 'vswr-db',
+            unit: 'dB',
+            read: (gamma) => calcs.rflCoeffToDBS(gamma),
+            title: 'Standing-wave ratio · dB',
+            values: [0, 3, 6, 10, 15, 20, Infinity],
+            position: (v) => (v === Infinity ? 1 : calcs.dBSToAbsRflCoeff(v)),
+        },
+        {
+            id: 'return-loss',
+            unit: 'dB',
+            read: (gamma) => calcs.rflCoeffToReturnLoss(gamma),
+            title: 'Return loss · dB',
+            values: [Infinity, 20, 14, 10, 6, 3, 0],
+            position: (v) => calcs.returnLossToRflCoeffEOrI(v),
+        },
+        {
+            id: 'mismatch-loss',
+            unit: 'dB',
+            read: (gamma) => calcs.rflCoeffToMismatchLoss(gamma),
+            title: 'Reflection loss · dB',
+            description: 'Reflection loss (mismatch loss): −10 log10(1 − |Γ|²), in dB.',
+            values: [0, 0.1, 0.5, 1, 2, 4, Infinity],
+            position: (v) => calcs.mismatchLossToRflCoeffEOrI(v),
+        },
+        {
+            id: 'reflected-power',
+            unit: 'ratio',
+            read: (gamma) => calcs.rflCoeffP(gamma),
+            title: 'Power reflection coefficient',
+            description: 'Reflected power divided by incident power: |Γ|² (dimensionless).',
+            values: [0, 0.01, 0.1, 0.25, 0.5, 0.75, 1],
+            position: (v) => calcs.rflCoeffPToEOrI(v),
+        },
+        {
+            id: 'transmitted-power',
+            unit: 'ratio',
+            read: (gamma) => calcs.rflCoeffToTransmCoeffP(gamma),
+            title: 'Power transmission coefficient',
+            description: 'Net power delivered to the load divided by incident power: 1 − |Γ|² (dimensionless).',
+            values: [1, 0.99, 0.9, 0.75, 0.5, 0.25, 0],
+            position: (v) => calcs.transmCoeffPToRflCoeffEOrI(v),
+        },
+        {
+            id: 'standing-wave-loss',
+            unit: 'ratio',
+            read: (gamma) => calcs.rflCoeffToSwLossCoeff(gamma),
+            title: 'Standing-wave loss coefficient',
+            values: [1, 1.1, 1.5, 2, 3, 5, Infinity],
+            position: (v) => (v === Infinity ? 1 : calcs.swLossCoeffToRflCoeffEOrI(v)),
+        },
+        {
+            id: 'standing-wave-peak',
+            unit: 'ratio',
+            read: (gamma) => calcs.rflCoeffToSwPeakConstP(gamma),
+            title: 'Standing-wave peak · constant power',
+            values: [1, 1.2, 1.5, 2, 3, Infinity],
+            position: (v) => (v === Infinity ? 1 : calcs.swPeakConstPToRflCoeffEOrI(v)),
+        },
+        {
+            id: 'reflection-coefficient',
+            unit: 'ratio',
+            read: (gamma) => calcs.rflCoeffEOrI(gamma),
+            title: 'Reflection coefficient · |Γ|',
+            values: [0, 0.2, 0.4, 0.6, 0.8, 1],
+            position: (v) => v,
+        },
+        {
+            id: 'attenuation',
+            unit: 'dB',
+            read: (gamma) => calcs.rflCoeffToAttenuation(gamma),
+            title: 'Attenuation · dB',
+            description: 'One-way attenuation of a matched line or attenuator terminated in an open or short circuit. Not insertion loss of an arbitrary load.',
+            values: [Infinity, 10, 7, 5, 3, 1, 0],
+            position: (v) => calcs.attenuationToRflCoeff(v),
+        },
+        {
+            id: 'voltage-transmission',
+            unit: 'ratio',
+            read: (gamma) => calcs.rflCoeffToTransmCoeffEOrI(gamma),
+            title: 'Voltage transmission coefficient',
+            description: 'Voltage transmission magnitude: |1 + Γ| (dimensionless).',
+            values: [0, 0.4, 0.8, 1.2, 1.6, 2],
+            position: (v) => v / 2,
+        },
+        {
+            id: 'current-transmission',
+            unit: 'ratio',
+            read: (gamma) => calcs.rflCoeffToCurrentTransmission(gamma),
+            title: 'Current transmission coefficient',
+            description: 'Current transmission magnitude: |1 − Γ|, using the voltage reflection coefficient Γ (dimensionless).',
+            values: [0, 0.4, 0.8, 1.2, 1.6, 2],
+            position: (v) => v / 2,
+        },
+    ];
+}

package/dist/lib/shapes/Arc.d.ts

@@ -0,0 +1,6 @@
+import { Point } from './Point.js';
+export interface Arc {
+    p1: Point;
+    p2: Point;
+    r: number;
+}

package/dist/lib/shapes/Arc.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/shapes/Circle.d.ts

@@ -0,0 +1,5 @@
+import { Point } from './Point.js';
+export interface Circle {
+    p: Point;
+    r: number;
+}

package/dist/lib/shapes/Circle.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/shapes/Line.d.ts

@@ -0,0 +1,5 @@
+import { Point } from './Point.js';
+export interface Line {
+    p1: Point;
+    p2: Point;
+}

package/dist/lib/shapes/Line.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/shapes/Point.d.ts

@@ -0,0 +1 @@
+export type Point = [number, number];

package/dist/lib/shapes/Point.js

@@ -0,0 +1 @@
+export {};