layerchart 2.0.0-next.6 → 2.0.0-next.60

package/dist/components/{ForceSimulation.svelte → force/ForceSimulation.svelte}

@@ -1,8 +1,22 @@
 <script lang="ts" module>
-  import { forceSimulation, type Force, type Simulation, type SimulationNodeDatum } from 'd3-force';
+  import {
+    forceSimulation,
+    type Force,
+    type Simulation,
+    type SimulationLinkDatum,
+    type SimulationNodeDatum,
+  } from 'd3-force';
   import type { Snippet } from 'svelte';
 
-  type Forces = Record<string, Force<any, any>>;
+  export type Forces<
+    NodeDatum extends SimulationNodeDatum,
+    LinkDatum extends SimulationLinkDatum<NodeDatum> | undefined,
+  > = Record<string, Force<NodeDatum, LinkDatum>>;
+
+  export type Data<TNode = any, TLink = any> = {
+    nodes: TNode[];
+    links?: TLink[];
+  };
 
   export type LinkPosition = {
     x1: number;
@@ -11,44 +25,115 @@
     y2: number;
   };
 
-  export type ForceSimulationProps = {
+  export type OnStartEvent<
+    NodeDatum extends SimulationNodeDatum,
+    LinkDatum extends SimulationLinkDatum<NodeDatum> | undefined,
+  > = {
+    alpha: number;
+    alphaTarget: number;
+    simulation: Simulation<NodeDatum, LinkDatum>;
+  };
+
+  export type OnTickEvent<
+    NodeDatum extends SimulationNodeDatum,
+    LinkDatum extends SimulationLinkDatum<NodeDatum> | undefined,
+  > = {
+    alpha: number;
+    alphaTarget: number;
+    nodes: NodeDatum[];
+    links: LinkDatum[];
+    simulation: Simulation<NodeDatum, LinkDatum>;
+  };
+
+  export type OnEndEvent<
+    NodeDatum extends SimulationNodeDatum,
+    LinkDatum extends SimulationLinkDatum<NodeDatum> | undefined,
+  > = {
+    alpha: number;
+    alphaTarget: number;
+    simulation: Simulation<NodeDatum, LinkDatum>;
+  };
+
+  export type OnNodesChangeEvent<
+    NodeDatum extends SimulationNodeDatum,
+    LinkDatum extends SimulationLinkDatum<NodeDatum> | undefined,
+  > = {
+    alpha: number;
+    alphaTarget: number;
+    nodes: NodeDatum[];
+    links: LinkDatum[];
+    simulation: Simulation<NodeDatum, LinkDatum>;
+  };
+
+  /**
+   * Default initial alpha value of the simulation.
+   */
+  export const DEFAULT_ALPHA: number = 1;
+
+  /**
+   * Default target alpha value for the simulation.
+   */
+  export const DEFAULT_ALPHA_TARGET: number = 0;
+
+  /**
+   * Default alpha decay rate per tick.
+   *
+   * Formula: `1 - Math.pow(0.001, 1 / 300)`.
+   */
+  export const DEFAULT_ALPHA_DECAY: number = 1 - Math.pow(0.001, 1 / 300);
+
+  /**
+   * Default minimum alpha value at which simulation stops.
+   */
+  export const DEFAULT_ALPHA_MIN: number = 0.01;
+
+  /**
+   * Default velocity decay factor applied to nodes each tick.
+   */
+  export const DEFAULT_VELOCITY_DECAY: number = 0.4;
+
+  export type ForceSimulationProps<
+    NodeDatum extends SimulationNodeDatum,
+    LinkDatum extends SimulationLinkDatum<NodeDatum> | undefined,
+  > = {
     /**
      * Force simulation parameters
      */
-    forces: Forces;
+    forces: Forces<NodeDatum, LinkDatum>;
 
     /**
-     * An array of links to be used for position calculation.
+     * An object with arrays of nodes and links,
+     * to be used for position calculation.
      */
-    links?: any[];
+    data: Data<NodeDatum, LinkDatum>;
 
     /**
      * Current alpha value of the simulation
-     * @default 1
+     * @default DEFAULT_ALPHA
      */
     alpha?: number;
 
     /**
      * Target alpha value for the simulation
-     * @default 0
+     * @default DEFAULT_ALPHA_TARGET
      */
     alphaTarget?: number;
 
     /**
      * Alpha decay rate per tick
-     * @default 1 - Math.pow(0.001, 1 / 300)
+     * @default DEFAULT_ALPHA_DECAY
      */
     alphaDecay?: number;
 
     /**
      * Minimum alpha value at which simulation stops
-     * @default 0.01
+     * @default DEFAULT_ALPHA_MIN
      */
     alphaMin?: number;
 
     /**
      * Velocity decay factor applied to nodes each tick
-     * @default 0.4
+     * @default DEFAULT_VELOCITY_DECAY
      */
     velocityDecay?: number;
 
@@ -73,65 +158,78 @@
     /**
      * Callback function triggered when simulation starts
      */
-    onStart?: () => void;
+    onStart?: (e: OnStartEvent<NodeDatum, LinkDatum | undefined>) => void;
+
+    /**
+     * Callback function triggered right before nodes get passed to the simulation
+     */
+    onNodesChange?: (e: OnNodesChangeEvent<NodeDatum, LinkDatum | undefined>) => void;
 
     /**
      * Callback function triggered on each simulation tick
      */
-    onTick?: (e: { alpha: number; alphaTarget: number }) => void;
+    onTick?: (e: OnTickEvent<NodeDatum, LinkDatum | undefined>) => void;
 
     /**
      * Callback function triggered when simulation ends
      */
-    onEnd?: () => void;
+    onEnd?: (e: OnEndEvent<NodeDatum, LinkDatum | undefined>) => void;
 
     children?: Snippet<
       [
         {
-          nodes: any[];
-          simulation: Simulation<SimulationNodeDatum, undefined>;
+          nodes: NodeDatum[];
+          links: LinkDatum[];
           linkPositions: LinkPosition[];
+          simulation: Simulation<NodeDatum, LinkDatum>;
         },
       ]
     >;
   };
 </script>
 
-<script lang="ts">
-  import { getChartContext } from './Chart.svelte';
+<script
+  lang="ts"
+  generics="NodeDatum extends SimulationNodeDatum,
+    LinkDatum extends SimulationLinkDatum<NodeDatum> | undefined,"
+>
   import { watch } from 'runed';
 
   let {
     forces,
-    links = [],
-    alpha = $bindable(1),
-    alphaTarget = 0,
-    alphaDecay = 1 - Math.pow(0.001, 1 / 300),
-    alphaMin = 0.001,
-    velocityDecay = 0.4,
+    data,
+    alpha = $bindable(DEFAULT_ALPHA),
+    alphaTarget = DEFAULT_ALPHA_TARGET,
+    alphaDecay = DEFAULT_ALPHA_DECAY,
+    alphaMin = DEFAULT_ALPHA_MIN,
+    velocityDecay = DEFAULT_VELOCITY_DECAY,
     stopped = false,
     static: staticProp,
-    onStart: onStartProp = () => {},
-    onTick: onTickProp = () => {},
-    onEnd: onEndProp = () => {},
+    onStart: onStartProp,
+    onNodesChange: onNodesChangeProp,
+    onTick: onTickProp,
+    onEnd: onEndProp,
     children,
     cloneNodes = false,
-  }: ForceSimulationProps = $props();
-
-  const ctx = getChartContext();
+  }: ForceSimulationProps<NodeDatum, LinkDatum> = $props();
 
   // MARK: Public Props
 
   // MARK: Private Props
 
-  let nodes: SimulationNodeDatum[] = $state([]);
   let linkPositions: LinkPosition[] = $state([]);
+  let simulatedNodes: NodeDatum[] = $state([]);
+  let simulatedLinks: LinkDatum[] = $derived(data.links ?? []);
 
-  const simulation = forceSimulation().stop();
+  // This casting is unfortunately necessary, due to unfortunate
+  // overloading choices made, over at `@typed/d3-force`:
+  const simulation: Simulation<NodeDatum, LinkDatum> = (
+    forceSimulation<NodeDatum>() as Simulation<NodeDatum, LinkDatum>
+  ).stop();
 
   // d3.Simulation does not provide a `.forces()` getter, so we need to
   // keep track of previous forces ourselves, for diffing against `forces`.
-  let previousForces: Forces = {};
+  let previousForces: Forces<NodeDatum, LinkDatum> = {};
 
   let paused: boolean = true;
 
@@ -166,11 +264,12 @@
   );
 
   watch.pre(
-    () => ctx.data,
+    () => data,
     () => {
-      // Any time the `data` store gets changed we
-      // pass them to the internal d3 simulation object:
-      pushNodesToSimulation(ctx.data as any[]);
+      // Any time the `nodes` prop, or the `data` store gets changed
+      // we pass them to the internal d3 simulation object:
+      onNodesChange();
+      pushNodesToSimulation(data.nodes);
       runOrResumeSimulation();
     }
   );
@@ -192,12 +291,8 @@
       // pass it to the internal d3 simulation object:
       pushAlphaToSimulation(alpha);
 
-      // Only resume the simulation as long as `alpha`
-      // is above the cut-off threshold of `alphaMin`,
-      // otherwise our simulation will never terminate:
-      if (simulation.alpha() >= simulation.alphaMin()) {
-        runOrResumeSimulation();
-      }
+      // Then we attempt to resume the simulation:
+      runOrResumeSimulation();
     }
   );
 
@@ -235,7 +330,7 @@
     simulation.nodes(nodes);
   }
 
-  function pushForcesToSimulation(forces: Forces) {
+  function pushForcesToSimulation(forces: Forces<NodeDatum, LinkDatum>) {
     // Evict obsolete forces:
     const names = Object.keys(previousForces);
     for (const name of names) {
@@ -259,7 +354,7 @@
     // Keeping the link positions in sync with the simulation
     // so we don't need to recalculate _all_ link positions on each tick
     // which bogs down the simulation
-    linkPositions = links.map((link: any) => ({
+    linkPositions = simulatedLinks.map((link: any) => ({
       x1: link.source.x ?? 0,
       y1: link.source.y ?? 0,
       x2: link.target.x ?? 0,
@@ -270,7 +365,8 @@
   // MARK: Pull State
 
   function pullNodesFromSimulation() {
-    nodes = cloneNodes ? structuredClone(simulation.nodes()) : simulation.nodes();
+    const simulationNodes = simulation.nodes();
+    simulatedNodes = cloneNodes ? structuredClone(simulationNodes) : simulationNodes;
   }
 
   function pullAlphaFromSimulation() {
@@ -337,6 +433,13 @@
       return;
     }
 
+    if (simulation.alpha() < simulation.alphaMin()) {
+      // Only resume the simulation as long as `alpha`
+      // is above the cut-off threshold of `alphaMin`,
+      // otherwise our simulation will never terminate:
+      return;
+    }
+
     onStart();
     simulation.restart();
 
@@ -364,7 +467,12 @@
     }
 
     paused = false;
-    onStartProp();
+
+    onStartProp?.({
+      alpha,
+      alphaTarget,
+      simulation,
+    });
   }
 
   function onTick() {
@@ -372,7 +480,13 @@
     pullAlphaFromSimulation();
     updateLinkPositions();
 
-    onTickProp({ alpha, alphaTarget });
+    onTickProp?.({
+      alpha,
+      alphaTarget,
+      nodes: simulatedNodes,
+      links: simulatedLinks,
+      simulation,
+    });
   }
 
   function onEnd() {
@@ -382,7 +496,22 @@
     }
 
     paused = true;
-    onEndProp();
+
+    onEndProp?.({
+      alpha,
+      alphaTarget,
+      simulation,
+    });
+  }
+
+  function onNodesChange() {
+    onNodesChangeProp?.({
+      alpha,
+      alphaTarget,
+      nodes: data.nodes,
+      links: data.links ?? [],
+      simulation,
+    });
   }
 
   $effect(() => {
@@ -393,4 +522,9 @@
   });
 </script>
 
-{@render children?.({ nodes: nodes, simulation, linkPositions })}
+{@render children?.({
+  nodes: simulatedNodes,
+  links: simulatedLinks,
+  simulation,
+  linkPositions,
+})}

package/dist/components/force/ForceSimulation.svelte.d.ts

@@ -0,0 +1,158 @@
+import { type Force, type Simulation, type SimulationLinkDatum, type SimulationNodeDatum } from 'd3-force';
+import type { Snippet } from 'svelte';
+export type Forces<NodeDatum extends SimulationNodeDatum, LinkDatum extends SimulationLinkDatum<NodeDatum> | undefined> = Record<string, Force<NodeDatum, LinkDatum>>;
+export type Data<TNode = any, TLink = any> = {
+    nodes: TNode[];
+    links?: TLink[];
+};
+export type LinkPosition = {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+};
+export type OnStartEvent<NodeDatum extends SimulationNodeDatum, LinkDatum extends SimulationLinkDatum<NodeDatum> | undefined> = {
+    alpha: number;
+    alphaTarget: number;
+    simulation: Simulation<NodeDatum, LinkDatum>;
+};
+export type OnTickEvent<NodeDatum extends SimulationNodeDatum, LinkDatum extends SimulationLinkDatum<NodeDatum> | undefined> = {
+    alpha: number;
+    alphaTarget: number;
+    nodes: NodeDatum[];
+    links: LinkDatum[];
+    simulation: Simulation<NodeDatum, LinkDatum>;
+};
+export type OnEndEvent<NodeDatum extends SimulationNodeDatum, LinkDatum extends SimulationLinkDatum<NodeDatum> | undefined> = {
+    alpha: number;
+    alphaTarget: number;
+    simulation: Simulation<NodeDatum, LinkDatum>;
+};
+export type OnNodesChangeEvent<NodeDatum extends SimulationNodeDatum, LinkDatum extends SimulationLinkDatum<NodeDatum> | undefined> = {
+    alpha: number;
+    alphaTarget: number;
+    nodes: NodeDatum[];
+    links: LinkDatum[];
+    simulation: Simulation<NodeDatum, LinkDatum>;
+};
+/**
+ * Default initial alpha value of the simulation.
+ */
+export declare const DEFAULT_ALPHA: number;
+/**
+ * Default target alpha value for the simulation.
+ */
+export declare const DEFAULT_ALPHA_TARGET: number;
+/**
+ * Default alpha decay rate per tick.
+ *
+ * Formula: `1 - Math.pow(0.001, 1 / 300)`.
+ */
+export declare const DEFAULT_ALPHA_DECAY: number;
+/**
+ * Default minimum alpha value at which simulation stops.
+ */
+export declare const DEFAULT_ALPHA_MIN: number;
+/**
+ * Default velocity decay factor applied to nodes each tick.
+ */
+export declare const DEFAULT_VELOCITY_DECAY: number;
+export type ForceSimulationProps<NodeDatum extends SimulationNodeDatum, LinkDatum extends SimulationLinkDatum<NodeDatum> | undefined> = {
+    /**
+     * Force simulation parameters
+     */
+    forces: Forces<NodeDatum, LinkDatum>;
+    /**
+     * An object with arrays of nodes and links,
+     * to be used for position calculation.
+     */
+    data: Data<NodeDatum, LinkDatum>;
+    /**
+     * Current alpha value of the simulation
+     * @default DEFAULT_ALPHA
+     */
+    alpha?: number;
+    /**
+     * Target alpha value for the simulation
+     * @default DEFAULT_ALPHA_TARGET
+     */
+    alphaTarget?: number;
+    /**
+     * Alpha decay rate per tick
+     * @default DEFAULT_ALPHA_DECAY
+     */
+    alphaDecay?: number;
+    /**
+     * Minimum alpha value at which simulation stops
+     * @default DEFAULT_ALPHA_MIN
+     */
+    alphaMin?: number;
+    /**
+     * Velocity decay factor applied to nodes each tick
+     * @default DEFAULT_VELOCITY_DECAY
+     */
+    velocityDecay?: number;
+    /**
+     * Stop simulation
+     * @default false
+     */
+    stopped?: boolean;
+    /**
+     * If true, will only update nodes after simulation has completed
+     * @default false
+     */
+    static?: boolean;
+    /**
+     * Clone nodes since simulation mutates original
+     * @default false
+     */
+    cloneNodes?: boolean;
+    /**
+     * Callback function triggered when simulation starts
+     */
+    onStart?: (e: OnStartEvent<NodeDatum, LinkDatum | undefined>) => void;
+    /**
+     * Callback function triggered right before nodes get passed to the simulation
+     */
+    onNodesChange?: (e: OnNodesChangeEvent<NodeDatum, LinkDatum | undefined>) => void;
+    /**
+     * Callback function triggered on each simulation tick
+     */
+    onTick?: (e: OnTickEvent<NodeDatum, LinkDatum | undefined>) => void;
+    /**
+     * Callback function triggered when simulation ends
+     */
+    onEnd?: (e: OnEndEvent<NodeDatum, LinkDatum | undefined>) => void;
+    children?: Snippet<[
+        {
+            nodes: NodeDatum[];
+            links: LinkDatum[];
+            linkPositions: LinkPosition[];
+            simulation: Simulation<NodeDatum, LinkDatum>;
+        }
+    ]>;
+};
+declare function $$render<NodeDatum extends SimulationNodeDatum, LinkDatum extends SimulationLinkDatum<NodeDatum> | undefined>(): {
+    props: ForceSimulationProps<NodeDatum, LinkDatum>;
+    exports: {};
+    bindings: "alpha";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<NodeDatum extends SimulationNodeDatum, LinkDatum extends SimulationLinkDatum<NodeDatum> | undefined> {
+    props(): ReturnType<typeof $$render<NodeDatum, LinkDatum>>['props'];
+    events(): ReturnType<typeof $$render<NodeDatum, LinkDatum>>['events'];
+    slots(): ReturnType<typeof $$render<NodeDatum, LinkDatum>>['slots'];
+    bindings(): "alpha";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <NodeDatum extends SimulationNodeDatum, LinkDatum extends SimulationLinkDatum<NodeDatum> | undefined>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<NodeDatum, LinkDatum>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<NodeDatum, LinkDatum>['props']>, ReturnType<__sveltets_Render<NodeDatum, LinkDatum>['events']>, ReturnType<__sveltets_Render<NodeDatum, LinkDatum>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<NodeDatum, LinkDatum>['bindings']>;
+    } & ReturnType<__sveltets_Render<NodeDatum, LinkDatum>['exports']>;
+    <NodeDatum extends SimulationNodeDatum, LinkDatum extends SimulationLinkDatum<NodeDatum> | undefined>(internal: unknown, props: ReturnType<__sveltets_Render<NodeDatum, LinkDatum>['props']> & {}): ReturnType<__sveltets_Render<NodeDatum, LinkDatum>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any, any>['bindings']>;
+}
+declare const ForceSimulation: $$IsomorphicComponent;
+type ForceSimulation<NodeDatum extends SimulationNodeDatum, LinkDatum extends SimulationLinkDatum<NodeDatum> | undefined> = InstanceType<typeof ForceSimulation<NodeDatum, LinkDatum>>;
+export default ForceSimulation;

package/dist/components/force/index.d.ts

@@ -0,0 +1,2 @@
+export { default as ForceSimulation } from './ForceSimulation.svelte';
+export * from './ForceSimulation.svelte';

package/dist/components/force/index.js

@@ -0,0 +1,2 @@
+export { default as ForceSimulation } from './ForceSimulation.svelte';
+export * from './ForceSimulation.svelte';

package/dist/components/{GeoCircle.svelte → geo/GeoCircle.svelte}

@@ -1,6 +1,6 @@
 <script lang="ts" module>
   import GeoPath, { type GeoPathProps } from './GeoPath.svelte';
-  import type { Without } from '../utils/types.js';
+  import type { Without } from '../../utils/types.js';
   export type GeoCirclePropsWithoutHTML = {
     /**
      * The radius of the circle in degrees.
@@ -27,11 +27,11 @@
 
 <script lang="ts">
   import { geoCircle } from 'd3-geo';
-  import { extractLayerProps } from '../utils/attributes.js';
+  import { extractLayerProps } from '../../utils/attributes.js';
 
   let { radius = 90, center = [0, 0], precision = 6, ...restProps }: GeoCircleProps = $props();
 
   const geojson = $derived(geoCircle().radius(radius).center(center).precision(precision)());
 </script>
 
-<GeoPath {geojson} {...extractLayerProps(restProps, 'geo-circle')} />
+<GeoPath {geojson} {...extractLayerProps(restProps, 'lc-geo-circle')} />

package/dist/components/{GeoCircle.svelte.d.ts → geo/GeoCircle.svelte.d.ts}

@@ -1,5 +1,5 @@
 import { type GeoPathProps } from './GeoPath.svelte';
-import type { Without } from '../utils/types.js';
+import type { Without } from '../../utils/types.js';
 export type GeoCirclePropsWithoutHTML = {
     /**
      * The radius of the circle in degrees.

package/dist/components/geo/GeoClipPath.svelte

@@ -0,0 +1,72 @@
+<script lang="ts" module>
+  import type { GeoPermissibleObjects } from 'd3-geo';
+  import type { Snippet } from 'svelte';
+
+  import type { ClipPathPropsWithoutHTML } from '../ClipPath.svelte';
+  import type { GeoPathPropsWithoutHTML } from './GeoPath.svelte';
+  import type { Without } from '../../utils/types.js';
+
+  export type BaseGeoClipPathPropsWithoutHTML = {
+    /**
+     * A unique id for the clipPath.
+     */
+    id?: string;
+
+    /**
+     * GeoJSON data defining the clip boundary.
+     */
+    geojson: GeoPermissibleObjects;
+
+    /**
+     * Whether to disable clipping (show all).
+     *
+     * @default false
+     */
+    disabled?: boolean;
+
+    /**
+     * Invert the clip — content renders *outside* the geojson shape.
+     *
+     * @default false
+     */
+    invert?: boolean;
+
+    /**
+     * The children snippet to render content inside the clipPath.
+     */
+    children?: ClipPathPropsWithoutHTML['children'];
+  };
+
+  export type GeoClipPathPropsWithoutHTML = BaseGeoClipPathPropsWithoutHTML &
+    Without<GeoPathPropsWithoutHTML, BaseGeoClipPathPropsWithoutHTML>;
+
+  export type GeoClipPathProps = GeoClipPathPropsWithoutHTML;
+</script>
+
+<script lang="ts">
+  import { geoPath as d3GeoPath } from 'd3-geo';
+
+  import ClipPath from '../ClipPath.svelte';
+  import { createId } from '../../utils/createId.js';
+  import { getGeoContext } from '../../contexts/geo.js';
+
+  const uid = $props.id();
+
+  let {
+    id = createId('clipPath-', uid),
+    geojson,
+    disabled = false,
+    invert = false,
+    children,
+  }: GeoClipPathProps = $props();
+
+  const geo = getGeoContext();
+
+  // d3-geo-path emits an SVG path `d` string that Path2D and
+  // `clip-path: path()` also accept — single source of truth for all layers.
+  const path = $derived(
+    geo.projection && geojson ? (d3GeoPath(geo.projection)(geojson) ?? undefined) : undefined
+  );
+</script>
+
+<ClipPath {id} {disabled} {invert} {children} {path} />

package/dist/components/geo/GeoClipPath.svelte.d.ts

@@ -0,0 +1,35 @@
+import type { GeoPermissibleObjects } from 'd3-geo';
+import type { ClipPathPropsWithoutHTML } from '../ClipPath.svelte';
+import type { GeoPathPropsWithoutHTML } from './GeoPath.svelte';
+import type { Without } from '../../utils/types.js';
+export type BaseGeoClipPathPropsWithoutHTML = {
+    /**
+     * A unique id for the clipPath.
+     */
+    id?: string;
+    /**
+     * GeoJSON data defining the clip boundary.
+     */
+    geojson: GeoPermissibleObjects;
+    /**
+     * Whether to disable clipping (show all).
+     *
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Invert the clip — content renders *outside* the geojson shape.
+     *
+     * @default false
+     */
+    invert?: boolean;
+    /**
+     * The children snippet to render content inside the clipPath.
+     */
+    children?: ClipPathPropsWithoutHTML['children'];
+};
+export type GeoClipPathPropsWithoutHTML = BaseGeoClipPathPropsWithoutHTML & Without<GeoPathPropsWithoutHTML, BaseGeoClipPathPropsWithoutHTML>;
+export type GeoClipPathProps = GeoClipPathPropsWithoutHTML;
+declare const GeoClipPath: import("svelte").Component<GeoClipPathPropsWithoutHTML, {}, "">;
+type GeoClipPath = ReturnType<typeof GeoClipPath>;
+export default GeoClipPath;