smithkit 0.1.1 → 0.2.0

package/dist/lib/scales/RadialScaleDefinitions.js

@@ -0,0 +1,112 @@
+import { SmithConstantCircle } from '../rf/SmithConstantCircle.js';
+export class RadialScaleDefinitions {
+    constructor() { }
+    /** Normalized positions along each scale, from zero to one. */
+    static create() {
+        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/scales/SmithPeripheralScales.d.ts

@@ -1,7 +1,9 @@
-import type { Complex } from '../complex/Complex.js';
-import { SmithGroup } from '../draw/SmithGroup.js';
+import type { Complex } from '../math/Complex.js';
+import { SmithGroup } from '../svg/SmithGroup.js';
 /** Peripheral rulers in the chart's 500-unit coordinate system. */
 export declare class SmithPeripheralScales extends SmithGroup {
+    private static point;
+    private static rulerRadius;
     readonly labels: SmithGroup;
     private readonly scales;
     private readonly axes;

package/dist/lib/scales/SmithPeripheralScales.js

@@ -1,19 +1,22 @@
 import { select, format } from 'd3';
-import { SmithGroup } from '../draw/SmithGroup.js';
-import { peripheralScales } from './peripheralScales.js';
+import { SmithGroup } from '../svg/SmithGroup.js';
+import { PeripheralScaleDefinitions } from './PeripheralScaleDefinitions.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)];
-}
+const chartRadius = 250;
+const groupWidth = 40;
 /** Peripheral rulers in the chart's 500-unit coordinate system. */
 export class SmithPeripheralScales extends SmithGroup {
+    static point(radius, degrees) {
+        const angle = (degrees * Math.PI) / 180;
+        return [250 + radius * Math.cos(angle), 250 - radius * Math.sin(angle)];
+    }
+    static rulerRadius(index) {
+        return chartRadius + groupWidth / 2 + Math.floor(index / 2) * groupWidth;
+    }
     labels = new SmithGroup()
         .attr('data-label-layer', 'peripheral-scales')
         .attr('pointer-events', 'none');
-    scales = peripheralScales();
+    scales = PeripheralScaleDefinitions.create();
     axes = this.Element.attr('data-layer', 'peripheral-scales')
         .attr('pointer-events', 'none')
         .selectAll('g')
@@ -29,26 +32,43 @@ export class SmithPeripheralScales extends SmithGroup {
             .join('g')
             .attr('data-label-scale', (scale) => scale.id)
             .nodes();
+        // Two paired rulers: transmission/reflection phase, then electrical length
+        // toward load/generator. Strong boundaries enclose each pair.
+        this.Element.selectAll('circle.peripheral-boundary')
+            .data([chartRadius, chartRadius + groupWidth, chartRadius + 2 * groupWidth])
+            .join('circle')
+            .attr('class', 'peripheral-boundary')
+            .attr('cx', 250)
+            .attr('cy', 250)
+            .attr('r', (radius) => radius)
+            .attr('fill', 'none')
+            .attr('stroke', '#334155')
+            .attr('stroke-width', 1.1)
+            .attr('vector-effect', 'non-scaling-stroke');
         this.axes.each(function (scale, index) {
             const labelAxis = select(labelAxes[index]);
             const axis = select(this);
-            const radius = firstRadius + index * ringSpacing;
+            const radius = SmithPeripheralScales.rulerRadius(index);
+            const side = index % 2 === 0 ? -1 : 1;
             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');
+            if (index % 2 === 0) {
+                axis
+                    .append('circle')
+                    .attr('class', 'peripheral-ruler')
+                    .attr('cx', 250)
+                    .attr('cy', 250)
+                    .attr('r', radius)
+                    .attr('fill', 'none')
+                    .attr('stroke', '#475569')
+                    .attr('stroke-width', 0.6)
+                    .attr('vector-effect', 'non-scaling-stroke');
+            }
             for (const value of scale.ticks) {
                 const angle = scale.angle(value);
-                const [x1, y1] = point(radius, angle);
+                const [x1, y1] = SmithPeripheralScales.point(radius, angle);
                 const major = scale.major(value);
-                const [x2, y2] = point(radius - (major ? 4 : 2), angle);
+                const [x2, y2] = SmithPeripheralScales.point(radius + side * (major ? 4 : 2), angle);
                 axis
                     .append('line')
                     .attr('x1', x1)
@@ -60,7 +80,7 @@ export class SmithPeripheralScales extends SmithGroup {
                     .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 [x, y] = SmithPeripheralScales.point(radius + side * 11, angle);
                     const rotation = angle >= 0 ? 90 - angle : -90 - angle;
                     labelAxis
                         .append('text')
@@ -76,9 +96,9 @@ export class SmithPeripheralScales extends SmithGroup {
                 }
             }
             // 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 captionRadius = radius + (side < 0 ? -15 : 5);
+            const start = SmithPeripheralScales.point(captionRadius, captionAngle + 45);
+            const end = SmithPeripheralScales.point(captionRadius, captionAngle - 45);
             const pathId = `smithkit-peripheral-caption-${nextScaleId++}`;
             axis
                 .append('defs')
@@ -134,7 +154,7 @@ export class SmithPeripheralScales extends SmithGroup {
                 dot.attr('visibility', 'hidden').attr('data-value', null);
                 return;
             }
-            const [x, y] = point(firstRadius + index * ringSpacing, scale.angle(value));
+            const [x, y] = SmithPeripheralScales.point(SmithPeripheralScales.rulerRadius(index), scale.angle(value));
             dot.attr('cx', x).attr('cy', y).attr('data-value', value).attr('visibility', null);
         });
     }

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

@@ -1,4 +1,4 @@
-import type { Complex } from '../complex/Complex.js';
+import type { Complex } from '../math/Complex.js';
 /** Independent parameter scales. Connect update() to a chart's cursor events. */
 export declare class SmithScales {
     private readonly scales;
@@ -11,6 +11,8 @@ export declare class SmithScales {
     draw(target: string | HTMLElement): void;
     /** Show a passive-load reflection coefficient, or hide indicators with null. */
     update(gamma: Complex | null): void;
+    /** Export all mounted scales in their current layout as a standalone SVG. */
+    toSvg(): string;
     destroy(): void;
     private assertAlive;
 }

package/dist/lib/scales/SmithScales.js

@@ -1,8 +1,9 @@
 import { select, format } from 'd3';
-import { radialScales } from './radialScales.js';
+import { RadialScaleDefinitions } from './RadialScaleDefinitions.js';
+import { SvgExporter } from '../svg/SvgExporter.js';
 /** Independent parameter scales. Connect update() to a chart's cursor events. */
 export class SmithScales {
-    scales = radialScales();
+    scales = RadialScaleDefinitions.create();
     container = select(document.createElement('div'))
         .attr('class', 'radial-scales')
         .style('display', 'grid')
@@ -127,6 +128,11 @@ export class SmithScales {
                 .attr('visibility', null);
         });
     }
+    /** Export all mounted scales in their current layout as a standalone SVG. */
+    toSvg() {
+        this.assertAlive();
+        return SvgExporter.scales(this.container.node(), this.axes.nodes());
+    }
     destroy() {
         if (this.destroyed) {
             return;

package/dist/lib/svg/LabelLayout.d.ts

@@ -0,0 +1,17 @@
+/** Responsive label placement measured in the default view, independent of user zoom. */
+export declare class LabelLayout {
+    private readonly viewport;
+    private readonly container;
+    private readonly baseView;
+    private width;
+    private height;
+    private readonly resizedFonts;
+    constructor(viewport: SVGSVGElement, container: SVGGElement, baseView: {
+        x: number;
+        y: number;
+        k: number;
+    });
+    update(force?: boolean): void;
+    private static transformBox;
+    private static overlaps;
+}

package/dist/lib/svg/LabelLayout.js

@@ -0,0 +1,145 @@
+/** Responsive label placement measured in the default view, independent of user zoom. */
+export class LabelLayout {
+    viewport;
+    container;
+    baseView;
+    width = 0;
+    height = 0;
+    resizedFonts = new Map();
+    constructor(viewport, container, baseView) {
+        this.viewport = viewport;
+        this.container = container;
+        this.baseView = baseView;
+    }
+    update(force = false) {
+        const viewport = this.viewport.getBoundingClientRect();
+        if (!this.viewport.isConnected || viewport.width <= 0 || viewport.height <= 0) {
+            return;
+        }
+        if (!force && viewport.width === this.width && viewport.height === this.height) {
+            return;
+        }
+        this.width = viewport.width;
+        this.height = viewport.height;
+        const rootMatrix = this.viewport.getScreenCTM();
+        const containerMatrix = this.container.getScreenCTM();
+        if (!rootMatrix || !containerMatrix) {
+            return;
+        }
+        const reference = rootMatrix.translate(this.baseView.x, this.baseView.y).scale(this.baseView.k);
+        const normalize = reference.multiply(containerMatrix.inverse());
+        // Peripheral rulers retain their complete, fixed-scale lettering. Only grid
+        // labels participate in thinning and minimum-font-size adjustments.
+        const labels = [...this.container.querySelectorAll('text')].filter((label) => !label.closest('[data-label-layer=peripheral-scales]'));
+        const view = this.viewport.ownerDocument.defaultView;
+        // Restore only properties owned by this layout before measuring the base styling.
+        for (const label of labels) {
+            if (label.hasAttribute('data-label-hidden')) {
+                label.removeAttribute('visibility');
+                label.removeAttribute('data-label-hidden');
+            }
+            const previousFont = this.resizedFonts.get(label);
+            if (previousFont !== undefined) {
+                if (previousFont) {
+                    label.style.fontSize = previousFont;
+                }
+                else {
+                    label.style.removeProperty('font-size');
+                }
+            }
+        }
+        this.resizedFonts.clear();
+        const styles = new Map();
+        const style = (element) => {
+            let result = styles.get(element);
+            if (!result) {
+                result = view.getComputedStyle(element);
+                styles.set(element, result);
+            }
+            return result;
+        };
+        const candidates = labels.flatMap((label, order) => {
+            for (let parent = label; parent; parent = parent.parentElement) {
+                const computed = style(parent);
+                if (computed.display === 'none' ||
+                    computed.visibility === 'hidden' ||
+                    Number(computed.opacity) === 0) {
+                    return [];
+                }
+                if (parent === this.viewport) {
+                    break;
+                }
+            }
+            const screenMatrix = label.getScreenCTM();
+            const matrix = screenMatrix ? normalize.multiply(screenMatrix) : null;
+            const scale = matrix ? Math.hypot(matrix.a, matrix.b) : 0;
+            if (scale <= 0) {
+                return [];
+            }
+            return [
+                {
+                    label,
+                    order,
+                    scale,
+                    matrix: matrix,
+                    baseSize: parseFloat(style(label).fontSize),
+                    priority: Number(label.dataset.labelPriority ?? 0),
+                },
+            ];
+        });
+        // Batch font changes before reading bounds to avoid alternating layout reads/writes.
+        for (const { label, scale, baseSize } of candidates) {
+            if (Number.isFinite(baseSize) && baseSize * scale < 9) {
+                this.resizedFonts.set(label, label.style.fontSize);
+                label.style.fontSize = `${9 / scale}px`;
+            }
+        }
+        const measured = candidates.map((entry) => ({
+            ...entry,
+            box: LabelLayout.transformBox(entry.label.getBBox(), entry.matrix),
+        }));
+        measured.sort((a, b) => b.priority - a.priority || a.order - b.order);
+        const occupied = [];
+        const hidden = [];
+        for (const { label, box } of measured) {
+            const outside = box.right <= box.left ||
+                box.bottom <= box.top ||
+                box.left < viewport.left + 1 ||
+                box.right > viewport.right - 1 ||
+                box.top < viewport.top + 1 ||
+                box.bottom > viewport.bottom - 1;
+            const collision = occupied.some((other) => LabelLayout.overlaps(box, other));
+            if (outside || collision) {
+                hidden.push(label);
+            }
+            else {
+                occupied.push(box);
+            }
+        }
+        for (const label of hidden) {
+            label.setAttribute('visibility', 'hidden');
+            label.setAttribute('data-label-hidden', 'true');
+        }
+    }
+    static transformBox(box, matrix) {
+        const points = [
+            new DOMPoint(box.x, box.y),
+            new DOMPoint(box.x + box.width, box.y),
+            new DOMPoint(box.x, box.y + box.height),
+            new DOMPoint(box.x + box.width, box.y + box.height),
+        ].map((point) => point.matrixTransform(matrix));
+        return {
+            left: Math.min(...points.map((point) => point.x)),
+            right: Math.max(...points.map((point) => point.x)),
+            top: Math.min(...points.map((point) => point.y)),
+            bottom: Math.max(...points.map((point) => point.y)),
+        };
+    }
+    static overlaps(a, b) {
+        const gap = 2;
+        return (a.left < b.right + gap &&
+            a.right + gap > b.left &&
+            a.top < b.bottom + gap &&
+            a.bottom + gap > b.top);
+    }
+}

package/dist/lib/{draw → svg}/SmithArc.d.ts

@@ -1,4 +1,4 @@
-import { Point } from '../shapes/Point.js';
+import { Point } from '../math/geometry.js';
 import { SmithShape } from './SmithShape.js';
 import { SmithDrawOptions } from './SmithDrawOptions.js';
 export declare class SmithArc extends SmithShape {

package/dist/lib/{draw → svg}/SmithCircle.d.ts

@@ -1,4 +1,4 @@
-import { Circle } from '../shapes/Circle.js';
+import { Circle } from '../math/geometry.js';
 import { SmithShape } from './SmithShape.js';
 import { SmithDrawOptions } from './SmithDrawOptions.js';
 export declare class SmithCircle extends SmithShape {

package/dist/lib/{draw → svg}/SmithLine.d.ts

@@ -1,4 +1,4 @@
-import { Point } from '../shapes/Point.js';
+import { Point } from '../math/geometry.js';
 import { SmithShape } from './SmithShape.js';
 import { SmithDrawOptions } from './SmithDrawOptions.js';
 export declare class SmithLine extends SmithShape {

package/dist/lib/{draw → svg}/SmithScaler.d.ts

@@ -1,8 +1,5 @@
 import * as d3 from 'd3';
-import { Circle } from '../shapes/Circle.js';
-import { Point } from '../shapes/Point.js';
-import { Line } from '../shapes/Line.js';
-import { Arc } from '../shapes/Arc.js';
+import type { Circle, Point, Line, Arc } from '../math/geometry.js';
 export declare class SmithScaler {
     readonly x: d3.ScaleLinear<number, number>;
     readonly y: d3.ScaleLinear<number, number>;

package/dist/lib/{draw → svg}/SmithText.d.ts

@@ -1,4 +1,4 @@
-import { Point } from '../shapes/Point.js';
+import { Point } from '../math/geometry.js';
 import { SmithShape } from './SmithShape.js';
 interface TextOptions {
     dx?: string;

package/dist/lib/svg/SvgExporter.d.ts

@@ -0,0 +1,14 @@
+/** Captures rendered SVG with presentation styles resolved in its source document. */
+export declare class SvgExporter {
+    private constructor();
+    private static readonly namespace;
+    private static readonly properties;
+    private static readonly nonInherited;
+    static chart(source: SVGElement): string;
+    /** Preserve the current CSS layout of separate scale SVGs in one SVG document. */
+    static scales(container: HTMLElement, axes: readonly SVGSVGElement[]): string;
+    private static bounds;
+    private static copy;
+    private static size;
+    private static serialize;
+}

package/dist/lib/svg/SvgExporter.js

@@ -0,0 +1,137 @@
+/** Captures rendered SVG with presentation styles resolved in its source document. */
+export class SvgExporter {
+    constructor() { }
+    static namespace = 'http://www.w3.org/2000/svg';
+    static properties = [
+        'color',
+        'display',
+        'visibility',
+        'opacity',
+        'fill',
+        'fill-opacity',
+        'fill-rule',
+        'stroke',
+        'stroke-width',
+        'stroke-opacity',
+        'stroke-dasharray',
+        'stroke-dashoffset',
+        'stroke-linecap',
+        'stroke-linejoin',
+        'stroke-miterlimit',
+        'vector-effect',
+        'paint-order',
+        'shape-rendering',
+        'text-rendering',
+        'font-family',
+        'font-size',
+        'font-style',
+        'font-weight',
+        'font-variant',
+        'font-stretch',
+        'letter-spacing',
+        'word-spacing',
+        'text-anchor',
+        'dominant-baseline',
+        'alignment-baseline',
+        'baseline-shift',
+        'text-decoration',
+        'white-space',
+    ];
+    static nonInherited = new Set([
+        'display',
+        'opacity',
+        'vector-effect',
+        'alignment-baseline',
+        'dominant-baseline',
+        'baseline-shift',
+        'text-decoration',
+    ]);
+    static chart(source) {
+        const bounds = SvgExporter.bounds(source);
+        const copy = SvgExporter.copy(source);
+        SvgExporter.size(copy, bounds.width, bounds.height);
+        return SvgExporter.serialize(copy);
+    }
+    /** Preserve the current CSS layout of separate scale SVGs in one SVG document. */
+    static scales(container, axes) {
+        const bounds = SvgExporter.bounds(container);
+        const root = container.ownerDocument.createElementNS(SvgExporter.namespace, 'svg');
+        root.setAttribute('viewBox', `0 0 ${bounds.width} ${bounds.height}`);
+        SvgExporter.size(root, bounds.width, bounds.height);
+        for (const axis of axes) {
+            const position = SvgExporter.bounds(axis);
+            const copy = SvgExporter.copy(axis);
+            copy.setAttribute('x', String(position.x - bounds.x));
+            copy.setAttribute('y', String(position.y - bounds.y));
+            SvgExporter.size(copy, position.width, position.height);
+            root.appendChild(copy);
+        }
+        return SvgExporter.serialize(root);
+    }
+    static bounds(element) {
+        const bounds = element.getBoundingClientRect();
+        if (!element.isConnected || bounds.width <= 0 || bounds.height <= 0) {
+            throw new Error('SVG export requires a mounted component with a visible, non-zero size.');
+        }
+        return bounds;
+    }
+    static copy(source) {
+        const copy = source.cloneNode(true);
+        const originals = [source, ...source.querySelectorAll('*')];
+        const copies = [copy, ...copy.querySelectorAll('*')];
+        const view = source.ownerDocument.defaultView;
+        const styles = new Map(originals.map((element) => [element, view.getComputedStyle(element)]));
+        originals.forEach((original, index) => {
+            const element = copies[index];
+            const style = styles.get(original);
+            const parentStyle = original.parentElement ? styles.get(original.parentElement) : undefined;
+            // Keep SVG geometry/transform attributes, but replace page-dependent CSS.
+            element.removeAttribute('style');
+            for (const property of SvgExporter.properties) {
+                const value = style.getPropertyValue(property);
+                element.removeAttribute(property);
+                // Resolve inherited values at their boundary instead of repeating every font and
+                // stroke property on thousands of descendants. CSS overrides may replace attributes.
+                if (value &&
+                    (SvgExporter.nonInherited.has(property) ||
+                        parentStyle?.getPropertyValue(property) !== value)) {
+                    element.style.setProperty(property, value);
+                }
+            }
+            // An exported image has no event handlers or interactive controls.
+            element.removeAttribute('tabindex');
+            if (original.getAttribute('data-role') === 'marker') {
+                // A static marker is an image, not an operable sample slider.
+                element.setAttribute('role', 'img');
+                element.setAttribute('aria-label', `${original.getAttribute('aria-label')}; ${original.getAttribute('aria-valuetext')}`);
+                for (const attribute of [
+                    'aria-valuemin',
+                    'aria-valuemax',
+                    'aria-valuenow',
+                    'aria-valuetext',
+                    'aria-orientation',
+                    'aria-description',
+                    'aria-disabled',
+                ]) {
+                    element.removeAttribute(attribute);
+                }
+            }
+            element.removeAttribute('class');
+            for (const attribute of [...element.attributes]) {
+                if (attribute.name.startsWith('on')) {
+                    element.removeAttribute(attribute.name);
+                }
+            }
+        });
+        return copy;
+    }
+    static size(svg, width, height) {
+        svg.setAttribute('width', String(width));
+        svg.setAttribute('height', String(height));
+        svg.style.setProperty('overflow', 'hidden');
+    }
+    static serialize(svg) {
+        svg.setAttribute('xmlns', SvgExporter.namespace);
+        return new XMLSerializer().serializeToString(svg);
+    }
+}