smithkit 0.2.0 → 0.4.0

package/dist/lib/appearance/Theme.js

@@ -0,0 +1,125 @@
+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.');
+        }
+        for (const key of Object.keys(appearance)) {
+            if (key !== 'theme' && key !== 'overrides') {
+                throw new TypeError(`Unknown appearance option: ${key}.`);
+            }
+        }
+        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/appearance/types.js

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

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

@@ -9,7 +9,7 @@ export declare class CircleLayerControl extends LayerControl implements CircleLa
     constructor(layer: ConstQCircles | ConstSwrCircles, minimum: number, assertAlive: () => void);
     setVisible(visible: boolean): void;
     setStyle(style: Partial<CircleStyle>): void;
+    setValues(values: readonly number[]): void;
     addValue(value: number): void;
     removeValue(value: number): void;
-    private validateValue;
 }

package/dist/lib/grid/CircleLayerControl.js

@@ -1,3 +1,4 @@
+import { OptionsValidation } from '../OptionsValidation.js';
 import { LayerControl } from './LayerControl.js';
 /** Exposes Q/VSWR circle controls without exposing the SVG renderer. */
 export class CircleLayerControl extends LayerControl {
@@ -10,11 +11,12 @@ export class CircleLayerControl extends LayerControl {
     }
     setVisible(visible) {
         this.assertAlive();
+        OptionsValidation.boolean(visible, 'Circle visibility');
         this.layer.visibility(visible);
     }
     setStyle(style) {
         this.assertAlive();
-        this.validateLengths(style, ['strokeWidth']);
+        OptionsValidation.circleStyle(style);
         if (style.stroke !== undefined) {
             this.layer.Stroke = style.stroke;
         }
@@ -22,19 +24,19 @@ export class CircleLayerControl extends LayerControl {
             this.layer.StrokeWidth = String(style.strokeWidth);
         }
     }
+    setValues(values) {
+        this.assertAlive();
+        OptionsValidation.circleValues(values, this.minimum);
+        this.layer.setValues(values);
+    }
     addValue(value) {
         this.assertAlive();
-        this.validateValue(value);
+        OptionsValidation.circleValue(value, this.minimum);
         this.layer.append(value);
     }
     removeValue(value) {
         this.assertAlive();
-        this.validateValue(value);
+        OptionsValidation.circleValue(value, this.minimum);
         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/grid/ConstCircles.d.ts

@@ -35,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/grid/ConstCircles.js

@@ -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/grid/ConstQCircles.d.ts

@@ -24,6 +24,7 @@ export declare class ConstQCircles {
     show(): void;
     hide(): void;
     append(Q: number): void;
+    setValues(values: readonly number[]): void;
     remove(Q: number): void;
 }
 export {};

package/dist/lib/grid/ConstQCircles.js

@@ -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;
@@ -74,6 +74,11 @@ export class ConstQCircles {
         this.circles.push(Q);
         this.drawConstQCircle(Q);
     }
+    setValues(values) {
+        this.circles = [...new Set(values)];
+        this.container.Element.selectAll('*').remove();
+        this.drawConstQCircles(this.circles);
+    }
     remove(Q) {
         const index = this.circles.indexOf(Q);
         if (index === -1) {

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

@@ -24,6 +24,7 @@ export declare class ConstSwrCircles {
     show(): void;
     hide(): void;
     append(swr: number): void;
+    setValues(values: readonly number[]): void;
     remove(swr: number): void;
 }
 export {};

package/dist/lib/grid/ConstSwrCircles.js

@@ -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;
@@ -73,6 +73,11 @@ export class ConstSwrCircles {
         this.circles.push(swr);
         this.drawConstSwrCircle(swr);
     }
+    setValues(values) {
+        this.circles = [...new Set(values)];
+        this.container.Element.selectAll('*').remove();
+        this.drawConstSwrCircles(this.circles);
+    }
     remove(swr) {
         const index = this.circles.indexOf(swr);
         if (index === -1) {

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

@@ -1,6 +1,12 @@
-import type { SmithTicksData } from './types.js';
+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;

package/dist/lib/grid/GridDefinitions.js

@@ -1,5 +1,34 @@
 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],

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

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

package/dist/lib/grid/GridLayerControl.js

@@ -1,3 +1,4 @@
+import { OptionsValidation } from '../OptionsValidation.js';
 import { LayerControl } from './LayerControl.js';
 /** Exposes grid controls without exposing the SVG renderer. */
 export class GridLayerControl extends LayerControl {
@@ -10,16 +11,25 @@ export class GridLayerControl extends LayerControl {
     }
     setVisible(visible) {
         this.assertAlive();
+        OptionsValidation.boolean(visible, 'Grid visibility');
         this.layer.visibility(visible);
         this.changed();
     }
-    setMinorVisible(visible) {
+    setLabelsVisible(visible) {
         this.assertAlive();
-        this.layer.displayMinor(visible);
+        OptionsValidation.boolean(visible, 'Grid visibility');
+        this.layer.setLabelsVisible(visible);
+        this.changed();
+    }
+    setDetail(detail) {
+        this.assertAlive();
+        OptionsValidation.detail(detail);
+        this.layer.setDetail(detail);
+        this.changed();
     }
     setStyle(style) {
         this.assertAlive();
-        this.validateLengths(style, ['majorWidth', 'minorWidth', 'textFontSize']);
+        OptionsValidation.gridStyle(style);
         const properties = {
             stroke: 'Stroke',
             majorWidth: 'MajorWidth',

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

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

package/dist/lib/grid/LayerControl.js

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

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

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

package/dist/lib/grid/SmithGridLayer.js

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

package/dist/lib/index.d.ts

@@ -9,6 +9,9 @@ export { MarkerMeasurements } from './MarkerMeasurements.js';
 export type { TraceOptions, TraceUpdateOptions, MarkerSelectionStrategy, TraceStyle, TraceRenderMode, TraceInfo, MarkerInfo, MarkerSnapshot, MarkerComparison, } from './measurements.js';
 export { RfCalculations } from './rf/RfCalculations.js';
 export type { SmithReading } from './rf/RfCalculations.js';
-export type { GridStyle, CircleStyle, GridLayer, CircleLayer, ChartLayers, PeripheralScales, } from './layers.js';
+export type { GridStyle, CircleStyle, GridLayer, GridDetail, CircleLayer, ChartLayers, PeripheralScales, } from './layers.js';
 export { SmithFormatter } from './SmithFormatter.js';
 export type { ReactiveComponent } from './rf/RfCalculations.js';
+export type { SmithAppearance, SmithTheme, SmithThemeOverrides } from './appearance/types.js';
+export type { MarkerLegendField, MarkerLegendOptions, ImageExportOptions, SmithImageExportOptions, ScaleImageExportOptions, ScaleExportReadout, } from './svg/export.js';
+export type { SmithOptions, GridOptions, GridLayerOptions, CircleLayerOptions, CircleOptions, InteractionOptions, PeripheralScalesOptions, } from './options.js';

package/dist/lib/interaction/SmithCursor.d.ts

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