https://favorite.app/_next/static/media/maplibre-gl-dev.2790ibatt4woy.mjs

7";
8//#endregion
9//#region src/util/browser.ts
10let linkEl;
11let reducedMotionQuery;
12let reducedMotionOverride;
13/** */
14const browser = {
15	/**
16	* Schedules a callback to be invoked on the next animation frame.
17	* @param abortController - Controller to abort the scheduled frame.
18	* @param fn - Callback to invoke with the paint start timestamp.
19	* @param reject - Callback to invoke if the frame is aborted.
20	* @param targetWindow - Optional window to use for requestAnimationFrame.
21	*   When the map is rendered in a popup window or iframe, pass the owning
22	*   window to ensure animation frames continue even when the main window
23	*   is not focused.
24	*/
25	frame(abortController, fn, reject, targetWindow) {
26		const win = targetWindow || window;
27		const frameId = win.requestAnimationFrame((paintStartTimestamp) => {
28			unsubscribe();
29			fn(paintStartTimestamp);
30		});
31		const { unsubscribe } = subscribe(abortController.signal, "abort", () => {
32			unsubscribe();
33			win.cancelAnimationFrame(frameId);
34			reject(new AbortError(abortController.signal.reason));
35		}, false);
36	},
37	/**
38	* Returns a promise that resolves on the next animation frame.
39	* @param abortController - Controller to abort the scheduled frame.
40	* @param targetWindow - Optional window to use for requestAnimationFrame.
41	* @see {@link browser.frame}
42	*/
43	frameAsync(abortController, targetWindow) {
44		return new Promise((resolve, reject) => {
45			this.frame(abortController, resolve, reject, targetWindow);
46		});
47	},
48	getImageData(img, padding = 0) {
49		return this.getImageCanvasContext(img).getImageData(-padding, -padding, img.width + 2 * padding, img.height + 2 * padding);
50	},
51	/**
52	* Draws an image into a 2D canvas whose pixels can be read back cheaply. An `OffscreenCanvas`
53	* is used where the browser has one that reads back faithfully: drawing a GPU-backed
54	* `ImageBitmap` into a document canvas opened with `willReadFrequently` stalls the main thread
55	* for tens of milliseconds on GPU-accelerated browsers, an `OffscreenCanvas` does not.
56	*/
57	getImageCanvasContext(img) {
58		let context;
59		if (offscreenCanvasSupported() && !isOffscreenCanvasDistorted()) context = new OffscreenCanvas(img.width, img.height).getContext("2d", { willReadFrequently: true });
60		else {
61			const canvas = window.document.createElement("canvas");
62			canvas.width = img.width;
63			canvas.height = img.height;
64			context = canvas.getContext("2d", { willReadFrequently: true });
65		}
66		if (!context) throw new Error("failed to create canvas 2d context");
67		context.drawImage(img, 0, 0, img.width, img.height);
68		return context;
69	},
70	resolveURL(path) {
71		linkEl ||= document.createElement("a");
72		linkEl.href = path;
73		return linkEl.href;
74	},
75	get hardwareConcurrency() {
76		return typeof navigator !== "undefined" && navigator.hardwareConcurrency || 4;
77	},
78	get prefersReducedMotion() {
79		if (reducedMotionOverride !== void 0) return reducedMotionOverride;
80		if (!matchMedia) return false;
81		reducedMotionQuery ??= matchMedia("(prefers-reduced-motion: reduce)");
82		return reducedMotionQuery.matches;
83	},
84	set prefersReducedMotion(value) {
85		reducedMotionOverride = value;
86	}
87};
88//#endregion
89//#region src/util/time_control.ts
90/**
91* Manages time flow with optional freezing capability for deterministic rendering.
92*/
93var TimeManager = class {
94	constructor() {
95		this._frozenAt = null;
96	}
97	/**
98	* Gets the current time, either real or frozen.
99	* @returns Current time in milliseconds
100	*/
101	getCurrentTime() {
102		return this._frozenAt !== null ? this._frozenAt : performance.now();
103	}
104	/**
105	* Sets time at a specific timestamp.
106	* @param timestamp - Time in milliseconds to set
107	*/
108	setNow(timestamp) {
109		this._frozenAt = timestamp;
110	}
111	/**
112	* Restores normal time flow.
113	*/
114	restoreNow() {
115		this._frozenAt = null;
116	}
117	/**
118	* Returns whether time is currently frozen.
119	* @returns True if time is frozen, false otherwise
120	*/
121	isFrozen() {
122		return this._frozenAt !== null;
123	}
124};
125const timeManager = new TimeManager();
126/**
127* Returns the current time in milliseconds.
128* When time is frozen via setNow(), returns the frozen timestamp.
129* Otherwise returns real browser time via performance.now().
130*
131* @returns Current time in milliseconds
132* @example
133* ```ts
134* // Measure elapsed time
135* const start = maplibregl.now();
136* // ... later ...
137* const elapsed = maplibregl.now() - start;
138*
139* // During frozen time
140* maplibregl.setNow(16.67);
141* console.log(maplibregl.now()); // 16.67
142* maplibregl.restoreNow();
143* console.log(maplibregl.now()); // real time
144* ```
145*/
146function now() {
147	return timeManager.getCurrentTime();
148}
149/**
150* Freezes time at a specific timestamp for deterministic rendering.
151* Useful for frame-by-frame video capture where each frame needs
152* a consistent time value.
153*
154* @param timestamp - Time in milliseconds to freeze at
155* @example
156* ```ts
157* // Freeze time for video export at 60fps
158* setNow(0);           // First frame
159* // ... render frame ...
160* setNow(16.67);       // Second frame
161* // ... render frame ...
162* setNow(33.34);       // Third frame
163* // ... done ...
164* restoreNow();        // Resume normal time
165* ```
166*/
167function setNow(timestamp) {
168	timeManager.setNow(timestamp);
169}
170/**
171* Restores normal time flow after freezing with setNow().
172* Call this after finishing deterministic rendering operations.
173*
174* @example
175* ```ts
176* // After video export, resume normal time
177* setNow(0);
178* // ... export frames ...
179* restoreNow(); // Map animations resume normally
180* ```
181*/
182function restoreNow() {
183	timeManager.restoreNow();
184}
185/**
186* Returns whether time is currently frozen.
187* @returns True if time is frozen via setNow(), false otherwise
188* @example
189* ```ts
190* setNow(1000);
191* console.log(isTimeFrozen()); // true
192* restoreNow();
193* console.log(isTimeFrozen()); // false
194* ```
195*/
196function isTimeFrozen() {
197	return timeManager.isFrozen();
198}
199//#endregion
200//#region src/util/dom.ts

308;
309		}
310	}
311};
312//#endregion
313//#region src/util/image_request.ts
314let ImageRequest;
315(function(_ImageRequest) {
316	let imageRequestQueue;
317	let currentParallelImageRequests;
318	let throttleControlCallbackHandleCounter;
319	let throttleControlCallbacks;
320	_ImageRequest.resetRequestQueue = () => {
321		imageRequestQueue = [];
322		currentParallelImageRequests = 0;
323		throttleControlCallbackHandleCounter = 0;
324		throttleControlCallbacks = {};
325	};
326	_ImageRequest.addThrottleControl = (callback) => {
327		const handle = throttleControlCallbackHandleCounter++;
328		throttleControlCallbacks[handle] = callback;
329		return handle;
330	};
331	_ImageRequest.removeThrottleControl = (callbackHandle) => {
332		delete throttleControlCallbacks[callbackHandle];
333		processQueue();
334	};
335	/**
336	* Check to see if any of the installed callbacks are requesting the queue
337	* to be throttled.
338	* @returns `true` if any callback is causing the queue to be throttled.
339	*/
340	const isThrottled = () => {
341		for (const key of Object.keys(throttleControlCallbacks)) if (throttleControlCallbacks[key]()) return true;
342		return false;
343	};
344	async function transformAndGetImage(requestManager, url, resourceType, abortController, supportImageRefresh = true, imageBitmapOptions) {
345		const requestParameters = await requestManager.transformRequest(url, resourceType);
346		throwIfAborted(abortController.signal);
347		return ImageRequest.getImage(requestParameters, abortController, supportImageRefresh, imageBitmapOptions);
348	}
349	_ImageRequest.transformAndGetImage = transformAndGetImage;
350	_ImageRequest.getImage = (requestParameters, abortController, supportImageRefresh = true, imageBitmapOptions) => {
351		return new Promise((resolve, reject) => {
352			requestParameters.headers ||= {};
353			requestParameters.headers.accept = "image/webp,*/*";
354			extend(requestParameters, { type: "image" });
355			const request = {
356				abortController,
357				requestParameters,
358				supportImageRefresh,
359				imageBitmapOptions,
360				state: "queued",
361				onError: (error) => {
362					reject(error);
363				},
364				onSuccess: (response) => {
365					resolve(response);
366				}
367			};
368			imageRequestQueue.push(request);
369			processQueue();
370		});
371	};
372	const arrayBufferToCanvasImageSource = (data, imageBitmapOptions) => {
373		if (typeof createImageBitmap === "function") return arrayBufferToImageBitmap(data, imageBitmapOptions);
374		else return arrayBufferToImage(data);
375	};
376	/**
377	* Runs one queued image request.
378	*
379	* An empty response body (e.g. HTTP 204 for a tile without content) resolves with
380	* `data: null`, keeping the expiry headers, so callers can handle the absence
381	* explicitly and re-request when the headers say so.
382	*/
383	const doImageRequest = async (itemInQueue) => {
384		itemInQueue.state = "running";
385		const { requestParameters, supportImageRefresh, imageBitmapOptions, onError, onSuccess, abortController } = itemInQueue;
386		const canUseHTMLImageElement = supportImageRefresh === false && !imageBitmapOptions && !isWorker(self) && !getProtocol(requestParameters.url) && (!requestParameters.headers || Object.keys(requestParameters.headers).reduce((acc, item) => acc && item === "accept", true));
387		currentParallelImageRequests++;
388		const getImagePromise = canUseHTMLImageElement ? getImageUsingHtmlImage(requestParameters, abortController) : makeRequest(requestParameters, abortController);
389		try {
390			const response = await getImagePromise;
391			delete itemInQueue.abortController;
392			itemInQueue.state = "completed";
393			if (response.data instanceof HTMLImageElement || isImageBitmap(response.data)) onSuccess(response);
394			else if (!response.data || response.data.byteLength === 0) onSuccess({
395				data: null,
396				cacheControl: response.cacheControl,
397				expires: response.expires
398			});
399			else onSuccess({
400				data: await arrayBufferToCanvasImageSource(response.data, imageBitmapOptions),
401				cacheControl: response.cacheControl,
402				expires: response.expires
403			});
404		} catch (err) {
405			delete itemInQueue.abortController;
406			onError(ensureError(err));
407		} finally {
408			currentParallelImageRequests--;
409			processQueue();
410		}
411	};
412	/**
413	* Process some number of items in the image request queue.
414	*/
415	const processQueue = () => {
416		const maxImageRequests = isThrottled() ? config.MAX_PARALLEL_IMAGE_REQUESTS_PER_FRAME : config.MAX_PARALLEL_IMAGE_REQUESTS;
417		for (let numImageRequests = currentParallelImageRequests; numImageRequests < maxImageRequests && imageRequestQueue.length > 0; numImageRequests++) {
418			const topItemInQueue = imageRequestQueue.shift();
419			if (topItemInQueue.abortController.signal.aborted) {
420				numImageRequests--;
421				continue;
422			}
423			doImageRequest(topItemInQueue);
424		}
425	};
426	const getImageUsingHtmlImage = (requestParameters, abortController) => {
427		return new Promise((resolve, reject) => {
428			const image = new Image();
429			const url = requestParameters.url;
430			const credentials = requestParameters.credentials;
431			if (credentials && credentials === "include") image.crossOrigin = "use-credentials";
432			else if (credentials && credentials === "same-origin" || !sameOrigin(url)) image.crossOrigin = "anonymous";
433			abortController.signal.addEventListener("abort", () => {
434				image.src = "";
435				reject(new AbortError(abortController.signal.reason));
436			});
437			image.fetchPriority = "high";
438			image.onload = () => {
439				image.onerror = image.onload = null;
440				resolve({ data: image });
441			};
442			image.onerror = () => {
443				image.onerror = image.onload = null;
444				if (abortController.signal.aborted) return;
445				reject(/* @__PURE__ */ new Error("Could not load image. Please make sure to use a supported image type such as PNG or JPEG. Note that SVGs are not supported."));
446			};
447			image.src = url;
448		});
449	};
450})(ImageRequest || (ImageRequest = {}));
451ImageRequest.resetRequestQueue();
452var RequestManager = class {
453	constructor(transformRequestFn) {
454		this._transformRequestFn = transformRequestFn ?? null;
455	}
456	transformRequest(url, type) {
457		if (this._transformRequestFn) return this._transformRequestFn(url, type) || { url };
458		return { url };
459	}
460	setTransformRequest(transformRequest) {
461		this._transformRequestFn = transformRequest;
462	}
463};
464//#endregion
465//#region src/ui/events.ts
466/**
467* The base event for MapLibre
468*
469* @group Event Related
470*/
471var MapLibreEvent = class extends Event {};
472/**
473* `MapMovementEvent` is the event type for the camera-transition map events:
474* `movestart`, `move`, `moveend`, `zoomstart`, `zoom`, `zoomend`, `rotatestart`, `rotate`, `rotateend`,
475* `dragstart`, `drag`, `dragend`, `pitchstart`, `pitch`, `pitchend`, `rollstart`, `roll` and `rollend`.
476* These are fired as the map's view changes, as a result of either user interaction or methods such
477* as {@link Map.jumpTo} / {@link Map.flyTo}.
478*
479* @group Event Related
480*/
481var MapMovementEvent = class extends MapLibreEvent {};
482/**
483* The `style.load` event, fired once the map's style has fully loaded or changed.
484*
485* @group Event Related
486*/
487var MapStyleLoadEvent = class extends MapLibreEvent {
488	constructor(data = {}) {
489		super("style.load", data);
490	}
491};
492/**
493* The style data event
494*
495* @group Event Related
496*/
497var MapStyleDataEvent = class extends MapLibreEvent {
498	constructor(type, data = {}) {
499		super(type, data);
500		this.dataType = "style";
501	}
502};
503/**
504* A `MapSourceDataEvent` is emitted with the source-related `data`, `dataloading`, `dataabort`,
505* `sourcedata`, `sourcedataloading` and `sourcedataabort` events. Its `dataType` is always `'source'`.
506*
507* Possible values for `sourceDataType`s are:
508*
509* - `'metadata'`: indicates that any necessary source metadata has been loaded (such as TileJSON) and it is ok to start loading tiles
510* - `'content'`: indicates the source data has changed (such as when source.setData() has been called on GeoJSONSource)
511* - `'visibility'`: send when the source becomes used when at least one of its layers becomes visible in style sense (inside the layer's zoom range and with layout.visibility set to 'visible')
512* - `'idle'`: indicates that no new source data has been fetched (but the source has done loading)
513*
514* @group Event Related
515*
516* @example
517* ```ts
518* // The sourcedata event is an example of a MapSourceDataEvent.
519* // Set up an event listener on the map.
520* map.on('sourcedata', (e) => {
521*    if (e.isSourceLoaded) {
522*        // Do something when the source has finished loading
523*    }
524* });
525* ```
526*/
527var MapSourceDataEvent = class extends MapLibreEvent {
528	constructor(type, data = {}) {
529		super(type, data);
530		this.dataType = "source";
531	}
532};
533/**
534* `MapMouseEvent` is the event type for mouse-related map events.
535*
536* @group Event Related
537*
538* @example
539* ```ts
540* // The `click` event is an example of a `MapMouseEvent`.
541* // Set up an event listener on the map.
542* map.on('click', (e) => {
543*   // The event object (e) contains information like the
544*   // coordinates of the point on the map that was clicked.
545*   console.log('A click event has occurred at ' + e.lngLat);
546* });
547* ```
548*/
549var MapMouseEvent = class extends MapLibreEvent {
550	/**
551	* Prevents subsequent default processing of the event by the map.
552	*
553	* Calling this method will prevent the following default map behaviors:
554	*
555	*   * On `mousedown` events, the behavior of {@link DragPanHandler}
556	*   * On `mousedown` events, the behavior of {@link DragRotateHandler}
557	*   * On `mousedown` events, the behavior of {@link BoxZoomHandler}
558	*   * On `dblclick` events, the behavior of {@link DoubleClickZoomHandler}
559	*
560	*/
561	preventDefault() {
562		this._defaultPrevented = true;
563	}
564	/**
565	* `true` if `preventDefault` has been called.
566	*/
567	get defaultPrevented() {
568		return this._defaultPrevented;
569	}
570	constructor(type, map, originalEvent, data = {}) {
571		originalEvent = originalEvent instanceof MouseEvent ? originalEvent : new MouseEvent(type, originalEvent);
572		const point = DOM.mousePos(map.getCanvas(), originalEvent);
573		const lngLat = map.unproject(point);
574		super(type, extend({
575			point,
576			lngLat,
577			originalEvent
578		}, data));
579		this._defaultPrevented = false;
580		this.target = map;
581	}
582};
583/**
584* `MapTouchEvent` is the event type for touch-related map events.
585*
586* @group Event Related
587*/
588var MapTouchEvent = class extends MapLibreEvent {
589	/**
590	* Prevents subsequent default processing of the event by the map.
591	*
592	* Calling this method will prevent the following default map behaviors:
593	*
594	*   * On `touchstart` events, the behavior of {@link DragPanHandler}
595	*   * On `touchstart` events, the behavior of {@link TwoFingersTouchZoomRotateHandler}
596	*
597	*/
598	preventDefault() {
599		this._defaultPrevented = true;
600	}
601	/**
602	* `true` if `preventDefault` has been called.
603	*/
604	get defaultPrevented() {
605		return this._defaultPrevented;
606	}
607	constructor(type, map, originalEvent) {
608		const touches = type === "touchend" ? originalEvent.changedTouches : originalEvent.touches;
609		const points = DOM.touchPos(map.getCanvasContainer(), touches);
610		const lngLats = points.map((t) => map.unproject(t));
611		const point = points.reduce((prev, curr, i, arr) => {
612			return prev.add(curr.div(arr.length));
613		}, new Point(0, 0));
614		const lngLat = map.unproject(point);
615		super(type, {
616			points,
617			point,
618			lngLats,
619			lngLat,
620			originalEvent
621		});
622		this._defaultPrevented = false;
623	}
624};
625/**
626* `MapWheelEvent` is the event type for the `wheel` map event.
627*
628* @group Event Related
629*/
630var MapWheelEvent = class extends MapLibreEvent {
631	/**
632	* Prevents subsequent default processing of the event by the map.
633	*
634	* Calling this method will prevent the behavior of {@link ScrollZoomHandler}.
635	*/
636	preventDefault() {
637		this._defaultPrevented = true;
638	}
639	/**
640	* `true` if `preventDefault` has been called.
641	*/
642	get defaultPrevented() {
643		return this._defaultPrevented;
644	}
645	/** */
646	constructor(map, originalEvent) {
647		super("wheel", { originalEvent });
648		this._defaultPrevented = false;
649	}
650};
651/**
652* A `MapBoxZoomEvent` is the event type for the boxzoom-related map events emitted by the {@link BoxZoomHandler}.
653*
654* @group Event Related
655*/
656var MapBoxZoomEvent = class extends MapLibreEvent {};
657/**
658* The terrain event
659*
660* @group Event Related
661*/
662var MapTerrainEvent = class extends MapLibreEvent {
663	constructor(data = {}) {
664		super("terrain", data);
665	}
666};
667/**
668* The map projection event
669*
670* @group Event Related
671*/
672var MapProjectionEvent = class extends MapLibreEvent {
673	constructor(data = {}) {
674		super("projectiontransition", data);
675	}
676};
677/**
678* An event related to the web gl context
679*
680* @group Event Related
681*/
682var MapContextEvent = class extends MapLibreEvent {};
683/**
684* The style image missing event, fired when an image is still missing after the missing style image
685* resolver has been given a chance to supply it. To load or generate images on demand,
686* use {@link Map.setMissingStyleImageResolver}.
687* Event listeners cannot resolve the missing image for the current request.
688*
689* @group Event Related
690*
691* @see [Generate and add a missing icon to the map](https://maplibre.org/maplibre-gl-js/docs/examples/generate-and-add-a-missing-icon-to-the-map/)
692*/
693var MapStyleImageMissingEvent = class extends MapLibreEvent {
694	constructor(data = {}) {
695		super("styleimagemissing", data);
696	}
697};
698//#endregion
699//#region src/util/style.ts
700/**
701* Takes a SpriteSpecification value and returns it in its array form. If `undefined` is passed as an input value, an
702* empty array is returned.
703* duplicated entries with identical id/url will be removed in returned array
704* @param sprite - optional sprite to coerce
705* @returns an empty array in case `undefined` is passed; id-url pairs otherwise
706*/
707function coerceSpriteToArray(sprite) {
708	const resultArray = [];
709	if (typeof sprite === "string") resultArray.push({
710		id: "default",
711		url: sprite
712	});
713	else if (sprite && sprite.length > 0) {
714		const dedupArray = [];
715		for (const { id, url } of sprite) {
716			const key = `${id}${url}`;
717			if (!dedupArray.includes(key)) {
718				dedupArray.push(key);
719				resultArray.push({
720					id,
721					url
722				});
723			}
724		}
725	}
726	return resultArray;
727}
728//#endregion
729//#region src/style/load_sprite.ts
730function normalizeSpriteURL(url, format, extension) {
731	try {
732		const parsed = new URL(url);
733		parsed.pathname += `${format}${extension}`;
734		return parsed.toString();
735	} catch {
736		throw new Error(`Invalid sprite URL "${url}", must be absolute. Modify style specification directly or use TransformStyleFunction to correct the issue dynamically`);
737	}
738}
739async function loadSprite(originalSprite, requestManager, pixelRatio, abortController) {
740	const spriteArray = coerceSpriteToArray(originalSprite);
741	const format = pixelRatio > 1 ? "@2x" : "";
742	const jsonsMap = {};
743	const imagesMap = {};
744	for (const { id, url } of spriteArray) {
745		const jsonRequestParameters = await requestManager.transformRequest(normalizeSpriteURL(url, format, ".json"), "SpriteJSON");
746		jsonsMap[id] = getJSON(jsonRequestParameters, abortController);
747		const imageRequestParameters = await requestManager.transformRequest(normalizeSpriteURL(url, format, ".png"), "SpriteImage");
748		imagesMap[id] = ImageRequest.getImage(imageRequestParameters, abortController);
749	}
750	await Promise.all([...Object.values(jsonsMap), ...Object.values(imagesMap)]);
751	return doOnceCompleted(jsonsMap, imagesMap);
752}
753/**
754* @param jsonsMap - JSON data map
755* @param imagesMap - image data map
756*/
757async function doOnceCompleted(jsonsMap, imagesMap) {
758	const result = {};
759	for (const spriteName in jsonsMap) {
760		result[spriteName] = {};
761		const image = (await imagesMap[spriteName]).data;
762		if (!image) throw new Error(`Could not load sprite image for ${spriteName}: the response is empty`);
763		const context = browser.getImageCanvasContext(image);
764		const json = (await jsonsMap[spriteName]).data;
765		for (const id in json) {
766			const { width, height, x, y, sdf, pixelRatio, stretchX, stretchY, content, textFitWidth, textFitHeight } = json[id];
767			const spriteData = {
768				width,
769				height,
770				x,
771				y,
772				context
773			};
774			result[spriteName][id] = {
775				data: null,
776				pixelRatio,
777				sdf,
778				stretchX,
779				stretchY,
780				content,
781				textFitWidth,
782				textFitHeight,
783				spriteData
784			};
785		}
786	}
787	return result;
788}
789//#endregion
790//#region src/render/image_manager.ts
791/**
792* Owns every image of the style - the ones the sprites bring in as well as the ones added at
793* runtime - and tracks requests for them from the tile workers, sending responses when the
794* requests are fulfilled.
795*/
796var ImageManager = class extends Evented {
797	constructor() {
798		super();
799		this.images = {};
800		this.updateVersion = 0;
801		this.loaded = false;
802		this.requestors = [];
803		this.missingImageResolver = null;
804		this._spriteImagesIds = {};
805		this._imagesIds = null;
806		this._renderCallbacksDispatchedThisFrame = {};
807	}
808	destroy() {
809		for (const id of Object.keys(this.images)) this.removeImage(id);
810		this._spriteImagesIds = {};
811	}
812	isLoaded() {
813		return this.loaded;
814	}
815	setLoaded(loaded) {
816		if (this.loaded === loaded) return;
817		this.loaded = loaded;
818		if (loaded) {
819			for (const { ids, promiseResolve } of this.requestors) promiseResolve(this._getImagesForIds(ids));
820			this.requestors = [];
821		}
822	}
823	getImage(id) {
824		const image = this.images[id];
825		if (image && !image.data && image.spriteData) {
826			const spriteData = image.spriteData;
827			image.data = new RGBAImage({
828				width: spriteData.width,
829				height: spriteData.height
830			}, spriteData.context.getImageData(spriteData.x, spriteData.y, spriteData.width, spriteData.height).data);
831			image.spriteData = null;
832		}
833		return image;
834	}
835	addImage(id, image) {
836		if (this.images[id]) throw new Error(`Image id ${id} already exist, use updateImage instead`);
837		if (this._validate(id, image)) {
838			this.images[id] = image;
839			this._imagesIds = null;
840			if (image.isWebGLImage) this.updateImage(id, image, false);
841		}
842	}
843	_validate(id, image) {
844		let valid = true;
845		const data = image.data || image.spriteData;
846		if (!this._validateStretch(image.stretchX, data?.width)) {
847			this.fire(new ErrorEvent(/* @__PURE__ */ new Error(`Image "${id}" has invalid "stretchX" value`)));
848			valid = false;
849		}
850		if (!this._validateStretch(image.stretchY, data?.height)) {
851			this.fire(new ErrorEvent(/* @__PURE__ */ new Error(`Image "${id}" has invalid "stretchY" value`)));
852			valid = false;
853		}
854		if (!this._validateContent(image.content, image)) {
855			this.fire(new ErrorEvent(/* @__PURE__ */ new Error(`Image "${id}" has invalid "content" value`)));
856			valid = false;
857		}
858		return valid;
859	}
860	_validateStretch(stretch, size) {
861		if (!stretch) return true;
862		let last = 0;
863		for (const part of stretch) {
864			if (part[0] < last || part[1] < part[0] || size < part[1]) return false;
865			last = part[1];
866		}
867		return true;
868	}
869	_validateContent(content, image) {
870		if (!content) return true;
871		if (content.length !== 4) return false;
872		const spriteData = image.spriteData;
873		const width = spriteData?.width || image.data.width;
874		const height = spriteData?.height || image.data.height;
875		if (content[0] < 0 || width < content[0]) return false;
876		if (content[1] < 0 || height < content[1]) return false;
877		if (content[2] < 0 || width < content[2]) return false;
878		if (content[3] < 0 || height < content[3]) return false;
879		if (content[2] < content[0]) return false;
880		return content[3] >= content[1];
881	}
882	/**
883	* Replaces an image that is already known under this id, bumping its version so that the
884	* atlases holding it notice.
885	*
886	* The old record is read directly rather than through {@link ImageManager.getImage}, which
887	* would force a synchronous decode of the sprite data of the very image being replaced. Its
888	* size therefore comes from whichever of the two the pixels are still in, since an image that
889	* came from a sprite and was never rendered has not been decoded yet, and its version is
890	* defaulted, since images start out without one.
891	*
892	* @param validate - whether to reject an image of a different size than the one it replaces
893	*/
894	updateImage(id, image, validate = true) {
895		const oldImage = this.images[id];
896		if (validate) {
897			const oldData = oldImage.data || oldImage.spriteData;
898			if (oldData.width !== image.data.width || oldData.height !== image.data.height) throw new Error(`size mismatch between old image (${oldData.width}x${oldData.height}) and new image (${image.data.width}x${image.data.height}).`);
899		}
900		image.version = (oldImage.version ?? 0) + 1;
901		this.images[id] = image;
902		this.updateVersion++;
903	}
904	removeImage(id) {
905		const image = this.images[id];
906		if (!image) return;
907		delete this.images[id];
908		this._imagesIds = null;
909		if (image.userImage?.onRemove) image.userImage.onRemove();
910	}
911	/**
912	* @returns the ids of every image currently held, sprite images and runtime ones alike. The
913	* returned array is shared between callers and must not be modified.
914	*/
915	listImages() {
916		this._imagesIds ??= Object.keys(this.images);
917		return this._imagesIds;
918	}
919	/**
920	* Images of the `default` sprite keep their plain id, the ones of any other sprite are
921	* namespaced by their sprite's id.
922	*/
923	_getSpriteImageId(spriteId, imageId) {
924		return spriteId === "default" ? imageId : `${spriteId}:${imageId}`;
925	}
926	/**
927	* Takes over the images of a single sprite: adds the new ones, updates the ones that are
928	* already known, and removes the ones that a previous load of this same sprite had brought in
929	* but that are not part of it anymore.
930	*
931	* @param spriteId - the id of the sprite the images belong to
932	* @param images - the sprite's images, keyed by their id within the sprite
933	* @returns the ids of the images that this sprite now provides, and the ids of the ones that
934	* were removed because they are no longer part of it
935	*/
936	setSpriteImages(spriteId, images) {
937		const previousIds = this._spriteImagesIds[spriteId] ?? [];
938		const loaded = [];
939		for (const id in images) {
940			const imageId = this._getSpriteImageId(spriteId, id);
941			loaded.push(imageId);
942			if (imageId in this.images) this.updateImage(imageId, images[id], false);
943			else this.addImage(imageId, images[id]);
944		}
945		const loadedIds = new Set(loaded);
946		const removed = previousIds.filter((imageId) => !loadedIds.has(imageId));
947		for (const imageId of removed) this.removeImage(imageId);
948		this._spriteImagesIds[spriteId] = loaded;
949		return {
950			loaded,
951			removed
952		};
953	}
954	/**
955	* Removes all the images a single sprite has brought in.
956	* @returns the ids of the removed images
957	*/
958	removeSpriteImages(spriteId) {
959		const removed = this._spriteImagesIds[spriteId] ?? [];
960		for (const imageId of removed) this.removeImage(imageId);
961		delete this._spriteImagesIds[spriteId];
962		return removed;
963	}
964	/**
965	* Removes the images of every sprite, leaving the images added at runtime alone.
966	* @returns the ids of the removed images
967	*/
968	removeAllSpriteImages() {
969		const removed = Object.values(this._spriteImagesIds).flat();
970		for (const imageId of removed) this.removeImage(imageId);
971		this._spriteImagesIds = {};
972		return removed;
973	}
974	setMissingImageResolver(resolver) {
975		this.missingImageResolver = resolver;
976	}
977	getImages(ids) {
978		return new Promise((resolve, _reject) => {
979			let hasAllDependencies = true;
980			if (!this.isLoaded()) {
981				for (const id of ids) if (!this.images[id]) hasAllDependencies = false;
982			}
983			if (this.isLoaded() || hasAllDependencies) resolve(this._getImagesForIds(ids));
984			else this.requestors.push({
985				ids,
986				promiseResolve: resolve
987			});
988		});
989	}
990	async _getImagesForIds(ids) {
991		const unresolvedIds = new Set(ids.filter((id) => !this.getImage(id)));
992		const resolver = this.missingImageResolver;
993		if (resolver) await Promise.allSettled(Array.from(unresolvedIds, (id) => resolver(id)));
994		const response = {};
995		for (const id of ids) {
996			const image = this.getImage(id);
997			if (image) {
998				unresolvedIds.delete(id);
999				response[id] = {
1000					data: image.data.clone(),
1001					pixelRatio: image.pixelRatio,
1002					sdf: image.sdf,
1003					version: image.version,
1004					stretchX: image.stretchX,
1005					stretchY: image.stretchY,
1006					content: image.content,
1007					textFitWidth: image.textFitWidth,
1008					textFitHeight: image.textFitHeight,
1009					hasRenderCallback: Boolean(image.userImage?.render),
1010					isWebGLImage: image.isWebGLImage
1011				};
1012			}
1013		}
1014		for (const id of unresolvedIds) {
1015			this.fire(new MapStyleImageMissingEvent({ id }));
1016			warnOnce(`Image "${id}" could not be loaded. Please make sure you have added the image before it is needed with map.addImage(), resolved it with map.setMissingStyleImageResolver(), or included it in a "sprite" property in your style.`);
1017		}
1018		return response;
1019	}
1020	beginFrame() {
1021		this._renderCallbacksDispatchedThisFrame = {};
1022	}
1023	/**
1024	* Re-renders the images among `ids` that were added with a `render` callback (see
1025	* `StyleImageInterface`), at most once per frame each.
1026	*/
1027	dispatchRenderCallbacks(ids) {
1028		for (const id of ids) {
1029			if (this._renderCallbacksDispatchedThisFrame[id]) continue;
1030			this._renderCallbacksDispatchedThisFrame[id] = true;
1031			const image = this.getImage(id);
1032			if (!image) warnOnce(`Image with ID: "${id}" was not found`);
1033			if (renderStyleImage(image)) this.updateImage(id, image);
1034		}
1035	}
1036	cloneImages() {
1037		const clonedImages = {};
1038		for (const id in this.images) {
1039			const image = this.images[id];
1040			clonedImages[id] = {
1041				...image,
1042				data: image.data ? image.data.clone() : null
1043			};
1044		}
1045		return clonedImages;
1046	}
1047};
1048//#endregion
1049//#region src/render/pattern_atlas.ts
1050/**
1051* When copied into the atlas texture, pattern images are padded by one pixel on each side with a
1052* copy of the image data wrapped from the opposite side. This ensures the correct behavior of
1053* GL_LINEAR texture sampling mode.
1054*/
1055const PADDING = 1;
1056/**
1057* A texture atlas of the pattern images that are drawn without a tile's own {@link ImageAtlas},
1058* i.e. `background-pattern`. Entries are packed on demand and re-packed whenever one of them is
1059* added or changes, which is rare enough for the repacking cost not to matter.
1060*/
1061var PatternAtlas = class {
1062	constructor(imageManager) {
1063		this._imageManager = imageManager;
1064		this._entries = {};
1065		this._image = new RGBAImage({
1066			width: 1,
1067			height: 1
1068		});
1069		this._dirty = true;
1070	}
1071	destroy() {
1072		if (this._texture) {
1073			this._texture.destroy();
1074			this._texture = null;
1075		}
1076		this._entries = {};
1077		this._image = new RGBAImage({
1078			width: 1,
1079			height: 1
1080		});
1081		this._dirty = true;
1082	}
1083	getPixelSize() {
1084		const { width, height } = this._image;
1085		return {
1086			width,
1087			height
1088		};
1089	}
1090	/**
1091	* @returns the position of the pattern within the atlas, or `null` if there is no such image
1092	*/
1093	getPattern(id) {
1094		const image = this._imageManager.getImage(id);
1095		if (!image) return null;
1096		const entry = this._entries[id];
1097		if (entry?.image !== image) {
1098			const bin = {
1099				w: image.data.width + 2,
1100				h: image.data.height + 2,
1101				x: 0,
1102				y: 0
1103			};
1104			this._entries[id] = {
1105				bin,
1106				position: new ImagePosition(bin, image),
1107				image
1108			};
1109		} else if (entry.position.version !== image.version) entry.position.version = image.version;
1110		else return entry.position;
1111		this._update();
1112		return this._entries[id].position;
1113	}
1114	bind(context) {
1115		const gl = context.gl;
1116		if (!this._texture) {
1117			this._texture = new Texture(context, this._image, gl.RGBA);
1118			this._dirty = false;
1119		} else if (this._dirty) {
1120			this._texture.update(this._image);
1121			this._dirty = false;
1122		}
1123		this._texture.bind(gl.LINEAR, gl.CLAMP_TO_EDGE);
1124	}
1125	_update() {
1126		for (const id in this._entries) if (!this._imageManager.getImage(id)) delete this._entries[id];
1127		const bins = [];
1128		for (const id in this._entries) bins.push(this._entries[id].bin);
1129		const { w, h } = potpack(bins);
1130		const dst = this._image;
1131		dst.resize({
1132			width: w || 1,
1133			height: h || 1
1134		});
1135		for (const id in this._entries) {
1136			const { bin } = this._entries[id];
1137			const x = bin.x + PADDING;
1138			const y = bin.y + PADDING;
1139			const src = this._entries[id].image.data;
1140			const w = src.width;
1141			const h = src.height;
1142			RGBAImage.copy(src, dst, {
1143				x: 0,
1144				y: 0
1145			}, {
1146				x,
1147				y
1148			}, {
1149				width: w,
1150				height: h
1151			});
1152			RGBAImage.copy(src, dst, {
1153				x: 0,
1154				y: h - 1
1155			}, {
1156				x,
1157				y: y - 1
1158			}, {
1159				width: w,
1160				height: 1
1161			});
1162			RGBAImage.copy(src, dst, {
1163				x: 0,
1164				y: 0
1165			}, {
1166				x,
1167				y: y + h
1168			}, {
1169				width: w,
1170				height: 1
1171			});
1172			RGBAImage.copy(src, dst, {
1173				x: w - 1,
1174				y: 0
1175			}, {
1176				x: x - 1,
1177				y
1178			}, {
1179				width: 1,
1180				height: h
1181			});
1182			RGBAImage.copy(src, dst, {
1183				x: 0,
1184				y: 0
1185			}, {
1186				x: x + w,
1187				y
1188			}, {
1189				width: 1,
1190				height: h
1191			});
1192		}
1193		this._dirty = true;
1194	}
1195};
1196//#endregion
1197//#region src/render/font_face_manager.ts
1198const MAX_CODE_POINT = 1114111;
1199/**
1200* What a font file covers when the style does not narrow it down with `unicode-range`.
1201*/
1202const DEFAULT_UNICODE_RANGE = {
1203	start: 0,
1204	end: MAX_CODE_POINT
1205};
1206/**
1207* Makes the family names unique across every map on the page, since `document.fonts` is shared.
1208*/
1209let nextFamilyId = 0;
1210/**
1211* Parses one `unicode-range` entry, in the CSS grammar the style specification borrows: `U+A5`,
1212* `U+0-10FFFF` or `U+4??`.
1213* @param value - a single `unicode-range` entry
1214* @returns the codepoints it covers, or `null` if it is not a range this can make sense of
1215*/
1216function parseUnicodeRange(value) {
1217	const wildcard = /^u\+([0-9a-f]*)(\?+)$/i.exec(value);
1218	if (wildcard) {
1219		const [, prefix, questionMarks] = wildcard;
1220		if (prefix.length + questionMarks.length > 6) return null;
1221		return clampRange(parseInt(`${prefix}${"0".repeat(questionMarks.length)}`, 16), parseInt(`${prefix}${"f".repeat(questionMarks.length)}`, 16));
1222	}
1223	const explicit = /^u\+([0-9a-f]{1,6})(?:-([0-9a-f]{1,6}))?$/i.exec(value);
1224	if (!explicit) return null;
1225	const start = parseInt(explicit[1], 16);
1226	return clampRange(start, explicit[2] === void 0 ? start : parseInt(explicit[2], 16));
1227}
1228function clampRange(start, end) {
1229	if (start > end || start > MAX_CODE_POINT) return null;
1230	return {
1231		start,
1232		end: Math.min(end, MAX_CODE_POINT)
1233	};
1234}
1235/**
1236* Whether the style lets this file cover the given codepoint.
1237*/
1238function covers(face, codePoint) {
1239	return face.ranges.some(({ start, end }) => codePoint >= start && codePoint <= end);
1240}
1241/**
1242* Keeps the font files a style declares in its
1243* [`font-faces`](https://maplibre.org/maplibre-style-spec/root/#font-faces) property, and hands the
1244* {@link GlyphManager} the CSS family to draw a given codepoint with.
1245*
1246* The files go to the browser's CSS Font Loading API, so any format it can render text with works.
1247* Each is registered under a family name of our own making, so that a style cannot restyle the
1248* surrounding page and a codepoint can be pinned to one file rather than to whatever font matching
1249* picks.
1250*
1251* Rasterizing happens a grapheme cluster at a time, so a letter reaches the browser's text engine
1252* with its marks. Shaping across cluster boundaries still needs the RTL text plugin.
1253*/
1254var FontFaceManager = class {
1255	constructor(requestManager) {
1256		this.requestManager = requestManager;
1257		this._faces = {};
1258		this._registered = /* @__PURE__ */ new Set();
1259	}
1260	/**
1261	* Replaces the declared font faces. Nothing is downloaded here: each file waits until a
1262	* codepoint it covers is actually drawn.
1263	*/
1264	setFontFaces(fontFaces) {
1265		this._unregisterAll();
1266		this._faces = {};
1267		for (const [fontName, declaration] of Object.entries(fontFaces ?? {})) {
1268			const declarations = Array.isArray(declaration) ? declaration : [declaration];
1269			this._faces[fontName] = declarations.map((entry) => this._declareFontFace(fontName, entry)).filter((face) => face !== null);
1270		}
1271	}
1272	/**
1273	* Whether the style declared any font face at all, so that the common case of a style without
1274	* `font-faces` costs nothing.
1275	*/
1276	hasFontFaces() {
1277		return Object.keys(this._faces).length > 0;
1278	}
1279	/**
1280	* Finds the font file to draw a codepoint with: each name of the `text-font` stack in turn, and
1281	* within a name each declared file, until one covers it. A file that fails to load is skipped,
1282	* the specification asking for unsupported fonts to be ignored.
1283	*
1284	* @returns the CSS family to draw with, or `null` to leave the codepoint to the `glyphs` URL
1285	*/
1286	async getFontFamily(fontStack, codePoint) {
1287		for (const fontName of fontStack.split(",")) for (const face of this._faces[fontName.trim()] ?? []) {
1288			if (!covers(face, codePoint)) continue;
1289			face.loaded ??= this._loadFontFace(face);
1290			if (await face.loaded) return face.family;
1291		}
1292		return null;
1293	}
1294	/**
1295	* Turns one declaration into a face to draw with, or `null` if there is nothing usable in it.
1296	*
1297	* A bare URL is the same as a face that names no `unicode-range`: it covers every codepoint.
1298	*/
1299	_declareFontFace(fontName, declaration) {
1300		const face = typeof declaration === "string" ? { url: declaration } : declaration;
1301		if (typeof face?.url !== "string") {
1302			warnOnce(`Ignoring the font face declared for "${fontName}": it has no URL.`);
1303			return null;
1304		}
1305		const family = `maplibre-gl-font-face-${nextFamilyId++}`;
1306		const unicodeRange = face["unicode-range"];
1307		if (!unicodeRange?.length) return {
1308			url: face.url,
1309			ranges: [DEFAULT_UNICODE_RANGE],
1310			family
1311		};
1312		const ranges = [];
1313		for (const entry of unicodeRange) {
1314			const range = parseUnicodeRange(entry);
1315			if (!range) {
1316				warnOnce(`Ignoring the unicode range "${entry}" of the font face at ${face.url}: it is not a valid range.`);
1317				continue;
1318			}
1319			ranges.push(range);
1320		}
1321		if (!ranges.length) return null;
1322		return {
1323			url: face.url,
1324			ranges,
1325			family
1326		};
1327	}
1328	/**
1329	* Downloads a declared file and hands it to the browser, reporting whether it can be drawn with.
1330	* A failure is not an error: its codepoints fall through to the next file, then to `glyphs`.
1331	*/
1332	async _loadFontFace(face) {
1333		if (typeof FontFace === "undefined" || typeof document === "undefined" || !document.fonts) {
1334			warnOnce(`Ignoring the font face at ${face.url}: this environment has no CSS Font Loading API.`);
1335			return false;
1336		}
1337		let fontFace;
1338		try {
1339			fontFace = new FontFace(face.family, await this._downloadFontFile(face.url));
1340			if (!Object.values(this._faces).some((faces) => faces.includes(face))) return false;
1341			document.fonts.add(fontFace);
1342			this._registered.add(fontFace);
1343			await fontFace.load();
1344			return true;
1345		} catch (e) {
1346			if (fontFace) this._unregister(fontFace);
1347			warnOnce(`Ignoring the font face at ${face.url}: ${ensureError(e).message}`);
1348			return false;
1349		}
1350	}
1351	/**
1352	* Downloads a font file, giving the map's `transformRequest` a chance to rewrite the request the
1353	* same way it gets one for a glyph range.
1354	*/
1355	async _downloadFontFile(url) {
1356		const request = await this.requestManager.transformRequest(url, "Glyphs");
1357		const response = await getArrayBuffer(request, new AbortController());
1358		if (!response?.data) throw new Error(`the response was empty for the font file at ${url}`);
1359		return response.data;
1360	}
1361	_unregister(fontFace) {
1362		document.fonts?.delete(fontFace);
1363		this._registered.delete(fontFace);
1364	}
1365	_unregisterAll() {
1366		for (const fontFace of this._registered) document.fonts?.delete(fontFace);
1367		this._registered.clear();
1368	}
1369	destroy() {
1370		this._unregisterAll();
1371		this._faces = {};
1372	}
1373};
1374//#endregion
1375//#region node_modules/@mapbox/tiny-sdf/index.js
1376const INF = 0x56bc75e2d63100000;
1377const alphaTable = /* @__PURE__ */ new Float64Array(256);
1378for (let i = 0; i < 256; i++) {
1379	const d = .5 - Math.pow(i / 255, 1 / 2.2);
1380	alphaTable[i] = d * Math.abs(d);
1381}
1382alphaTable[255] = -0x56bc75e2d63100000;
1383var TinySDF = class {
1384	constructor({ fontSize = 24, buffer = 3, radius = 8, cutoff = .25, fontFamily = "sans-serif", fontWeight = "normal", fontStyle = "normal", lang = null } = {}) {
1385		this.buffer = buffer;
1386		this.radius = radius;
1387		this.cutoff = cutoff;
1388		this.lang = lang;
1389		const size = this.size = fontSize + buffer * 4;
1390		const canvas = this._createCanvas(size);
1391		const ctx = this.ctx = canvas.getContext("2d", { willReadFrequently: true });
1392		ctx.font = `${fontStyle} ${fontWeight} ${fontSize}px ${fontFamily}`;
1393		ctx.textBaseline = "alphabetic";
1394		ctx.textAlign = "left";
1395		ctx.fillStyle = "black";
1396		this.gridOuter = new Float64Array(size * size);
1397		this.gridInner = new Float64Array(size * size);
1398		this.f = new Float64Array(size);
1399		this.z = new Float64Array(size + 1);
1400		this.v = new Uint16Array(size);
1401	}
1402	_createCanvas(size) {
1403		if (typeof OffscreenCanvas !== "undefined") return new OffscreenCanvas(size, size);
1404		const canvas = document.createElement("canvas");
1405		canvas.width = canvas.height = size;
1406		return canvas;
1407	}
1408	draw(char) {
1409		const { width: glyphAdvance, actualBoundingBoxAscent, actualBoundingBoxDescent, actualBoundingBoxLeft, actualBoundingBoxRight } = this.ctx.measureText(char);
1410		const glyphTop = Math.ceil(actualBoundingBoxAscent);
1411		const glyphLeft = Math.floor(-actualBoundingBoxLeft);
1412		const glyphWidth = Math.max(0, Math.min(this.size - this.buffer, Math.ceil(actualBoundingBoxRight) - glyphLeft));
1413		const glyphHeight = Math.max(0, Math.min(this.size - this.buffer, glyphTop + Math.ceil(actualBoundingBoxDescent)));
1414		const width = glyphWidth + 2 * this.buffer;
1415		const height = glyphHeight + 2 * this.buffer;
1416		const len = Math.max(width * height, 0);
1417		const data = new Uint8ClampedArray(len);
1418		const glyph = {
1419			data,
1420			width,
1421			height,
1422			glyphWidth,
1423			glyphHeight,
1424			glyphTop,
1425			glyphLeft,
1426			glyphAdvance
1427		};
1428		if (glyphWidth === 0 || glyphHeight === 0) return glyph;
1429		const { ctx, buffer, gridInner, gridOuter } = this;
1430		if (this.lang) ctx.lang = this.lang;
1431		ctx.clearRect(buffer, buffer, glyphWidth, glyphHeight);
1432		ctx.fillText(char, buffer - glyphLeft, buffer + glyphTop);
1433		const imgData = ctx.getImageData(buffer, buffer, glyphWidth, glyphHeight);
1434		gridOuter.fill(INF, 0, len);
1435		gridInner.fill(0, 0, len);
1436		let imgIdx = 3;
1437		for (let y = 0; y < glyphHeight; y++) {
1438			let j = (y + buffer) * width + buffer;
1439			for (let x = 0; x < glyphWidth; x++, imgIdx += 4, j++) {
1440				const a = imgData.data[imgIdx];
1441				if (a === 0) continue;
1442				const t = alphaTable[a];
1443				gridOuter[j] = Math.max(0, t);
1444				gridInner[j] = Math.max(0, -t);
1445			}
1446		}
1447		edt(gridOuter, 0, 0, width, height, width, this.f, this.v, this.z);
1448		const pad = Math.min(buffer, 1);
1449		edt(gridInner, buffer - pad, buffer - pad, glyphWidth + 2 * pad, glyphHeight + 2 * pad, width, this.f, this.v, this.z);
1450		const scale = 255 / this.radius;
1451		const base = 255 * (1 - this.cutoff);
1452		for (let i = 0; i < len; i++) {
1453			const d = Math.sqrt(gridOuter[i]) - Math.sqrt(gridInner[i]);
1454			data[i] = Math.round(base - scale * d);
1455		}
1456		return glyph;
1457	}
1458};
1459function edt(data, x0, y0, width, height, gridSize, f, v, z) {
1460	for (let x = x0; x < x0 + width; x++) edt1d(data, y0 * gridSize + x, gridSize, height, f, v, z);
1461	for (let y = y0; y < y0 + height; y++) edt1d(data, y * gridSize + x0, 1, width, f, v, z);
1462}
1463function edt1d(grid, offset, stride, length, f, v, z) {
1464	v[0] = 0;
1465	z[0] = -0x56bc75e2d63100000;
1466	z[1] = INF;
1467	f[0] = grid[offset];
1468	for (let q = 1, k = 0, s = 0; q < length; q++) {
1469		f[q] = grid[offset + q * stride];
1470		const q2 = q * q;
1471		do {
1472			const r = v[k];
1473			s = (f[q] - f[r] + q2 - r * r) / (q - r) / 2;
1474		} while (s <= z[k] && --k > -1);
1475		k++;
1476		v[k] = q;
1477		z[k] = s;
1478		z[k + 1] = INF;
1479	}
1480	for (let q = 0, k = 0; q < length; q++) {
1481		while (z[k + 1] < q) k++;
1482		const r = v[k];
1483		const qr = q - r;
1484		grid[offset + q * stride] = f[r] + qr * qr;
1485	}
1486}
1487//#endregion
1488//#region src/render/glyph_manager.ts
1489/**
1490* The style specification hard-codes some last resort fonts as a default fontstack.
1491*/
1492const defaultStack = latest.layout_symbol["text-font"].default.join(",");
1493/**
1494* The CSS generic font family closest to `defaultStack`.
1495*/
1496const defaultGenericFontFamily = "sans-serif";
1497/**
1498* Scale factor for client-generated glyphs.
1499*
1500* Client-generated glyphs are rendered at 2× because CJK glyphs are more detailed than others.
1501*/
1502const textureScale = 2;
1503const defaultCreateRasterizer = (options, padding) => {
1504	const tinySDF = new TinySDF(options);
1505	tinySDF.buffer = padding;
1506	return tinySDF;
1507};
1508/**
1509* How wide a grapheme cluster may be drawn, in multiples of the font size.
1510*
1511* TinySDF sizes its canvas for a single character and cuts off the rest, but a cluster is a whole
1512* syllable: Burmese `လား` is nearly twice the font size. Three ems fits the ones that occur.
1513*/
1514const clusterEmsWide = 3;
1515var GlyphManager = class {
1516	constructor(requestManager, localIdeographFontFamily, lang, createRasterizer = defaultCreateRasterizer) {
1517		this.requestManager = requestManager;
1518		this.localIdeographFontFamily = localIdeographFontFamily;
1519		this.entries = {};
1520		this.lang = lang;
1521		this.fontFaceManager = new FontFaceManager(requestManager);
1522		this.createRasterizer = createRasterizer;
1523	}
1524	setURL(url) {
1525		this.url = url;
1526	}

1527	/**
1528	* Replaces the font files the style declares in its `font-faces` property, dropping every glyph
1529	* drawn with the previous ones.
1530	*/
1531	setFontFaces(fontFaces) {
1532		this.fontFaceManager.setFontFaces(fontFaces);
1533		this.entries = {};
1534	}
1535	async getGlyphs(glyphs) {
1536		const glyphsPromises = [];
1537		for (const stack in glyphs) for (const id of glyphs[stack]) glyphsPromises.push(this._getAndCacheGlyphsPromise(stack, id));
1538		const updatedGlyphs = await Promise.all(glyphsPromises);
1539		const result = {};
1540		for (const { stack, id, glyph } of updatedGlyphs) {
1541			result[stack] ||= {};
1542			result[stack][id] = glyph && {
1543				id: glyph.id,
1544				bitmap: glyph.bitmap.clone(),
1545				metrics: glyph.metrics
1546			};
1547		}
1548		return result;
1549	}
1550	/**
1551	* Gets one glyph, asked for by grapheme cluster so that a letter and its marks are drawn as the
1552	* one shape they are written as.
1553	*
1554	* A cluster is drawn from a font rather than fetched, because a glyphs URL serves codepoints and
1555	* has no way to serve the one shape they are written as. A file the style pinned with
1556	* `font-faces` draws it where one covers it, and the local fonts otherwise. For a single
1557	* codepoint a declared file still wins over the glyphs URL and the local fallbacks.
1558	*/
1559	async _getAndCacheGlyphsPromise(stack, id) {
1560		this.entries[stack] ??= {
1561			glyphs: {},
1562			requests: {},
1563			ranges: {}
1564		};
1565		const entry = this.entries[stack];
1566		let glyph = entry.glyphs[id];
1567		if (glyph !== void 0) return {
1568			stack,
1569			id,
1570			glyph
1571		};
1572		const codePoint = id.codePointAt(0);
1573		const fontFaceFamily = this.fontFaceManager.hasFontFaces() ? await this.fontFaceManager.getFontFamily(stack, codePoint) : null;
1574		if (fontFaceFamily) {
1575			glyph = entry.glyphs[id] = await this._drawGlyph(entry, stack, id, fontFaceFamily);
1576			return {
1577				stack,
1578				id,
1579				glyph
1580			};
1581		}
1582		if (!this.url || isCluster(id) || this._charUsesLocalIdeographFontFamily(codePoint)) {
1583			glyph = entry.glyphs[id] = await this._drawGlyph(entry, stack, id);
1584			return {
1585				stack,
1586				id,
1587				glyph
1588			};
1589		}
1590		return await this._downloadAndCacheRangePromise(stack, id);
1591	}
1592	/**
1593	* Gets a glyph from the server-side cache, downloading the PBF range it falls in if need be.
1594	*
1595	* Only reached for a single codepoint. What comes back is keyed by codepoint, as the file is,
1596	* and is cached by cluster -- which for one codepoint is the character itself.
1597	*/
1598	async _downloadAndCacheRangePromise(stack, id) {
1599		const codePoint = id.codePointAt(0);
1600		const entry = this.entries[stack];
1601		const range = Math.floor(codePoint / 256);
1602		if (entry.ranges[range]) return {
1603			stack,
1604			id,
1605			glyph: null
1606		};
1607		entry.requests[range] ||= this._loadGlyphRange(stack, range);
1608		try {
1609			const response = await entry.requests[range];
1610			for (const responseId in response) entry.glyphs[String.fromCodePoint(+responseId)] = response[+responseId];
1611			entry.ranges[range] = true;
1612			return {
1613				stack,
1614				id,
1615				glyph: response[codePoint] || null
1616			};
1617		} catch (e) {
1618			const glyph = entry.glyphs[id] = await this._drawGlyph(entry, stack, id);
1619			this._warnOnMissingGlyphRange(glyph, range, codePoint, ensureError(e));
1620			return {
1621				stack,
1622				id,
1623				glyph
1624			};
1625		}
1626	}
1627	/**
1628	* Downloads one range of 256 codepoints from the glyphs URL and parses the glyphs out of it.
1629	*/
1630	async _loadGlyphRange(fontstack, range) {
1631		const begin = range * 256;
1632		const end = begin + 255;
1633		const request = await this.requestManager.transformRequest(this.url.replace("{fontstack}", fontstack).replace("{range}", `${begin}-${end}`), "Glyphs");
1634		const response = await getArrayBuffer(request, new AbortController());
1635		if (!response?.data) throw new Error(`Could not load glyph range. range: ${range}, ${begin}-${end}`);
1636		const glyphs = {};
1637		for (const glyph of parseGlyphPbf(response.data)) glyphs[glyph.id] = glyph;
1638		return glyphs;
1639	}
1640	_warnOnMissingGlyphRange(glyph, range, id, err) {
1641		const begin = range * 256;
1642		const end = begin + 255;
1643		const codePoint = id.toString(16).padStart(4, "0").toUpperCase();
1644		warnOnce(`Unable to load glyph range ${range}, ${begin}-${end}. Rendering codepoint U+${codePoint} locally instead. ${err}`);
1645	}
1646	/**
1647	* Returns whether the given codepoint should be rendered locally.
1648	*/
1649	_charUsesLocalIdeographFontFamily(id) {
1650		return !!this.localIdeographFontFamily && codePointUsesLocalIdeographFontFamily(id);
1651	}
1652	/**
1653	* Draws a glyph offscreen using TinySDF, created lazily. The whole cluster goes to TinySDF, which
1654	* is what lets the browser's text engine place a letter's marks on it.
1655	*
1656	* @param fontFaceFamily - the CSS family of the `font-faces` file covering this codepoint, if any
1657	*/
1658	async _drawGlyph(entry, stack, id, fontFaceFamily) {
1659		const char = (await this._getTinySDF(entry, stack, id, fontFaceFamily)).draw(id);
1660		/**
1661		* TinySDF's "top" is the distance from the alphabetic baseline to the top of the glyph.
1662		* Server-generated fonts specify "top" relative to an origin above the em box (the origin
1663		* comes from FreeType, but I'm unclear on exactly how it's derived)
1664		* ref: https://github.com/mapbox/sdf-glyph-foundry
1665		*
1666		* Server fonts don't yet include baseline information, so we can't line up exactly with them
1667		* (and they don't line up with each other)
1668		* ref: https://github.com/mapbox/node-fontnik/pull/160
1669		*
1670		* To approximately align TinySDF glyphs with server-provided glyphs, we use this baseline adjustment
1671		* factor calibrated to be in between DIN Pro and Arial Unicode (but closer to Arial Unicode)
1672		*/
1673		const topAdjustment = 27.5;
1674		const leftAdjustment = .5;
1675		const isControl = /^\p{gc=Cf}+$/u.test(id);
1676		return {
1677			id: id.codePointAt(0),
1678			bitmap: new AlphaImage({
1679				width: char.width || 60,
1680				height: char.height || 60
1681			}, char.data),
1682			metrics: {
1683				width: isControl ? 0 : char.glyphWidth / textureScale || 24,
1684				height: char.glyphHeight / textureScale || 24,
1685				left: char.glyphLeft / textureScale + leftAdjustment || 0,
1686				top: char.glyphTop / textureScale - topAdjustment || -8,
1687				advance: isControl ? 0 : char.glyphAdvance / textureScale || 24,
1688				isDoubleResolution: true
1689			}
1690		};
1691	}
1692	/**
1693	* Returns the TinySDF that draws this grapheme, created lazily. A stack keeps one per font
1694	* selection, so a fallback cannot bleed into the rest of the text, and one more per font file
1695	* for the clusters drawn from it, which need a wider canvas.
1696	*
1697	* A font file carries its own weight and style, so neither is sniffed out of the family name.
1698	* Where no file covers the grapheme, `localIdeographFontFamily` beats the last resort fontstack.
1699	*/
1700	_getTinySDF(entry, stack, id, fontFaceFamily) {
1701		const cluster = isCluster(id);
1702		if (fontFaceFamily) {
1703			const cache = cluster ? "clusterTinySDFs" : "fontFaceTinySDFs";
1704			entry[cache] ??= {};
1705			entry[cache][fontFaceFamily] ||= this._createTinySDF(fontFaceFamily, false, cluster ? clusterEmsWide : 1);
1706			return entry[cache][fontFaceFamily];
1707		}
1708		const usesLocalIdeographFontFamily = stack === defaultStack && this.localIdeographFontFamily !== "" && this._charUsesLocalIdeographFontFamily(id.codePointAt(0));
1709		const family = usesLocalIdeographFontFamily ? this.localIdeographFontFamily : stack;
1710		if (cluster) {
1711			entry.clusterTinySDFs ??= {};
1712			entry.clusterTinySDFs[family] ||= this._createTinySDF(family, true, clusterEmsWide);
1713			return entry.clusterTinySDFs[family];
1714		}
1715		const cache = usesLocalIdeographFontFamily ? "ideographTinySDF" : "tinySDF";
1716		entry[cache] ||= this._createTinySDF(family);
1717		return entry[cache];
1718	}
1719	/**
1720	* Builds the TinySDF that draws with a given font selection.
1721	*
1722	* TinySDF derives its canvas from `fontSize + buffer * 4`, so the buffer is the only way in to a
1723	* wider one. It also stands for the padding the atlas expects to be `GLYPH_PBF_BORDER`, so the
1724	* two are passed separately.
1725	*
1726	* @param emsWide - how wide the glyphs may be, in font sizes, before TinySDF cuts them off
1727	*/
1728	async _createTinySDF(stack, sniffFontStyles = true, emsWide = 1) {
1729		const fontFamilies = stack ? stack.split(",") : [];
1730		fontFamilies.push(defaultGenericFontFamily);
1731		const fontFamily = fontFamilies.map((fontName) => /[-\w]+/.test(fontName) ? fontName : `'${CSS.escape(fontName)}'`).join(",");
1732		const fontSize = 48;
1733		const fontWeight = sniffFontStyles ? this._fontWeight(fontFamilies[0]) : void 0;
1734		const fontStyle = sniffFontStyles ? this._fontStyle(fontFamilies[0]) : "normal";
1735		if (typeof document !== "undefined" && document.fonts?.load) try {
1736			await document.fonts.load(`${fontStyle} ${fontWeight || "normal"} ${fontSize}px ${fontFamily}`);
1737		} catch (e) {
1738			warnOnce(`Failed to load font "${fontFamily}": ${ensureError(e).message}`);
1739		}
1740		const padding = 6;
1741		return this.createRasterizer({
1742			fontSize,
1743			buffer: Math.max(padding, Math.ceil(fontSize * (emsWide - 1) / 4)),
1744			radius: 16,
1745			cutoff: .25,
1746			fontFamily,
1747			fontWeight,
1748			fontStyle,
1749			lang: this.lang
1750		}, padding);
1751	}
1752	/**
1753	* Sniffs the font style out of a font family name.
1754	*/
1755	_fontStyle(fontFamily) {
1756		if (/italic/i.test(fontFamily)) return "italic";
1757		else if (/oblique/i.test(fontFamily)) return "oblique";
1758		return "normal";
1759	}
1760	/**
1761	* Sniffs the font weight out of a font family name.
1762	*/
1763	_fontWeight(fontFamily) {
1764		const weightsByName = {
1765			thin: 100,
1766			hairline: 100,
1767			"extra light": 200,
1768			"ultra light": 200,
1769			light: 300,
1770			normal: 400,
1771			regular: 400,
1772			medium: 500,
1773			semibold: 600,
1774			demibold: 600,
1775			bold: 700,
1776			"extra bold": 800,
1777			"ultra bold": 800,
1778			black: 900,
1779			heavy: 900,
1780			"extra black": 950,
1781			"ultra black": 950
1782		};
1783		let match;
1784		for (const [name, weight] of Object.entries(weightsByName)) if (new RegExp(`\\b${name}\\b`, "i").test(fontFamily)) match = `${weight}`;
1785		return match;
1786	}
1787	destroy() {
1788		for (const stack in this.entries) {
1789			const entry = this.entries[stack];
1790			entry.tinySDF = null;
1791			entry.ideographTinySDF = null;
1792			entry.fontFaceTinySDFs = {};
1793			entry.glyphs = {};
1794			entry.requests = {};
1795			entry.ranges = {};
1796		}
1797		this.entries = {};
1798		this.fontFaceManager.destroy();
1799	}
1800};
1801//#endregion
1802//#region src/style/light_properties.g.ts
1803let properties$2;
1804const getProperties$2 = () => properties$2 = properties$2 || new Properties({
1805	"anchor": new DataConstantProperty(latest["light"]["anchor"], "anchor"),
1806	"position": new DataConstantProperty(latest["light"]["position"], "position"),
1807	"color": new DataConstantProperty(latest["light"]["color"], "color"),
1808	"intensity": new DataConstantProperty(latest["light"]["intensity"], "intensity")
1809});
1810//#endregion
1811//#region src/style/light.ts
1812var Light = class extends Evented {
1813	constructor(lightOptions, globalState) {
1814		super();
1815		this._transitionable = new Transitionable(getProperties$2(), "light", globalState);
1816		this.setLight(lightOptions);
1817		this._transitioning = this._transitionable.untransitioned();
1818	}
1819	getLight() {
1820		return this._transitionable.serialize();
1821	}
1822	/**
1823	* Gets the light position in cartesian coordinates.
1824	*/
1825	getCartesianPosition() {
1826		return sphericalToCartesian(this.properties.get("position"));
1827	}
1828	setLight(light, options = {}) {
1829		if (this._validate(validateStyle.light, light, options)) return;
1830		this._transitionable.setValues(light);
1831	}
1832	updateTransitions(parameters) {
1833		this._transitioning = this._transitionable.transitioned(parameters, this._transitioning);
1834	}
1835	hasTransition() {
1836		return this._transitioning.hasTransition();
1837	}
1838	applyGlobalStateChange(refs, priorGlobalState, parameters) {
1839		this._transitioning = this._transitionable.applyGlobalStateChange(refs, priorGlobalState, this._transitioning, parameters);
1840	}
1841	recalculate(parameters) {
1842		this.properties = this._transitioning.possiblyEvaluate(parameters);
1843	}
1844	_validate(validate, value, options) {
1845		return validateAndEmit(this, validate, { value }, options);
1846	}
1847};
1848//#endregion
1849//#region src/style/sky_properties.g.ts
1850let properties$1;
1851const getProperties$1 = () => properties$1 = properties$1 || new Properties({
1852	"sky-color": new DataConstantProperty(latest["sky"]["sky-color"], "sky-color"),
1853	"horizon-color": new DataConstantProperty(latest["sky"]["horizon-color"], "horizon-color"),
1854	"fog-color": new DataConstantProperty(latest["sky"]["fog-color"], "fog-color"),
1855	"fog-ground-blend": new DataConstantProperty(latest["sky"]["fog-ground-blend"], "fog-ground-blend"),
1856	"horizon-fog-blend": new DataConstantProperty(latest["sky"]["horizon-fog-blend"], "horizon-fog-blend"),
1857	"sky-horizon-blend": new DataConstantProperty(latest["sky"]["sky-horizon-blend"], "sky-horizon-blend"),
1858	"atmosphere-blend": new DataConstantProperty(latest["sky"]["atmosphere-blend"], "atmosphere-blend")
1859});
1860//#endregion
1861//#region src/style/sky.ts
1862var Sky = class extends Evented {
1863	constructor(sky, globalState) {
1864		super();
1865		this._transitionable = new Transitionable(getProperties$1(), "sky", globalState);
1866		this.setSky(sky);
1867		this._transitioning = this._transitionable.untransitioned();
1868		this.recalculate(new EvaluationParameters(0));
1869	}
1870	/**
1871	* Validates and applies the sky. Returns false, after firing `error`, when
1872	* the value was rejected and nothing changed.
1873	*/
1874	setSky(sky, options = {}) {
1875		if (this._validate(validateStyle.sky, sky, options)) return false;
1876		sky ||= {
1877			"sky-color": "transparent",
1878			"horizon-color": "transparent",
1879			"fog-color": "transparent",
1880			"fog-ground-blend": 1,
1881			"atmosphere-blend": 0
1882		};
1883		this._transitionable.setValues(sky);
1884		return true;
1885	}
1886	getSky() {
1887		return this._transitionable.serialize();
1888	}
1889	updateTransitions(parameters) {
1890		this._transitioning = this._transitionable.transitioned(parameters, this._transitioning);
1891	}
1892	hasTransition() {
1893		return this._transitioning.hasTransition();
1894	}
1895	applyGlobalStateChange(refs, priorGlobalState, parameters) {
1896		this._transitioning = this._transitionable.applyGlobalStateChange(refs, priorGlobalState, this._transitioning, parameters);
1897	}
1898	recalculate(parameters) {
1899		this.properties = this._transitioning.possiblyEvaluate(parameters);
1900	}
1901	_validate(validate, value, options = {}) {
1902		return validateAndEmit(this, validate, { value }, options);
1903	}
1904	/**
1905	* Currently fog is a very simple implementation, and should only used
1906	* to create an atmosphere near the horizon.
1907	* But because the fog is drawn from the far-clipping-plane to
1908	* map-center, and because the fog does nothing know about the horizon,
1909	* this method does a fadeout in respect of pitch. So, when the horizon
1910	* gets out of view, which is at about pitch 70, this methods calculates
1911	* the corresponding opacity values. Below pitch 60 the fog is completely
1912	* invisible.
1913	*/
1914	calculateFogBlendOpacity(pitch) {
1915		if (pitch < 60) return 0;
1916		if (pitch < 70) return (pitch - 60) / 10;
1917		return 1;
1918	}
1919};
1920//#endregion
1921//#region src/render/line_atlas.ts
1922/**
1923* @internal
1924* A LineAtlas lets us reuse rendered dashed lines
1925* by writing many of them to a texture and then fetching their positions
1926* using {@link LineAtlas.getDash}.
1927*
1928* @param width - the width
1929* @param height - the height
1930*/
1931var LineAtlas = class {
1932	constructor(width, height) {
1933		this.width = width;
1934		this.height = height;
1935		this.nextRow = 0;
1936		this.data = new Uint8Array(this.width * this.height);
1937		this.dashEntry = {};
1938	}
1939	/**
1940	* Get or create a dash line pattern.
1941	*
1942	* @param dasharray - the key (represented by numbers) to get the dash texture
1943	* @param round - whether to add circle caps in between dash segments
1944	* @returns position of dash texture in {@link DashEntry}
1945	*/
1946	getDash(dasharray, round) {
1947		const key = dasharray.join(",") + String(round);
1948		this.dashEntry[key] ||= this.addDash(dasharray, round);
1949		return this.dashEntry[key];
1950	}
1951	getDashRanges(dasharray, lineAtlasWidth, stretch) {
1952		const oddDashArray = dasharray.length % 2 === 1;
1953		const ranges = [];
1954		let left = oddDashArray ? -dasharray[dasharray.length - 1] * stretch : 0;
1955		let right = dasharray[0] * stretch;
1956		let isDash = true;
1957		ranges.push({
1958			left,
1959			right,
1960			isDash,
1961			zeroLength: dasharray[0] === 0
1962		});
1963		let currentDashLength = dasharray[0];
1964		for (let i = 1; i < dasharray.length; i++) {
1965			isDash = !isDash;
1966			const dashLength = dasharray[i];
1967			left = currentDashLength * stretch;
1968			currentDashLength += dashLength;
1969			right = currentDashLength * stretch;
1970			ranges.push({
1971				left,
1972				right,
1973				isDash,
1974				zeroLength: dashLength === 0
1975			});
1976		}
1977		return ranges;
1978	}
1979	addRoundDash(ranges, stretch, n) {
1980		const halfStretch = stretch / 2;
1981		for (let y = -n; y <= n; y++) {
1982			const row = this.nextRow + n + y;
1983			const index = this.width * row;
1984			let currIndex = 0;
1985			let range = ranges[currIndex];
1986			for (let x = 0; x < this.width; x++) {
1987				if (x / range.right > 1) range = ranges[++currIndex];
1988				const distLeft = Math.abs(x - range.left);
1989				const distRight = Math.abs(x - range.right);
1990				const minDist = Math.min(distLeft, distRight);
1991				let signedDistance;
1992				const distMiddle = y / n * (halfStretch + 1);
1993				if (range.isDash) {
1994					const distEdge = halfStretch - Math.abs(distMiddle);
1995					signedDistance = Math.sqrt(minDist * minDist + distEdge * distEdge);
1996				} else signedDistance = halfStretch - Math.sqrt(minDist * minDist + distMiddle * distMiddle);
1997				this.data[index + x] = Math.max(0, Math.min(255, signedDistance + 128));
1998			}
1999		}
2000	}
2001	addRegularDash(ranges) {
2002		for (let i = ranges.length - 1; i >= 0; --i) {
2003			const part = ranges[i];
2004			const next = ranges[i + 1];
2005			if (part.zeroLength) ranges.splice(i, 1);
2006			else if (next?.isDash === part.isDash) {
2007				next.left = part.left;
2008				ranges.splice(i, 1);
2009			}
2010		}
2011		const first = ranges[0];
2012		const last = ranges[ranges.length - 1];
2013		if (first.isDash === last.isDash) {
2014			first.left = last.left - this.width;
2015			last.right = first.right + this.width;
2016		}
2017		const index = this.width * this.nextRow;
2018		let currIndex = 0;
2019		let range = ranges[currIndex];
2020		for (let x = 0; x < this.width; x++) {
2021			if (x / range.right > 1) range = ranges[++currIndex];
2022			const distLeft = Math.abs(x - range.left);
2023			const distRight = Math.abs(x - range.right);
2024			const minDist = Math.min(distLeft, distRight);
2025			const signedDistance = range.isDash ? minDist : -minDist;
2026			this.data[index + x] = Math.max(0, Math.min(255, signedDistance + 128));
2027		}
2028	}
2029	addDash(dasharray, round) {
2030		const n = round ? 7 : 0;
2031		const height = 2 * n + 1;
2032		if (this.nextRow + height > this.height) {
2033			warnOnce("LineAtlas out of space");
2034			return null;
2035		}
2036		let length = 0;
2037		for (const dash of dasharray) length += dash;
2038		if (length !== 0) {
2039			const stretch = this.width / length;
2040			const ranges = this.getDashRanges(dasharray, this.width, stretch);
2041			if (round) this.addRoundDash(ranges, stretch, n);
2042			else this.addRegularDash(ranges);
2043		}
2044		const dashEntry = {
2045			y: this.nextRow + n,
2046			height: 2 * n,
2047			width: length
2048		};
2049		this.nextRow += height;
2050		this.dirty = true;
2051		return dashEntry;
2052	}
2053	bind(context) {
2054		const gl = context.gl;
2055		if (!this.texture) {
2056			this.texture = gl.createTexture();
2057			gl.bindTexture(gl.TEXTURE_2D, this.texture);
2058			gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT);
2059			gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT);
2060			gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
2061			gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
2062			gl.texImage2D(gl.TEXTURE_2D, 0, gl.ALPHA, this.width, this.height, 0, gl.ALPHA, gl.UNSIGNED_BYTE, this.data);
2063		} else {
2064			gl.bindTexture(gl.TEXTURE_2D, this.texture);
2065			if (this.dirty) {
2066				this.dirty = false;

2067				gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, this.width, this.height, gl.ALPHA, gl.UNSIGNED_BYTE, this.data);
2068			}
2069		}
2070	}
2071};
2072//#endregion
2073//#region src/util/web_worker.ts
2074function isCrossOrigin(url) {
2075	if (!url) return false;
2076	const loc = globalThis.location;
2077	if (!loc) return false;
2078	try {
2079		return new URL(url, loc.href).origin !== loc.origin;
2080	} catch {
2081		return false;
2082	}
2083}
2084function defaultWorkerUrl() {
2085	const moduleUrl = import.meta.url;
2086	if (!/^https?:/.test(moduleUrl)) return "";
2087	const workerName = moduleUrl.endsWith("-dev.mjs") ? "maplibre-gl-worker-dev.mjs" : "maplibre-gl-worker.mjs";
2088	return new URL(`./${workerName}`, moduleUrl).href;
2089}
2090function createWorker(url, asModule) {
2091	if (asModule) try {
2092		return new Worker(url, { type: "module" });
2093	} catch (e) {
2094		console.warn("Module worker not supported, falling back to classic worker", e);
2095	}
2096	return new Worker(url);
2097}
2098async function fetchAsBlobUrl(url) {
2099	const response = await fetch(url);
2100	if (!response.ok) throw new Error(`Failed to fetch worker script (${response.status}): ${url}`);
2101	const code = await response.text();
2102	const blob = new Blob([code], { type: "text/javascript" });
2103	return URL.createObjectURL(blob);
2104}
2105function importAsBlobUrl(url) {
2106	const blob = new Blob([`import ${JSON.stringify(new URL(url, import.meta.url).href)}`], { type: "text/javascript" });
2107	return URL.createObjectURL(blob);
2108}
2109async function workerFactory() {
2110	const url = config.WORKER_URL || defaultWorkerUrl();
2111	const asModule = url?.endsWith(".cjs") ? false : true;
2112	if (!isCrossOrigin(url)) return createWorker(url, asModule);
2113	if (asModule) {
2114		const blobUrl = importAsBlobUrl(url);
2115		try {
2116			return createWorker(blobUrl, asModule);
2117		} finally {
2118			URL.revokeObjectURL(blobUrl);
2119		}
2120	}
2121	const blobUrl = await fetchAsBlobUrl(url);
2122	try {
2123		return createWorker(blobUrl, asModule);
2124	} finally {
2125		URL.revokeObjectURL(blobUrl);
2126	}
2127}
2128//#endregion
2129//#region src/util/worker_pool.ts
2130const PRELOAD_POOL_ID = "maplibre_preloaded_worker_pool";
2131/**
2132* Constructs a worker pool.
2133*/
2134var WorkerPool = class WorkerPool {
2135	constructor() {
2136		this.active = {};
2137		this.workersPromise = null;
2138	}
2139	async acquire(mapId) {
2140		this.active[mapId] = true;
2141		if (!this.workersPromise) {
2142			const promises = [];
2143			while (promises.length < WorkerPool.workerCount) promises.push(workerFactory());
2144			this.workersPromise = Promise.all(promises);
2145		}
2146		return (await this.workersPromise).slice();
2147	}
2148	release(mapId) {
2149		delete this.active[mapId];
2150		if (this.numActive() === 0 && this.workersPromise) {
2151			const promise = this.workersPromise;
2152			this.workersPromise = null;
2153			promise.then((workers) => {
2154				for (const w of workers) w.terminate();
2155			});
2156		}
2157	}
2158	isPreloaded() {
2159		return !!this.active[PRELOAD_POOL_ID];
2160	}
2161	numActive() {
2162		return Object.keys(this.active).length;
2163	}
2164};
2165const availableLogicalProcessors = Math.floor(browser.hardwareConcurrency / 2);
2166WorkerPool.workerCount = isSafari(globalThis) ? Math.max(Math.min(availableLogicalProcessors, 3), 1) : 1;
2167//#endregion
2168//#region src/util/global_worker_pool.ts
2169let globalWorkerPool;
2170/**
2171* Creates (if necessary) and returns the single, global WorkerPool instance
2172* to be shared across each Map
2173*/
2174function getGlobalWorkerPool() {
2175	globalWorkerPool ||= new WorkerPool();
2176	return globalWorkerPool;
2177}
2178/**
2179* Initializes resources like WebWorkers that can be shared across maps to lower load
2180* times in some situations. `setWorkerUrl()` and `setWorkerCount()`, if being
2181* used, must be set before `prewarm()` is called to have an effect.
2182*
2183* By default, the lifecycle of these resources is managed automatically, and they are
2184* lazily initialized when a Map is first created. By invoking `prewarm()`, these
2185* resources will be created ahead of time, and will not be cleared when the last Map
2186* is removed from the page. This allows them to be re-used by new Map instances that
2187* are created later. They can be manually cleared by calling
2188* `clearPrewarmedResources()`. This is only necessary if your web page remains
2189* active but stops using maps altogether.
2190*
2191* This is primarily useful when using GL-JS maps in a single page app, wherein a user
2192* would navigate between various views that can cause Map instances to constantly be
2193* created and destroyed.
2194*
2195* @example
2196* ```ts
2197* prewarm()
2198* ```
2199*/
2200function prewarm() {
2201	getGlobalWorkerPool().acquire(PRELOAD_POOL_ID);
2202}
2203/**
2204* Clears up resources that have previously been created by `prewarm()`.
2205* Note that this is typically not necessary. You should only call this function
2206* if you expect the user of your app to not return to a Map view at any point
2207* in your application.
2208*
2209* @example
2210* ```ts
2211* clearPrewarmedResources()
2212* ```
2213*/
2214function clearPrewarmedResources() {
2215	const pool = globalWorkerPool;
2216	if (pool) {
2217		if (pool.isPreloaded() && pool.numActive() === 1) {
2218			pool.release(PRELOAD_POOL_ID);
2219			globalWorkerPool = null;
2220		} else console.warn("Could not clear WebWorkers since there are active Map instances that still reference it. The pre-warmed WebWorker pool can only be cleared when all map instances have been removed with map.remove()");
2221	}
2222}
2223//#endregion
2224//#region src/util/dispatcher.ts
2225/**
2226* Responsible for sending messages from a {@link Source} to an associated worker source (usually with the same name).
2227*/
2228var Dispatcher = class extends Evented {
2229	constructor(workerPool, mapId) {
2230		super();
2231		this.workerPool = workerPool;
2232		this.actors = [];
2233		this.currentActor = 0;
2234		this.id = mapId;
2235		this.removed = false;
2236		this.workerErrorSubscriptions = [];
2237		this.actorsPromise = this.initActors(mapId);
2238	}
2239	async initActors(mapId) {
2240		const workers = await this.workerPool.acquire(mapId);
2241		if (this.removed) return [];
2242		this.actors = workers.map((worker, i) => {
2243			this.workerErrorSubscriptions.push(subscribe(worker, "error", () => {
2244				this.fire(new ErrorEvent(/* @__PURE__ */ new Error("Worker failed to load. Check that the worker URL is correct.")));
2245			}, false));
2246			const actor = new Actor(worker, mapId);
2247			actor.name = `Worker ${i}`;
2248			return actor;
2249		});
2250		if (!this.actors.length) throw new Error("No actors found");
2251		return this.actors;
2252	}
2253	/**
2254	* Broadcast a message to all Workers.
2255	*/
2256	async broadcast(type, data) {
2257		const actors = await this.actorsPromise;
2258		return Promise.all(actors.map((actor) => actor.sendAsync({
2259			type,
2260			data
2261		})));
2262	}
2263	/**
2264	* Acquires an actor to dispatch messages to. The actors are distributed in round-robin fashion.
2265	* @returns An actor object backed by a web worker for processing messages.
2266	*/
2267	async getActor() {
2268		const actors = await this.actorsPromise;
2269		this.currentActor = (this.currentActor + 1) % actors.length;
2270		return actors[this.currentActor];
2271	}
2272	async waitForInitComplete() {
2273		if (this.actors.length === 0) await this.actorsPromise;
2274	}
2275	getReadyActor() {
2276		this.currentActor = (this.currentActor + 1) % this.actors.length;
2277		return this.actors[this.currentActor];
2278	}
2279	remove(mapRemoved = true) {
2280		this.removed = true;
2281		for (const actor of this.actors) actor.remove();
2282		for (const subscription of this.workerErrorSubscriptions) subscription.unsubscribe();
2283		this.actors = [];
2284		this.workerErrorSubscriptions = [];
2285		this.setEventedParent(null);
2286		if (mapRemoved) this.workerPool.release(this.id);
2287	}
2288	async registerMessageHandler(type, handler) {
2289		const actors = await this.actorsPromise;
2290		for (const actor of actors) actor.registerMessageHandler(type, handler);
2291	}
2292	async unregisterMessageHandler(type) {
2293		const actors = await this.actorsPromise;
2294		for (const actor of actors) actor.unregisterMessageHandler(type);
2295	}
2296};
2297let globalDispatcher;
2298/**
2299* This function is used to get the global dispatcher that is shared across all maps instances.
2300* It is used by the main thread to send messages to the workers, and by the workers to send messages back to the main thread.
2301* If you import a script into the worker and need to send a message to the workers to pass some parameters for example,
2302* you can use this function to get the global dispatcher and send a message to the workers.
2303* @returns The global dispatcher instance.
2304*/
2305function getGlobalDispatcher() {
2306	if (!globalDispatcher) {
2307		globalDispatcher = new Dispatcher(getGlobalWorkerPool(), GLOBAL_DISPATCHER_ID);
2308		globalDispatcher.registerMessageHandler("GR", (_mapId, params, abortController) => {
2309			return makeRequest(params, abortController);
2310		});
2311	}
2312	return globalDispatcher;
2313}
2314//#endregion
2315//#region src/source/query_features.ts
2316function getPixelPosMatrix(transform, tileID) {
2317	const t = create$1();
2318	translate(t, t, [
2319		1,
2320		1,
2321		0
2322	]);
2323	scale(t, t, [
2324		transform.width * .5,
2325		transform.height * .5,
2326		1
2327	]);
2328	if (transform.calculatePosMatrix) return multiply(t, t, transform.calculatePosMatrix(tileID.toUnwrapped()));
2329	else return t;
2330}
2331function queryIncludes3DLayer(layers, styleLayers, sourceID) {
2332	if (layers) for (const layerID of layers) {
2333		const layer = styleLayers[layerID];
2334		if (layer?.source === sourceID && layer.type === "fill-extrusion") return true;
2335	}
2336	else for (const key in styleLayers) {
2337		const layer = styleLayers[key];
2338		if (layer.source === sourceID && layer.type === "fill-extrusion") return true;
2339	}
2340	return false;
2341}
2342function queryRenderedFeatures(tileManager, styleLayers, serializedLayers, queryGeometry, params, transform, getElevation) {
2343	const has3DLayer = queryIncludes3DLayer(params?.layers ?? null, styleLayers, tileManager.id);
2344	const maxPitchScaleFactor = transform.maxPitchScaleFactor();
2345	const tilesIn = tileManager.tilesIn(queryGeometry, maxPitchScaleFactor, has3DLayer);
2346	tilesIn.sort(sortTilesIn);
2347	const renderedFeatureLayers = [];
2348	for (const tileIn of tilesIn) renderedFeatureLayers.push({
2349		wrappedTileID: tileIn.tileID.wrapped().key,
2350		queryResults: tileIn.tile.queryRenderedFeatures(styleLayers, serializedLayers, tileManager.getState(), tileIn.queryGeometry, tileIn.cameraQueryGeometry, tileIn.scale, params, transform, maxPitchScaleFactor, getPixelPosMatrix(transform, tileIn.tileID), getElevation ? (x, y) => getElevation(tileIn.tileID, x, y) : void 0)
2351	});
2352	return convertFeaturesToMapFeatures(mergeRenderedFeatureLayers(renderedFeatureLayers), tileManager);
2353}
2354function queryRenderedSymbols(styleLayers, serializedLayers, tileManagers, queryGeometry, params, collisionIndex, retainedQueryData) {
2355	const result = {};
2356	const renderedSymbols = collisionIndex.queryRenderedSymbols(queryGeometry);
2357	const bucketQueryData = [];
2358	for (const bucketInstanceId of Object.keys(renderedSymbols).map(Number)) bucketQueryData.push(retainedQueryData[bucketInstanceId]);
2359	bucketQueryData.sort(sortTilesIn);
2360	for (const queryData of bucketQueryData) {
2361		const bucketSymbols = queryData.featureIndex.lookupSymbolFeatures(renderedSymbols[queryData.bucketInstanceId], serializedLayers, queryData.bucketIndex, queryData.sourceLayerIndex, {
2362			filterSpec: params.filter,
2363			globalState: params.globalState
2364		}, params.layers, params.availableImages, styleLayers);
2365		for (const layerID in bucketSymbols) {
2366			result[layerID] ||= [];
2367			const layerSymbols = bucketSymbols[layerID];
2368			layerSymbols.sort((a, b) => {
2369				const featureSortOrder = queryData.featureSortOrder;
2370				if (featureSortOrder) {
2371					const sortedA = featureSortOrder.indexOf(a.featureIndex);
2372					return featureSortOrder.indexOf(b.featureIndex) - sortedA;
2373				} else return b.featureIndex - a.featureIndex;
2374			});
2375			for (const symbolFeature of layerSymbols) result[layerID].push(symbolFeature);
2376		}
2377	}
2378	return convertFeaturesToMapFeaturesMultiple(result, styleLayers, tileManagers);
2379}
2380function querySourceFeatures(tileManager, params) {
2381	const tiles = tileManager.getRenderableIds().map((id) => {
2382		return tileManager.getTileByID(id);
2383	});
2384	const result = [];
2385	const dataTiles = {};
2386	for (const tile of tiles) {
2387		const dataID = tile.tileID.canonical.key;
2388		if (!dataTiles[dataID]) {
2389			dataTiles[dataID] = true;
2390			tile.querySourceFeatures(result, params);
2391		}
2392	}
2393	return result;
2394}
2395function sortTilesIn(a, b) {
2396	const idA = a.tileID;
2397	const idB = b.tileID;
2398	return idA.overscaledZ - idB.overscaledZ || idA.canonical.y - idB.canonical.y || idA.wrap - idB.wrap || idA.canonical.x - idB.canonical.x;
2399}
2400function mergeRenderedFeatureLayers(tiles) {
2401	const result = {};
2402	const wrappedIDLayerMap = {};
2403	for (const { queryResults, wrappedTileID } of tiles) {
2404		wrappedIDLayerMap[wrappedTileID] ||= {};
2405		const wrappedIDLayers = wrappedIDLayerMap[wrappedTileID];
2406		for (const layerID in queryResults) {
2407			const tileFeatures = queryResults[layerID];
2408			wrappedIDLayers[layerID] ||= {};
2409			const wrappedIDFeatures = wrappedIDLayers[layerID];
2410			result[layerID] ||= [];
2411			for (const tileFeature of tileFeatures) if (!wrappedIDFeatures[tileFeature.featureIndex]) {
2412				wrappedIDFeatures[tileFeature.featureIndex] = true;
2413				result[layerID].push(tileFeature);
2414			}
2415		}
2416	}
2417	return result;
2418}
2419function convertFeaturesToMapFeatures(result, tileManager) {
2420	for (const layerID in result) for (const featureWrapper of result[layerID]) convertFeatureToMapFeature(featureWrapper, tileManager);
2421	return result;
2422}
2423function convertFeaturesToMapFeaturesMultiple(result, styleLayers, tileManagers) {
2424	for (const layerName in result) for (const featureWrapper of result[layerName]) {
2425		const tileManager = tileManagers[styleLayers[layerName].source];
2426		convertFeatureToMapFeature(featureWrapper, tileManager);
2427	}
2428	return result;
2429}
2430function convertFeatureToMapFeature(featureWrapper, tileManager) {
2431	const feature = featureWrapper.feature;
2432	const state = tileManager.getFeatureState(feature.layer["source-layer"], feature.id);
2433	feature.source = feature.layer.source;
2434	if (feature.layer["source-layer"]) feature.sourceLayer = feature.layer["source-layer"];
2435	feature.state = state;
2436}
2437//#endregion
2438//#region src/source/load_tilejson.ts
2439async function loadTileJson(options, requestManager, abortController, targetWindow) {
2440	let tileJSON = options;
2441	if (options.url) tileJSON = (await getJSON(await requestManager.transformRequest(options.url, "Source"), abortController)).data;
2442	else await browser.frameAsync(abortController, targetWindow);
2443	if (!tileJSON) return null;
2444	const result = pick(extend(tileJSON, options), [
2445		"tiles",
2446		"minzoom",
2447		"maxzoom",
2448		"attribution",
2449		"bounds",
2450		"scheme",
2451		"tileSize",
2452		"encoding"
2453	]);
2454	if ("vector_layers" in tileJSON && tileJSON.vector_layers) result.vectorLayerIds = tileJSON.vector_layers.map((layer) => layer.id);
2455	return result;
2456}
2457//#endregion
2458//#region src/geo/lng_lat_bounds.ts
2459/**
2460* A `LngLatBounds` object represents a geographical bounding box,
2461* defined by its southwest and northeast points in longitude and latitude.
2462*
2463* If no arguments are provided to the constructor, a `null` bounding box is created.
2464*
2465* Note that any MapLibre GL method that accepts a `LngLatBounds` object as an argument or option
2466* can also accept an `Array` of two {@link LngLatLike} constructs and will perform an implicit conversion.
2467* This flexible type is documented as {@link LngLatBoundsLike}.
2468*
2469* @group Geography and Geometry
2470*
2471* @example
2472* ```ts
2473* let sw = new LngLat(-73.9876, 40.7661);
2474* let ne = new LngLat(-73.9397, 40.8002);
2475* let llb = new LngLatBounds(sw, ne);
2476* ```
2477* @see [Fit to the bounds of a LineString](https://maplibre.org/maplibre-gl-js/docs/examples/fit-to-the-bounds-of-a-linestring/)
2478*/
2479var LngLatBounds = class LngLatBounds {
2480	/**
2481	* @param sw - The southwest corner of the bounding box.
2482	* OR array of 4 numbers in the order of  west, south, east, north
2483	* OR array of 2 LngLatLike: `[sw, ne]`
2484	* @param ne - The northeast corner of the bounding box.
2485	* @example
2486	* ```ts
2487	* let sw = new LngLat(-73.9876, 40.7661);
2488	* let ne = new LngLat(-73.9397, 40.8002);
2489	* let llb = new LngLatBounds(sw, ne);
2490	* ```
2491	* OR
2492	* ```ts
2493	* let llb = new LngLatBounds([-73.9876, 40.7661, -73.9397, 40.8002]);
2494	* ```
2495	* OR
2496	* ```ts
2497	* let llb = new LngLatBounds([sw, ne]);
2498	* ```
2499	*/
2500	constructor(sw, ne) {
2501		if (!sw) {} else if (ne) this.setSouthWest(sw).setNorthEast(ne);
2502		else if (Array.isArray(sw)) {
2503			if (sw.length === 4) this.setSouthWest([sw[0], sw[1]]).setNorthEast([sw[2], sw[3]]);
2504			else this.setSouthWest(sw[0]).setNorthEast(sw[1]);
2505		}
2506	}
2507	/**
2508	* Set the northeast corner of the bounding box
2509	*
2510	* @param ne - a {@link LngLatLike} object describing the northeast corner of the bounding box.
2511	*/
2512	setNorthEast(ne) {
2513		this._ne = ne instanceof LngLat ? new LngLat(ne.lng, ne.lat) : LngLat.convert(ne);
2514		return this;
2515	}
2516	/**
2517	* Set the southwest corner of the bounding box
2518	*
2519	* @param sw - a {@link LngLatLike} object describing the southwest corner of the bounding box.
2520	*/
2521	setSouthWest(sw) {
2522		this._sw = sw instanceof LngLat ? new LngLat(sw.lng, sw.lat) : LngLat.convert(sw);
2523		return this;
2524	}
2525	/**
2526	* Extend the bounds to include a given LngLatLike or LngLatBoundsLike.
2527	*
2528	* @param obj - object to extend to
2529	*/
2530	extend(obj) {
2531		const sw = this._sw, ne = this._ne;
2532		let sw2, ne2;
2533		if (obj instanceof LngLat) {
2534			sw2 = obj;
2535			ne2 = obj;
2536		} else if (obj instanceof LngLatBounds) {
2537			sw2 = obj._sw;
2538			ne2 = obj._ne;
2539			if (!sw2 || !ne2) return this;
2540		} else {
2541			if (Array.isArray(obj)) {
2542				if (obj.length === 4 || obj.every(Array.isArray)) {
2543					const lngLatBoundsObj = obj;
2544					return this.extend(LngLatBounds.convert(lngLatBoundsObj));
2545				} else {
2546					const lngLatObj = obj;
2547					return this.extend(LngLat.convert(lngLatObj));
2548				}
2549			} else if (obj && ("lng" in obj || "lon" in obj) && "lat" in obj) return this.extend(LngLat.convert(obj));
2550			return this;
2551		}
2552		if (!sw && !ne) {
2553			this._sw = new LngLat(sw2.lng, sw2.lat);
2554			this._ne = new LngLat(ne2.lng, ne2.lat);
2555		} else {
2556			sw.lng = Math.min(sw2.lng, sw.lng);
2557			sw.lat = Math.min(sw2.lat, sw.lat);
2558			ne.lng = Math.max(ne2.lng, ne.lng);
2559			ne.lat = Math.max(ne2.lat, ne.lat);
2560		}
2561		return this;
2562	}
2563	/**
2564	* Returns the geographical coordinate equidistant from the bounding box's corners.
2565	*
2566	* @returns The bounding box's center.
2567	* @example
2568	* ```ts
2569	* let llb = new LngLatBounds([-73.9876, 40.7661], [-73.9397, 40.8002]);
2570	* llb.getCenter(); // = LngLat {lng: -73.96365, lat: 40.78315}
2571	* ```
2572	*/
2573	getCenter() {
2574		return new LngLat((this._sw.lng + this._ne.lng) / 2, (this._sw.lat + this._ne.lat) / 2);
2575	}
2576	/**
2577	* Returns the southwest corner of the bounding box.
2578	*
2579	* @returns The southwest corner of the bounding box.
2580	*/
2581	getSouthWest() {
2582		return this._sw;
2583	}
2584	/**
2585	* Returns the northeast corner of the bounding box.
2586	*
2587	* @returns The northeast corner of the bounding box.
2588	*/
2589	getNorthEast() {
2590		return this._ne;
2591	}
2592	/**
2593	* Returns the northwest corner of the bounding box.
2594	*
2595	* @returns The northwest corner of the bounding box.
2596	*/
2597	getNorthWest() {
2598		return new LngLat(this.getWest(), this.getNorth());
2599	}
2600	/**
2601	* Returns the southeast corner of the bounding box.
2602	*
2603	* @returns The southeast corner of the bounding box.
2604	*/
2605	getSouthEast() {
2606		return new LngLat(this.getEast(), this.getSouth());
2607	}
2608	/**
2609	* Returns the west edge of the bounding box.
2610	*
2611	* @returns The west edge of the bounding box.
2612	*/
2613	getWest() {
2614		return this._sw.lng;
2615	}
2616	/**
2617	* Returns the south edge of the bounding box.
2618	*
2619	* @returns The south edge of the bounding box.
2620	*/
2621	getSouth() {
2622		return this._sw.lat;
2623	}
2624	/**
2625	* Returns the east edge of the bounding box.
2626	*
2627	* @returns The east edge of the bounding box.
2628	*/
2629	getEast() {
2630		return this._ne.lng;
2631	}
2632	/**
2633	* Returns the north edge of the bounding box.
2634	*
2635	* @returns The north edge of the bounding box.
2636	*/
2637	getNorth() {
2638		return this._ne.lat;
2639	}
2640	/**
2641	* Returns the bounding box represented as an array.
2642	*
2643	* @returns The bounding box represented as an array, consisting of the
2644	* southwest and northeast coordinates of the bounding represented as arrays of numbers.
2645	* @example
2646	* ```ts
2647	* let llb = new LngLatBounds([-73.9876, 40.7661], [-73.9397, 40.8002]);
2648	* llb.toArray(); // = [[-73.9876, 40.7661], [-73.9397, 40.8002]]
2649	* ```
2650	*/
2651	toArray() {
2652		return [this._sw.toArray(), this._ne.toArray()];
2653	}
2654	/**
2655	* Return the bounding box represented as a string.
2656	*
2657	* @returns The bounding box represents as a string of the format
2658	* `'LngLatBounds(LngLat(lng, lat), LngLat(lng, lat))'`.
2659	* @example
2660	* ```ts
2661	* let llb = new LngLatBounds([-73.9876, 40.7661], [-73.9397, 40.8002]);
2662	* llb.toString(); // = "LngLatBounds(LngLat(-73.9876, 40.7661), LngLat(-73.9397, 40.8002))"
2663	* ```
2664	*/
2665	toString() {
2666		return `LngLatBounds(${this._sw.toString()}, ${this._ne.toString()})`;
2667	}
2668	/**
2669	* Check if the bounding box is an empty/`null`-type box.
2670	*
2671	* @returns True if bounds have been defined, otherwise false.
2672	*/
2673	isEmpty() {
2674		return !(this._sw && this._ne);
2675	}
2676	/**
2677	* Check if the point is within the bounding box.
2678	*
2679	* @param lnglat - geographic point to check against.
2680	* @returns `true` if the point is within the bounding box.
2681	* @example
2682	* ```ts
2683	* let llb = new LngLatBounds(
2684	*   new LngLat(-73.9876, 40.7661),
2685	*   new LngLat(-73.9397, 40.8002)
2686	* );
2687	*
2688	* let ll = new LngLat(-73.9567, 40.7789);
2689	*
2690	* console.log(llb.contains(ll)); // = true
2691	* ```
2692	*/
2693	contains(lnglat) {
2694		const { lng, lat } = LngLat.convert(lnglat);
2695		const containsLatitude = this._sw.lat <= lat && lat <= this._ne.lat;
2696		let containsLongitude = this._sw.lng <= lng && lng <= this._ne.lng;
2697		if (this._sw.lng > this._ne.lng) containsLongitude = this._sw.lng >= lng && lng >= this._ne.lng;
2698		return containsLatitude && containsLongitude;
2699	}
2700	/**
2701	* Checks if this bounding box intersects with another bounding box.
2702	*
2703	* Returns true if the bounding boxes share any area, including cases where
2704	* they only touch along an edge or at a corner.
2705	*
2706	* This method properly handles cases where either or both bounding boxes cross
2707	* the antimeridian (date line).
2708	*/
2709	intersects(other) {
2710		other = LngLatBounds.convert(other);
2711		if (!(other.getNorth() >= this.getSouth() && other.getSouth() <= this.getNorth())) return false;
2712		const thisSpan = Math.abs(this.getEast() - this.getWest());
2713		const otherSpan = Math.abs(other.getEast() - other.getWest());
2714		if (thisSpan >= 360 || otherSpan >= 360) return true;
2715		const thisWest = wrap(this.getWest(), -180, 180);
2716		const thisEast = wrap(this.getEast(), -180, 180);
2717		const otherWest = wrap(other.getWest(), -180, 180);
2718		const otherEast = wrap(other.getEast(), -180, 180);
2719		const thisWraps = thisWest > thisEast;
2720		const otherWraps = otherWest > otherEast;
2721		if (thisWraps && otherWraps) return true;
2722		if (thisWraps) return otherEast >= thisWest || otherWest <= thisEast;
2723		if (otherWraps) return thisEast >= otherWest || thisWest <= otherEast;
2724		return otherWest <= thisEast && otherEast >= thisWest;
2725	}
2726	/**
2727	* Converts an array to a `LngLatBounds` object.
2728	*
2729	* If a `LngLatBounds` object is passed in, the function returns it unchanged.
2730	*
2731	* Internally, the function calls {@link LngLat.convert} to convert arrays to `LngLat` values.
2732	*
2733	* @param input - An array of two coordinates to convert, or a `LngLatBounds` object to return.
2734	* @returns A new `LngLatBounds` object, if a conversion occurred, or the original `LngLatBounds` object.
2735	* @example
2736	* ```ts
2737	* let arr = [[-73.9876, 40.7661], [-73.9397, 40.8002]];
2738	* let llb = LngLatBounds.convert(arr); // = LngLatBounds {_sw: LngLat {lng: -73.9876, lat: 40.7661}, _ne: LngLat {lng: -73.9397, lat: 40.8002}}
2739	* ```
2740	*/
2741	static convert(input) {
2742		if (input instanceof LngLatBounds) return input;
2743		if (!input) return input;
2744		return new LngLatBounds(input);
2745	}
2746	/**
2747	* Returns a `LngLatBounds` from the coordinates extended by a given `radius`. The returned `LngLatBounds` completely contains the `radius`.
2748	*
2749	* @param center - center coordinates of the new bounds.
2750	* @param radius - Distance in meters from the coordinates to extend the bounds.
2751	* @returns A new `LngLatBounds` object representing the coordinates extended by the `radius`.
2752	* @example
2753	* ```ts
2754	* let center = new LngLat(-73.9749, 40.7736);
2755	* LngLatBounds.fromLngLat(100).toArray(); // = [[-73.97501862141328, 40.77351016847229], [-73.97478137858673, 40.77368983152771]]
2756	* ```
2757	*/
2758	static fromLngLat(center, radius = 0) {
2759		const latAccuracy = 360 * radius / 40075017, lngAccuracy = latAccuracy / Math.cos(Math.PI / 180 * center.lat);
2760		return new LngLatBounds(new LngLat(center.lng - lngAccuracy, center.lat - latAccuracy), new LngLat(center.lng + lngAccuracy, center.lat + latAccuracy));
2761	}
2762	/**
2763	* Adjusts the given bounds to handle the case where the bounds cross the 180th meridian (antimeridian).
2764	*
2765	* @returns The adjusted LngLatBounds
2766	* @example
2767	* ```ts
2768	* let bounds = new LngLatBounds([175.813127, -20.157768], [-178. 340903, -15.449124]);
2769	* let adjustedBounds = bounds.adjustAntiMeridian();
2770	* // adjustedBounds will be: [[175.813127, -20.157768], [181.659097, -15.449124]]
2771	* ```
2772	*/
2773	adjustAntiMeridian() {
2774		const sw = new LngLat(this._sw.lng, this._sw.lat);
2775		const ne = new LngLat(this._ne.lng, this._ne.lat);
2776		if (sw.lng > ne.lng) return new LngLatBounds(sw, new LngLat(ne.lng + 360, ne.lat));
2777		return new LngLatBounds(sw, ne);
2778	}
2779};
2780//#endregion
2781//#region src/tile/tile_bounds.ts
2782var TileBounds = class {
2783	constructor(bounds, minzoom, maxzoom) {
2784		this.bounds = LngLatBounds.convert(this.validateBounds(bounds));
2785		this.minzoom = minzoom || 0;
2786		this.maxzoom = maxzoom || 24;
2787	}
2788	validateBounds(bounds) {
2789		if (!Array.isArray(bounds) || bounds.length !== 4) return [
2790			-180,
2791			-90,
2792			180,
2793			90
2794		];
2795		return [
2796			Math.max(-180, bounds[0]),
2797			Math.max(-90, bounds[1]),
2798			Math.min(180, bounds[2]),
2799			Math.min(90, bounds[3])
2800		];
2801	}
2802	contains(tileID) {
2803		const worldSize = Math.pow(2, tileID.z);
2804		const level = {
2805			minX: Math.floor(mercatorXfromLng(this.bounds.getWest()) * worldSize),
2806			minY: Math.floor(mercatorYfromLat(this.bounds.getNorth()) * worldSize),
2807			maxX: Math.ceil(mercatorXfromLng(this.bounds.getEast()) * worldSize),
2808			maxY: Math.ceil(mercatorYfromLat(this.bounds.getSouth()) * worldSize)
2809		};
2810		return tileID.x >= level.minX && tileID.x < level.maxX && tileID.y >= level.minY && tileID.y < level.maxY;
2811	}
2812};
2813//#endregion
2814//#region src/source/vector_tile_source.ts
2815/**
2816* A source containing vector tiles in [Maplibre Vector Tile format](https://maplibre.org/maplibre-tile-spec/) or [Mapbox Vector Tile format](https://docs.mapbox.com/vector-tiles/reference/).
2817* (See the [Style Specification](https://maplibre.org/maplibre-style-spec/) for detailed documentation of options.)
2818*
2819* @group Sources
2820*
2821* @example
2822* ```ts
2823* map.addSource('some id', {
2824*     type: 'vector',
2825*     url: 'https://demotiles.maplibre.org/tiles/tiles.json'
2826* });
2827* ```
2828*
2829* @example
2830* ```ts
2831* map.addSource('some id', {
2832*     type: 'vector',
2833*     tiles: ['https://d25uarhxywzl1j.cloudfront.net/v0.1/{z}/{x}/{y}.mvt'],
2834*     minzoom: 6,
2835*     maxzoom: 14
2836* });
2837* ```
2838*
2839* @example
2840* ```ts
2841* map.getSource('some id').setUrl("https://demotiles.maplibre.org/tiles/tiles.json");
2842* ```
2843*
2844* @example
2845* ```ts
2846* map.getSource('some id').setTiles(['https://d25uarhxywzl1j.cloudfront.net/v0.1/{z}/{x}/{y}.mvt']);
2847* ```
2848* @see [Add a vector tile source](https://maplibre.org/maplibre-gl-js/docs/examples/add-a-vector-tile-source/)
2849*/
2850var VectorTileSource = class extends Evented {
2851	constructor(id, options, dispatcher, eventedParent) {
2852		super();
2853		this.id = id;
2854		this.dispatcher = dispatcher;
2855		this.type = "vector";
2856		this.minzoom = 0;
2857		this.maxzoom = 22;
2858		this.scheme = "xyz";
2859		this.tileSize = 512;
2860		this.reparseOverscaled = true;
2861		this.isTileClipped = true;
2862		this._loaded = false;
2863		extend(this, pick(options, [
2864			"url",
2865			"scheme",
2866			"tileSize",
2867			"promoteId",
2868			"encoding"
2869		]));
2870		this._options = extend({ type: "vector" }, options);
2871		this._collectResourceTiming = options.collectResourceTiming;
2872		if (this.tileSize !== 512) throw new Error("vector tile sources must have a tileSize of 512");
2873		this.setEventedParent(eventedParent);
2874	}
2875	async load(sourceDataChanged = false) {
2876		this._loaded = false;
2877		this.fire(new MapSourceDataEvent("dataloading"));
2878		this._tileJSONRequest = new AbortController();
2879		try {
2880			const tileJSON = await loadTileJson(this._options, this.map._requestManager, this._tileJSONRequest, this.map._ownerWindow);
2881			this._tileJSONRequest = null;
2882			this._loaded = true;
2883			if (tileJSON) {
2884				extend(this, tileJSON);
2885				if (tileJSON.bounds) this.tileBounds = new TileBounds(tileJSON.bounds, this.minzoom, this.maxzoom);
2886				this.fire(new MapSourceDataEvent("data", { sourceDataType: "metadata" }));
2887				this.fire(new MapSourceDataEvent("data", {
2888					sourceDataType: "content",
2889					sourceDataChanged
2890				}));
2891			}
2892		} catch (err) {
2893			this._tileJSONRequest = null;
2894			this._loaded = true;
2895			if (!isAbortError(err)) this.fire(new ErrorEvent(ensureError(err)));
2896		}
2897	}
2898	loaded() {
2899		return this._loaded;
2900	}
2901	hasTile(tileID) {
2902		return !this.tileBounds || this.tileBounds.contains(tileID.canonical);
2903	}
2904	onAdd(map) {
2905		this.map = map;
2906		this.load();
2907	}
2908	setSourceProperty(callback) {
2909		if (this._tileJSONRequest) this._tileJSONRequest.abort();
2910		callback();
2911		this.load(true);
2912	}
2913	/**
2914	* Sets the source `tiles` property and re-renders the map.
2915	*
2916	* @param tiles - An array of one or more tile source URLs, as in the TileJSON spec.
2917	*/
2918	setTiles(tiles) {
2919		this.setSourceProperty(() => {
2920			this.tiles = tiles;
2921			this._options.tiles = tiles;
2922		});
2923		return this;
2924	}
2925	/**
2926	* Sets the source `url` property and re-renders the map.
2927	*
2928	* @param url - A URL to a TileJSON resource. Supported protocols are `http:` and `https:`.
2929	*/
2930	setUrl(url) {
2931		this.setSourceProperty(() => {
2932			this.url = url;
2933			this._options.url = url;
2934		});
2935		return this;
2936	}
2937	onRemove() {
2938		if (this._tileJSONRequest) {
2939			this._tileJSONRequest.abort();
2940			this._tileJSONRequest = null;
2941		}
2942	}
2943	serialize() {
2944		return extend({}, this._options);
2945	}
2946	async loadTile(tile) {
2947		const url = tile.tileID.canonical.url(this.tiles, this.map.getPixelRatio(), this.scheme);
2948		const params = {
2949			request: await this.map._requestManager.transformRequest(url, "Tile"),
2950			uid: tile.uid,
2951			tileID: tile.tileID,
2952			zoom: tile.tileID.overscaledZ,
2953			tileSize: this.tileSize * tile.tileID.overscaleFactor(),
2954			type: this.type,
2955			source: this.id,
2956			pixelRatio: this.map.getPixelRatio(),
2957			showCollisionBoxes: this.map.showCollisionBoxes,
2958			promoteId: this.promoteId,
2959			subdivisionGranularity: this.map.style.projection.subdivisionGranularity,
2960			encoding: this.encoding,
2961			overzoomParameters: await this._getOverzoomParameters(tile),
2962			etag: tile.etag
2963		};
2964		params.request.collectResourceTiming = this._collectResourceTiming;
2965		await this.dispatcher.waitForInitComplete();
2966		let messageType = "RT";
2967		if (!tile.actor || tile.state === "expired") {
2968			tile.actor = this.dispatcher.getReadyActor();
2969			messageType = "LT";
2970		} else if (tile.state === "loading") return new Promise((resolve, reject) => {
2971			tile.reloadPromise = {
2972				resolve,
2973				reject
2974			};
2975		});
2976		tile.abortController = new AbortController();
2977		try {
2978			const data = await tile.actor.sendAsync({
2979				type: messageType,
2980				data: params
2981			}, tile.abortController);
2982			delete tile.abortController;
2983			if (tile.aborted) return;
2984			this._afterTileLoadWorkerResponse(tile, data);
2985			const result = {};
2986			if (data?.etagUnmodified) result.unmodified = true;
2987			return result;
2988		} catch (err) {
2989			delete tile.abortController;
2990			if (tile.aborted || isAbortError(err)) return;
2991			if (err && err.status !== 404) throw err;
2992			this._afterTileLoadWorkerResponse(tile, null);
2993		}
2994	}
2995	/**
2996	* When the requested tile has a higher canonical Z than source maxzoom, pass overzoom parameters so worker can load the
2997	* deepest tile at source max zoom to generate sub tiles using geojsonvt for highest performance on vector overscaling
2998	*/
2999	async _getOverzoomParameters(tile) {
3000		if (tile.tileID.canonical.z <= this.maxzoom) return;
3001		if (this.map._zoomLevelsToOverscale === void 0) return;
3002		const maxZoomTileID = tile.tileID.scaledTo(this.maxzoom).canonical;
3003		const maxZoomTileUrl = maxZoomTileID.url(this.tiles, this.map.getPixelRatio(), this.scheme);
3004		return {
3005			maxZoomTileID,
3006			overzoomRequest: await this.map._requestManager.transformRequest(maxZoomTileUrl, "Tile")
3007		};
3008	}
3009	_afterTileLoadWorkerResponse(tile, data) {
3010		if (data?.resourceTiming) tile.resourceTiming = data.resourceTiming;
3011		if (data && this.map._refreshExpiredTiles) tile.setExpiryData(data);
3012		tile.etag = data?.etag;
3013		tile.loadVectorData(data, this.map.painter);
3014		if (tile.reloadPromise) {
3015			const reloadPromise = tile.reloadPromise;
3016			tile.reloadPromise = null;
3017			this.loadTile(tile).then(reloadPromise.resolve).catch(reloadPromise.reject);
3018		}
3019	}
3020	async abortTile(tile) {
3021		if (tile.abortController) {
3022			tile.abortController.abort();
3023			delete tile.abortController;
3024		}
3025		if (tile.actor) await tile.actor.sendAsync({
3026			type: "AT",
3027			data: {
3028				uid: tile.uid,
3029				type: this.type,
3030				source: this.id
3031			}
3032		});
3033	}
3034	async unloadTile(tile) {
3035		tile.unloadVectorData();
3036		if (tile.actor) await tile.actor.sendAsync({
3037			type: "RMT",
3038			data: {
3039				uid: tile.uid,
3040				type: this.type,
3041				source: this.id
3042			}
3043		});
3044	}
3045	hasTransition() {
3046		return false;
3047	}
3048};
3049//#endregion
3050//#region src/source/raster_tile_source.ts
3051/**
3052* A source containing raster tiles (See the [raster source documentation](https://maplibre.org/maplibre-style-spec/sources/#raster) for detailed documentation of options.)
3053*
3054* @group Sources
3055*
3056* \> ℹ️ **Note:** The default `tileSize` is `512`. If your tile provider (such as OpenStreetMap or Stadia Maps) serves 256px tiles, set `tileSize: 256` manually to avoid blurry rendering due to upscaling.
3057*
3058* @example
3059* ```ts
3060* map.addSource('raster-source', {
3061*     'type': 'raster',
3062*     'tiles': ['https://tiles.stadiamaps.com/tiles/stamen_watercolor/{z}/{x}/{y}.jpg'],
3063*     'tileSize': 256, // Set this to match tile server output to avoid blurry rendering
3064* });
3065* ```
3066*
3067* @example
3068* ```ts
3069* map.addSource('wms-test-source', {
3070*      'type': 'raster',
3071* // use the tiles option to specify a WMS tile source URL
3072*      'tiles': [
3073*          'https://img.nj.gov/imagerywms/Natural2015?bbox={bbox-epsg-3857}&format=image/png&service=WMS&version=1.1.1&request=GetMap&srs=EPSG:3857&transparent=true&width=256&height=256&layers=Natural2015'
3074*      ],
3075*      'tileSize': 256 // Important for WMS if tiles are 256px
3076* });
3077* ```
3078* @see [Add a raster tile source](https://maplibre.org/maplibre-gl-js/docs/examples/map-tiles/)
3079* @see [Add a WMS source](https://maplibre.org/maplibre-gl-js/docs/examples/add-a-wms-source/)
3080* @see [Display a satellite map](https://maplibre.org/maplibre-gl-js/docs/examples/display-a-satellite-map/)
3081*/
3082var RasterTileSource = class extends Evented {
3083	constructor(id, options, dispatcher, eventedParent) {
3084		super();
3085		this.id = id;
3086		this.dispatcher = dispatcher;
3087		this.setEventedParent(eventedParent);
3088		this.type = "raster";
3089		this.minzoom = 0;
3090		this.maxzoom = 22;
3091		this.roundZoom = true;
3092		this.scheme = "xyz";
3093		this.tileSize = 512;
3094		this._loaded = false;
3095		this._premultiplyAlpha = true;
3096		this._options = extend({ type: "raster" }, options);
3097		extend(this, pick(options, [
3098			"url",
3099			"scheme",
3100			"tileSize"
3101		]));
3102	}
3103	async load(sourceDataChanged = false) {
3104		this._loaded = false;
3105		this.fire(new MapSourceDataEvent("dataloading"));
3106		this._tileJSONRequest = new AbortController();
3107		try {
3108			const tileJSON = await loadTileJson(this._options, this.map._requestManager, this._tileJSONRequest, this.map._ownerWindow);
3109			this._tileJSONRequest = null;
3110			this._loaded = true;
3111			if (tileJSON) {
3112				extend(this, tileJSON);
3113				if (tileJSON.bounds) this.tileBounds = new TileBounds(tileJSON.bounds, this.minzoom, this.maxzoom);
3114				this.fire(new MapSourceDataEvent("data", { sourceDataType: "metadata" }));
3115				this.fire(new MapSourceDataEvent("data", {
3116					sourceDataType: "content",
3117					sourceDataChanged
3118				}));
3119			}
3120		} catch (err) {
3121			this._tileJSONRequest = null;
3122			this._loaded = true;
3123			if (!isAbortError(err)) this.fire(new ErrorEvent(ensureError(err)));
3124		}
3125	}
3126	loaded() {
3127		return this._loaded;
3128	}
3129	onAdd(map) {
3130		this.map = map;
3131		this.load();
3132	}
3133	onRemove() {
3134		if (this._tileJSONRequest) {
3135			this._tileJSONRequest.abort();
3136			this._tileJSONRequest = null;
3137		}
3138	}
3139	setSourceProperty(callback) {
3140		if (this._tileJSONRequest) {
3141			this._tileJSONRequest.abort();
3142			this._tileJSONRequest = null;
3143		}
3144		callback();
3145		this.load(true);
3146	}
3147	/**
3148	* Sets the source `tiles` property and re-renders the map.
3149	*
3150	* @param tiles - An array of one or more tile source URLs, as in the raster tiles spec (See the [Style Specification](https://maplibre.org/maplibre-style-spec/)
3151	*/
3152	setTiles(tiles) {
3153		this.setSourceProperty(() => {
3154			this.tiles = tiles;
3155			this._options.tiles = tiles;
3156		});
3157		return this;
3158	}
3159	/**
3160	* Sets the source `url` property and re-renders the map.
3161	*
3162	* @param url - A URL to a TileJSON resource. Supported protocols are `http:` and `https:`.
3163	*/
3164	setUrl(url) {
3165		this.setSourceProperty(() => {
3166			this.url = url;
3167			this._options.url = url;
3168		});
3169		return this;
3170	}
3171	serialize() {
3172		return extend({}, this._options);
3173	}
3174	/**
3175	* Sets whether alpha premultiplication is applied to raster tile images.
3176	* Set to `false` to preserve exact RGBA byte values when alpha carries data instead of opacity.
3177	*
3178	* @param premultiplyAlpha - If `false`, disables alpha premultiplication for raster tile image decode and texture upload.
3179	* @example
3180	* ```ts
3181	* map.getSource<RasterTileSource>('raster-source').setPremultiplyAlpha(false);
3182	* ```
3183	*/
3184	setPremultiplyAlpha(premultiplyAlpha) {
3185		if (this._premultiplyAlpha === premultiplyAlpha) return this;
3186		this.setSourceProperty(() => {
3187			this._premultiplyAlpha = premultiplyAlpha;
3188		});
3189		return this;
3190	}
3191	hasTile(tileID) {
3192		return !this.tileBounds || this.tileBounds.contains(tileID.canonical);
3193	}
3194	async loadTile(tile) {
3195		const url = tile.tileID.canonical.url(this.tiles, this.map.getPixelRatio(), this.scheme);
3196		const premultiply = this._premultiplyAlpha;
3197		const imageBitmapOptions = premultiply ? void 0 : { premultiplyAlpha: "none" };
3198		tile.abortController = new AbortController();
3199		try {
3200			const response = await ImageRequest.transformAndGetImage(this.map._requestManager, url, "Tile", tile.abortController, this.map._refreshExpiredTiles, imageBitmapOptions);
3201			delete tile.abortController;
3202			if (tile.aborted) {
3203				tile.state = "unloaded";
3204				return;
3205			}
3206			if (response) {
3207				if (this.map._refreshExpiredTiles && (response.cacheControl || response.expires)) tile.setExpiryData({
3208					cacheControl: response.cacheControl,
3209					expires: response.expires
3210				});
3211				const context = this.map.painter.context;
3212				const gl = context.gl;
3213				const img = response.data ?? new RGBAImage({
3214					width: 1,
3215					height: 1
3216				}, /* @__PURE__ */ new Uint8Array(4));
3217				tile.texture = this.map.painter.getTileTexture(img.width);
3218				if (tile.texture) tile.texture.update(img, {
3219					useMipmap: true,
3220					premultiply
3221				});
3222				else {
3223					tile.texture = new Texture(context, img, gl.RGBA, {
3224						useMipmap: true,
3225						premultiply
3226					});
3227					tile.texture.bind(gl.LINEAR, gl.CLAMP_TO_EDGE, gl.LINEAR_MIPMAP_NEAREST);
3228				}
3229				tile.state = "loaded";
3230			}
3231		} catch (err) {
3232			delete tile.abortController;
3233			if (tile.aborted) tile.state = "unloaded";
3234			else if (err) {
3235				tile.state = "errored";
3236				throw err;
3237			}
3238		}
3239	}
3240	async abortTile(tile) {
3241		if (tile.abortController) {
3242			tile.abortController.abort();
3243			delete tile.abortController;
3244		}
3245	}
3246	async unloadTile(tile) {
3247		if (tile.texture) this.map.painter.saveTileTexture(tile.texture);
3248	}
3249	hasTransition() {
3250		return false;
3251	}
3252};
3253//#endregion
3254//#region src/source/raster_dem_tile_source.ts
3255/**
3256* A source containing raster DEM tiles (See the [Style Specification](https://maplibre.org/maplibre-style-spec/) for detailed documentation of options.)
3257* This source can be used to show hillshading and 3D terrain
3258*
3259* @group Sources
3260*
3261* @example
3262* ```ts
3263* map.addSource('raster-dem-source', {
3264*      type: 'raster-dem',
3265*      url: 'https://demotiles.maplibre.org/terrain-tiles/tiles.json',
3266*      tileSize: 256
3267* });
3268* ```
3269* @see [3D Terrain](https://maplibre.org/maplibre-gl-js/docs/examples/3d-terrain/)
3270*/
3271var RasterDEMTileSource = class extends RasterTileSource {
3272	constructor(id, options, dispatcher, eventedParent) {
3273		super(id, options, dispatcher, eventedParent);
3274		this.type = "raster-dem";
3275		this.maxzoom = 22;
3276		this._options = extend({ type: "raster-dem" }, options);
3277		this.encoding = options.encoding || "mapbox";
3278		this.redFactor = options.redFactor;
3279		this.greenFactor = options.greenFactor;
3280		this.blueFactor = options.blueFactor;
3281		this.baseShift = options.baseShift;
3282	}
3283	async loadTile(tile) {
3284		const url = tile.tileID.canonical.url(this.tiles, this.map.getPixelRatio(), this.scheme);
3285		tile.neighboringTiles = this._getNeighboringTiles(tile.tileID);
3286		tile.abortController = new AbortController();
3287		try {
3288			const response = await ImageRequest.transformAndGetImage(this.map._requestManager, url, "Tile", tile.abortController, this.map._refreshExpiredTiles, { colorSpaceConversion: "none" });
3289			delete tile.abortController;
3290			if (tile.aborted) {
3291				tile.state = "unloaded";
3292				return;
3293			}
3294			if (response) {
3295				if (this.map._refreshExpiredTiles && (response.cacheControl || response.expires)) tile.setExpiryData({
3296					cacheControl: response.cacheControl,
3297					expires: response.expires
3298				});
3299				if (!response.data) {
3300					tile.state = "loaded";
3301					return;
3302				}
3303				const img = response.data;
3304				const rawImageData = isImageBitmap(img) && offscreenCanvasSupported() ? img : await this.readImageNow(img);
3305				const params = {
3306					type: this.type,
3307					uid: tile.uid,
3308					source: this.id,
3309					rawImageData,
3310					encoding: this.encoding,
3311					redFactor: this.redFactor,
3312					greenFactor: this.greenFactor,
3313					blueFactor: this.blueFactor,
3314					baseShift: this.baseShift
3315				};
3316				if (tile.actor && tile.state !== "expired" && tile.state !== "reloading") return;
3317				await this.dispatcher.waitForInitComplete();
3318				if (!tile.actor || tile.state === "expired") tile.actor = this.dispatcher.getReadyActor();
3319				tile.dem = await tile.actor.sendAsync({
3320					type: "LDT",
3321					data: params
3322				});
3323				tile.needsHillshadePrepare = true;
3324				tile.needsTerrainPrepare = true;
3325				tile.needsColorReliefPrepare = true;
3326				tile.state = "loaded";
3327			}
3328		} catch (err) {
3329			delete tile.abortController;
3330			if (tile.aborted) tile.state = "unloaded";
3331			else if (err) {
3332				tile.state = "errored";
3333				throw err;
3334			}
3335		}
3336	}
3337	async readImageNow(img) {
3338		if (typeof VideoFrame !== "undefined" && isOffscreenCanvasDistorted()) {
3339			const width = img.width + 4;
3340			const height = img.height + 4;
3341			try {
3342				return new RGBAImage({
3343					width,
3344					height
3345				}, await readImageUsingVideoFrame(img, -2, -2, width, height));
3346			} catch {}
3347		}
3348		return browser.getImageData(img, 2);
3349	}
3350	_getNeighboringTiles(tileID) {
3351		const canonical = tileID.canonical;
3352		const dim = Math.pow(2, canonical.z);
3353		const px = (canonical.x - 1 + dim) % dim;
3354		const pxw = canonical.x === 0 ? tileID.wrap - 1 : tileID.wrap;
3355		const nx = (canonical.x + 1 + dim) % dim;
3356		const nxw = canonical.x + 1 === dim ? tileID.wrap + 1 : tileID.wrap;
3357		const neighboringTiles = {};
3358		neighboringTiles[new OverscaledTileID(tileID.overscaledZ, pxw, canonical.z, px, canonical.y).key] = { backfilled: false };
3359		neighboringTiles[new OverscaledTileID(tileID.overscaledZ, nxw, canonical.z, nx, canonical.y).key] = { backfilled: false };
3360		if (canonical.y > 0) {
3361			neighboringTiles[new OverscaledTileID(tileID.overscaledZ, pxw, canonical.z, px, canonical.y - 1).key] = { backfilled: false };
3362			neighboringTiles[new OverscaledTileID(tileID.overscaledZ, tileID.wrap, canonical.z, canonical.x, canonical.y - 1).key] = { backfilled: false };
3363			neighboringTiles[new OverscaledTileID(tileID.overscaledZ, nxw, canonical.z, nx, canonical.y - 1).key] = { backfilled: false };
3364		}
3365		if (canonical.y + 1 < dim) {
3366			neighboringTiles[new OverscaledTileID(tileID.overscaledZ, pxw, canonical.z, px, canonical.y + 1).key] = { backfilled: false };
3367			neighboringTiles[new OverscaledTileID(tileID.overscaledZ, tileID.wrap, canonical.z, canonical.x, canonical.y + 1).key] = { backfilled: false };
3368			neighboringTiles[new OverscaledTileID(tileID.overscaledZ, nxw, canonical.z, nx, canonical.y + 1).key] = { backfilled: false };
3369		}
3370		return neighboringTiles;
3371	}
3372	async unloadTile(tile) {
3373		if (tile.demTexture) this.map.painter.saveTileTexture(tile.demTexture);
3374		if (tile.fbo) {
3375			tile.fbo.destroy();
3376			delete tile.fbo;
3377		}
3378		if (tile.dem) delete tile.dem;
3379		delete tile.neighboringTiles;
3380		tile.state = "unloaded";
3381		if (tile.actor) await tile.actor.sendAsync({
3382			type: "RDT",
3383			data: {
3384				type: this.type,
3385				uid: tile.uid,
3386				source: this.id
3387			}
3388		});
3389	}
3390};
3391//#endregion
3392//#region src/source/geojson_source_diff.ts
3393function getFeatureId(feature, promoteId) {
3394	return promoteId ? feature.properties[promoteId] : feature.id;
3395}
3396/**
3397* Converts a GeoJSON object into a map of feature IDs to GeoJSON features.
3398* @param data - The GeoJSON object to convert.
3399* @param promoteId - If set, the feature id will be set to the promoteId property value.
3400* @returns A map of feature IDs to GeoJSON features, or `undefined` if the GeoJSON object is not a valid updateable object.
3401*
3402* Features must have unique identifiers to be updateable. IDs can come from:
3403* - The feature's `id` property (standard GeoJSON)
3404* - A promoted property specified by `promoteId` (e.g., a "name" property)
3405*/
3406function toUpdateable(data, promoteId) {
3407	const updateable = /* @__PURE__ */ new Map();
3408	if (data == null) return updateable;
3409	if (data.type == null) return updateable;
3410	if (data.type === "Feature") {
3411		const id = getFeatureId(data, promoteId);
3412		if (id == null) return void 0;
3413		updateable.set(id, data);
3414		return updateable;
3415	}
3416	if (data.type === "FeatureCollection") {
3417		const seenIds = /* @__PURE__ */ new Set();
3418		for (const feature of data.features) {
3419			const id = getFeatureId(feature, promoteId);
3420			if (id == null) return void 0;
3421			if (seenIds.has(id)) return void 0;
3422			seenIds.add(id);
3423			updateable.set(id, feature);
3424		}
3425		return updateable;
3426	}
3427}
3428/**
3429* Mutates updateable and applies a {@link GeoJSONSourceDiff}. Operations are processed in a specific order to ensure predictable behavior:
3430* 1. Remove operations (removeAll, remove)
3431* 2. Add operations (add)
3432* 3. Update operations (update)
3433* @returns an array of geometries that were affected by the diff - with the exception of removeAll which does not track any affected geometries.
3434*/
3435function applySourceDiff(updateable, diff, promoteId) {
3436	const affectedGeometries = [];
3437	if (diff.removeAll) updateable.clear();
3438	else if (diff.remove) for (const id of diff.remove) {
3439		const existing = updateable.get(id);
3440		if (!existing) continue;
3441		affectedGeometries.push(existing.geometry);
3442		updateable.delete(id);
3443	}
3444	if (diff.add) for (const feature of diff.add) {
3445		const id = getFeatureId(feature, promoteId);
3446		if (id == null) continue;
3447		const existing = updateable.get(id);
3448		if (existing) affectedGeometries.push(existing.geometry);
3449		affectedGeometries.push(feature.geometry);
3450		updateable.set(id, feature);
3451	}
3452	if (diff.update) for (const update of diff.update) {
3453		const existing = updateable.get(update.id);
3454		if (!existing) continue;
3455		const changeGeometry = !!update.newGeometry;
3456		const changeProps = update.removeAllProperties || update.removeProperties?.length > 0 || update.addOrUpdateProperties?.length > 0;
3457		if (!changeGeometry && !changeProps) continue;
3458		affectedGeometries.push(existing.geometry);
3459		const feature = { ...existing };
3460		updateable.set(update.id, feature);
3461		if (changeGeometry) {
3462			affectedGeometries.push(update.newGeometry);
3463			feature.geometry = update.newGeometry;
3464		}
3465		if (changeProps) {
3466			if (update.removeAllProperties) feature.properties = {};
3467			else feature.properties = { ...feature.properties || {} };
3468			if (update.removeProperties) for (const key of update.removeProperties) delete feature.properties[key];
3469			if (update.addOrUpdateProperties) for (const { key, value } of update.addOrUpdateProperties) feature.properties[key] = value;
3470		}
3471	}
3472	return affectedGeometries;
3473}
3474/**
3475* Merge two GeoJSONSourceDiffs, considering the order of operations as specified above (remove, add, update).
3476*
3477*