layerchart 2.0.0-next.9 → 2.0.0

package/dist/components/RadialGradient/RadialGradient.canvas.svelte

@@ -0,0 +1,69 @@
+<script lang="ts" module>
+  export type {
+    RadialGradientProps,
+    RadialGradientPropsWithoutHTML,
+  } from './RadialGradient.shared.svelte.js';
+</script>
+
+<script lang="ts">
+  import { getChartContext } from '../../contexts/chart.js';
+  import { getComputedStyles } from '../../utils/canvas.js';
+  import { parsePercent } from '../../utils/math.js';
+  import { createId } from '../../utils/createId.js';
+  import type { RadialGradientProps } from './RadialGradient.shared.svelte.js';
+
+  const uid = $props.id();
+
+  let {
+    id = createId('radialGradient-', uid),
+    stops = ['var(--tw-gradient-from)', 'var(--tw-gradient-to)'],
+    cx = '50%',
+    cy = '50%',
+    fx = cx,
+    fy = cy,
+    children,
+    class: className,
+    ...rest
+  }: RadialGradientProps = $props();
+
+  const ctx = getChartContext();
+
+  let canvasGradient = $state<CanvasGradient>();
+
+  function render(_ctx: CanvasRenderingContext2D) {
+    // TODO: Set correct values: https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/createRadialGradient.
+    // TODO: Memoize `createRadialGradient()` (see LinearGradient)
+    const gradient = _ctx.createRadialGradient(0, 0, 0, 0, 0, 0);
+
+    // Use `getComputedStyles()` to convert each stop (if using CSS variables and/or classes) to color values
+    for (let i = 0; i < stops.length; i++) {
+      const stop = stops[i];
+      if (Array.isArray(stop)) {
+        const { fill } = getComputedStyles(_ctx.canvas, {
+          styles: { fill: stop[1] },
+          classes: className,
+        });
+        gradient.addColorStop(parsePercent(stop[0]), fill);
+      } else {
+        const { fill } = getComputedStyles(_ctx.canvas, {
+          styles: { fill: stop },
+          classes: className,
+        });
+        gradient.addColorStop(i / (stops.length - 1), fill);
+      }
+    }
+
+    canvasGradient = gradient;
+  }
+
+  ctx.registerComponent({
+    name: 'Gradient',
+    kind: 'group',
+    canvasRender: {
+      render,
+      deps: () => [stops, cx, cy, fx, fy, ctx.width, ctx.height],
+    },
+  });
+</script>
+
+{@render children?.({ id, gradient: canvasGradient as any })}

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

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

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

@@ -0,0 +1,46 @@
+import type { Snippet } from 'svelte';
+import type { SVGAttributes } from 'svelte/elements';
+import type { Without } from '../../utils/types.js';
+export type RadialGradientPropsWithoutHTML = {
+    /** Unique id for radialGradient */
+    id?: string;
+    /**
+     * Array of strings (colors), distributed equally from 0-100%.
+     * If array of tuples, will use first value as the offset, and second as color.
+     *
+     * @default ['var(--tw-gradient-from)', 'var(--tw-gradient-to)']
+     */
+    stops?: string[] | [string | number, string][];
+    /** The x coordinate of the center of the gradient @default '50%' */
+    cx?: string;
+    /** The y coordinate of the center of the gradient @default '50%' */
+    cy?: string;
+    /** The x coordinate of the focal point of the gradient @default cx */
+    fx?: string;
+    /** The y coordinate of the focal point of the gradient @default cy */
+    fy?: string;
+    /** The radius of the gradient */
+    r?: string;
+    /**
+     * Indicates how the gradient behaves if it starts or ends inside the bounds
+     * of the shape containing the gradient
+     *
+     * @default 'pad'
+     */
+    spreadMethod?: 'pad' | 'reflect' | 'repeat';
+    /** Transform attribute for the gradient */
+    transform?: string | null;
+    /**
+     * Define the coordinate system for attributes (i.e. gradientUnits)
+     *
+     * @default 'objectBoundingBox'
+     */
+    units?: 'objectBoundingBox' | 'userSpaceOnUse';
+    children?: Snippet<[{
+        id: string;
+        gradient: string;
+    }]>;
+    /** Render as a child of the gradient and will opt out of the default stops being rendered. */
+    stopsContent?: Snippet;
+};
+export type RadialGradientProps = RadialGradientPropsWithoutHTML & Without<SVGAttributes<SVGRadialGradientElement>, RadialGradientPropsWithoutHTML>;

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

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

package/dist/components/RadialGradient/RadialGradient.svelte

@@ -0,0 +1,23 @@
+<script lang="ts" module>
+  export type {
+    RadialGradientProps,
+    RadialGradientPropsWithoutHTML,
+  } from './RadialGradient.shared.svelte.js';
+</script>
+
+<script lang="ts">
+  import { getLayerContext } from '../../contexts/layer.js';
+  import RadialGradientSvg from './RadialGradient.svg.svelte';
+  import RadialGradientCanvas from './RadialGradient.canvas.svelte';
+  import type { RadialGradientProps } from './RadialGradient.shared.svelte.js';
+
+  const layerCtx = getLayerContext();
+
+  let props: RadialGradientProps = $props();
+</script>
+
+{#if layerCtx === 'svg'}
+  <RadialGradientSvg {...props} />
+{:else if layerCtx === 'canvas'}
+  <RadialGradientCanvas {...props} />
+{/if}

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

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

package/dist/components/RadialGradient/RadialGradient.svg.svelte

@@ -0,0 +1,66 @@
+<script lang="ts" module>
+  export type {
+    RadialGradientProps,
+    RadialGradientPropsWithoutHTML,
+  } from './RadialGradient.shared.svelte.js';
+</script>
+
+<script lang="ts">
+  import { cls } from '@layerstack/tailwind';
+  import { createId } from '../../utils/createId.js';
+  import { extractLayerProps } from '../../utils/attributes.js';
+  import type { RadialGradientProps } from './RadialGradient.shared.svelte.js';
+
+  const uid = $props.id();
+
+  let {
+    id = createId('radialGradient-', uid),
+    stops = ['var(--tw-gradient-from)', 'var(--tw-gradient-to)'],
+    cx = '50%',
+    cy = '50%',
+    fx = cx,
+    fy = cy,
+    r = '50%',
+    spreadMethod = 'pad',
+    transform = undefined,
+    units = 'objectBoundingBox',
+    children,
+    stopsContent,
+    class: className,
+    ...rest
+  }: RadialGradientProps = $props();
+</script>
+
+<defs>
+  <radialGradient
+    {id}
+    {cx}
+    {cy}
+    {fx}
+    {fy}
+    {r}
+    {spreadMethod}
+    gradientTransform={transform}
+    gradientUnits={units}
+    {...extractLayerProps({ ...rest, class: className }, 'lc-radial-gradient')}
+  >
+    {#if stopsContent}
+      {@render stopsContent()}
+    {:else if stops}
+      {@const stopClass = cls('lc-radial-gradient-stop', className)}
+      {#each stops as stop, i}
+        {#if Array.isArray(stop)}
+          <stop offset={stop[0]} stop-color={stop[1]} class={stopClass} />
+        {:else}
+          <stop
+            offset="{i * (100 / (stops.length - 1))}%"
+            stop-color={stop}
+            class={stopClass}
+          />
+        {/if}
+      {/each}
+    {/if}
+  </radialGradient>
+</defs>
+
+{@render children?.({ id, gradient: `url(#${id})` })}

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

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

package/dist/components/Raster/Raster.base.svelte

@@ -0,0 +1,275 @@
+<script lang="ts" module>
+  import type { Component } from 'svelte';
+  import type { RasterProps } from './Raster.shared.svelte.js';
+
+  export type RasterBaseLayerComponents = {
+    Image: Component<any>;
+  };
+
+  export type RasterBaseProps = RasterProps & RasterBaseLayerComponents;
+</script>
+
+<script lang="ts">
+  import { cls } from '@layerstack/tailwind';
+  import { scaleSequential } from 'd3-scale';
+  import { interpolateYlGnBu } from 'd3-scale-chromatic';
+  import { max, min } from 'd3-array';
+  import { rgb } from 'd3-color';
+
+  import { accessor as resolveAccessor, chartDataArray, type Accessor } from '../../utils/common.js';
+  import { getChartContext } from '../../contexts/chart.js';
+  import { getGeoContext } from '../../contexts/geo.js';
+  import { gridCellCenterToBounds, resolveRasterBounds } from '../../utils/index.js';
+  import { interpolateGrid } from '../../utils/rasterInterpolate.js';
+
+  const ctx = getChartContext();
+  const geo = getGeoContext();
+
+  let {
+    Image,
+    data: dataProp,
+    width: widthProp,
+    height: heightProp,
+    x1: x1Prop,
+    y1: y1Prop,
+    x2: x2Prop,
+    y2: y2Prop,
+    value: valueProp,
+    x: xProp,
+    y: yProp,
+    interpolate: interpolateMethod = 'barycentric',
+    pixelSize = 1,
+    blur: blurRadius = 0,
+    imageRendering = 'auto',
+    opacity,
+    class: className,
+    ...restProps
+  }: RasterBaseProps = $props();
+
+  const isGridMode = $derived(!!(dataProp && widthProp && heightProp));
+  const hasExplicitBounds = $derived(
+    x1Prop !== undefined || y1Prop !== undefined || x2Prop !== undefined || y2Prop !== undefined
+  );
+  const gridBounds = $derived(
+    resolveRasterBounds(widthProp ?? 0, heightProp ?? 0, x1Prop, y1Prop, x2Prop, y2Prop)
+  );
+  const useProjectedGridSampling = $derived(
+    !!(geo.projection && geo.projection.invert && isGridMode && hasExplicitBounds)
+  );
+
+  ctx.registerComponent({
+    name: 'Raster',
+    kind: 'composite-mark',
+    markInfo: () => {
+      if (!isGridMode) return {};
+      return {
+        data: [
+          { x: gridBounds.x1, y: gridBounds.y1 },
+          { x: gridBounds.x2, y: gridBounds.y2 },
+        ],
+        x: 'x',
+        y: 'y',
+      };
+    },
+  });
+
+  const gridW = $derived(widthProp ?? Math.max(1, Math.ceil(ctx.width / pixelSize)));
+  const gridH = $derived(heightProp ?? Math.max(1, Math.ceil(ctx.height / pixelSize)));
+
+  const scaleX = $derived(ctx.width / gridW);
+  const scaleY = $derived(ctx.height / gridH);
+  const rasterScaleX = $derived(gridW / ctx.width);
+  const rasterScaleY = $derived(gridH / ctx.height);
+
+  const sourceGridValues = $derived.by(() => {
+    if (!ctx.width || !ctx.height) return new Float64Array(0);
+
+    if (isGridMode) {
+      return dataProp instanceof Float64Array ? dataProp : Float64Array.from(dataProp as number[]);
+    }
+
+    if (typeof valueProp === 'function' && valueProp.length >= 2) {
+      const fn = valueProp as (x: number, y: number) => number;
+      const grid = new Float64Array(gridW * gridH);
+      const xInvert = ctx.xScale.invert;
+      const yInvert = ctx.yScale.invert;
+      for (let j = 0; j < gridH; j++) {
+        for (let i = 0; i < gridW; i++) {
+          const px = (i + 0.5) * scaleX;
+          const py = (j + 0.5) * scaleY;
+          const dataX = xInvert ? xInvert(px) : px;
+          const dataY = yInvert ? yInvert(py) : py;
+          grid[j * gridW + i] = fn(dataX, dataY);
+        }
+      }
+      return grid;
+    }
+
+    const chartData = dataProp ? (dataProp as any[]) : chartDataArray(ctx.data);
+    if (!chartData || chartData.length === 0) return new Float64Array(0);
+
+    const xAcc = xProp ? resolveAccessor(xProp) : ctx.x;
+    const yAcc = yProp ? resolveAccessor(yProp) : ctx.y;
+    const valAcc = resolveAccessor((valueProp ?? 'value') as Accessor);
+
+    const points: [number, number, number][] = chartData.map((d: any) => [
+      ctx.xScale(xAcc(d)) / scaleX,
+      ctx.yScale(yAcc(d)) / scaleY,
+      valAcc(d),
+    ]);
+
+    return interpolateGrid(points, gridW, gridH, interpolateMethod);
+  });
+
+  const projectedGridPoints = $derived.by(() => {
+    if (!useProjectedGridSampling || !widthProp || !heightProp || !geo.projection) return [];
+
+    const points: [number, number, number][] = [];
+    for (let row = 0; row < heightProp; row++) {
+      for (let column = 0; column < widthProp; column++) {
+        const value = sourceGridValues[row * widthProp + column];
+        if (!Number.isFinite(value)) continue;
+
+        const point = gridCellCenterToBounds(column, row, widthProp, heightProp, gridBounds);
+        const projected = geo.projection([point.x, point.y]);
+        if (!projected || !Number.isFinite(projected[0]) || !Number.isFinite(projected[1]))
+          continue;
+
+        points.push([projected[0] * rasterScaleX, projected[1] * rasterScaleY, value]);
+      }
+    }
+
+    return points;
+  });
+
+  const rasterValues = $derived.by(() => {
+    if (useProjectedGridSampling) {
+      return interpolateGrid(projectedGridPoints, gridW, gridH, interpolateMethod);
+    }
+    return sourceGridValues;
+  });
+
+  const colorScale = $derived.by(() => {
+    const validValues = rasterValues.filter((v) => !isNaN(v));
+    const minValue = min(validValues) ?? 0;
+    const maxValue = max(validValues) ?? 1;
+    if (ctx.cScale) {
+      const scale = ctx.cScale.copy();
+      return ctx.props.cDomain ? scale : scale.domain([minValue, maxValue]);
+    }
+    return scaleSequential([minValue, maxValue], interpolateYlGnBu);
+  });
+
+  const LUT_SIZE = 256;
+  const colorLut = $derived.by(() => {
+    const lut = new Uint8ClampedArray(LUT_SIZE * 4);
+    for (let i = 0; i < LUT_SIZE; i++) {
+      const t = i / (LUT_SIZE - 1);
+      const [lo, hi] = colorScale.domain();
+      const value = lo + t * (hi - lo);
+      const c = rgb(String(colorScale(value)));
+      lut[i * 4] = c.r;
+      lut[i * 4 + 1] = c.g;
+      lut[i * 4 + 2] = c.b;
+      lut[i * 4 + 3] = 255;
+    }
+    return lut;
+  });
+
+  const imagePlacement = $derived.by(() => {
+    if (useProjectedGridSampling) {
+      return {
+        x: ctx.width / 2,
+        y: ctx.height / 2,
+        width: ctx.width,
+        height: ctx.height,
+      };
+    }
+
+    if (isGridMode && hasExplicitBounds) {
+      const x1 = ctx.xScale(gridBounds.x1);
+      const x2 = ctx.xScale(gridBounds.x2);
+      const y1 = ctx.yScale(gridBounds.y1);
+      const y2 = ctx.yScale(gridBounds.y2);
+
+      return {
+        x: (x1 + x2) / 2,
+        y: (y1 + y2) / 2,
+        width: Math.abs(x2 - x1),
+        height: Math.abs(y2 - y1),
+      };
+    }
+
+    return {
+      x: ctx.width / 2,
+      y: ctx.height / 2,
+      width: ctx.width,
+      height: ctx.height,
+    };
+  });
+
+  const imageDataUrl = $derived.by(() => {
+    if (typeof document === 'undefined') return '';
+    if (rasterValues.length === 0 || gridW <= 0 || gridH <= 0) return '';
+
+    const [minValue, maxValue] = colorScale.domain();
+    const range = maxValue - minValue || 1;
+
+    const canvas = document.createElement('canvas');
+
+    canvas.width = gridW;
+    canvas.height = gridH;
+    const canvasCtx = canvas.getContext('2d')!;
+    const imageData = canvasCtx.createImageData(gridW, gridH);
+    const pixels = imageData.data;
+
+    for (let i = 0; i < rasterValues.length; i++) {
+      const v = rasterValues[i];
+      const offset = i * 4;
+
+      if (isNaN(v)) {
+        pixels[offset] = 0;
+        pixels[offset + 1] = 0;
+        pixels[offset + 2] = 0;
+        pixels[offset + 3] = 0;
+        continue;
+      }
+
+      const t = Math.max(0, Math.min(1, (v - minValue) / range));
+      const lutIndex = Math.round(t * (LUT_SIZE - 1));
+      const lutOffset = lutIndex * 4;
+      pixels[offset] = colorLut[lutOffset];
+      pixels[offset + 1] = colorLut[lutOffset + 1];
+      pixels[offset + 2] = colorLut[lutOffset + 2];
+      pixels[offset + 3] = colorLut[lutOffset + 3];
+    }
+
+    canvasCtx.putImageData(imageData, 0, 0);
+
+    if (blurRadius > 0) {
+      const blurredCanvas = document.createElement('canvas');
+      blurredCanvas.width = gridW;
+      blurredCanvas.height = gridH;
+      const blurredCtx = blurredCanvas.getContext('2d')!;
+      blurredCtx.filter = `blur(${blurRadius}px)`;
+      blurredCtx.drawImage(canvas, 0, 0);
+      return blurredCanvas.toDataURL();
+    }
+
+    return canvas.toDataURL();
+  });
+</script>
+
+{#if imageDataUrl}
+  <Image
+    href={imageDataUrl}
+    x={imagePlacement.x}
+    y={imagePlacement.y}
+    width={imagePlacement.width}
+    height={imagePlacement.height}
+    {imageRendering}
+    {opacity}
+    preserveAspectRatio="none"
+    class={cls('lc-raster', className)}
+  />
+{/if}

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

@@ -0,0 +1,9 @@
+import type { Component } from 'svelte';
+import type { RasterProps } from './Raster.shared.svelte.js';
+export type RasterBaseLayerComponents = {
+    Image: Component<any>;
+};
+export type RasterBaseProps = RasterProps & RasterBaseLayerComponents;
+declare const Raster: Component<RasterBaseProps, {}, "">;
+type Raster = ReturnType<typeof Raster>;
+export default Raster;

package/dist/components/Raster/Raster.canvas.svelte

@@ -0,0 +1,13 @@
+<script lang="ts" module>
+  export type { RasterProps, RasterPropsWithoutHTML } from './Raster.shared.svelte.js';
+</script>
+
+<script lang="ts">
+  import RasterBase from './Raster.base.svelte';
+  import Image from '../Image/Image.canvas.svelte';
+  import type { RasterProps } from './Raster.shared.svelte.js';
+
+  let props: RasterProps = $props();
+</script>
+
+<RasterBase {Image} {...props} />

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

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

package/dist/components/Raster/Raster.html.svelte

@@ -0,0 +1,13 @@
+<script lang="ts" module>
+  export type { RasterProps, RasterPropsWithoutHTML } from './Raster.shared.svelte.js';
+</script>
+
+<script lang="ts">
+  import RasterBase from './Raster.base.svelte';
+  import Image from '../Image/Image.html.svelte';
+  import type { RasterProps } from './Raster.shared.svelte.js';
+
+  let props: RasterProps = $props();
+</script>
+
+<RasterBase {Image} {...props} />

package/dist/components/Raster/Raster.html.svelte.d.ts

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

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

@@ -0,0 +1,26 @@
+import type { SVGAttributes } from 'svelte/elements';
+import type { CommonStyleProps, Without } from '../../utils/types.js';
+import type { Accessor } from '../../utils/common.js';
+import type { InterpolateMethod } from '../../utils/rasterInterpolate.js';
+export type RasterPropsWithoutHTML = {
+    data?: number[] | Float64Array | any[];
+    width?: number;
+    height?: number;
+    x1?: number;
+    y1?: number;
+    x2?: number;
+    y2?: number;
+    /** @default 'value' */
+    value?: Accessor | ((x: number, y: number) => number);
+    x?: Accessor;
+    y?: Accessor;
+    /** @default 'barycentric' */
+    interpolate?: InterpolateMethod;
+    /** @default 1 */
+    pixelSize?: number;
+    /** @default 0 */
+    blur?: number;
+    /** @default 'auto' */
+    imageRendering?: 'auto' | 'pixelated' | 'crisp-edges';
+} & Pick<CommonStyleProps, 'opacity'>;
+export type RasterProps = RasterPropsWithoutHTML & Without<SVGAttributes<SVGImageElement>, RasterPropsWithoutHTML>;

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

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

package/dist/components/Raster/Raster.svelte

@@ -0,0 +1,23 @@
+<script lang="ts" module>
+  export type { RasterProps, RasterPropsWithoutHTML } from './Raster.shared.svelte.js';
+</script>
+
+<script lang="ts">
+  import { getLayerContext } from '../../contexts/layer.js';
+  import RasterSvg from './Raster.svg.svelte';
+  import RasterCanvas from './Raster.canvas.svelte';
+  import RasterHtml from './Raster.html.svelte';
+  import type { RasterProps } from './Raster.shared.svelte.js';
+
+  const layerCtx = getLayerContext();
+
+  let props: RasterProps = $props();
+</script>
+
+{#if layerCtx === 'svg'}
+  <RasterSvg {...props} />
+{:else if layerCtx === 'canvas'}
+  <RasterCanvas {...props} />
+{:else if layerCtx === 'html'}
+  <RasterHtml {...props} />
+{/if}

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

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

package/dist/components/Raster/Raster.svg.svelte

@@ -0,0 +1,13 @@
+<script lang="ts" module>
+  export type { RasterProps, RasterPropsWithoutHTML } from './Raster.shared.svelte.js';
+</script>
+
+<script lang="ts">
+  import RasterBase from './Raster.base.svelte';
+  import Image from '../Image/Image.svg.svelte';
+  import type { RasterProps } from './Raster.shared.svelte.js';
+
+  let props: RasterProps = $props();
+</script>
+
+<RasterBase {Image} {...props} />

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

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