@radiofrance/svelte-leaflet 0.1.0-alpha.8 → 1.0.0-next.0

package/dist/Popup.svelte.d.ts

@@ -1,19 +1,10 @@
-import { SvelteComponent } from "svelte";
-import type { PopupOptions } from 'leaflet';
-declare const __propDef: {
-    props: {
-        options?: PopupOptions | undefined;
-    };
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {
-        default: {};
-    };
-};
-export type PopupProps = typeof __propDef.props;
-export type PopupEvents = typeof __propDef.events;
-export type PopupSlots = typeof __propDef.slots;
-export default class Popup extends SvelteComponent<PopupProps, PopupEvents, PopupSlots> {
-}
-export {};
+import type { LatLngExpression, PopupOptions, Popup as LeafletPopup } from 'leaflet';
+import { type Snippet } from 'svelte';
+import { type PopupEvents } from './popup.svelte.js';
+declare const Popup: import("svelte").Component<{
+    latlng?: LatLngExpression;
+    options?: PopupOptions;
+    instance?: LeafletPopup;
+    children?: Snippet;
+} & PopupEvents, {}, "instance" | "options">;
+export default Popup;

package/dist/contexts.d.ts

@@ -0,0 +1,4 @@
+export declare const MAP: unique symbol;
+export declare const LAYERGROUP: unique symbol;
+export declare const MARKER: unique symbol;
+export declare const FOCUSABLE: unique symbol;

package/dist/contexts.js

@@ -0,0 +1,4 @@
+export const MAP = Symbol('map');
+export const LAYERGROUP = Symbol('layerGroup');
+export const MARKER = Symbol('marker');
+export const FOCUSABLE = Symbol('focusable');

package/dist/events.d.ts

@@ -0,0 +1,11 @@
+export declare const interactiveLayerEvents: readonly ["click", "dblclick", "mousedown", "mouseup", "mouseover", "mouseout", "contextmenu"];
+export declare const draggingEvents: readonly ["dragstart", "movestart", "drag", "dragend", "moveend"];
+export declare const keyboardEvents: readonly ["keypress", "keydown", "keyup"];
+export declare const locationEvents: readonly ["locationfound", "locationerror"];
+export declare const leafletMouseEvents: readonly ["click", "dblclick", "mousedown", "mouseup", "mouseover", "mouseout", "contextmenu", "mousemove", "preclick"];
+export declare const layerEvents: readonly ["add", "remove"];
+export declare const popupSpecificEvents: readonly ["popupopen", "popupclose"];
+export declare const tooltipEvents: readonly ["tooltipopen", "tooltipclose"];
+export declare const layerGroupEvents: readonly ["layeradd", "layerremove"];
+export declare const layersControlEvents: readonly ["baselayerchange", "overlayadd", "overlayremove"];
+export declare const mapStateChangeEvents: readonly ["load", "move", "moveend", "movestart", "unload", "viewreset", "zoom", "zoomend", "zoomlevelschange", "zoomstart", "resize"];

package/dist/events.js

@@ -0,0 +1,31 @@
+export const interactiveLayerEvents = [
+    'click',
+    'dblclick',
+    'mousedown',
+    'mouseup',
+    'mouseover',
+    'mouseout',
+    'contextmenu',
+];
+export const draggingEvents = ['dragstart', 'movestart', 'drag', 'dragend', 'moveend'];
+export const keyboardEvents = ['keypress', 'keydown', 'keyup'];
+export const locationEvents = ['locationfound', 'locationerror'];
+export const leafletMouseEvents = [...interactiveLayerEvents, 'mousemove', 'preclick'];
+export const layerEvents = ['add', 'remove'];
+export const popupSpecificEvents = ['popupopen', 'popupclose'];
+export const tooltipEvents = ['tooltipopen', 'tooltipclose'];
+export const layerGroupEvents = ['layeradd', 'layerremove'];
+export const layersControlEvents = ['baselayerchange', 'overlayadd', 'overlayremove'];
+const leafletEvents = [
+    'load',
+    'move',
+    'moveend',
+    'movestart',
+    'unload',
+    'viewreset',
+    'zoom',
+    'zoomend',
+    'zoomlevelschange',
+    'zoomstart',
+];
+export const mapStateChangeEvents = [...leafletEvents, 'resize'];

package/dist/index.d.ts

@@ -1,8 +1,19 @@
-export { default as Map } from './Map.svelte';
-export { default as Marker } from './Marker.svelte';
-export { default as MarkerClusterGroup } from './MarkerClusterGroup.svelte';
-export { default as Polyline } from './Polyline.svelte';
-export { default as Popup } from './Popup.svelte';
-export { default as Circle } from './Circle.svelte';
-export type { Marker as LeafletMarker } from './Marker.svelte';
-export type { CircleOptions, LatLngExpression, LatLngLiteral, LatLngTuple, LeafletEvent, LeafletKeyboardEvent, LeafletMouseEvent, Map as LeafletMap, MapOptions, MarkerOptions, PathOptions } from 'leaflet';
+import type { ControlPosition, Evented, LatLngExpression, LeafletEventHandlerFnMap, LocateOptions } from 'leaflet';
+import DivIcon from './DivIcon.svelte';
+import Map from './Map.svelte';
+import Marker from './Marker.svelte';
+import MarkerClusterGroup from './MarkerClusterGroup.svelte';
+import Popup from './Popup.svelte';
+import Polygon from './Polygon.svelte';
+import LocateControl from './LocateControl.svelte';
+export { DivIcon, Map, Marker, MarkerClusterGroup, Popup, Polygon, LocateControl };
+export type { Circle as LeafletCircle, CircleOptions, DragEndEvent, ErrorEvent, LatLngBoundsLiteral, LatLngExpression, LatLngLiteral, LatLngTuple, LayerEvent, LayersControlEvent, LeafletEvent, LeafletKeyboardEvent, LeafletMouseEvent, LocationEvent, Map as LeafletMap, MapOptions, MarkerOptions, PathOptions, PopupEvent, PopupOptions, ResizeEvent, TooltipEvent, } from 'leaflet';
+export type Latlngs<D = 2> = 2 extends D ? LatLngExpression[] | LatLngExpression[][] : 3 extends D ? LatLngExpression[] | LatLngExpression[][] | LatLngExpression[][][] : never;
+export type PrefixedLeafletEventHandlerFnMap = {
+    [K in keyof LeafletEventHandlerFnMap as `on${K}`]: LeafletEventHandlerFnMap[K];
+};
+export declare function bindEvents(instance: Evented, eventsProps: PrefixedLeafletEventHandlerFnMap, events: readonly (keyof LeafletEventHandlerFnMap)[]): void;
+export type LocateControlOptions = {
+    position?: ControlPosition;
+    options?: LocateOptions;
+};

package/dist/index.js

@@ -1,7 +1,17 @@
 // Reexport your entry components here
-export { default as Map } from './Map.svelte';
-export { default as Marker } from './Marker.svelte';
-export { default as MarkerClusterGroup } from './MarkerClusterGroup.svelte';
-export { default as Polyline } from './Polyline.svelte';
-export { default as Popup } from './Popup.svelte';
-export { default as Circle } from './Circle.svelte';
+import DivIcon from './DivIcon.svelte';
+import Map from './Map.svelte';
+import Marker from './Marker.svelte';
+import MarkerClusterGroup from './MarkerClusterGroup.svelte';
+import Popup from './Popup.svelte';
+import Polygon from './Polygon.svelte';
+import LocateControl from './LocateControl.svelte';
+export { DivIcon, Map, Marker, MarkerClusterGroup, Popup, Polygon, LocateControl };
+export function bindEvents(instance, eventsProps, events) {
+    events.forEach((event) => {
+        const eventCallback = eventsProps[`on${event}`];
+        if (typeof eventCallback !== 'function')
+            return;
+        instance.on(event, (e) => eventCallback(e));
+    });
+}

package/dist/map.svelte.d.ts

@@ -0,0 +1,10 @@
+import type { Map as LeafletMap, MapOptions } from 'leaflet';
+import { type CreateSvelteEventsMap } from './utils.js';
+export declare function updateMapProps(instance: LeafletMap, newProps: MapOptions): void;
+export declare const mapEvents: readonly ["keypress", "keydown", "keyup", "layeradd", "layerremove", "baselayerchange", "overlayadd", "overlayremove", "click", "dblclick", "mousedown", "mouseup", "mouseover", "mouseout", "contextmenu", "mousemove", "preclick", "locationfound", "locationerror", "load", "move", "moveend", "movestart", "unload", "viewreset", "zoom", "zoomend", "zoomlevelschange", "zoomstart", "resize", "popupopen", "popupclose", "tooltipopen", "tooltipclose", "autopanstart", "zoomanim"];
+export type MapEvents = CreateSvelteEventsMap<typeof mapEvents, LeafletMap>;
+declare module 'leaflet' {
+    interface Handler {
+        _setPanDelta(delta: number): void;
+    }
+}

package/dist/map.svelte.js

@@ -0,0 +1,117 @@
+import { capitalize } from './utils.js';
+import { keyboardEvents, layerGroupEvents, layersControlEvents, leafletMouseEvents, locationEvents, mapStateChangeEvents, popupSpecificEvents, tooltipEvents, } from './events.js';
+// stores the function bound to the event listener so it can be removed later
+let boundInvalidateMapSize = null;
+function invalidateMapSize(map) {
+    map.invalidateSize({
+        // TODO : add a way to customize these default values
+        debounceMoveend: true,
+        pan: true,
+    });
+}
+export function updateMapProps(instance, newProps) {
+    if (!newProps)
+        return;
+    // any is the default type for the Object.entries values anyway
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    for (const [key, value] of Object.entries(newProps)) {
+        // skip if the option value is unchanged
+        if (instance.options[key] === value)
+            continue;
+        // update the option value :
+        // - needed for future comparison (CF above)
+        // - handles simple cases :
+        //		untested :
+        //		  closePopupOnClick	markerZoomAnimation	tapTolerance	worldCopyJump(untested)
+        //		tested :
+        //		  bounceAtZoomLimits	preferCanvas
+        //		  easeLinearity				transform3DLimit
+        //		  inertia							wheelDebounceTime
+        //		  inertiaDeceleration	zoomAnimationThreshold
+        //		  inertiaMaxSpeed			zoomDelta
+        //		  maxBoundsViscosity	zoomSnap
+        instance.options[key] = value;
+        switch (key) {
+            // TODO : move check of unsupported options before the unchanged check
+            case 'fadeAnimation':
+            case 'zoomAnimation':
+            case 'wheelPxPerZoomLevel':
+            case 'crs':
+            case 'layers':
+            case 'renderer':
+                // animations could be hacked around by changing style attributes
+                // not a priority
+                throw new Error(`mutation of ${key} option is not supported`);
+            // setters cases
+            case 'maxBounds':
+            case 'minZoom':
+            case 'maxZoom':
+            case 'zoom': {
+                const setterName = `set${capitalize(key)}`;
+                const setter = instance[setterName].bind(instance);
+                setter(value);
+                break;
+            }
+            // enable/disable cases (Handlers)
+            case 'boxZoom':
+            case 'scrollWheelZoom':
+            case 'doubleClickZoom':
+            case 'dragging':
+            case 'keyboard':
+            case 'tapHold':
+            case 'touchZoom': // untested
+                if (value)
+                    instance[key]?.enable();
+                else
+                    instance[key]?.disable();
+                break;
+            // Control cases
+            case 'zoomControl':
+                if (value) {
+                    instance.zoomControl = instance.zoomControl || window.L.control.zoom();
+                    instance.zoomControl.addTo(instance);
+                }
+                else
+                    instance.zoomControl?.remove();
+                break;
+            case 'attributionControl':
+                if (value) {
+                    instance.attributionControl =
+                        instance.attributionControl || window.L.control.attribution();
+                    instance.attributionControl.addTo(instance);
+                }
+                else
+                    instance.attributionControl?.remove();
+                break;
+            //complex cases
+            case 'center':
+                instance.setView(value, instance.getZoom());
+                break;
+            case 'keyboardPanDelta':
+                // seems fine despite using a private method
+                instance.keyboard._setPanDelta(value);
+                break;
+            case 'trackResize':
+                if (boundInvalidateMapSize === null)
+                    boundInvalidateMapSize = invalidateMapSize.bind(null, instance);
+                window.removeEventListener('resize', boundInvalidateMapSize);
+                if (value) {
+                    window.addEventListener('resize', boundInvalidateMapSize);
+                    invalidateMapSize(instance);
+                }
+                break;
+        }
+    }
+}
+export const mapEvents = [
+    ...keyboardEvents,
+    ...layerGroupEvents,
+    ...layersControlEvents,
+    ...leafletMouseEvents,
+    ...locationEvents,
+    ...mapStateChangeEvents,
+    ...popupSpecificEvents,
+    ...tooltipEvents,
+    'autopanstart',
+    'zoomanim',
+];

package/dist/marker.svelte.d.ts

@@ -0,0 +1,5 @@
+import type { Marker as LeafletMarker, MarkerOptions } from 'leaflet';
+import { type CreateSvelteEventsMap } from './utils.js';
+export declare function updateMarkerProps(instance: LeafletMarker, options: MarkerOptions): void;
+export declare const markerEvents: readonly ["move", "dragstart", "movestart", "drag", "dragend", "moveend", "click", "dblclick", "mousedown", "mouseup", "mouseover", "mouseout", "contextmenu", "add", "remove", "popupopen", "popupclose", "tooltipopen", "tooltipclose"];
+export type MarkerEvents = CreateSvelteEventsMap<typeof markerEvents, LeafletMarker>;

package/dist/marker.svelte.js

@@ -0,0 +1,61 @@
+import { capitalize } from './utils.js';
+import { draggingEvents, interactiveLayerEvents, layerEvents, popupSpecificEvents, tooltipEvents, } from './events.js';
+// const L = globalThis.window.L;
+export function updateMarkerProps(instance, options) {
+    if (!options)
+        return;
+    for (const [key, value] of Object.entries(options)) {
+        // skip if the option value is unchanged
+        if (instance.options[key] === value)
+            continue;
+        // update the option value :
+        // - needed for future comparison (CF above)
+        // - handles simple cases
+        //     bubblingMouseEvents	riseOffset	autoPanPadding
+        //     autoPanSpeed
+        instance.options[key] = value;
+        switch (key) {
+            // setter cases
+            case 'icon': // untested
+            case 'zIndexOffset':
+            case 'opacity': {
+                const setterName = `set${capitalize(key)}`;
+                const setter = instance[setterName].bind(instance);
+                setter(value);
+                break;
+            }
+            // complex cases
+            case 'title':
+                instance.getElement()?.setAttribute('title', value);
+                break;
+            case 'alt':
+                instance.getElement()?.setAttribute('alt', value);
+                break;
+            case 'draggable':
+                // option and handler are named differently
+                if (value)
+                    instance.dragging?.enable();
+                else
+                    instance.dragging?.disable();
+                break;
+            // TODO : move check of unsupported options before the unchanged check
+            case 'keyboard':
+            case 'riseOnHover':
+            case 'shadowPane':
+            case 'autoPan':
+            case 'autoPanOnFocus':
+            case 'interactive':
+            case 'pane':
+            case 'attribution':
+                throw new Error(`mutation of ${key} option is not supported`);
+        }
+    }
+}
+export const markerEvents = [
+    'move',
+    ...draggingEvents,
+    ...interactiveLayerEvents,
+    ...layerEvents,
+    ...popupSpecificEvents,
+    ...tooltipEvents,
+];

package/dist/markerClusterGroup.svelte.d.ts

@@ -0,0 +1,9 @@
+import { type MarkerEvents } from './marker.svelte.js';
+import type { CreateSvelteEventsMap } from './utils.js';
+type ClusterifyMarkerEvent<E> = E extends `on${infer N}` ? `oncluster${N}` : never;
+declare const clusterSpecificEvents: readonly ["animationend", "spiderfied", "unspiderfied"];
+export declare const markerClusterGroupEvents: readonly [...("clustermovestart" | "clustermove" | "clustermoveend" | "clusterdragstart" | "clusterdrag" | "clusteradd" | "clusterremove" | "clusterpopupopen" | "clusterpopupclose" | "clustertooltipopen" | "clustertooltipclose" | "clusterclick" | "clusterdblclick" | "clustermousedown" | "clustermouseup" | "clustermouseover" | "clustermouseout" | "clustercontextmenu" | "clusterdragend")[], "animationend", "spiderfied", "unspiderfied"];
+export type MarkerClusterGroupEvents = {
+    [K in keyof MarkerEvents as ClusterifyMarkerEvent<K>]: MarkerEvents[K];
+} & CreateSvelteEventsMap<typeof clusterSpecificEvents>;
+export {};

package/dist/markerClusterGroup.svelte.js

@@ -0,0 +1,7 @@
+import { markerEvents } from './marker.svelte.js';
+const clusteredMarkerEvents = markerEvents.map((event) => `cluster${event}`);
+const clusterSpecificEvents = ['animationend', 'spiderfied', 'unspiderfied'];
+export const markerClusterGroupEvents = [
+    ...clusteredMarkerEvents,
+    ...clusterSpecificEvents,
+];

package/dist/polygon.svelte.d.ts

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

package/dist/polygon.svelte.js

@@ -0,0 +1 @@
+"use strict";

package/dist/polyline.svelte.d.ts

@@ -0,0 +1,6 @@
+import type { CreateSvelteEventsMap } from './utils.js';
+import type { Polygon as LeafletPolygon, Polyline as LeafletPolyline, PolylineOptions } from 'leaflet';
+export declare function updatePolylineProps(instance: LeafletPolygon | LeafletPolyline, options: PolylineOptions): void;
+export declare const polygonEvents: readonly ["click", "dblclick", "mousedown", "mouseup", "mouseover", "mouseout", "contextmenu", "add", "remove", "popupopen", "popupclose", "tooltipopen", "tooltipclose"];
+export type PolygonEvents = CreateSvelteEventsMap<typeof polygonEvents, LeafletPolygon>;
+export type PolylineEvents = CreateSvelteEventsMap<typeof polygonEvents, LeafletPolyline>;

package/dist/polyline.svelte.js

@@ -0,0 +1,56 @@
+import { interactiveLayerEvents, layerEvents, popupSpecificEvents, tooltipEvents, } from './events.js';
+export function updatePolylineProps(instance, options) {
+    if (!options)
+        return;
+    for (const [key, value] of Object.entries(options)) {
+        // skip if the option value is unchanged
+        const oldValue = instance.options[key];
+        if (oldValue === value)
+            continue;
+        // update the option value :
+        // - needed for future comparison (CF above)
+        // - handles simple cases
+        //     bubblingMouseEvents	riseOffset	autoPanPadding
+        //     autoPanSpeed
+        instance.options[key] = value;
+        switch (key) {
+            case 'smoothFactor':
+            case 'noClip':
+            case 'renderer':
+            case 'interactive':
+            case 'bubblingMouseEvents':
+            case 'pane':
+            case 'attribution':
+                throw new Error(`mutation of ${key} option is not supported`);
+            case 'className':
+                if (value === '')
+                    instance.getElement()?.classList.remove(oldValue);
+                else if (oldValue === '')
+                    instance.getElement()?.classList.add(value);
+                else
+                    instance.getElement()?.classList.replace(oldValue, value);
+                break;
+            // setStyle case
+            case 'stroke':
+            case 'color':
+            case 'weight':
+            case 'opacity':
+            case 'lineCap':
+            case 'lineJoin':
+            case 'dashArray':
+            case 'dashOffset':
+            case 'fill':
+            case 'fillColor':
+            case 'fillOpacity':
+            case 'fillRule':
+                instance.setStyle(options);
+                break;
+        }
+    }
+}
+export const polygonEvents = [
+    ...interactiveLayerEvents,
+    ...layerEvents,
+    ...popupSpecificEvents,
+    ...tooltipEvents,
+];

package/dist/popup.svelte.d.ts

@@ -0,0 +1,10 @@
+import type { Popup as LeafletPopup, PopupOptions } from 'leaflet';
+import type { CreateSvelteEventsMap } from './utils.js';
+export declare function updatePopupProps(instance: LeafletPopup, options: PopupOptions): void;
+export declare const popupEvents: readonly ["click", "dblclick", "mousedown", "mouseup", "mouseover", "mouseout", "contextmenu", "add", "remove", "popupopen", "popupclose", "tooltipopen", "tooltipclose"];
+export type PopupEvents = CreateSvelteEventsMap<typeof popupEvents, LeafletPopup>;
+declare module 'leaflet' {
+    interface Popup {
+        _source: Layer;
+    }
+}

package/dist/popup.svelte.js

@@ -0,0 +1,50 @@
+import { interactiveLayerEvents, layerEvents, popupSpecificEvents, tooltipEvents, } from './events.js';
+export function updatePopupProps(instance, options) {
+    if (!options)
+        return;
+    for (const [key, value] of Object.entries(options)) {
+        // skip if the option value is unchanged
+        if (instance.options[key] === value)
+            continue;
+        // update the option value :
+        // - needed for future comparison (CF above)
+        // - handles simple cases
+        //     bubblingMouseEvents	riseOffset	autoPanPadding
+        //     autoPanSpeed
+        instance.options[key] = value;
+        switch (key) {
+            // unhandled
+            case 'className':
+            case 'interactive':
+            case 'closeButton':
+            case 'pane':
+                throw new Error(`mutation of ${key} option is not supported`);
+            // needs to reopen the popup
+            case 'keepInView':
+            case 'autoPan':
+            case 'autoClose':
+            case 'closeOnClick':
+            case 'closeOnEscapeKey':
+            case 'maxWidth':
+            case 'minWidth':
+            case 'maxHeight':
+            case 'offset':
+                if (instance.isOpen()) {
+                    const source = instance._source;
+                    source.closePopup();
+                    source.openPopup();
+                }
+                break;
+            case 'content':
+                instance.setContent(value);
+                break;
+        }
+    }
+}
+export const popupEvents = [
+    // 'contentupdate', // needs @types/leaflet PR ?
+    ...interactiveLayerEvents,
+    ...layerEvents,
+    ...popupSpecificEvents,
+    ...tooltipEvents,
+];

package/dist/private/GeolocationButton.svelte

@@ -0,0 +1,36 @@
+<script lang="ts">
+	import { getContext } from 'svelte';
+	import GeolocationIcon from './GeolocationIcon.svelte';
+	import { FOCUSABLE } from '../contexts.js';
+
+	const tabindex = getContext<-1 | null>(FOCUSABLE);
+</script>
+
+<div>
+	<button {tabindex}>
+		<GeolocationIcon width="1rem" />
+	</button>
+</div>
+
+<style>
+	button {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		width: 30px;
+		height: 30px;
+		background-color: white;
+		cursor: pointer;
+		border: none;
+		border-radius: 2px;
+	}
+
+	button:hover {
+		background-color: #f4f4f4;
+	}
+
+	div {
+		border-radius: 4px;
+		border: 2px solid rgba(0, 0, 0, 0.2);
+	}
+</style>

package/dist/private/GeolocationButton.svelte.d.ts

@@ -0,0 +1,18 @@
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const GeolocationButton: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type GeolocationButton = InstanceType<typeof GeolocationButton>;
+export default GeolocationButton;

package/dist/private/GeolocationIcon.svelte

@@ -0,0 +1,25 @@
+<script lang="ts">
+	interface Props {
+		width?: string;
+	}
+
+	let { width = '32px' }: Props = $props();
+</script>
+
+<svg
+	{width}
+	viewBox="0 0 16 16"
+	version="1.1"
+	xmlns="http://www.w3.org/2000/svg"
+	xmlns:xlink="http://www.w3.org/1999/xlink"
+	fill="#000000"
+>
+	<g id="SVGRepo_bgCarrier" stroke-width="0"></g>
+	<g id="SVGRepo_tracerCarrier" stroke-linecap="round" stroke-linejoin="round"></g>
+	<g id="SVGRepo_iconCarrier">
+		<rect width="16" height="16" id="icon-bound" fill="none"></rect>
+		<path
+			d="M13.916,7C13.494,4.488,11.512,2.506,9,2.084V0H7v2.084C4.488,2.506,2.506,4.488,2.084,7H0v2h2.084 C2.506,11.512,4.488,13.494,7,13.916V16h2v-2.084c2.512-0.422,4.494-2.403,4.916-4.916H16V7H13.916z M10.828,10.828 C10.072,11.584,9.069,12,8,12s-2.072-0.416-2.828-1.172S4,9.069,4,8s0.416-2.072,1.172-2.828S6.931,4,8,4s2.072,0.416,2.828,1.172 S12,6.931,12,8S11.584,10.072,10.828,10.828z M8,6C6.897,6,6,6.897,6,8s0.897,2,2,2s2-0.897,2-2S9.103,6,8,6z"
+		></path>
+	</g>
+</svg>

package/dist/private/GeolocationIcon.svelte.d.ts

@@ -0,0 +1,4 @@
+declare const GeolocationIcon: import("svelte").Component<{
+    width?: string;
+}, {}, "">;
+export default GeolocationIcon;

package/dist/utils.d.ts

@@ -0,0 +1,12 @@
+import type { LeafletEventHandlerFnMap } from 'leaflet';
+export declare function capitalize<T extends string>(str: T): Capitalize<T>;
+export declare function getFirstNonCommentChild(element: HTMLElement): HTMLElement | null;
+export type PickOptionByType<Options, Type> = keyof {
+    [K in keyof Options as true extends UnionContainsType<Options[K], Type> ? K : never]: Options[K];
+};
+export type UnionContainsType<Union, Type> = Union extends Type ? true : never;
+export type CreateSvelteEventsMap<EventNames extends readonly (keyof LeafletEventHandlerFnMap)[], SourceTarget = null> = {
+    [K in EventNames[number] as `on${K}`]?: SourceTarget extends null ? LeafletEventHandlerFnMap[K] : (e: Omit<Parameters<Exclude<LeafletEventHandlerFnMap[K], undefined>>[0], 'sourceTarget'> & {
+        sourceTarget: SourceTarget;
+    }) => void;
+};

package/dist/utils.js

@@ -0,0 +1,10 @@
+export function capitalize(str) {
+    return (str[0].toUpperCase() + str.slice(1));
+}
+export function getFirstNonCommentChild(element) {
+    let child = element.firstChild;
+    while (child && child.nodeType !== Node.ELEMENT_NODE) {
+        child = child.nextSibling;
+    }
+    return child;
+}