layerchart 2.0.0-next.60 → 2.0.0-next.62

package/dist/components/Vector/Vector.base.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { Component } from 'svelte';
+import type { VectorProps } from './Vector.shared.svelte.js';
+export type VectorBaseLayerComponents = {
+    Path: Component<any>;
+};
+export type VectorBaseProps = VectorProps & VectorBaseLayerComponents;
+declare const Vector: Component<VectorBaseProps, {}, "">;
+type Vector = ReturnType<typeof Vector>;
+export default Vector;

package/dist/components/Vector/Vector.canvas.svelte

@@ -0,0 +1,13 @@
+<script lang="ts" module>
+  export type { VectorProps, VectorPropsWithoutHTML, VectorShape } from './Vector.shared.svelte.js';
+</script>
+
+<script lang="ts">
+  import VectorBase from './Vector.base.svelte';
+  import Path from '../Path/Path.canvas.svelte';
+  import type { VectorProps } from './Vector.shared.svelte.js';
+
+  let props: VectorProps = $props();
+</script>
+
+<VectorBase {Path} {...props} />

package/dist/components/Vector/Vector.canvas.svelte.d.ts

@@ -0,0 +1,5 @@
+export type { VectorProps, VectorPropsWithoutHTML, VectorShape } from './Vector.shared.svelte.js';
+import type { VectorProps } from './Vector.shared.svelte.js';
+declare const Vector: import("svelte").Component<VectorProps, {}, "">;
+type Vector = ReturnType<typeof Vector>;
+export default Vector;

package/dist/components/Vector/Vector.shared.svelte.d.ts

@@ -0,0 +1,37 @@
+import type { Snippet } from 'svelte';
+import type { SVGAttributes } from 'svelte/elements';
+import type { Without } from '../../utils/types.js';
+import type { DataProp, DataDrivenStyleProps } from '../../utils/dataProp.js';
+import type { VectorAnchor } from '../../utils/path.js';
+import type { MotionProp } from '../../utils/motion.svelte.js';
+export type VectorShape = 'arrow' | 'arrow-filled' | 'spike';
+export type VectorPropsWithoutHTML = {
+    /** @default 0 */
+    x?: DataProp;
+    /** @default x */
+    initialX?: number;
+    /** @default 0 */
+    y?: DataProp;
+    /** @default y */
+    initialY?: number;
+    /** @default 12 */
+    length?: DataProp;
+    /** @default length */
+    initialLength?: number;
+    /** @default 0 */
+    rotate?: DataProp;
+    /** @default 'arrow' */
+    shape?: VectorShape;
+    anchor?: VectorAnchor;
+    /** Width of the vector shape in pixels. */
+    width?: number;
+    data?: any[];
+    /** @default (d, i) => i */
+    key?: (d: any, index: number) => any;
+    motion?: MotionProp;
+    children?: Snippet<[{
+        length: number;
+        d?: any;
+    }]>;
+} & DataDrivenStyleProps;
+export type VectorProps = VectorPropsWithoutHTML & Without<SVGAttributes<SVGPathElement>, VectorPropsWithoutHTML>;

package/dist/components/Vector/Vector.shared.svelte.js

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

package/dist/components/Vector/Vector.svelte

@@ -0,0 +1,20 @@
+<script lang="ts" module>
+  export type { VectorProps, VectorPropsWithoutHTML, VectorShape } from './Vector.shared.svelte.js';
+</script>
+
+<script lang="ts">
+  import { getLayerContext } from '../../contexts/layer.js';
+  import VectorSvg from './Vector.svg.svelte';
+  import VectorCanvas from './Vector.canvas.svelte';
+  import type { VectorProps } from './Vector.shared.svelte.js';
+
+  const layerCtx = getLayerContext();
+
+  let props: VectorProps = $props();
+</script>
+
+{#if layerCtx === 'svg'}
+  <VectorSvg {...props} />
+{:else if layerCtx === 'canvas'}
+  <VectorCanvas {...props} />
+{/if}

package/dist/components/Vector/Vector.svelte.d.ts

@@ -0,0 +1,5 @@
+export type { VectorProps, VectorPropsWithoutHTML, VectorShape } from './Vector.shared.svelte.js';
+import type { VectorProps } from './Vector.shared.svelte.js';
+declare const Vector: import("svelte").Component<VectorProps, {}, "">;
+type Vector = ReturnType<typeof Vector>;
+export default Vector;

package/dist/components/Vector/Vector.svg.svelte

@@ -0,0 +1,13 @@
+<script lang="ts" module>
+  export type { VectorProps, VectorPropsWithoutHTML, VectorShape } from './Vector.shared.svelte.js';
+</script>
+
+<script lang="ts">
+  import VectorBase from './Vector.base.svelte';
+  import Path from '../Path/Path.svg.svelte';
+  import type { VectorProps } from './Vector.shared.svelte.js';
+
+  let props: VectorProps = $props();
+</script>
+
+<VectorBase {Path} {...props} />

package/dist/components/Vector/Vector.svg.svelte.d.ts

@@ -0,0 +1,5 @@
+export type { VectorProps, VectorPropsWithoutHTML, VectorShape } from './Vector.shared.svelte.js';
+import type { VectorProps } from './Vector.shared.svelte.js';
+declare const Vector: import("svelte").Component<VectorProps, {}, "">;
+type Vector = ReturnType<typeof Vector>;
+export default Vector;

package/dist/components/{Violin.svelte → Violin/Violin.base.svelte}

@@ -1,80 +1,34 @@
 <script lang="ts" module>
-  import type { SVGAttributes } from 'svelte/elements';
-  import type { CurveFactory } from 'd3-shape';
-  import type { CommonStyleProps, CommonEvents, Without } from '../utils/types.js';
-  import type { Accessor } from '../utils/common.js';
-
-  export type ViolinPropsWithoutHTML = {
-    /** Data item containing violin data */
-    data: Object;
-
-    /**
-     * Pre-computed density data accessor. Should resolve to an array of `[value, density]` pairs.
-     * Use this when you want full control over the density estimation.
-     */
-    density?: Accessor;
-
-    /**
-     * Raw values accessor. If provided, KDE (kernel density estimation) is computed automatically.
-     * The accessor should resolve to an array of numbers.
-     */
-    values?: Accessor;
-
-    /** KDE bandwidth. Auto-computed via Silverman's rule of thumb if not specified. */
-    bandwidth?: number;
-
-    /** Number of evaluation points for KDE. @default 50 */
-    thresholds?: number;
-
-    /** Fixed width of the violin in pixels. Defaults to 80% of band scale bandwidth, or 40px. */
-    width?: number;
-
-    /** Curve interpolation for the violin shape. @default curveCardinal */
-    curve?: CurveFactory;
-
-    /**
-     * Show a median line inside the violin.
-     * Requires `values` prop to compute the median.
-     * @default false
-     */
-    median?: boolean;
-
-    /**
-     * Show an inner box (Q1-Q3 range) inside the violin.
-     * Pass `true` for defaults or `{ width: number }` to customize box width.
-     * Requires `values` prop to compute quartiles.
-     * @default false
-     */
-    box?: boolean | { width?: number };
-
-    /** Setup pointer events to show tooltip for this data item. */
-    tooltip?: boolean;
-  } & CommonStyleProps;
-
-  export type ViolinProps = ViolinPropsWithoutHTML &
-    Without<SVGAttributes<SVGPathElement>, ViolinPropsWithoutHTML> &
-    CommonEvents;
+  import type { Component } from 'svelte';
+  import type { ViolinProps } from './Violin.shared.svelte.js';
+
+  export type ViolinBaseLayerComponents = {
+    Group: Component<any>;
+    Path: Component<any>;
+    Rect: Component<any>;
+    Line: Component<any>;
+  };
+
+  export type ViolinBaseProps = ViolinProps & ViolinBaseLayerComponents;
 </script>
 
 <script lang="ts">
   import type { PointerEventHandler } from 'svelte/elements';
-  import { area as d3Area } from 'd3-shape';
-  import { curveCardinal } from 'd3-shape';
+  import { area as d3Area, curveCardinal } from 'd3-shape';
   import { quantile, ascending, deviation, max as d3Max } from 'd3-array';
-
   import { cls } from '@layerstack/tailwind';
 
-  import Group from './Group.svelte';
-  import Path from './Path.svelte';
-  import Rect from './Rect.svelte';
-  import Line from './Line.svelte';
-  import { accessor } from '../utils/common.js';
-  import { getChartContext } from '../contexts/chart.js';
-  import { isScaleBand } from '../utils/scales.svelte.js';
+  import { accessor } from '../../utils/common.js';
+  import { getChartContext } from '../../contexts/chart.js';
+  import { isScaleBand } from '../../utils/scales.svelte.js';
 
   const ctx = getChartContext();
 
   let {
+    Group,
+    Path,
+    Rect,
+    Line,
     data,
     density: densityProp,
     values: valuesProp,
@@ -95,17 +49,12 @@
     onpointerleave,
     class: className,
     ...restProps
-  }: ViolinProps = $props();
+  }: ViolinBaseProps = $props();
 
-  // Register as composite mark (shields child marks from domain calculation)
-  ctx.registerComponent({
-    name: 'Violin',
-    kind: 'composite-mark',
-  });
+  ctx.registerComponent({ name: 'Violin', kind: 'composite-mark' });
 
   const isVertical = $derived(ctx.valueAxis === 'y');
 
-  // Category position: center of the band for this data item
   const categoryPos = $derived.by(() => {
     const catAccessor = isVertical ? ctx.x : ctx.y;
     const catScale = isVertical ? ctx.xScale : ctx.yScale;
@@ -114,17 +63,14 @@
     return pos + bandwidth / 2;
   });
 
-  // Violin width: derived from band scale or explicit prop
   const violinWidth = $derived.by(() => {
     if (widthProp != null) return widthProp;
     const catScale = isVertical ? ctx.xScale : ctx.yScale;
     return isScaleBand(catScale) ? catScale.bandwidth() * 0.8 : 40;
   });
 
-  // Value scale for mapping data values to pixel positions
   const valueScale = $derived(isVertical ? ctx.yScale : ctx.xScale);
 
-  // Epanechnikov kernel
   function epanechnikov(bw: number) {
     return (x: number) => {
       const u = x / bw;
@@ -132,7 +78,6 @@
     };
   }
 
-  // Compute density data from raw values via KDE, or use pre-computed density
   const densityData = $derived.by<[number, number][]>(() => {
     if (densityProp) {
       return accessor(densityProp)(data);
@@ -147,7 +92,6 @@
     const sorted = [...raw].sort(ascending);
     const ext: [number, number] = [sorted[0], sorted[sorted.length - 1]];
 
-    // Silverman's rule of thumb for bandwidth
     const bw = bandwidthProp ?? 1.06 * (deviation(sorted) ?? 1) * Math.pow(sorted.length, -1 / 5);
 
     const kernelFn = epanechnikov(bw);
@@ -162,7 +106,6 @@
     });
   });
 
-  // Compute quartile stats for optional box/median overlays
   const stats = $derived.by(() => {
     if (!showMedian && !showBox) return null;
     if (!valuesProp) return null;
@@ -179,13 +122,9 @@
     };
   });
 
-  // Max density for scaling width
   const maxDensity = $derived(d3Max(densityData, (d) => d[1]) ?? 1);
-
-  // Map density value to half-width in pixels
   const densityToWidth = $derived.by(() => (d: number) => (d / maxDensity) * (violinWidth / 2));
 
-  // Generate the mirrored area SVG path for the violin shape
   const pathData = $derived.by(() => {
     if (densityData.length === 0) return '';
 
@@ -208,12 +147,10 @@
     }
   });
 
-  // Inner box width
   const innerBoxWidth = $derived(
     typeof showBox === 'object' && showBox.width != null ? showBox.width : violinWidth * 0.15
   );
 
-  // Tooltip event handlers
   const onPointerEnter: PointerEventHandler<Element> = (e) => {
     onpointerenter?.(e);
     if (tooltip) ctx.tooltip.show(e, data);
@@ -236,7 +173,6 @@
     onpointermove={onPointerMove}
     onpointerleave={onPointerLeave}
   >
-    <!-- Violin shape (mirrored density area) -->
     <Path
       {pathData}
       {fill}
@@ -247,7 +183,6 @@
     />
 
     {#if showBox && stats}
-      <!-- Inner box (Q1-Q3) -->
       {#if isVertical}
         <Rect
           x={categoryPos - innerBoxWidth / 2}
@@ -274,7 +209,6 @@
     {/if}
 
     {#if showMedian && stats}
-      <!-- Median line -->
       {#if isVertical}
         <Line
           x1={categoryPos - violinWidth * 0.15}

package/dist/components/Violin/Violin.base.svelte.d.ts

@@ -0,0 +1,12 @@
+import type { Component } from 'svelte';
+import type { ViolinProps } from './Violin.shared.svelte.js';
+export type ViolinBaseLayerComponents = {
+    Group: Component<any>;
+    Path: Component<any>;
+    Rect: Component<any>;
+    Line: Component<any>;
+};
+export type ViolinBaseProps = ViolinProps & ViolinBaseLayerComponents;
+declare const Violin: Component<ViolinBaseProps, {}, "">;
+type Violin = ReturnType<typeof Violin>;
+export default Violin;

package/dist/components/Violin/Violin.canvas.svelte

@@ -0,0 +1,16 @@
+<script lang="ts" module>
+  export type { ViolinProps, ViolinPropsWithoutHTML } from './Violin.shared.svelte.js';
+</script>
+
+<script lang="ts">
+  import ViolinBase from './Violin.base.svelte';
+  import Group from '../Group/Group.canvas.svelte';
+  import Path from '../Path/Path.canvas.svelte';
+  import Rect from '../Rect/Rect.canvas.svelte';
+  import Line from '../Line/Line.canvas.svelte';
+  import type { ViolinProps } from './Violin.shared.svelte.js';
+
+  let props: ViolinProps = $props();
+</script>
+
+<ViolinBase {Group} {Path} {Rect} {Line} {...props} />

package/dist/components/Violin/Violin.canvas.svelte.d.ts

@@ -0,0 +1,5 @@
+export type { ViolinProps, ViolinPropsWithoutHTML } from './Violin.shared.svelte.js';
+import type { ViolinProps } from './Violin.shared.svelte.js';
+declare const Violin: import("svelte").Component<ViolinProps, {}, "">;
+type Violin = ReturnType<typeof Violin>;
+export default Violin;

package/dist/components/Violin/Violin.shared.svelte.d.ts

@@ -0,0 +1,23 @@
+import type { SVGAttributes } from 'svelte/elements';
+import type { CurveFactory } from 'd3-shape';
+import type { CommonStyleProps, CommonEvents, Without } from '../../utils/types.js';
+import type { Accessor } from '../../utils/common.js';
+export type ViolinPropsWithoutHTML = {
+    data: Object;
+    density?: Accessor;
+    values?: Accessor;
+    bandwidth?: number;
+    /** @default 50 */
+    thresholds?: number;
+    width?: number;
+    /** @default curveCardinal */
+    curve?: CurveFactory;
+    /** @default false */
+    median?: boolean;
+    /** @default false */
+    box?: boolean | {
+        width?: number;
+    };
+    tooltip?: boolean;
+} & CommonStyleProps;
+export type ViolinProps = ViolinPropsWithoutHTML & Without<SVGAttributes<SVGPathElement>, ViolinPropsWithoutHTML> & CommonEvents;

package/dist/components/Violin/Violin.shared.svelte.js

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

package/dist/components/Violin/Violin.svelte

@@ -0,0 +1,20 @@
+<script lang="ts" module>
+  export type { ViolinProps, ViolinPropsWithoutHTML } from './Violin.shared.svelte.js';
+</script>
+
+<script lang="ts">
+  import { getLayerContext } from '../../contexts/layer.js';
+  import ViolinSvg from './Violin.svg.svelte';
+  import ViolinCanvas from './Violin.canvas.svelte';
+  import type { ViolinProps } from './Violin.shared.svelte.js';
+
+  const layerCtx = getLayerContext();
+
+  let props: ViolinProps = $props();
+</script>
+
+{#if layerCtx === 'svg'}
+  <ViolinSvg {...props} />
+{:else if layerCtx === 'canvas'}
+  <ViolinCanvas {...props} />
+{/if}

package/dist/components/Violin/Violin.svelte.d.ts

@@ -0,0 +1,5 @@
+export type { ViolinProps, ViolinPropsWithoutHTML } from './Violin.shared.svelte.js';
+import type { ViolinProps } from './Violin.shared.svelte.js';
+declare const Violin: import("svelte").Component<ViolinProps, {}, "">;
+type Violin = ReturnType<typeof Violin>;
+export default Violin;

package/dist/components/Violin/Violin.svg.svelte

@@ -0,0 +1,16 @@
+<script lang="ts" module>
+  export type { ViolinProps, ViolinPropsWithoutHTML } from './Violin.shared.svelte.js';
+</script>
+
+<script lang="ts">
+  import ViolinBase from './Violin.base.svelte';
+  import Group from '../Group/Group.svg.svelte';
+  import Path from '../Path/Path.svg.svelte';
+  import Rect from '../Rect/Rect.svg.svelte';
+  import Line from '../Line/Line.svg.svelte';
+  import type { ViolinProps } from './Violin.shared.svelte.js';
+
+  let props: ViolinProps = $props();
+</script>
+
+<ViolinBase {Group} {Path} {Rect} {Line} {...props} />

package/dist/components/Violin/Violin.svg.svelte.d.ts

@@ -0,0 +1,5 @@
+export type { ViolinProps, ViolinPropsWithoutHTML } from './Violin.shared.svelte.js';
+import type { ViolinProps } from './Violin.shared.svelte.js';
+declare const Violin: import("svelte").Component<ViolinProps, {}, "">;
+type Violin = ReturnType<typeof Violin>;
+export default Violin;

package/dist/components/Voronoi/Voronoi.base.svelte

@@ -0,0 +1,151 @@
+<script lang="ts" module>
+  import type { Component } from 'svelte';
+  import type { VoronoiProps } from './Voronoi.shared.svelte.js';
+
+  export type VoronoiBaseLayerComponents = {
+    Group: Component<any>;
+    Path: Component<any>;
+    CircleClipPath: Component<any>;
+  };
+
+  export type VoronoiBaseProps = VoronoiProps & VoronoiBaseLayerComponents;
+</script>
+
+<script lang="ts">
+  import { max } from 'd3-array';
+  import { Delaunay } from 'd3-delaunay';
+  // @ts-expect-error
+  import { geoVoronoi } from 'd3-geo-voronoi';
+  import { pointRadial } from 'd3-shape';
+  import { cls } from '@layerstack/tailwind';
+
+  // GeoPath lives in geo/ subpath; agnostic import (only used in geo charts).
+  import GeoPath from '../geo/GeoPath/GeoPath.svelte';
+  import { getChartContext } from '../../contexts/chart.js';
+  import { getGeoContext } from '../../contexts/geo.js';
+  import { accessor } from '../../utils/common.js';
+
+  let {
+    Group,
+    Path,
+    CircleClipPath,
+    data,
+    x: xProp,
+    y: yProp,
+    r,
+    classes = {},
+    onclick,
+    onpointerenter,
+    onpointerdown,
+    onpointermove,
+    class: className,
+    ...restProps
+  }: VoronoiBaseProps = $props();
+
+  const ctx = getChartContext();
+  const geo = getGeoContext();
+
+  const xAccessorOverride = $derived(xProp != null ? accessor(xProp) : undefined);
+  const yAccessorOverride = $derived(yProp != null ? accessor(yProp) : undefined);
+
+  const points = $derived(
+    (data ?? ctx.flatData).map((d: any) => {
+      const xValue = xAccessorOverride
+        ? geo.projection
+          ? xAccessorOverride(d)
+          : ctx.xScale(xAccessorOverride(d))
+        : geo.projection
+          ? ctx.x(d)
+          : ctx.xGet(d);
+      const yValue = yAccessorOverride
+        ? geo.projection
+          ? yAccessorOverride(d)
+          : ctx.yScale(yAccessorOverride(d))
+        : geo.projection
+          ? ctx.y(d)
+          : ctx.yGet(d);
+
+      const x = Array.isArray(xValue) ? max(xValue) : xValue;
+      const y = Array.isArray(yValue) ? max(yValue) : yValue;
+
+      let point: [number, number];
+      if (ctx.radial) {
+        const radialPoint = pointRadial(x, y);
+        point = [radialPoint[0] + ctx.width / 2, radialPoint[1] + ctx.height / 2];
+      } else {
+        point = [x, y];
+      }
+      // @ts-expect-error
+      point.data = d;
+      return point;
+    })
+  );
+
+  const boundWidth = $derived(Math.max(ctx.width, 0));
+  const boundHeight = $derived(Math.max(ctx.height, 0));
+
+  const disableClip = $derived(r === 0 || r == null || r === Infinity);
+</script>
+
+<Group {...restProps} class={cls('lc-voronoi-g', classes.root, className)}>
+  {#if geo.projection}
+    {@const polygons = geoVoronoi().polygons(points)}
+    {#each polygons.features as feature}
+      {@const point = r ? geo.projection?.(feature.properties.sitecoordinates) : null}
+      <CircleClipPath
+        cx={point?.[0]}
+        cy={point?.[1]}
+        r={r ?? 0}
+        disabled={point == null || disableClip}
+      >
+        <GeoPath
+          geojson={feature}
+          class={['lc-voronoi-geo-path', classes.path]}
+          onclick={(e: MouseEvent) =>
+            onclick?.(e, { data: feature.properties.site.data, feature })}
+          onpointerenter={(e: PointerEvent) =>
+            onpointerenter?.(e, { data: feature.properties.site.data, feature })}
+          onpointermove={(e: PointerEvent) =>
+            onpointermove?.(e, { data: feature.properties.site.data, feature })}
+          onpointerdown={(e: PointerEvent) =>
+            onpointerdown?.(e, { data: feature.properties.site.data, feature })}
+          ontouchmove={(e: TouchEvent) => {
+            e.preventDefault();
+          }}
+        />
+      </CircleClipPath>
+    {/each}
+  {:else}
+    {@const voronoi = Delaunay.from(points).voronoi([0, 0, boundWidth, boundHeight])}
+    {#each points as point, i}
+      {@const pathData = voronoi.renderCell(i)}
+      {#if pathData}
+        <CircleClipPath cx={point[0]} cy={point[1]} r={r ?? 0} disabled={disableClip}>
+          <Path
+            {pathData}
+            class={['lc-voronoi-path', classes.path]}
+            onclick={(e: MouseEvent) => onclick?.(e, { data: (point as any).data, point })}
+            onpointerenter={(e: PointerEvent) =>
+              onpointerenter?.(e, { data: (point as any).data, point })}
+            onpointermove={(e: PointerEvent) =>
+              onpointermove?.(e, { data: (point as any).data, point })}
+            onpointerdown={(e: PointerEvent) =>
+              onpointerdown?.(e, { data: (point as any).data, point })}
+            ontouchmove={(e: TouchEvent) => {
+              e.preventDefault();
+            }}
+          />
+        </CircleClipPath>
+      {/if}
+    {/each}
+  {/if}
+</Group>
+
+<style>
+  @layer components {
+    :global(:where(.lc-voronoi-path, .lc-voronoi-geo-path)) {
+      fill: transparent;
+      stroke: transparent;
+    }
+  }
+</style>

package/dist/components/Voronoi/Voronoi.base.svelte.d.ts

@@ -0,0 +1,11 @@
+import type { Component } from 'svelte';
+import type { VoronoiProps } from './Voronoi.shared.svelte.js';
+export type VoronoiBaseLayerComponents = {
+    Group: Component<any>;
+    Path: Component<any>;
+    CircleClipPath: Component<any>;
+};
+export type VoronoiBaseProps = VoronoiProps & VoronoiBaseLayerComponents;
+declare const Voronoi: Component<VoronoiBaseProps, {}, "">;
+type Voronoi = ReturnType<typeof Voronoi>;
+export default Voronoi;

package/dist/components/Voronoi/Voronoi.canvas.svelte

@@ -0,0 +1,15 @@
+<script lang="ts" module>
+  export type { VoronoiProps, VoronoiPropsWithoutHTML } from './Voronoi.shared.svelte.js';
+</script>
+
+<script lang="ts">
+  import VoronoiBase from './Voronoi.base.svelte';
+  import Group from '../Group/Group.canvas.svelte';
+  import Path from '../Path/Path.canvas.svelte';
+  import CircleClipPath from '../CircleClipPath/CircleClipPath.canvas.svelte';
+  import type { VoronoiProps } from './Voronoi.shared.svelte.js';
+
+  let props: VoronoiProps = $props();
+</script>
+
+<VoronoiBase {Group} {Path} {CircleClipPath} {...props} />

package/dist/components/Voronoi/Voronoi.canvas.svelte.d.ts

@@ -0,0 +1,5 @@
+export type { VoronoiProps, VoronoiPropsWithoutHTML } from './Voronoi.shared.svelte.js';
+import type { VoronoiProps } from './Voronoi.shared.svelte.js';
+declare const Voronoi: import("svelte").Component<VoronoiProps, {}, "">;
+type Voronoi = ReturnType<typeof Voronoi>;
+export default Voronoi;