smithkit 0.1.1 → 0.3.0

package/dist/lib/appearance/Theme.js

@@ -0,0 +1,120 @@
+import { color } from 'd3';
+/** Resolve and validate a detached theme before touching any chart state or DOM. */
+export class Theme {
+    constructor() { }
+    static resolve(appearance = {}) {
+        if (!appearance || typeof appearance !== 'object' || Array.isArray(appearance)) {
+            throw new TypeError('Appearance must be an object.');
+        }
+        const name = appearance.theme === undefined ? 'light' : appearance.theme;
+        if (name !== 'light' && name !== 'dark') {
+            throw new TypeError('Theme must be light or dark.');
+        }
+        const dark = name === 'dark';
+        const theme = {
+            background: dark ? '#0f172a' : 'transparent',
+            fontFamily: 'Verdana, sans-serif',
+            grid: {
+                stroke: dark ? '#94a3b8' : '#64748b',
+                textColor: dark ? '#e2e8f0' : '#111827',
+                majorWidth: 1,
+                minorWidth: 0.6,
+                fontSize: 7,
+            },
+            boundary: { stroke: dark ? '#cbd5e1' : '#334155', width: 1 },
+            circles: { q: dark ? '#93c5fd' : 'blue', vswr: dark ? '#fbbf24' : 'orange', width: 1 },
+            scales: {
+                stroke: dark ? '#94a3b8' : '#64748b',
+                boundaryColor: dark ? '#cbd5e1' : '#334155',
+                textColor: dark ? '#e2e8f0' : '#334155',
+                valueColor: dark ? '#fca5a5' : '#b42318',
+                indicatorColor: dark ? '#f87171' : '#dc2626',
+                indicatorOutline: dark ? '#0f172a' : 'white',
+                fontSize: 10,
+                titleFontSize: 12,
+                valueFontSize: 11,
+                peripheralFontSize: 10.5,
+            },
+            cursor: {
+                pointColor: dark ? '#fca5a5' : 'red',
+                impedanceColor: dark ? '#fca5a5' : 'red',
+                admittanceColor: dark ? '#86efac' : 'green',
+                pointSize: 5,
+                lineWidth: 1,
+            },
+            marker: {
+                outlineColor: dark ? '#e2e8f0' : 'gray',
+                textColor: 'white',
+                focusColor: dark ? '#93c5fd' : '#1d4ed8',
+                focusHaloColor: dark ? '#0f172a' : 'white',
+            },
+            traceColors: dark
+                ? [
+                    '#fb923c',
+                    '#4ade80',
+                    '#f87171',
+                    '#c084fc',
+                    '#d6a681',
+                    '#f472b6',
+                    '#cbd5e1',
+                    '#d4d45c',
+                    '#22d3ee',
+                    '#60a5fa',
+                ]
+                : [
+                    '#ff7f0e',
+                    '#2ca02c',
+                    '#d62728',
+                    '#9467bd',
+                    '#8c564b',
+                    '#e377c2',
+                    '#7f7f7f',
+                    '#bcbd22',
+                    '#17becf',
+                    '#1f77b4',
+                ],
+        };
+        if (appearance.overrides !== undefined) {
+            Theme.merge(theme, appearance.overrides);
+        }
+        return theme;
+    }
+    static merge(target, source, path = 'appearance') {
+        if (!source || typeof source !== 'object' || Array.isArray(source)) {
+            throw new TypeError(`${path} overrides must be an object.`);
+        }
+        for (const [key, value] of Object.entries(source)) {
+            if (!Object.hasOwn(target, key)) {
+                throw new TypeError(`Unknown appearance setting: ${path}.${key}.`);
+            }
+            if (value === undefined) {
+                continue;
+            }
+            const previous = target[key];
+            if (Array.isArray(previous)) {
+                if (!Array.isArray(value) || value.length === 0 || !value.every(Theme.isColor)) {
+                    throw new TypeError('Trace colors must be a non-empty array of solid CSS colors.');
+                }
+                target[key] = [...value];
+            }
+            else if (typeof previous === 'object') {
+                Theme.merge(previous, value, `${path}.${key}`);
+            }
+            else if (typeof previous === 'number') {
+                if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0) {
+                    throw new RangeError(`${path}.${key} must be positive and finite.`);
+                }
+                target[key] = value;
+            }
+            else {
+                if (key === 'fontFamily' ? typeof value !== 'string' || !value.trim() : !Theme.isColor(value)) {
+                    throw new TypeError(`${path}.${key} must be ${key === 'fontFamily' ? 'a non-empty font family' : 'a solid CSS color'}.`);
+                }
+                target[key] = value;
+            }
+        }
+    }
+    static isColor(value) {
+        return typeof value === 'string' && color(value) !== null;
+    }
+}

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

@@ -0,0 +1,55 @@
+/** Resolved appearance shared by charts and independent scales. Lengths are positive. */
+export interface SmithTheme {
+    background: string;
+    fontFamily: string;
+    grid: {
+        stroke: string;
+        textColor: string;
+        majorWidth: number;
+        minorWidth: number;
+        fontSize: number;
+    };
+    boundary: {
+        stroke: string;
+        width: number;
+    };
+    circles: {
+        q: string;
+        vswr: string;
+        width: number;
+    };
+    scales: {
+        stroke: string;
+        boundaryColor: string;
+        textColor: string;
+        valueColor: string;
+        indicatorColor: string;
+        indicatorOutline: string;
+        fontSize: number;
+        titleFontSize: number;
+        valueFontSize: number;
+        peripheralFontSize: number;
+    };
+    cursor: {
+        pointColor: string;
+        impedanceColor: string;
+        admittanceColor: string;
+        pointSize: number;
+        lineWidth: number;
+    };
+    marker: {
+        outlineColor: string;
+        textColor: string;
+        focusColor: string;
+        focusHaloColor: string;
+    };
+    traceColors: readonly string[];
+}
+export type SmithThemeOverrides = {
+    [K in keyof SmithTheme]?: SmithTheme[K] extends readonly string[] ? readonly string[] : SmithTheme[K] extends object ? Partial<SmithTheme[K]> : SmithTheme[K];
+};
+/** Each application replaces the previous appearance, starting from the named preset. */
+export interface SmithAppearance {
+    theme?: 'light' | 'dark';
+    overrides?: SmithThemeOverrides;
+}

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

@@ -0,0 +1,15 @@
+import type { ConstQCircles } from './ConstQCircles.js';
+import type { ConstSwrCircles } from './ConstSwrCircles.js';
+import type { CircleLayer, CircleStyle } from '../layers.js';
+import { LayerControl } from './LayerControl.js';
+/** Exposes Q/VSWR circle controls without exposing the SVG renderer. */
+export declare class CircleLayerControl extends LayerControl implements CircleLayer {
+    private readonly layer;
+    private readonly minimum;
+    constructor(layer: ConstQCircles | ConstSwrCircles, minimum: number, assertAlive: () => void);
+    setVisible(visible: boolean): void;
+    setStyle(style: Partial<CircleStyle>): void;
+    addValue(value: number): void;
+    removeValue(value: number): void;
+    private validateValue;
+}

package/dist/lib/grid/CircleLayerControl.js

@@ -0,0 +1,40 @@
+import { LayerControl } from './LayerControl.js';
+/** Exposes Q/VSWR circle controls without exposing the SVG renderer. */
+export class CircleLayerControl extends LayerControl {
+    layer;
+    minimum;
+    constructor(layer, minimum, assertAlive) {
+        super(assertAlive);
+        this.layer = layer;
+        this.minimum = minimum;
+    }
+    setVisible(visible) {
+        this.assertAlive();
+        this.layer.visibility(visible);
+    }
+    setStyle(style) {
+        this.assertAlive();
+        this.validateLengths(style, ['strokeWidth']);
+        if (style.stroke !== undefined) {
+            this.layer.Stroke = style.stroke;
+        }
+        if (style.strokeWidth !== undefined) {
+            this.layer.StrokeWidth = String(style.strokeWidth);
+        }
+    }
+    addValue(value) {
+        this.assertAlive();
+        this.validateValue(value);
+        this.layer.append(value);
+    }
+    removeValue(value) {
+        this.assertAlive();
+        this.validateValue(value);
+        this.layer.remove(value);
+    }
+    validateValue(value) {
+        if (!Number.isFinite(value) || value < this.minimum || value <= 0) {
+            throw new RangeError(`Circle value must be finite, positive, and at least ${this.minimum}.`);
+        }
+    }
+}

package/dist/lib/{draw → grid}/ConstCircles.d.ts

@@ -1,10 +1,8 @@
 import type * as d3 from 'd3';
-import { SmithGroup } from './SmithGroup.js';
-import { SmithScaler } from './SmithScaler.js';
-import { Line } from '../shapes/Line.js';
-import { Circle } from '../shapes/Circle.js';
-import { Point } from '../shapes/Point.js';
-import { SmithConstantCircle } from '../SmithConstantCircle.js';
+import { SmithGroup } from '../svg/SmithGroup.js';
+import { SmithScaler } from '../svg/SmithScaler.js';
+import type { Line, Circle, Point } from '../math/geometry.js';
+import { SmithConstantCircle } from '../rf/SmithConstantCircle.js';
 export interface ArcData {
     p1: Point;
     p2: Point;
@@ -37,9 +35,6 @@ export declare abstract class ConstCircles {
     visibility(visible: boolean): void;
     show(): void;
     hide(): void;
-    displayMinor(display: boolean): void;
-    showMinor(): void;
-    hideMinor(): void;
     protected build(): SmithGroup;
     /** Mount labels separately so every grid line is painted before any label. */
     get labels(): SmithGroup;

package/dist/lib/{draw → grid}/ConstCircles.js

@@ -1,5 +1,5 @@
-import { SmithGroup } from './SmithGroup.js';
-import { SmithConstantCircle } from '../SmithConstantCircle.js';
+import { SmithGroup } from '../svg/SmithGroup.js';
+import { SmithConstantCircle } from '../rf/SmithConstantCircle.js';
 export class ConstCircles {
     scaler;
     calcs = new SmithConstantCircle();
@@ -26,20 +26,6 @@ export class ConstCircles {
         this.container.hide();
         this.texts.hide();
     }
-    displayMinor(display) {
-        if (display) {
-            this.minor.show();
-        }
-        else {
-            this.minor.hide();
-        }
-    }
-    showMinor() {
-        this.minor.show();
-    }
-    hideMinor() {
-        this.minor.hide();
-    }
     build() {
         this.texts.hide();
         return this.container.append(this.minor).append(this.major).hide();
@@ -108,12 +94,12 @@ export class ConstCircles {
     defaultDrawingOptions() {
         return {
             // Keep curved grid strokes visible at normal browser zoom and low pixel density.
-            stroke: '#64748b',
-            majorWidth: '1',
-            minorWidth: '0.6',
-            textColor: 'black',
-            textFontFamily: 'Verdana',
-            textFontSize: '1',
+            stroke: 'var(--smithkit-grid-stroke)',
+            majorWidth: 'var(--smithkit-grid-majorWidth)',
+            minorWidth: 'var(--smithkit-grid-minorWidth)',
+            textColor: 'var(--smithkit-grid-textColor)',
+            textFontFamily: 'var(--smithkit-fontFamily)',
+            textFontSize: 'var(--smithkit-grid-fontSize)',
         };
     }
     scaleArc(scaler, d) {

package/dist/lib/{draw → grid}/ConstQCircles.d.ts

@@ -1,5 +1,5 @@
-import { SmithGroup } from './SmithGroup.js';
-import { SmithScaler } from './SmithScaler.js';
+import { SmithGroup } from '../svg/SmithGroup.js';
+import { SmithScaler } from '../svg/SmithScaler.js';
 interface ConstQDrawOptions {
     stroke: string;
     strokeWidth: string;

package/dist/lib/{draw → grid}/ConstQCircles.js

@@ -1,6 +1,6 @@
-import { SmithGroup } from './SmithGroup.js';
-import { SmithArc } from './SmithArc.js';
-import { SmithConstantCircle } from '../SmithConstantCircle.js';
+import { SmithGroup } from '../svg/SmithGroup.js';
+import { SmithArc } from '../svg/SmithArc.js';
+import { SmithConstantCircle } from '../rf/SmithConstantCircle.js';
 export class ConstQCircles {
     scaler;
     calcs = new SmithConstantCircle();
@@ -28,7 +28,7 @@ export class ConstQCircles {
         this.container.append(a2);
     }
     getDefaultDrawOptions() {
-        return { stroke: 'blue', strokeWidth: '1' };
+        return { stroke: 'var(--smithkit-circles-q)', strokeWidth: 'var(--smithkit-circles-width)' };
     }
     setDrawOptions(opts) {
         this.opts = opts;

package/dist/lib/{draw → grid}/ConstSwrCircles.d.ts

@@ -1,5 +1,5 @@
-import { SmithGroup } from './SmithGroup.js';
-import { SmithScaler } from './SmithScaler.js';
+import { SmithGroup } from '../svg/SmithGroup.js';
+import { SmithScaler } from '../svg/SmithScaler.js';
 interface ConstSwrDrawOptions {
     stroke: string;
     strokeWidth: string;

package/dist/lib/{draw → grid}/ConstSwrCircles.js

@@ -1,6 +1,6 @@
-import { SmithGroup } from './SmithGroup.js';
-import { SmithCircle } from './SmithCircle.js';
-import { SmithConstantCircle } from '../SmithConstantCircle.js';
+import { SmithGroup } from '../svg/SmithGroup.js';
+import { SmithCircle } from '../svg/SmithCircle.js';
+import { SmithConstantCircle } from '../rf/SmithConstantCircle.js';
 export class ConstSwrCircles {
     scaler;
     calcs = new SmithConstantCircle();
@@ -27,7 +27,7 @@ export class ConstSwrCircles {
         this.container.append(circle);
     }
     getDefaultDrawOptions() {
-        return { stroke: 'orange', strokeWidth: '1' };
+        return { stroke: 'var(--smithkit-circles-vswr)', strokeWidth: 'var(--smithkit-circles-width)' };
     }
     setDrawOptions(opts) {
         this.opts = opts;

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

@@ -0,0 +1,18 @@
+import type { SmithTicksData, SmithTicksShapes } from './types.js';
+export declare class GridDefinitions {
+    private constructor();
+    static readonly basicValues: readonly number[];
+    /** Complete principal circles and boundary-to-axis arcs for a sparse grid. */
+    static basic(): {
+        resistance: SmithTicksShapes;
+        reactance: SmithTicksShapes;
+    };
+    private static readonly resistanceMajor;
+    private static readonly resistanceMinor;
+    private static readonly reactanceMajor;
+    private static readonly reactanceMinor;
+    private static resistanceArcs;
+    private static reactanceArcs;
+    /** Build fresh definitions so callers cannot mutate another chart's grid. */
+    static create(): SmithTicksData;
+}

package/dist/lib/grid/GridDefinitions.js

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

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

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

package/dist/lib/grid/GridGeometry.js

@@ -0,0 +1,58 @@
+import { SmithConstantCircle } from '../rf/SmithConstantCircle.js';
+import { Complex } from '../math/Complex.js';
+export class GridGeometry {
+    constructor() { }
+    static calcs = new SmithConstantCircle();
+    static circles = {
+        resistance: (value) => GridGeometry.calcs.resistanceCircle(value),
+        reactance: (value) => GridGeometry.calcs.reactanceCircle(value),
+        conductance: (value) => GridGeometry.calcs.conductanceCircle(value),
+        susceptance: (value) => GridGeometry.calcs.susceptanceCircle(value),
+    };
+    static clipping = {
+        resistance: 'reactance',
+        reactance: 'resistance',
+        conductance: 'susceptance',
+        susceptance: 'conductance',
+    };
+    /** Normalized geometry only: no DOM, D3, or pixel coordinates. */
+    static shapes(kind, data) {
+        const circle = GridGeometry.circles[kind];
+        const clip = GridGeometry.circles[GridGeometry.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]) => GridGeometry.calcs.circleCircleIntersection(c, clip(limit))[index]);
+                return [a, b, c.r, options[0], options[1]];
+            }),
+        };
+    }
+    static label(kind, definition) {
+        const { point, transform, dp, textAnchor, dominantBaseline } = definition;
+        const admittance = kind === 'conductance' || kind === 'susceptance';
+        const real = kind === 'resistance' || kind === 'conductance';
+        const rc = admittance
+            ? GridGeometry.calcs.admittanceToRflCoeff(Complex.from(point.r, point.i))
+            : GridGeometry.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 = GridGeometry.circles[kind](value);
+        let rotate = -GridGeometry.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/GridLabels.d.ts

@@ -0,0 +1,8 @@
+import { Tick } from './Tick.js';
+export declare class GridLabels {
+    private constructor();
+    private static readonly values;
+    private static readonly interiorValues;
+    static resistance(): Tick[];
+    static reactance(): Tick[];
+}