layerchart 2.0.0-next.6 → 2.0.0-next.61

package/dist/states/transform.svelte.js

@@ -0,0 +1,408 @@
+import { createControlledMotion, createMotionTracker, parseMotionProp, } from '../utils/motion.svelte.js';
+import { localPoint } from '@layerstack/utils';
+import { watch } from 'runed';
+export const DEFAULT_TRANSLATE = { x: 0, y: 0 };
+export const DEFAULT_SCALE = 1;
+export class TransformState {
+    // Context reference
+    ctx;
+    // Options
+    mode;
+    axis;
+    processTranslate;
+    disablePointer;
+    clickDistance;
+    initialTranslate;
+    initialScale;
+    onTransform;
+    ondragstart;
+    ondragend;
+    scrollActivationKey;
+    scaleExtent;
+    translateExtent;
+    constrain;
+    inertia;
+    // State
+    pointerDown = $state(false);
+    dragging = $state(false);
+    scrollMode = $state('none');
+    startPoint = $state({ x: 0, y: 0 });
+    startTranslate = $state({ x: 0, y: 0 });
+    // Velocity tracking for inertia
+    _pointerSamples = [];
+    // Motion controllers (internal)
+    _translate;
+    _scale;
+    _translating;
+    _scaling;
+    constructor(ctx, options = {}) {
+        this.ctx = ctx;
+        // Initialize options with defaults
+        this.mode = options.mode ?? 'none';
+        this.axis = options.axis ?? 'both';
+        this.processTranslate = options.processTranslate;
+        this.disablePointer = options.disablePointer ?? false;
+        this.clickDistance = options.clickDistance ?? 10;
+        this.initialTranslate = options.initialTranslate ?? DEFAULT_TRANSLATE;
+        this.initialScale = options.initialScale ?? DEFAULT_SCALE;
+        this.onTransform = options.onTransform ?? (() => { });
+        this.ondragstart = options.ondragstart ?? (() => { });
+        this.ondragend = options.ondragend ?? (() => { });
+        this.scrollActivationKey = options.scrollActivationKey;
+        this.scaleExtent = options.scaleExtent;
+        this.translateExtent = options.translateExtent;
+        this.constrain = options.constrain;
+        // Inertia
+        const inertiaOpt = options.inertia;
+        if (inertiaOpt === true) {
+            this.inertia = {
+                enabled: true,
+                decay: 0.99,
+                minVelocity: 0.1,
+                maxVelocity: Infinity,
+                velocityWindow: 160,
+            };
+        }
+        else if (typeof inertiaOpt === 'object') {
+            this.inertia = {
+                enabled: true,
+                decay: inertiaOpt.decay ?? 0.99,
+                minVelocity: inertiaOpt.minVelocity ?? 0.1,
+                maxVelocity: inertiaOpt.maxVelocity ?? Infinity,
+                velocityWindow: inertiaOpt.velocityWindow ?? 160,
+            };
+        }
+        else {
+            this.inertia = {
+                enabled: false,
+                decay: 0.99,
+                minVelocity: 0.1,
+                maxVelocity: Infinity,
+                velocityWindow: 160,
+            };
+        }
+        this.scrollMode = options.scrollMode ?? (this.mode === 'domain' ? 'scale' : 'none');
+        // Initialize motion controllers
+        const resolvedMotion = parseMotionProp(options.motion);
+        this._translate = createControlledMotion(this.initialTranslate, resolvedMotion);
+        this._scale = createControlledMotion(this.initialScale, resolvedMotion);
+        this._translating = createMotionTracker();
+        this._scaling = createMotionTracker();
+        // Watch for transform changes
+        watch([() => this._scale.current, () => this._translate.current], () => {
+            this.onTransform({
+                scale: this._scale.current,
+                translate: this._translate.current,
+            });
+        });
+    }
+    _applyTranslate(x, y, deltaX, deltaY) {
+        if (this.processTranslate)
+            return this.processTranslate(x, y, deltaX, deltaY);
+        if (this.mode === 'domain') {
+            // Negate deltaY because screen Y (top→bottom) is inverted vs data Y (bottom→top).
+            // This works for both normal and reversed Y domains because _computeTransformDomain
+            // uses signed range, which naturally handles the reversal.
+            if (this.axis === 'x')
+                return { x: x + deltaX, y: 0 };
+            if (this.axis === 'y')
+                return { x: 0, y: y - deltaY };
+            return { x: x + deltaX, y: y - deltaY };
+        }
+        return { x: x + deltaX, y: y + deltaY };
+    }
+    /** Clamp scale and translate using scaleExtent, translateExtent, and custom constrain. */
+    _clampScale(value) {
+        if (this.scaleExtent) {
+            value = Math.max(this.scaleExtent[0], Math.min(this.scaleExtent[1], value));
+        }
+        return value;
+    }
+    _clampTranslate(point) {
+        let { x, y } = point;
+        if (this.translateExtent) {
+            const [[minX, minY], [maxX, maxY]] = this.translateExtent;
+            x = Math.max(minX, Math.min(maxX, x));
+            y = Math.max(minY, Math.min(maxY, y));
+        }
+        return { x, y };
+    }
+    _applyConstraints(scale, translate) {
+        scale = this._clampScale(scale);
+        translate = this._clampTranslate(translate);
+        if (this.constrain) {
+            const constrained = this.constrain({ scale, translate });
+            scale = constrained.scale;
+            translate = constrained.translate;
+        }
+        return { scale, translate };
+    }
+    // Derived state
+    get moving() {
+        return this.dragging || this._translating.current || this._scaling.current;
+    }
+    // Public getters and setters for scale and translate
+    get scale() {
+        return this._scale.current;
+    }
+    set scale(value) {
+        this.setScale(value);
+    }
+    get translate() {
+        return this._translate.current;
+    }
+    set translate(point) {
+        this.setTranslate(point);
+    }
+    setScrollMode(mode) {
+        this.scrollMode = mode;
+    }
+    reset() {
+        this._translate.target = this.initialTranslate;
+        this._scale.target = this.initialScale;
+    }
+    zoomIn() {
+        if (!this.ctx)
+            return;
+        this.scaleTo(1.25, {
+            x: (this.ctx.width + this.ctx.padding.left) / 2,
+            y: (this.ctx.height + this.ctx.padding.top) / 2,
+        });
+    }
+    zoomOut() {
+        if (!this.ctx)
+            return;
+        this.scaleTo(0.8, {
+            x: (this.ctx.width + this.ctx.padding.left) / 2,
+            y: (this.ctx.height + this.ctx.padding.top) / 2,
+        });
+    }
+    translateCenter() {
+        this._translate.target = { x: 0, y: 0 };
+    }
+    zoomTo(center, rect) {
+        if (!this.ctx)
+            return;
+        let newScale = rect
+            ? this.ctx.width < this.ctx.height
+                ? this.ctx.width / rect.width
+                : this.ctx.height / rect.height
+            : 1;
+        newScale = this._clampScale(newScale);
+        const newTranslate = {
+            x: this.ctx.width / 2 - center.x * newScale,
+            y: this.ctx.height / 2 - center.y * newScale,
+        };
+        const constrained = this._applyConstraints(newScale, newTranslate);
+        this._translate.target = constrained.translate;
+        if (rect) {
+            this._scale.target = constrained.scale;
+        }
+    }
+    setTranslate(point, options) {
+        const constrained = this._applyConstraints(this._scale.current, point);
+        this._translating.handle(this._translate.set(constrained.translate, options));
+    }
+    setScale(value, options) {
+        const clamped = this._clampScale(value);
+        this._scaling.handle(this._scale.set(clamped, options));
+    }
+    scaleTo(value, point, options = undefined) {
+        if (!this.ctx)
+            return;
+        // In domain mode, reflect Y point because screen Y is inverted vs data Y.
+        // This ensures zoom targets the correct data position under the cursor.
+        if (this.mode === 'domain' && this.axis !== 'x') {
+            point = {
+                x: point.x,
+                y: this.ctx.padding.top + this.ctx.height - (point.y - this.ctx.padding.top),
+            };
+        }
+        const currentScale = this._scale.current;
+        const newScale = this._clampScale(this._scale.current * value);
+        this.setScale(newScale, options);
+        // Translate towards point (ex. mouse cursor/center) while zooming in/out
+        if (!this.processTranslate) {
+            const invertTransformPoint = {
+                x: (point.x - this.ctx.padding.left - this._translate.current.x) / currentScale,
+                y: (point.y - this.ctx.padding.top - this._translate.current.y) / currentScale,
+            };
+            const newTranslate = {
+                x: point.x - this.ctx.padding.left - invertTransformPoint.x * newScale,
+                y: point.y - this.ctx.padding.top - invertTransformPoint.y * newScale,
+            };
+            // Constrain translate to active axis in domain mode
+            if (this.mode === 'domain') {
+                if (this.axis === 'x')
+                    newTranslate.y = 0;
+                if (this.axis === 'y')
+                    newTranslate.x = 0;
+            }
+            this.setTranslate(newTranslate, options);
+        }
+    }
+    onPointerDown(e) {
+        if (this.mode === 'none' || this.disablePointer)
+            return;
+        e.preventDefault();
+        this.pointerDown = true;
+        this.dragging = false;
+        this.startPoint = localPoint(e);
+        this.startTranslate = this._translate.current;
+        this._pointerSamples = [];
+        this.ondragstart?.();
+    }
+    onPointerMove(e) {
+        if (!this.pointerDown)
+            return;
+        e.preventDefault(); // Stop text selection
+        const endPoint = localPoint(e);
+        const deltaX = endPoint.x - this.startPoint.x;
+        const deltaY = endPoint.y - this.startPoint.y;
+        if (!this.dragging) {
+            // If dragged beyond threshold, disable click propagation
+            this.dragging = deltaX * deltaX + deltaY * deltaY > this.clickDistance;
+        }
+        if (this.dragging) {
+            e.stopPropagation(); // Stop tooltip from triggering (along with `capture: true`)
+            e.currentTarget?.setPointerCapture(e.pointerId);
+            // Track pointer samples for inertia velocity calculation
+            if (this.inertia.enabled) {
+                const now = performance.now();
+                this._pointerSamples.push({ x: endPoint.x, y: endPoint.y, t: now });
+                // Trim to keep only samples within the velocity window (plus some buffer)
+                const windowStart = now - this.inertia.velocityWindow * 2;
+                while (this._pointerSamples.length > 2 && this._pointerSamples[0].t < windowStart) {
+                    this._pointerSamples.shift();
+                }
+            }
+            this.setTranslate(this._applyTranslate(this.startTranslate.x, this.startTranslate.y, deltaX, deltaY), this._translate.type === 'spring'
+                ? { instant: true }
+                : this._translate.type === 'tween'
+                    ? { duration: 0 }
+                    : undefined);
+        }
+    }
+    onPointerUp(_e) {
+        const wasDragging = this.dragging;
+        this.pointerDown = false;
+        this.dragging = false;
+        // Apply inertia if enabled and was dragging with enough velocity
+        if (this.inertia.enabled && wasDragging && this._pointerSamples.length >= 2) {
+            const now = performance.now();
+            // Filter samples to the velocity measurement window
+            const windowStart = now - this.inertia.velocityWindow;
+            const recentSamples = this._pointerSamples.filter((s) => s.t >= windowStart);
+            if (recentSamples.length >= 2) {
+                // Compute velocity using recency-weighted per-segment approach.
+                // More recent segments get higher weight, so the final gesture
+                // direction/speed dominates over earlier movement in the window.
+                let weightedVx = 0;
+                let weightedVy = 0;
+                let totalWeight = 0;
+                for (let i = 1; i < recentSamples.length; i++) {
+                    const prev = recentSamples[i - 1];
+                    const curr = recentSamples[i];
+                    const segDt = curr.t - prev.t;
+                    if (segDt <= 0)
+                        continue;
+                    const segVx = (curr.x - prev.x) / segDt;
+                    const segVy = (curr.y - prev.y) / segDt;
+                    // Quadratic recency weight: recent segments contribute more
+                    const recency = (curr.t - windowStart) / this.inertia.velocityWindow;
+                    const weight = recency * recency;
+                    weightedVx += segVx * weight;
+                    weightedVy += segVy * weight;
+                    totalWeight += weight;
+                }
+                if (totalWeight > 0) {
+                    let vx = weightedVx / totalWeight;
+                    let vy = weightedVy / totalWeight;
+                    let speed = Math.sqrt(vx * vx + vy * vy);
+                    // Cap velocity to prevent wild throws
+                    if (speed > this.inertia.maxVelocity) {
+                        const ratio = this.inertia.maxVelocity / speed;
+                        vx *= ratio;
+                        vy *= ratio;
+                        speed = this.inertia.maxVelocity;
+                    }
+                    if (speed > this.inertia.minVelocity) {
+                        // Project target: velocity * decay multiplier (converts decay 0-1 to a distance factor)
+                        // With decay=0.99, factor = 100, giving a natural coast distance
+                        const factor = 1 / (1 - this.inertia.decay);
+                        const current = this._translate.current;
+                        const projectedX = current.x + vx * factor;
+                        const projectedY = current.y + vy * factor;
+                        // For tween motion, compute coast duration proportional to velocity.
+                        // Faster flings coast longer (similar to MapLibre/Google Maps behavior).
+                        const motionOptions = this._translate.type === 'tween'
+                            ? { duration: Math.min(speed * 500, 1200) }
+                            : undefined;
+                        this.setTranslate(this._applyTranslate(current.x, current.y, projectedX - current.x, projectedY - current.y), motionOptions);
+                    }
+                }
+            }
+            this._pointerSamples = [];
+        }
+        this.ondragend?.();
+    }
+    onDoubleClick(e) {
+        if (this.mode === 'none')
+            return;
+        const point = localPoint(e);
+        this.scaleTo(e.shiftKey ? 0.5 : 2, point);
+    }
+    _isActivationKeyHeld(e) {
+        if (!this.scrollActivationKey)
+            return true;
+        switch (this.scrollActivationKey) {
+            case 'meta':
+                return e.metaKey;
+            case 'alt':
+                return e.altKey;
+            case 'control':
+                return e.ctrlKey;
+            case 'shift':
+                return e.shiftKey;
+        }
+    }
+    onWheel(e) {
+        if (this.mode === 'none' || this.scrollMode === 'none')
+            return;
+        if (!this._isActivationKeyHeld(e))
+            return;
+        e.preventDefault();
+        const point = (this.startPoint = localPoint(e));
+        // Pinch to zoom is registered as a wheel event with control key
+        const pinchToZoom = e.ctrlKey;
+        const instantMotionOptions = this._scale.type === 'spring'
+            ? { instant: true }
+            : this._scale.type === 'tween'
+                ? { duration: 0 }
+                : undefined;
+        if (this.scrollMode === 'scale' || pinchToZoom) {
+            // https://github.com/d3/d3-zoom#zoom_wheelDelta
+            const scaleBy = -e.deltaY * (e.deltaMode === 1 ? 0.05 : e.deltaMode ? 1 : 0.002) * (e.ctrlKey ? 10 : 1);
+            this.scaleTo(Math.pow(2, scaleBy), point, instantMotionOptions);
+            // In domain mode, also handle deltaX as pan (for trackpad horizontal scroll)
+            if (this.mode === 'domain' && e.deltaX !== 0) {
+                const startTranslate = this._translate.current;
+                this.setTranslate(this._applyTranslate(startTranslate.x, startTranslate.y, -e.deltaX, 0), instantMotionOptions);
+            }
+        }
+        else if (this.scrollMode === 'translate') {
+            const startTranslate = this._translate.current;
+            this._translate
+                .set(this._applyTranslate(startTranslate.x, startTranslate.y, -e.deltaX, -e.deltaY), instantMotionOptions)
+                .then(() => { })
+                .catch(() => { });
+        }
+    }
+}
+export function createDefaultTransformState() {
+    return new TransformState(null, {
+        mode: 'none',
+        initialTranslate: DEFAULT_TRANSLATE,
+        initialScale: DEFAULT_SCALE,
+    });
+}

package/dist/styles/daisyui-5.css

@@ -0,0 +1,6 @@
+.lc-root-container {
+  --color-surface-100: var(--color-base-100);
+  --color-surface-200: var(--color-base-200);
+  --color-surface-300: var(--color-base-300);
+  --color-surface-content: var(--color-base-content);
+}

package/dist/styles/shadcn-svelte.css

@@ -0,0 +1,11 @@
+/*
+  When NOT using shadcn-svelte Chart component.
+  Not typically needed even when using built-in Chart, as defaults typically are sufficient
+*/
+.lc-root-container {
+  --color-primary: var(--primary);
+  --color-surface-100: var(--card-background);
+  --color-surface-200: var(--card-muted);
+  /* No direct mapping, should add explicit color (light and dark mode) */
+  --color-surface-content: var(--card-foreground);
+}

package/dist/styles/skeleton-3.css

@@ -0,0 +1,15 @@
+.lc-root-container {
+  --color-primary: var(--color-primary-500);
+
+  --color-surface-100: var(--color-surface-50);
+  --color-surface-200: var(--color-surface-100);
+  --color-surface-300: var(--color-surface-200);
+  --color-surface-content: var(--base-font-color);
+
+  html.dark & {
+    --color-surface-100: var(--color-surface-700);
+    --color-surface-200: var(--color-surface-800);
+    --color-surface-300: var(--color-surface-900);
+    --color-surface-content: var(--base-font-color-dark);
+  }
+}

package/dist/styles/skeleton-4.css

@@ -0,0 +1,15 @@
+.lc-root-container {
+  --color-primary: var(--color-primary-500);
+
+  --color-surface-100: var(--color-surface-50);
+  --color-surface-200: var(--color-surface-100);
+  --color-surface-300: var(--color-surface-200);
+  --color-surface-content: var(--base-font-color);
+
+  html.dark & {
+    --color-surface-100: var(--color-surface-700);
+    --color-surface-200: var(--color-surface-800);
+    --color-surface-300: var(--color-surface-900);
+    --color-surface-content: var(--base-font-color-dark);
+  }
+}

package/dist/svg.d.ts

@@ -0,0 +1,178 @@
+/**
+ * SVG-only variants of layer-agnostic components.
+ *
+ * Each export here is a SVG-specific implementation that skips the runtime
+ * layer-detection branches in the agnostic version (e.g. `Circle.svelte`).
+ * Use these when you know your chart only renders to SVG and want a smaller
+ * bundle.
+ *
+ * The agnostic versions (e.g. `import { Circle } from './index.js'`) still
+ * work and dispatch to these per-layer variants under the hood.
+ */
+export { default as Svg, default as Layer } from './components/layers/Svg.svelte';
+export type { SVGProps } from './components/layers/Svg.svelte';
+export { default as Chart } from './components/Chart/Chart.svg.svelte';
+export { default as ChartCore } from './components/Chart/ChartCore.svelte';
+export type { ChartProps, ChartPropsWithoutHTML, ChartResizeDetail, PreservedChartConfig, LayerChartInternalMeta, } from './components/Chart/Chart.shared.svelte.js';
+export { default as ChartChildren } from './components/ChartChildren/ChartChildren.svg.svelte';
+export type { ChartChildrenProps } from './components/ChartChildren/ChartChildren.shared.svelte.js';
+export { default as Circle } from './components/Circle/Circle.svg.svelte';
+export type { CircleProps, CirclePropsWithoutHTML } from './components/Circle/Circle.shared.svelte.js';
+export { default as Text } from './components/Text/Text.svg.svelte';
+export type { TextProps, TextPropsWithoutHTML, TextSegment, } from './components/Text/Text.shared.svelte.js';
+export { default as Rect } from './components/Rect/Rect.svg.svelte';
+export type { RectProps, RectPropsWithoutHTML, } from './components/Rect/Rect.shared.svelte.js';
+export { default as Line } from './components/Line/Line.svg.svelte';
+export type { LineProps, LinePropsWithoutHTML, } from './components/Line/Line.shared.svelte.js';
+export { default as Path } from './components/Path/Path.svg.svelte';
+export type { PathProps, PathPropsWithoutHTML, } from './components/Path/Path.shared.svelte.js';
+export { default as ClipPath } from './components/ClipPath/ClipPath.svg.svelte';
+export type { ClipPathProps, ClipPathPropsWithoutHTML, } from './components/ClipPath/ClipPath.shared.svelte.js';
+export { default as RadialGradient } from './components/RadialGradient/RadialGradient.svg.svelte';
+export type { RadialGradientProps, RadialGradientPropsWithoutHTML, } from './components/RadialGradient/RadialGradient.shared.svelte.js';
+export { default as LinearGradient } from './components/LinearGradient/LinearGradient.svg.svelte';
+export type { LinearGradientProps, LinearGradientPropsWithoutHTML, } from './components/LinearGradient/LinearGradient.shared.svelte.js';
+export { default as Group } from './components/Group/Group.svg.svelte';
+export type { GroupProps, GroupPropsWithoutHTML, } from './components/Group/Group.shared.svelte.js';
+export { default as Pattern } from './components/Pattern/Pattern.svg.svelte';
+export type { PatternProps, PatternPropsWithoutHTML, PatternShape, CircleShape, LineShape, } from './components/Pattern/Pattern.shared.svelte.js';
+export { default as Ellipse } from './components/Ellipse/Ellipse.svg.svelte';
+export type { EllipseProps, EllipsePropsWithoutHTML, } from './components/Ellipse/Ellipse.shared.svelte.js';
+export { default as Polygon } from './components/Polygon/Polygon.svg.svelte';
+export type { PolygonProps, PolygonPropsWithoutHTML, } from './components/Polygon/Polygon.shared.svelte.js';
+export { default as Image } from './components/Image/Image.svg.svelte';
+export type { ImageProps, ImagePropsWithoutHTML, } from './components/Image/Image.shared.svelte.js';
+export { default as Axis } from './components/Axis/Axis.svg.svelte';
+export type { AxisProps, AxisPropsWithoutHTML, } from './components/Axis/Axis.shared.svelte.js';
+export { default as Rule } from './components/Rule/Rule.svg.svelte';
+export type { RuleProps, RulePropsWithoutHTML, } from './components/Rule/Rule.shared.svelte.js';
+export { default as Grid } from './components/Grid/Grid.svg.svelte';
+export type { GridProps, GridPropsWithoutHTML, } from './components/Grid/Grid.shared.svelte.js';
+export { default as Highlight } from './components/Highlight/Highlight.svg.svelte';
+export type { HighlightProps, HighlightPropsWithoutHTML, HighlightPoint, HighlightPointData, } from './components/Highlight/Highlight.shared.svelte.js';
+export { default as Arc } from './components/Arc/Arc.svg.svelte';
+export type { ArcProps, ArcPropsWithoutHTML } from './components/Arc/Arc.shared.svelte.js';
+export { default as Spline } from './components/Spline/Spline.svg.svelte';
+export type { SplineProps, SplinePropsWithoutHTML, } from './components/Spline/Spline.shared.svelte.js';
+export { default as Area } from './components/Area/Area.svg.svelte';
+export type { AreaProps, AreaPropsWithoutHTML, } from './components/Area/Area.shared.svelte.js';
+export { default as Pie } from './components/Pie/Pie.svg.svelte';
+export type { PieProps, PiePropsWithoutHTML } from './components/Pie/Pie.shared.svelte.js';
+export { default as ArcLabel } from './components/ArcLabel/ArcLabel.svg.svelte';
+export type { ArcLabelProps, ArcLabelConfig, ArcLabelPlacement, } from './components/ArcLabel/ArcLabel.shared.svelte.js';
+export { default as Bar } from './components/Bar/Bar.svg.svelte';
+export type { BarProps, BarPropsWithoutHTML } from './components/Bar/Bar.shared.svelte.js';
+export { default as Bars } from './components/Bars/Bars.svg.svelte';
+export type { BarsProps, BarsPropsWithoutHTML, } from './components/Bars/Bars.shared.svelte.js';
+export { default as Points } from './components/Points/Points.svg.svelte';
+export type { PointsProps, PointsPropsWithoutHTML, Point as PointDatum, } from './components/Points/Points.shared.svelte.js';
+export { default as Labels } from './components/Labels/Labels.svg.svelte';
+export type { LabelsProps, LabelsPropsWithoutHTML, } from './components/Labels/Labels.shared.svelte.js';
+export { default as Frame } from './components/Frame/Frame.svg.svelte';
+export type { FrameProps, FramePropsWithoutHTML, } from './components/Frame/Frame.shared.svelte.js';
+export { default as Cell } from './components/Cell/Cell.svg.svelte';
+export type { CellProps } from './components/Cell/Cell.shared.svelte.js';
+export { default as Threshold } from './components/Threshold/Threshold.svg.svelte';
+export type { ThresholdProps, ThresholdSnippetProps, } from './components/Threshold/Threshold.shared.svelte.js';
+export { default as AnnotationLine } from './components/AnnotationLine/AnnotationLine.svg.svelte';
+export type { AnnotationLineProps, AnnotationLinePropsWithoutHTML, } from './components/AnnotationLine/AnnotationLine.shared.svelte.js';
+export { default as AnnotationPoint } from './components/AnnotationPoint/AnnotationPoint.svg.svelte';
+export type { AnnotationPointProps, AnnotationPointPropsWithoutHTML, } from './components/AnnotationPoint/AnnotationPoint.shared.svelte.js';
+export { default as Trail } from './components/Trail/Trail.svg.svelte';
+export type { TrailProps, TrailPropsWithoutHTML, } from './components/Trail/Trail.shared.svelte.js';
+export { default as Vector } from './components/Vector/Vector.svg.svelte';
+export type { VectorProps, VectorPropsWithoutHTML, VectorShape, } from './components/Vector/Vector.shared.svelte.js';
+export { default as Link } from './components/Link/Link.svg.svelte';
+export type { LinkProps, LinkPropsWithoutHTML } from './components/Link/Link.shared.svelte.js';
+export { default as AnnotationRange } from './components/AnnotationRange/AnnotationRange.svg.svelte';
+export type { AnnotationRangeProps, AnnotationRangePropsWithoutHTML, } from './components/AnnotationRange/AnnotationRange.shared.svelte.js';
+export { default as Hull } from './components/Hull/Hull.svg.svelte';
+export type { HullProps, HullPropsWithoutHTML } from './components/Hull/Hull.shared.svelte.js';
+export { default as Density } from './components/Density/Density.svg.svelte';
+export type { DensityProps, DensityPropsWithoutHTML, } from './components/Density/Density.shared.svelte.js';
+export { default as Calendar } from './components/Calendar/Calendar.svg.svelte';
+export type { CalendarProps, CalendarPropsWithoutHTML, CalendarCell, } from './components/Calendar/Calendar.shared.svelte.js';
+export { default as CircleClipPath } from './components/CircleClipPath/CircleClipPath.svg.svelte';
+export type { CircleClipPathPropsWithoutHTML } from './components/CircleClipPath/CircleClipPath.shared.svelte.js';
+export { default as Voronoi } from './components/Voronoi/Voronoi.svg.svelte';
+export type { VoronoiProps, VoronoiPropsWithoutHTML, } from './components/Voronoi/Voronoi.shared.svelte.js';
+export { default as Contour } from './components/Contour/Contour.svg.svelte';
+export type { ContourProps, ContourPropsWithoutHTML, } from './components/Contour/Contour.shared.svelte.js';
+export { default as Month } from './components/Month/Month.svg.svelte';
+export type { MonthProps, MonthPropsWithoutHTML, MonthCell, } from './components/Month/Month.shared.svelte.js';
+export { default as Raster } from './components/Raster/Raster.svg.svelte';
+export type { RasterProps, RasterPropsWithoutHTML, } from './components/Raster/Raster.shared.svelte.js';
+export { default as Violin } from './components/Violin/Violin.svg.svelte';
+export type { ViolinProps, ViolinPropsWithoutHTML, } from './components/Violin/Violin.shared.svelte.js';
+export { default as BoxPlot } from './components/BoxPlot/BoxPlot.svg.svelte';
+export type { BoxPlotProps, BoxPlotPropsWithoutHTML, } from './components/BoxPlot/BoxPlot.shared.svelte.js';
+export { default as GeoPath } from './components/geo/GeoPath/GeoPath.svg.svelte';
+export type { GeoPathProps, GeoPathPropsWithoutHTML, } from './components/geo/GeoPath/GeoPath.shared.svelte.js';
+export { default as GeoSpline } from './components/geo/GeoSpline/GeoSpline.svg.svelte';
+export type { GeoSplineProps, GeoSplinePropsWithoutHTML, } from './components/geo/GeoSpline/GeoSpline.shared.svelte.js';
+export { default as GeoPoint } from './components/geo/GeoPoint/GeoPoint.svg.svelte';
+export type { GeoPointProps, GeoPointPropsWithoutHTML, } from './components/geo/GeoPoint/GeoPoint.shared.svelte.js';
+export { default as GeoCircle } from './components/geo/GeoCircle/GeoCircle.svg.svelte';
+export type { GeoCircleProps, GeoCirclePropsWithoutHTML, } from './components/geo/GeoCircle/GeoCircle.shared.svelte.js';
+export { default as GeoClipPath } from './components/geo/GeoClipPath/GeoClipPath.svg.svelte';
+export type { GeoClipPathProps, GeoClipPathPropsWithoutHTML, } from './components/geo/GeoClipPath/GeoClipPath.shared.svelte.js';
+export { default as GeoEdgeFade } from './components/geo/GeoEdgeFade/GeoEdgeFade.svg.svelte';
+export type { GeoEdgeFadeProps, GeoEdgeFadePropsWithoutHTML, } from './components/geo/GeoEdgeFade/GeoEdgeFade.shared.svelte.js';
+export { default as GeoTile } from './components/geo/GeoTile/GeoTile.svg.svelte';
+export type { GeoTilePropsWithoutHTML } from './components/geo/GeoTile/GeoTile.shared.svelte.js';
+export { default as TileImage } from './components/geo/TileImage/TileImage.svg.svelte';
+export type { TileImageProps, TileImagePropsWithoutHTML, } from './components/geo/TileImage/TileImage.shared.svelte.js';
+export { default as Graticule } from './components/geo/Graticule/Graticule.svg.svelte';
+export type { GraticuleProps, GraticulePropsWithoutHTML, } from './components/geo/Graticule/Graticule.shared.svelte.js';
+export { default as Ribbon } from './components/graph/Ribbon/Ribbon.svg.svelte';
+export type { RibbonProps, RibbonPropsWithoutHTML, } from './components/graph/Ribbon/Ribbon.shared.svelte.js';
+export { default as Blur } from './components/Blur.svelte';
+export * from './components/Blur.svelte';
+export { default as Bounds } from './components/Bounds.svelte';
+export * from './components/Bounds.svelte';
+export { default as BrushContext } from './components/BrushContext.svelte';
+export * from './components/BrushContext.svelte';
+export { default as CircleLegend } from './components/CircleLegend.svelte';
+export * from './components/CircleLegend.svelte';
+export { default as ColorRamp } from './components/ColorRamp.svelte';
+export * from './components/ColorRamp.svelte';
+export { default as Legend } from './components/Legend.svelte';
+export * from './components/Legend.svelte';
+export { default as MotionPath } from './components/MotionPath.svelte';
+export * from './components/MotionPath.svelte';
+export { default as Point } from './components/Point.svelte';
+export * from './components/Point.svelte';
+export { default as TransformContext } from './components/TransformContext.svelte';
+export * from './components/TransformContext.svelte';
+export * as Tooltip from './components/tooltip/index.js';
+export * from './components/tooltip/TooltipContext.svelte';
+export { default as LineChart } from './components/charts/LineChart/LineChart.svg.svelte';
+export { default as AreaChart } from './components/charts/AreaChart/AreaChart.svg.svelte';
+export { default as BarChart } from './components/charts/BarChart/BarChart.svg.svelte';
+export { default as PieChart } from './components/charts/PieChart/PieChart.svg.svelte';
+export { default as ScatterChart } from './components/charts/ScatterChart/ScatterChart.svg.svelte';
+export { default as ArcChart } from './components/charts/ArcChart/ArcChart.svg.svelte';
+export { default as Tree } from './components/hierarchy/Tree.svelte';
+export * from './components/hierarchy/Tree.svelte';
+export { default as Treemap } from './components/hierarchy/Treemap.svelte';
+export * from './components/hierarchy/Treemap.svelte';
+export { default as Pack } from './components/hierarchy/Pack.svelte';
+export * from './components/hierarchy/Pack.svelte';
+export { default as Partition } from './components/hierarchy/Partition.svelte';
+export * from './components/hierarchy/Partition.svelte';
+export { default as Chord } from './components/graph/Chord.svelte';
+export * from './components/graph/Chord.svelte';
+export { default as Dagre } from './components/graph/Dagre.svelte';
+export * from './components/graph/Dagre.svelte';
+export { default as Sankey } from './components/graph/Sankey.svelte';
+export * from './components/graph/Sankey.svelte';
+export { default as ForceSimulation } from './components/force/ForceSimulation.svelte';
+export * from './components/force/ForceSimulation.svelte';
+export { default as GeoLegend } from './components/geo/GeoLegend/GeoLegend.svelte';
+export { default as GeoProjection } from './components/geo/GeoProjection/GeoProjection.svelte';
+export { default as GeoRaster } from './components/geo/GeoRaster/GeoRaster.svelte';
+export { default as GeoVisible } from './components/geo/GeoVisible/GeoVisible.svelte';
+export { default as RectClipPath } from './components/RectClipPath/RectClipPath.svg.svelte';
+export type { RectClipPathProps, RectClipPathPropsWithoutHTML, } from './components/RectClipPath/RectClipPath.shared.svelte.js';
+export { default as ChartClipPath } from './components/ChartClipPath/ChartClipPath.svg.svelte';
+export type { ChartClipPathProps, ChartClipPathPropsWithoutHTML, } from './components/ChartClipPath/ChartClipPath.shared.svelte.js';