@versatiles/svelte 2.0.1 → 2.1.1

package/dist/components/MapEditor/lib/symbols.js

@@ -84,8 +84,7 @@ const entries = [
     [82, 'shield', 'basics:icon-historic', [0, -10]],
     [83, 'shoes', 'basics:icon-shoes', [-5, 0]],
     [84, 'shop', 'basics:icon-shop'],
-    [85, 'shop', 'basics:icon-shop'],
-    [86, 'shrine', 'basics:icon-shrine'],
+    [85, 'shrine', 'basics:icon-shrine'],
     [87, 'sports', 'basics:icon-sports'],
     [88, 'stadium', 'basics:icon-stadium'],
     [89, 'stationery', 'basics:icon-stationery'],
@@ -126,46 +125,66 @@ export class SymbolLibrary {
     getSymbol(index) {
         return symbols.get(index) ?? defaultSymbol;
     }
-    drawSymbol(canvas, index, halo = false) {
+    drawSymbol(canvas, index, halo = 0) {
         const symbol = this.getSymbol(index);
         if (!symbol.image)
             return;
-        const { sdf, data: imageData0 } = this.map.getImage(symbol.image);
-        const { data: data0, width: width0, height: height0 } = imageData0;
-        const { width: width1, height: height1 } = canvas;
-        const data1 = new Uint8ClampedArray(width1 * height1 * 4);
-        for (let y1 = 0; y1 < height1; y1++) {
-            const y0 = Math.floor((y1 / height1) * height0);
-            for (let x1 = 0; x1 < width1; x1++) {
-                const x0 = Math.floor((x1 / width1) * width0);
-                const i0 = (y0 * width0 + x0) * 4;
-                const i1 = (y1 * width1 + x1) * 4;
+        const { sdf, data: imageDataSrc } = this.map.getImage(symbol.image);
+        const { data: dataSrc, width: widthSrc, height: heightSrc } = imageDataSrc;
+        const { width: widthDst, height: heightDst } = canvas;
+        const scale = Math.min(widthDst / widthSrc, heightDst / heightSrc);
+        const x0 = (widthDst - widthSrc * scale) / 2;
+        const y0 = (heightDst - heightSrc * scale) / 2;
+        const border = halo;
+        const dataDst = new Uint8ClampedArray(widthDst * heightDst * 4);
+        for (let yi = 0; yi < heightDst; yi++) {
+            for (let xi = 0; xi < widthDst; xi++) {
+                const x = (xi - x0) / scale;
+                const y = (yi - y0) / scale;
+                const i = (yi * widthDst + xi) * 4;
                 if (sdf) {
-                    const v = (data0[i0 + 3] - 191) * 16;
-                    let a, b;
+                    const v = (interpolate(x, y, 3) - 191) * 8 * scale;
+                    let alpha, color;
                     if (halo) {
-                        b = Math.min(255, Math.max(0, 255 - v));
-                        a = Math.min(255, Math.max(0, 256 * 6 + v));
+                        color = Math.min(255, Math.max(0, 127.5 - v));
+                        alpha = Math.min(255, Math.max(0, 256 * border + v));
                     }
                     else {
-                        b = 0;
-                        a = Math.min(255, Math.max(0, v));
+                        color = 0;
+                        alpha = Math.min(255, Math.max(0, v));
                     }
-                    data1[i1] = b;
-                    data1[i1 + 1] = b;
-                    data1[i1 + 2] = b;
-                    data1[i1 + 3] = a;
+                    dataDst[i] = color;
+                    dataDst[i + 1] = color;
+                    dataDst[i + 2] = color;
+                    dataDst[i + 3] = alpha;
                 }
                 else {
-                    data1[i1] = data0[i0];
-                    data1[i1 + 1] = data0[i0 + 1];
-                    data1[i1 + 2] = data0[i0 + 2];
-                    data1[i1 + 3] = data0[i0 + 3];
+                    dataDst[i] = interpolate(x, y, 0);
+                    dataDst[i + 1] = interpolate(x, y, 1);
+                    dataDst[i + 2] = interpolate(x, y, 2);
+                    dataDst[i + 3] = interpolate(x, y, 3);
                 }
             }
         }
         const ctx = canvas.getContext('2d');
-        ctx.putImageData(new ImageData(data1, width1, height1), 0, 0);
+        ctx.putImageData(new ImageData(dataDst, widthDst, heightDst), 0, 0);
+        function interpolate(x, y, c) {
+            if (x < 0 || y < 0 || x >= widthSrc - 1 || y >= heightSrc - 1)
+                return 0;
+            const x0 = Math.floor(x);
+            const y0 = Math.floor(y);
+            const x1 = Math.ceil(x);
+            const y1 = Math.ceil(y);
+            const xa = (x - x0) / Math.max(1, x1 - x0);
+            const ya = (y - y0) / Math.max(1, y1 - y0);
+            const v00 = dataSrc[(y0 * widthSrc + x0) * 4 + c];
+            const v01 = dataSrc[(y0 * widthSrc + x1) * 4 + c];
+            const v10 = dataSrc[(y1 * widthSrc + x0) * 4 + c];
+            const v11 = dataSrc[(y1 * widthSrc + x1) * 4 + c];
+            const v0 = v00 * (1 - xa) + v01 * xa;
+            const v1 = v10 * (1 - xa) + v11 * xa;
+            return v0 * (1 - ya) + v1 * ya;
+        }
     }
     asList() {
         return Array.from(symbols.values());

package/dist/components/MapEditor/lib/utils/event_handler.d.ts

@@ -0,0 +1,10 @@
+export declare class EventHandler {
+    private index;
+    private events;
+    constructor();
+    emit(event: string): void;
+    on(name: string, callback: () => void): number;
+    once(name: string, callback: () => void): number;
+    off(name: string, index?: number): void;
+    clear(): void;
+}

package/dist/components/MapEditor/lib/utils/event_handler.js

@@ -0,0 +1,39 @@
+export class EventHandler {
+    index = 0;
+    events = new Map();
+    constructor() { }
+    emit(event) {
+        this.events.get(event)?.forEach((callback) => callback());
+    }
+    on(name, callback) {
+        if (!callback)
+            throw new Error('Callback is required');
+        if (!this.events.has(name))
+            this.events.set(name, new Map());
+        this.index++;
+        this.events.get(name).set(this.index, callback);
+        return this.index;
+    }
+    once(name, callback) {
+        if (!callback)
+            throw new Error('Callback is required');
+        const index = this.on(name, () => {
+            this.off(name, index);
+            callback();
+        });
+        return index;
+    }
+    off(name, index) {
+        if (!this.events.has(name))
+            return;
+        if (index) {
+            this.events.get(name)?.delete(index);
+        }
+        else {
+            this.events.delete(name);
+        }
+    }
+    clear() {
+        this.events.clear();
+    }
+}

package/dist/components/MapEditor/lib/utils/geometry.d.ts

@@ -0,0 +1,12 @@
+import type { GeoPath, GeoPoint } from './types.js';
+export declare const EARTH_RADIUS = 6371008.8;
+export declare function getMiddlePoint(p0: GeoPoint, p1: GeoPoint): GeoPoint;
+export declare function lat2mercator(lat: number): number;
+export declare function mercator2lat(y: number): number;
+export declare function distance(point1: GeoPoint, point2: GeoPoint): number;
+export declare function degreesToRadians(degrees: number): number;
+export declare function radiansToDegrees(radians: number): number;
+export declare function circle(center: GeoPoint, radius: number, steps: number): GeoPath;
+type SimpleGeometry = GeoJSON.Point | GeoJSON.LineString | GeoJSON.Polygon;
+export declare function flatten(features: GeoJSON.Feature[]): GeoJSON.Feature<SimpleGeometry>[];
+export {};

package/dist/components/MapEditor/lib/utils/geometry.js

@@ -0,0 +1,87 @@
+export const EARTH_RADIUS = 6371008.8; // Radius of the Earth in meters
+export function getMiddlePoint(p0, p1) {
+    const y0 = lat2mercator(p0[1]);
+    const y1 = lat2mercator(p1[1]);
+    return [(p0[0] + p1[0]) / 2, mercator2lat((y0 + y1) / 2)];
+}
+export function lat2mercator(lat) {
+    return Math.log(Math.tan(Math.PI / 4 + (lat * Math.PI) / 360));
+}
+export function mercator2lat(y) {
+    return ((2 * Math.atan(Math.exp(y)) - Math.PI / 2) * 180) / Math.PI;
+}
+export function distance(point1, point2) {
+    const lat1 = degreesToRadians(point1[1]);
+    const lat2 = degreesToRadians(point2[1]);
+    const deltaLat = degreesToRadians(point2[1] - point1[1]);
+    const deltaLng = degreesToRadians(point2[0] - point1[0]);
+    const a = Math.sin(deltaLat / 2) * Math.sin(deltaLat / 2) +
+        Math.cos(lat1) * Math.cos(lat2) * Math.sin(deltaLng / 2) * Math.sin(deltaLng / 2);
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    return EARTH_RADIUS * c; // Distance in meters
+}
+export function degreesToRadians(degrees) {
+    return ((degrees % 360) * Math.PI) / 180;
+}
+export function radiansToDegrees(radians) {
+    return ((radians / Math.PI) % 2) * 180;
+}
+export function circle(center, radius, steps) {
+    const radians = radius / EARTH_RADIUS;
+    const lng1 = degreesToRadians(center[0]);
+    const lat1 = degreesToRadians(center[1]);
+    const result = [];
+    for (let i = 0; i < steps; i++) {
+        const bearingRad = degreesToRadians((i * 360) / steps);
+        const lat2 = Math.asin(Math.sin(lat1) * Math.cos(radians) + Math.cos(lat1) * Math.sin(radians) * Math.cos(bearingRad));
+        const lng2 = lng1 +
+            Math.atan2(Math.sin(bearingRad) * Math.sin(radians) * Math.cos(lat1), Math.cos(radians) - Math.sin(lat1) * Math.sin(lat2));
+        result.push([radiansToDegrees(lng2), radiansToDegrees(lat2)]);
+    }
+    return result;
+}
+export function flatten(features) {
+    return features.flatMap((feature) => {
+        if (feature.type !== 'Feature') {
+            throw new Error(`Expected Feature, got ${feature.type}`);
+        }
+        return flattenGeometry(feature.geometry, feature.properties);
+    });
+    function flattenGeometry(geometry, properties) {
+        switch (geometry.type) {
+            case 'Point':
+            case 'LineString':
+            case 'Polygon':
+                return [
+                    {
+                        type: 'Feature',
+                        properties,
+                        geometry
+                    }
+                ];
+            case 'GeometryCollection':
+                return geometry.geometries.flatMap((g) => flattenGeometry(g, properties));
+            case 'MultiPoint':
+                return geometry.coordinates.map((coordinates) => ({
+                    type: 'Feature',
+                    properties,
+                    geometry: { type: 'Point', coordinates }
+                }));
+            case 'MultiLineString':
+                return geometry.coordinates.map((coordinates) => ({
+                    type: 'Feature',
+                    properties,
+                    geometry: { type: 'LineString', coordinates }
+                }));
+            case 'MultiPolygon':
+                return geometry.coordinates.map((coordinates) => ({
+                    type: 'Feature',
+                    properties,
+                    geometry: { type: 'Polygon', coordinates }
+                }));
+            default:
+                // @ts-expect-error error on unknown geometry type
+                throw new Error(`Unknown geometry type "${geometry?.type}"`);
+        }
+    }
+}

package/dist/components/MapEditor/lib/utils/types.d.ts

@@ -0,0 +1,2 @@
+export type GeoPoint = [number, number];
+export type GeoPath = GeoPoint[];

package/dist/components/MapEditor/lib/utils/types.js

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

package/dist/components/MapEditor/style/button.scss

@@ -0,0 +1,115 @@
+button.btn,
+fieldset.btn {
+	font-size: 0.8rem;
+}
+
+button.btn,
+fieldset.btn > div > label {
+	background-color: var(--color-blue);
+	opacity: 0.7;
+	border-radius: var(--border-radius);
+	border: none;
+	color: var(--color-bg);
+	cursor: pointer;
+	display: inline-block;
+	font-weight: 600;
+	position: relative;
+	padding: 0;
+	transition: opacity 0.1s ease-in-out;
+	padding-block: 0.6em;
+	padding-inline: 1.2em;
+}
+
+button.btn {
+	&:focus {
+		outline: 1px solid var(--color-blue);
+		outline-offset: 2px;
+	}
+
+	&:not([disabled]):hover {
+		opacity: 1;
+	}
+
+	&:disabled {
+		opacity: 0.3;
+	}
+
+	&:after {
+		content: '✓';
+		background-color: var(--color-green);
+		border-radius: 1em;
+		color: var(--color-bg);
+		display: block;
+		font-size: 1em;
+		height: 1.6em;
+		line-height: 1.6em;
+		margin-left: 5px;
+		opacity: 0;
+		pointer-events: none;
+		position: absolute;
+		right: -0.6em;
+		text-align: center;
+		top: -0.6em;
+		transition: opacity 0.1s ease-in-out;
+		width: 1.6em;
+	}
+
+	&.success {
+		&:after {
+			opacity: 1;
+		}
+	}
+}
+
+fieldset.btn {
+	position: relative;
+	display: inline-block;
+	border: none;
+	padding: 0;
+
+	legend {
+		padding-inline: 0;
+		position: absolute;
+		display: block;
+		text-align: center;
+		top: -1.3em;
+		left: 0;
+		right: 0;
+	}
+
+	& > div {
+		border-radius: var(--border-radius);
+		overflow: hidden;
+		border: none;
+		display: inline-flex;
+		padding: 0;
+
+		& > label {
+			margin: 0;
+			border-radius: 0;
+			border: none;
+			border-left: 0.5px solid color-mix(in srgb, var(--color-bg) 20%, transparent);
+
+			&:first-of-type {
+				border-left: none;
+			}
+		}
+
+		input[type='radio'] {
+			display: none;
+		}
+
+		input:checked + label,
+		label:hover {
+			background-color: var(--color-blue);
+			color: var(--color-bg);
+		}
+	}
+}
+
+.label {
+	opacity: 0.5;
+	font-size: 0.7rem;
+	font-weight: normal;
+	margin: 0;
+}

package/dist/components/MapEditor/style/index.scss

@@ -0,0 +1,3 @@
+@import url('button.scss');
+@import url('layout.scss');
+@import url('other.scss');

package/dist/components/MapEditor/style/layout.scss

@@ -0,0 +1,20 @@
+.grid1,
+.grid2 {
+	display: grid;
+	gap: var(--btn-gap);
+	margin: var(--btn-gap) 0;
+	width: 100%;
+}
+
+.grid1 {
+	grid-template-columns: 1fr;
+}
+
+.grid2 {
+	grid-template-columns: repeat(2, 1fr);
+}
+
+.grid1 > button,
+.grid2 > button {
+	width: 100%;
+}

package/dist/components/MapEditor/style/other.scss

@@ -0,0 +1,10 @@
+hr {
+	border: none;
+	border-top: 1px solid var(--color-text);
+	opacity: 0.1;
+	margin-block: var(--gap);
+
+	&.thick {
+		opacity: 0.2;
+	}
+}

package/dist/index.d.ts

@@ -3,3 +3,4 @@ import BBoxMap from './components/BBoxMap/BBoxMap.svelte';
 import LocatorMap from './components/LocatorMap/LocatorMap.svelte';
 import MapEditor from './components/MapEditor/MapEditor.svelte';
 export { BasicMap, BBoxMap, LocatorMap, MapEditor };
+export { type BBox } from './components/BBoxMap/lib/bbox.js';

package/dist/index.js

@@ -3,3 +3,4 @@ import BBoxMap from './components/BBoxMap/BBoxMap.svelte';
 import LocatorMap from './components/LocatorMap/LocatorMap.svelte';
 import MapEditor from './components/MapEditor/MapEditor.svelte';
 export { BasicMap, BBoxMap, LocatorMap, MapEditor };
+export {} from './components/BBoxMap/lib/bbox.js';

package/dist/utils/location.d.ts

@@ -2,3 +2,4 @@ import type { Language } from '@versatiles/style';
 export declare function getCountryName(): string | null;
 export declare function getCountryCode(): string | null;
 export declare function getLanguage(): Language;
+export declare function getCountryBoundingBox(): [number, number, number, number] | null;

package/dist/utils/location.js

@@ -38,3 +38,184 @@ export function getLanguage() {
         return null; // Fallback if no country can be determined
     }
 }
+const countryBoundingBoxes = {
+    AF: [60.5, 29.3, 75.2, 38.5],
+    AO: [11.6, -18, 24.1, -4.4],
+    AL: [19.3, 39.6, 21.1, 42.7],
+    AE: [51.5, 22.4, 56.4, 26.1],
+    AR: [-73.5, -55.3, -53.6, -21.8],
+    AM: [43.5, 38.7, 46.6, 41.3],
+    AQ: [-180, -90, 180, -63.2],
+    TF: [68.7, -49.8, 70.6, -48.6],
+    AU: [113.3, -43.7, 153.6, -10.6],
+    AT: [9.4, 46.4, 17, 49.1],
+    AZ: [44.7, 38.2, 50.4, 41.9],
+    BI: [29, -4.5, 30.8, -2.3],
+    BE: [2.5, 49.5, 6.2, 51.5],
+    BJ: [0.7, 6.1, 3.8, 12.3],
+    BF: [-5.5, 9.6, 2.2, 15.2],
+    BD: [88, 20.6, 92.7, 26.5],
+    BG: [22.3, 41.2, 28.6, 44.3],
+    BS: [-79, 23.7, -77, 27.1],
+    BA: [15.7, 42.6, 19.6, 45.3],
+    BY: [23.1, 51.3, 32.7, 56.2],
+    BZ: [-89.3, 15.8, -88.1, 18.5],
+    BO: [-69.6, -22.9, -57.4, -9.7],
+    BR: [-74, -33.8, -34.7, 5.3],
+    BN: [114.2, 4, 115.5, 5.5],
+    BT: [88.8, 26.7, 92.2, 28.3],
+    BW: [19.8, -26.9, 29.5, -17.6],
+    CF: [14.4, 2.2, 27.4, 11.2],
+    CA: [-141, 41.6, -52.6, 83.3],
+    CH: [6, 45.7, 10.5, 47.9],
+    CL: [-75.7, -55.7, -66.9, -17.5],
+    CN: [73.6, 18.1, 135.1, 53.5],
+    CI: [-8.7, 4.3, -2.5, 10.6],
+    CM: [8.4, 1.7, 16.1, 12.9],
+    CD: [12.1, -13.3, 31.2, 5.3],
+    CG: [11, -5.1, 18.5, 3.8],
+    CO: [-79, -4.3, -66.8, 12.5],
+    CR: [-86, 8.2, -82.5, 11.3],
+    CU: [-85, 19.8, -74.1, 23.2],
+    CY: [32.2, 34.5, 34.1, 35.2],
+    CZ: [12.2, 48.5, 18.9, 51.2],
+    DE: [5.9, 47.3, 15.1, 55],
+    DJ: [41.6, 10.9, 43.4, 12.7],
+    DK: [8, 54.8, 12.7, 57.8],
+    DO: [-72, 17.5, -68.3, 19.9],
+    DZ: [-8.7, 19, 12, 37.2],
+    EC: [-81, -5, -75.2, 1.4],
+    EG: [24.7, 22, 36.9, 31.6],
+    ER: [36.3, 12.4, 43.1, 18],
+    ES: [-9.4, 35.9, 3.1, 43.8],
+    EE: [23.3, 57.4, 28.2, 59.7],
+    ET: [32.9, 3.4, 47.8, 15],
+    FI: [20.6, 59.8, 31.6, 70.2],
+    FJ: [-180, -18.3, 180, -16],
+    FK: [-61.2, -52.3, -57.7, -51.1],
+    FR: [-54.6, 2, 9.6, 51.2],
+    GA: [8.7, -4, 14.5, 2.4],
+    GB: [-7.6, 49.9, 1.7, 58.7],
+    GE: [39.9, 41, 46.7, 43.6],
+    GH: [-3.3, 4.7, 1.1, 11.1],
+    GN: [-15.2, 7.3, -7.8, 12.6],
+    GM: [-16.9, 13.1, -13.8, 13.9],
+    GW: [-16.7, 11, -13.7, 12.7],
+    GQ: [9.3, 1, 11.3, 2.3],
+    GR: [20.1, 34.9, 26.7, 41.9],
+    GL: [-73.3, 60, -12.2, 83.7],
+    GT: [-92.3, 13.7, -88.2, 17.9],
+    GY: [-61.5, 1.2, -56.5, 8.4],
+    HN: [-89.4, 12.9, -83.1, 16.1],
+    HR: [13.6, 42.4, 19.4, 46.6],
+    HT: [-74.5, 18, -71.6, 20],
+    HU: [16.2, 45.7, 22.8, 48.7],
+    ID: [95.2, -10.4, 141.1, 5.5],
+    IN: [68.1, 7.9, 97.5, 35.5],
+    IE: [-10, 51.6, -6, 55.2],
+    IR: [44.1, 25, 63.4, 39.8],
+    IQ: [38.7, 29, 48.6, 37.4],
+    IS: [-24.4, 63.4, -13.6, 66.6],
+    IL: [34.2, 29.5, 35.9, 33.3],
+    IT: [6.7, 36.6, 18.5, 47.2],
+    JM: [-78.4, 17.7, -76.1, 18.6],
+    JO: [34.9, 29.1, 39.2, 33.4],
+    JP: [129.4, 31, 145.6, 45.6],
+    KZ: [46.4, 40.6, 87.4, 55.4],
+    KE: [33.8, -4.7, 41.9, 5.6],
+    KG: [69.4, 39.2, 80.3, 43.3],
+    KH: [102.3, 10.4, 107.7, 14.6],
+    KR: [126.1, 34.3, 129.5, 38.7],
+    KW: [46.5, 28.5, 48.5, 30.1],
+    LA: [100.1, 13.8, 107.6, 22.5],
+    LB: [35.1, 33, 36.7, 34.7],
+    LR: [-11.5, 4.3, -7.5, 8.6],
+    LY: [9.3, 19.5, 25.2, 33.2],
+    LK: [79.6, 5.9, 81.8, 9.9],
+    LS: [26.9, -30.7, 29.4, -28.6],
+    LT: [21, 53.9, 26.6, 56.4],
+    LU: [5.6, 49.4, 6.3, 50.2],
+    LV: [21, 55.6, 28.2, 58],
+    MA: [-17.1, 21.4, -1.1, 35.8],
+    MD: [26.6, 45.4, 30.1, 48.5],
+    MG: [43.2, -25.7, 50.5, -12],
+    MX: [-117.2, 14.5, -86.8, 32.8],
+    MK: [20.4, 40.8, 23, 42.4],
+    ML: [-12.2, 10, 4.3, 25],
+    MM: [92.3, 9.9, 101.2, 28.4],
+    ME: [18.4, 41.8, 20.4, 43.6],
+    MN: [87.7, 41.5, 119.8, 52.1],
+    MZ: [30.1, -26.8, 40.8, -10.3],
+    MR: [-17.1, 14.6, -4.9, 27.4],
+    MW: [32.6, -16.9, 35.8, -9.2],
+    MY: [100, 0.7, 119.2, 7],
+    NA: [11.7, -29.1, 25.1, -16.9],
+    NC: [164, -22.4, 167.2, -20.1],
+    NE: [0.2, 11.6, 16, 23.5],
+    NG: [2.6, 4.2, 14.6, 13.9],
+    NI: [-87.7, 10.7, -83.1, 15.1],
+    NL: [3.3, 50.8, 7.1, 53.6],
+    NO: [4.9, 58, 31.3, 80.7],
+    NP: [80, 26.3, 88.2, 30.5],
+    NZ: [166.5, -46.7, 178.6, -34.4],
+    OM: [52, 16.6, 59.9, 26.4],
+    PK: [60.8, 23.6, 77.9, 37.2],
+    PA: [-83, 7.2, -77.2, 9.7],
+    PE: [-81.5, -18.4, -68.6, 0],
+    PH: [117.1, 5.5, 126.6, 18.6],
+    PG: [141, -10.7, 156.1, -2.5],
+    PL: [14, 49, 24.1, 54.9],
+    PR: [-67.3, 17.9, -65.5, 18.6],
+    KP: [124.2, 37.6, 130.8, 43],
+    PT: [-9.6, 36.8, -6.3, 42.3],
+    PY: [-62.7, -27.6, -54.2, -19.3],
+    QA: [50.7, 24.5, 51.7, 26.2],
+    RO: [20.2, 43.6, 29.7, 48.3],
+    RU: [-180, 41.1, 180, 81.3],
+    RW: [29, -3, 30.9, -1.1],
+    SA: [34.6, 16.3, 55.7, 32.2],
+    SD: [21.9, 8.6, 38.5, 22],
+    SS: [23.8, 3.5, 35.3, 12.3],
+    SN: [-17.7, 12.3, -11.4, 16.6],
+    SB: [156.4, -10.9, 162.4, -6.5],
+    SL: [-13.3, 6.7, -10.2, 10.1],
+    SV: [-90.1, 13.1, -87.7, 14.5],
+    SO: [40.9, -1.7, 51.2, 12.1],
+    RS: [18.8, 42.2, 23, 46.2],
+    SR: [-58.1, 1.8, -53.9, 6.1],
+    SK: [16.8, 47.7, 22.6, 49.6],
+    SI: [13.6, 45.4, 16.6, 46.9],
+    SE: [11, 55.3, 24, 69.2],
+    SZ: [30.6, -27.3, 32.1, -25.6],
+    SY: [35.7, 32.3, 42.4, 37.3],
+    TD: [13.5, 7.4, 23.9, 23.5],
+    TG: [-0.1, 5.9, 1.9, 11.1],
+    TH: [97.3, 5.6, 105.6, 20.5],
+    TJ: [67.4, 36.7, 75, 41],
+    TM: [52.5, 35.2, 66.6, 42.8],
+    TL: [124.9, -9.4, 127.4, -8.2],
+    TT: [-62, 10, -60.8, 10.9],
+    TN: [7.5, 30.3, 11.5, 37.4],
+    TR: [26, 35.8, 44.8, 42.2],
+    TW: [120.1, 21.9, 122, 25.3],
+    TZ: [29.3, -11.8, 40.4, -0.9],
+    UG: [29.5, -1.5, 35.1, 4.3],
+    UA: [22, 44.3, 40.1, 52.4],
+    UY: [-58.5, -35, -53.2, -30.1],
+    US: [-171.8, 18.9, -66.9, 71.4],
+    UZ: [55.9, 37.1, 73.1, 45.6],
+    VE: [-73.4, 0.7, -59.7, 12.2],
+    VN: [102.1, 8.5, 109.4, 23.4],
+    VU: [166.6, -16.6, 167.9, -14.6],
+    PS: [34.9, 31.3, 35.6, 32.6],
+    YE: [42.6, 12.5, 53.2, 19.1],
+    ZA: [16.3, -34.9, 32.9, -22],
+    ZM: [21.8, -18, 33.5, -8.2],
+    ZW: [25.2, -22.3, 32.9, -15.5]
+};
+export function getCountryBoundingBox() {
+    const countryCode = getCountryCode();
+    if (!countryCode)
+        return null;
+    return countryBoundingBoxes[countryCode] ?? null;
+}

package/dist/utils/map_style.d.ts

@@ -1,6 +1,6 @@
 import { type StyleBuilderOptions } from '@versatiles/style';
-export declare function getMapStyle(darkMode: boolean, styleOptions?: StyleBuilderOptions & {
+export declare function getMapStyle(styleOptions?: StyleBuilderOptions & {
+    darkMode?: boolean;
     transitionDuration?: number;
-    disableDarkMode?: boolean;
 }): import("maplibre-gl").StyleSpecification;
 export declare function isDarkMode(element?: HTMLElement): boolean;

package/dist/utils/map_style.js

@@ -1,7 +1,7 @@
 import { styles } from '@versatiles/style';
 import { getLanguage } from './location.js';
-export function getMapStyle(darkMode, styleOptions = {}) {
-    darkMode = darkMode && !styleOptions.disableDarkMode;
+export function getMapStyle(styleOptions = {}) {
+    const darkMode = styleOptions.darkMode ?? isDarkMode();
     const style = styles.colorful({
         baseUrl: 'https://tiles.versatiles.org',
         language: getLanguage(),