@geolibre/core 3.3.0 → 3.5.0

package/dist/joins-CGcRoTpc.mjs

@@ -1,1822 +0,0 @@
-import { Color, createExpression } from "@maplibre/maplibre-gl-style-spec";
-//#region src/ellipsoids.ts
-/**
-* Built-in ellipsoids. Earth is WGS 84; every other body uses IAU-adopted
-* figures. Only Earth and Mars are appreciably oblate; the rest are modelled as
-* spheres (`inverseFlattening: 0`), which is how the IAU/USGS simple-cylindrical
-* products treat them and is well within the accuracy MapLibre's unit-sphere
-* rendering can represent anyway.
-*/
-const ELLIPSOIDS = [
-	{
-		id: "earth",
-		name: "Earth (WGS 84)",
-		semiMajorAxisMeters: 6378137,
-		inverseFlattening: 298.257223563
-	},
-	{
-		id: "moon",
-		name: "Moon",
-		semiMajorAxisMeters: 1737400,
-		inverseFlattening: 0
-	},
-	{
-		id: "mars",
-		name: "Mars (IAU 2000)",
-		semiMajorAxisMeters: 3396190,
-		inverseFlattening: 169.894447
-	},
-	{
-		id: "mercury",
-		name: "Mercury",
-		semiMajorAxisMeters: 2439400,
-		inverseFlattening: 0
-	},
-	{
-		id: "venus",
-		name: "Venus",
-		semiMajorAxisMeters: 6051800,
-		inverseFlattening: 0
-	},
-	{
-		id: "io",
-		name: "Io",
-		semiMajorAxisMeters: 1821600,
-		inverseFlattening: 0
-	},
-	{
-		id: "europa",
-		name: "Europa",
-		semiMajorAxisMeters: 1560800,
-		inverseFlattening: 0
-	},
-	{
-		id: "ganymede",
-		name: "Ganymede",
-		semiMajorAxisMeters: 2631200,
-		inverseFlattening: 0
-	},
-	{
-		id: "callisto",
-		name: "Callisto",
-		semiMajorAxisMeters: 2410300,
-		inverseFlattening: 0
-	},
-	{
-		id: "titan",
-		name: "Titan",
-		semiMajorAxisMeters: 2574730,
-		inverseFlattening: 0
-	},
-	{
-		id: "pluto",
-		name: "Pluto",
-		semiMajorAxisMeters: 1188300,
-		inverseFlattening: 0
-	},
-	{
-		id: "charon",
-		name: "Charon",
-		semiMajorAxisMeters: 606e3,
-		inverseFlattening: 0
-	}
-];
-const DEFAULT_ELLIPSOID_ID = "earth";
-/** Look an ellipsoid up by id, falling back to Earth for unknown ids. */
-function getEllipsoid(id) {
-	return ELLIPSOIDS.find((e) => e.id === id) ?? ELLIPSOIDS.find((e) => e.id === "earth");
-}
-/**
-* Mean radius `R = (2a + b) / 3` in metres, where `b` is the polar radius
-* derived from the inverse flattening. This is the radius used for spherical
-* (haversine) distance and area math.
-*/
-function meanRadiusMeters(ellipsoid) {
-	const a = ellipsoid.semiMajorAxisMeters;
-	if (!ellipsoid.inverseFlattening) return a;
-	const b = a * (1 - 1 / ellipsoid.inverseFlattening);
-	return (2 * a + b) / 3;
-}
-/** Earth's mean radius in metres — the radius Turf.js and MapLibre bake in. */
-const EARTH_MEAN_RADIUS_METERS = meanRadiusMeters(ELLIPSOIDS.find((e) => e.id === "earth"));
-let activeEllipsoidId = DEFAULT_ELLIPSOID_ID;
-/**
-* Point the measurement helpers at a body. Unknown ids fall back to Earth so a
-* malformed project can never break measurements. Safe to call on every
-* preferences change; it is a cheap assignment.
-*/
-function setActiveEllipsoidId(id) {
-	activeEllipsoidId = getEllipsoid(id).id;
-}
-function getActiveEllipsoid() {
-	return getEllipsoid(activeEllipsoidId);
-}
-/** Mean radius (metres) of the active body — for haversine distance/area. */
-function getActiveMeanRadiusMeters() {
-	return meanRadiusMeters(getActiveEllipsoid());
-}
-/** Semi-major axis (metres) of the active body — for its Web-Mercator scale. */
-function getActiveSemiMajorAxisMeters() {
-	return getActiveEllipsoid().semiMajorAxisMeters;
-}
-/**
-* The active body's mean radius as a fraction of Earth's — `R_body / R_earth`,
-* and exactly `1` on Earth.
-*
-* Everything GeoLibre measures ultimately comes from lon/lat *angles*, and the
-* only thing that turns an angle into a ground distance is the radius it is
-* multiplied by. Turf.js hardcodes Earth's, with no per-call override (that is
-* the "Turf is Earth-locked" half of GeoLibre#1128), so rather than patch or
-* replace Turf we post-scale what it returns and pre-scale what we hand it. The
-* result is exact for a sphere, which is how every non-Earth body GeoLibre
-* offers is modelled anyway, and within Mars' 0.6% flattening at worst.
-*
-* Suggested by @thareUSGS (USGS Astrogeology) on GeoLibre#1128 as the practical
-* workaround planetary web maps have long used on Earth-locked engines.
-*/
-function getActiveBodyRadiusRatio() {
-	return getActiveMeanRadiusMeters() / EARTH_MEAN_RADIUS_METERS;
-}
-/**
-* Convert a length Turf.js measured on Earth into the active body's true ground
-* length. A no-op on Earth.
-*
-* Use on anything Turf *returns* — a distance, a length, a perimeter.
-*
-* The correction is a dimensionless ratio, so it is unit-agnostic: pass the
-* length in whatever unit Turf gave it back (metres, kilometres, miles) and the
-* result is in that same unit. There is no hidden unit conversion here.
-*/
-function earthLengthToBody(length) {
-	return length * getActiveBodyRadiusRatio();
-}
-/**
-* Convert a true ground length on the active body into the Earth-equivalent
-* length to hand Turf.js. A no-op on Earth.
-*
-* Use on anything passed *into* Turf as a distance — a buffer width, a circle
-* or sector radius, a search threshold — so the resulting geometry spans that
-* distance on this body rather than on Earth.
-*
-* Unit-agnostic like {@link earthLengthToBody}: pass the length in whatever
-* unit you are about to hand Turf alongside it, and the result is in that unit.
-*/
-function bodyLengthToEarth(length) {
-	return length / getActiveBodyRadiusRatio();
-}
-/**
-* Convert an area Turf.js measured on Earth into the active body's true ground
-* area. A no-op on Earth.
-*
-* Areas scale with the *square* of the radius ratio, so this is not the same
-* correction as {@link earthLengthToBody}. Unit-agnostic in the same way, for
-* whatever squared unit the area is expressed in.
-*/
-function earthAreaToBody(area) {
-	const ratio = getActiveBodyRadiusRatio();
-	return area * ratio * ratio;
-}
-const PLANETARY_BASEMAP_SENTINEL_PREFIX = "geolibre://basemap/";
-const OPM_ATTRIBUTION = "<a href=\"https://www.openplanetary.org/opm\">OpenPlanetaryMap</a>";
-/** Data-source credit joined with the OpenPlanetaryMap attribution. */
-const opmCredit = (source) => `${source} · ${OPM_ATTRIBUTION}`;
-const TILE_PROXY_BASE = "https://tiles.geolibre.app/opm";
-const WMS_PROXY_BASE = "https://tiles.geolibre.app/wms";
-const USGS_ASTRO_ATTRIBUTION = "<a href=\"https://astrogeology.usgs.gov/\">USGS Astrogeology</a>";
-/** Data-source credit joined with the USGS Astrogeology attribution. */
-const usgsCredit = (source) => `${source} · ${USGS_ASTRO_ATTRIBUTION}`;
-const PLANETARY_BASEMAPS = [
-	{
-		id: "mars-colour-mola-elevation",
-		name: "Colour MOLA Elevation",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}mars-colour-mola-elevation`,
-		tileUrl: `${TILE_PROXY_BASE}/mars-mola-color-noshade/{z}/{x}/{y}.png`,
-		scheme: "tms",
-		maxZoom: 6,
-		attribution: opmCredit("NASA / MOLA"),
-		ellipsoidId: "mars"
-	},
-	{
-		id: "mars-viking-mdim21",
-		name: "Viking MDIM2.1",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}mars-viking-mdim21`,
-		tileUrl: `${TILE_PROXY_BASE}/mars-viking-mdim21/{z}/{x}/{y}.png`,
-		scheme: "tms",
-		maxZoom: 7,
-		attribution: opmCredit("NASA / Viking / USGS"),
-		ellipsoidId: "mars"
-	},
-	{
-		id: "mars-hillshade",
-		name: "Hillshade",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}mars-hillshade`,
-		tileUrl: `${TILE_PROXY_BASE}/mars-hillshade/{z}/{x}/{y}.png`,
-		scheme: "tms",
-		maxZoom: 6,
-		attribution: opmCredit("NASA / MOLA"),
-		ellipsoidId: "mars"
-	},
-	{
-		id: "mars-basemap-v0-2",
-		name: "OPM Basemap v0.2",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}mars-basemap-v0-2`,
-		tileUrl: "https://cartocdn-gusc.global.ssl.fastly.net/opmbuilder/api/v1/map/named/opm-mars-basemap-v0-2/all/{z}/{x}/{y}.png",
-		maxZoom: 6,
-		attribution: OPM_ATTRIBUTION,
-		ellipsoidId: "mars"
-	},
-	{
-		id: "mars-shaded-colour-mola-elevation",
-		name: "Shaded Colour MOLA Elevation",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}mars-shaded-colour-mola-elevation`,
-		tileUrl: `${TILE_PROXY_BASE}/mars-mola-color/{z}/{x}/{y}.png`,
-		scheme: "tms",
-		maxZoom: 6,
-		attribution: opmCredit("NASA / MOLA"),
-		ellipsoidId: "mars"
-	},
-	{
-		id: "mars-shaded-grayscale-mola-elevation",
-		name: "Shaded Grayscale MOLA Elevation",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}mars-shaded-grayscale-mola-elevation`,
-		tileUrl: `${TILE_PROXY_BASE}/mars-mola-gray/{z}/{x}/{y}.png`,
-		scheme: "tms",
-		maxZoom: 9,
-		attribution: opmCredit("NASA / MOLA"),
-		ellipsoidId: "mars"
-	},
-	{
-		id: "moon-hillshaded-albedo",
-		name: "Hillshaded Albedo",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}moon-hillshaded-albedo`,
-		tileUrl: `${TILE_PROXY_BASE}/moon-hillshaded-albedo/{z}/{x}/{y}.png`,
-		scheme: "tms",
-		maxZoom: 6,
-		attribution: opmCredit("NASA / LOLA / USGS"),
-		ellipsoidId: "moon"
-	},
-	{
-		id: "moon-basemap-v0-1",
-		name: "OPM Basemap v0.1",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}moon-basemap-v0-1`,
-		tileUrl: "https://cartocdn-gusc.global.ssl.fastly.net/opmbuilder/api/v1/map/named/opm-moon-basemap-v0-1/all/{z}/{x}/{y}.png",
-		maxZoom: 6,
-		attribution: OPM_ATTRIBUTION,
-		ellipsoidId: "moon"
-	},
-	{
-		id: "mercury-messenger-color",
-		name: "MESSENGER Colour Mosaic",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}mercury-messenger-color`,
-		tileUrl: `${WMS_PROXY_BASE}/mercury-messenger-color/{z}/{x}/{y}.png`,
-		maxZoom: 7,
-		attribution: usgsCredit("NASA / JHU APL / CIW"),
-		ellipsoidId: "mercury"
-	},
-	{
-		id: "mercury-messenger",
-		name: "MESSENGER Basemap",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}mercury-messenger`,
-		tileUrl: `${WMS_PROXY_BASE}/mercury-messenger/{z}/{x}/{y}.png`,
-		maxZoom: 7,
-		attribution: usgsCredit("NASA / JHU APL"),
-		ellipsoidId: "mercury"
-	},
-	{
-		id: "venus-magellan",
-		name: "Magellan FMAP",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}venus-magellan`,
-		tileUrl: `${WMS_PROXY_BASE}/venus-magellan/{z}/{x}/{y}.png`,
-		maxZoom: 6,
-		attribution: usgsCredit("NASA / JPL"),
-		ellipsoidId: "venus"
-	},
-	{
-		id: "venus-magellan-color",
-		name: "Magellan C3-MDIR Colour",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}venus-magellan-color`,
-		tileUrl: `${WMS_PROXY_BASE}/venus-magellan-color/{z}/{x}/{y}.png`,
-		maxZoom: 6,
-		attribution: usgsCredit("NASA / JPL"),
-		ellipsoidId: "venus"
-	},
-	{
-		id: "io-galileo-color",
-		name: "Galileo SSI Colour",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}io-galileo-color`,
-		tileUrl: `${WMS_PROXY_BASE}/io-galileo-color/{z}/{x}/{y}.png`,
-		maxZoom: 6,
-		attribution: usgsCredit("NASA / JPL"),
-		ellipsoidId: "io"
-	},
-	{
-		id: "europa-galileo-voyager",
-		name: "Galileo / Voyager",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}europa-galileo-voyager`,
-		tileUrl: `${WMS_PROXY_BASE}/europa-galileo-voyager/{z}/{x}/{y}.png`,
-		maxZoom: 6,
-		attribution: usgsCredit("NASA / JPL"),
-		ellipsoidId: "europa"
-	},
-	{
-		id: "ganymede-galileo-voyager",
-		name: "Galileo / Voyager",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}ganymede-galileo-voyager`,
-		tileUrl: `${WMS_PROXY_BASE}/ganymede-galileo-voyager/{z}/{x}/{y}.png`,
-		maxZoom: 6,
-		attribution: usgsCredit("NASA / JPL"),
-		ellipsoidId: "ganymede"
-	},
-	{
-		id: "callisto-galileo-voyager",
-		name: "Galileo / Voyager",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}callisto-galileo-voyager`,
-		tileUrl: `${WMS_PROXY_BASE}/callisto-galileo-voyager/{z}/{x}/{y}.png`,
-		maxZoom: 6,
-		attribution: usgsCredit("NASA / JPL"),
-		ellipsoidId: "callisto"
-	},
-	{
-		id: "titan-cassini",
-		name: "Cassini ISS Mosaic",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}titan-cassini`,
-		tileUrl: `${WMS_PROXY_BASE}/titan-cassini/{z}/{x}/{y}.png`,
-		maxZoom: 6,
-		attribution: usgsCredit("NASA / JPL / SSI"),
-		ellipsoidId: "titan"
-	},
-	{
-		id: "titan-hisar",
-		name: "Cassini HiSAR Mosaic",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}titan-hisar`,
-		tileUrl: `${WMS_PROXY_BASE}/titan-hisar/{z}/{x}/{y}.png`,
-		maxZoom: 6,
-		attribution: usgsCredit("NASA / JPL / USGS"),
-		ellipsoidId: "titan"
-	},
-	{
-		id: "pluto-mosaic",
-		name: "New Horizons Mosaic",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}pluto-mosaic`,
-		tileUrl: `${WMS_PROXY_BASE}/pluto-mosaic/{z}/{x}/{y}.png`,
-		maxZoom: 7,
-		attribution: usgsCredit("NASA / JHU APL / SwRI"),
-		ellipsoidId: "pluto"
-	},
-	{
-		id: "pluto-color",
-		name: "New Horizons Colour Shaded Relief",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}pluto-color`,
-		tileUrl: `${WMS_PROXY_BASE}/pluto-color/{z}/{x}/{y}.png`,
-		maxZoom: 7,
-		attribution: usgsCredit("NASA / JHU APL / SwRI"),
-		ellipsoidId: "pluto"
-	},
-	{
-		id: "charon-mosaic",
-		name: "New Horizons Mosaic",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}charon-mosaic`,
-		tileUrl: `${WMS_PROXY_BASE}/charon-mosaic/{z}/{x}/{y}.png`,
-		maxZoom: 6,
-		attribution: usgsCredit("NASA / JHU APL / SwRI"),
-		ellipsoidId: "charon"
-	},
-	{
-		id: "earth-usgs-imagery",
-		name: "USGS Imagery",
-		styleUrl: `${PLANETARY_BASEMAP_SENTINEL_PREFIX}earth-usgs-imagery`,
-		tileUrl: "https://basemap.nationalmap.gov/arcgis/rest/services/USGSImageryOnly/MapServer/tile/{z}/{y}/{x}",
-		maxZoom: 16,
-		attribution: "<a href=\"https://www.usgs.gov/programs/national-geospatial-program/national-map\">USGS The National Map</a>",
-		ellipsoidId: "earth"
-	}
-];
-const DEDICATED_SECTION_BODIES = ["moon", "mars"];
-/**
-* {@link PLANETARY_BASEMAPS} grouped for the pickers: one section each for the
-* Moon and Mars, then a single "Other celestial bodies" section for the rest,
-* in {@link PLANETARY_BASEMAPS} order (grouped by body). Empty sections are
-* dropped.
-*/
-const PLANETARY_BASEMAP_GROUPS = [
-	{
-		id: "moon",
-		ellipsoidId: "moon"
-	},
-	{
-		id: "mars",
-		ellipsoidId: "mars"
-	},
-	{
-		id: "other",
-		ellipsoidId: null
-	}
-].map(({ id, ellipsoidId }) => {
-	const basemaps = PLANETARY_BASEMAPS.filter((b) => ellipsoidId ? b.ellipsoidId === ellipsoidId : b.ellipsoidId !== "earth" && !DEDICATED_SECTION_BODIES.includes(b.ellipsoidId));
-	return {
-		id,
-		basemaps: id === "other" ? [...basemaps].sort((a, b) => getEllipsoid(a.ellipsoidId).name.localeCompare(getEllipsoid(b.ellipsoidId).name)) : basemaps
-	};
-}).filter((group) => group.basemaps.length > 0);
-const LEGACY_PLANETARY_BASEMAP_IDS = {
-	"mars-opm": "mars-basemap-v0-2",
-	"moon-opm": "moon-basemap-v0-1",
-	"mars-viking": "mars-viking-mdim21",
-	"moon-lroc": "moon-basemap-v0-1"
-};
-/** Resolve a `geolibre://basemap/<id>` sentinel to its planetary basemap. */
-function getPlanetaryBasemapByStyleUrl(styleUrl) {
-	if (!styleUrl?.startsWith("geolibre://basemap/")) return void 0;
-	const id = styleUrl.slice(19);
-	const resolvedId = Object.prototype.hasOwnProperty.call(LEGACY_PLANETARY_BASEMAP_IDS, id) ? LEGACY_PLANETARY_BASEMAP_IDS[id] : id;
-	return PLANETARY_BASEMAPS.find((b) => b.id === resolvedId);
-}
-/** Look a planetary basemap up by its stable id. */
-function getPlanetaryBasemapById(id) {
-	return PLANETARY_BASEMAPS.find((b) => b.id === id);
-}
-/**
-* The celestial bodies offered by the Layers-panel planet switcher, in menu
-* order (like Google Earth's planet dropdown). Each body is paired with the
-* basemap the switcher applies for it — USGS satellite imagery for Earth, the
-* OpenPlanetaryMap Hillshaded Albedo mosaic for the Moon, and the OpenPlanetaryMap
-* Viking mosaic for Mars.
-*/
-const PLANET_SWITCHER_OPTIONS = [
-	{
-		ellipsoidId: "earth",
-		basemapId: "earth-usgs-imagery"
-	},
-	{
-		ellipsoidId: "moon",
-		basemapId: "moon-hillshaded-albedo"
-	},
-	{
-		ellipsoidId: "mars",
-		basemapId: "mars-viking-mdim21"
-	},
-	{
-		ellipsoidId: "callisto",
-		basemapId: "callisto-galileo-voyager"
-	},
-	{
-		ellipsoidId: "charon",
-		basemapId: "charon-mosaic"
-	},
-	{
-		ellipsoidId: "europa",
-		basemapId: "europa-galileo-voyager"
-	},
-	{
-		ellipsoidId: "ganymede",
-		basemapId: "ganymede-galileo-voyager"
-	},
-	{
-		ellipsoidId: "io",
-		basemapId: "io-galileo-color"
-	},
-	{
-		ellipsoidId: "mercury",
-		basemapId: "mercury-messenger-color"
-	},
-	{
-		ellipsoidId: "pluto",
-		basemapId: "pluto-mosaic"
-	},
-	{
-		ellipsoidId: "titan",
-		basemapId: "titan-cassini"
-	},
-	{
-		ellipsoidId: "venus",
-		basemapId: "venus-magellan-color"
-	}
-];
-//#endregion
-//#region src/geojson-z.ts
-/**
-* Helpers for vector data whose coordinates carry a Z value (elevation), e.g.
-* GPX tracks with `<ele>` readings or LineStringZ/PointZ geometries. MapLibre's
-* 2D style layers ignore the third coordinate, so layers that want to render
-* their Z values use these helpers to detect and rescale elevations before
-* handing the data to a deck.gl overlay. The same data can carry its elevation
-* in a `bbox` member too, which `horizontalBbox` trims back to two dimensions.
-*/
-/**
-* Reduces a bounding box to its horizontal extent, `[west, south, east, north]`.
-*
-* RFC 7946 §5 lets a `bbox` member carry elevation, in which case it holds six
-* values — `[west, south, minAltitude, east, north, maxAltitude]` — and
-* `@turf/bbox` returns a collection's own member verbatim rather than
-* recomputing it. A consumer reading such a box as four values takes the
-* altitude for a longitude and the east edge for a latitude; that is how a 3D
-* feed reached MapLibre as an out-of-range latitude (#2358).
-*
-* Returns null when there is no usable horizontal extent: a box of any other
-* length, or one carrying a non-finite value anywhere — an empty collection, or
-* one whose features all have a null geometry, bboxes to ±Infinity, and a box
-* whose altitudes are not finite is not one to trust the rest of.
-*
-* @param box - A GeoJSON or Turf bounding box, of four or six values.
-*/
-function horizontalBbox(box) {
-	if (!box) return null;
-	if (box.length !== 4 && box.length !== 6) return null;
-	if (!box.every((value) => Number.isFinite(value))) return null;
-	return box.length === 6 ? [
-		box[0],
-		box[1],
-		box[3],
-		box[4]
-	] : [
-		box[0],
-		box[1],
-		box[2],
-		box[3]
-	];
-}
-const hasZCache = /* @__PURE__ */ new WeakMap();
-const hasFiniteZCache = /* @__PURE__ */ new WeakMap();
-/**
-* Returns true when any coordinate in the GeoJSON carries a finite, non-zero
-* Z value. All-zero Z arrays are treated as flat data because rendering them
-* "in 3D" would be indistinguishable from the 2D result. The result is
-* cached per GeoJSON object, so repeated calls on the same data are free.
-*
-* @param geojson - Any GeoJSON object (geometry, feature, or collection).
-* @param includeZero - Accept zero elevations when explicit absolute-height placement matters.
-*/
-function geojsonHasZCoordinates(geojson, includeZero = false) {
-	if (!geojson) return false;
-	const cache = includeZero ? hasFiniteZCache : hasZCache;
-	const cached = cache.get(geojson);
-	if (cached !== void 0) return cached;
-	const result = someGeometry(geojson, (geometry) => somePosition(geometry, (position) => {
-		const z = position[2];
-		return typeof z === "number" && Number.isFinite(z) && (includeZero || z !== 0);
-	}));
-	cache.set(geojson, result);
-	return result;
-}
-/**
-* Returns a copy of the GeoJSON with every coordinate's Z value mapped to
-* `z * verticalScale + offset` (missing or non-finite Z treated as 0). Used
-* to apply vertical exaggeration and a constant altitude offset before 3D
-* rendering. The identity transform (`verticalScale === 1 && offset === 0`)
-* still produces a copy so the non-finite-Z sanitization applies on every
-* path — WebGL does not handle NaN positions gracefully.
-*
-* @param geojson - The feature collection to transform.
-* @param verticalScale - Multiplier applied to each Z value.
-* @param offset - Constant altitude in meters added after scaling.
-*/
-function transformGeojsonElevation(geojson, verticalScale, offset) {
-	const mapPosition = (position) => [
-		position[0],
-		position[1],
-		(typeof position[2] === "number" && Number.isFinite(position[2]) ? position[2] : 0) * verticalScale + offset
-	];
-	return {
-		...geojson,
-		features: geojson.features.map((feature) => ({
-			...feature,
-			geometry: mapGeometryPositions(feature.geometry, mapPosition)
-		}))
-	};
-}
-function someGeometry(geojson, predicate) {
-	switch (geojson.type) {
-		case "FeatureCollection": return geojson.features.some((feature) => feature.geometry ? someGeometry(feature.geometry, predicate) : false);
-		case "Feature": return geojson.geometry ? someGeometry(geojson.geometry, predicate) : false;
-		case "GeometryCollection": return geojson.geometries.some((geometry) => someGeometry(geometry, predicate));
-		default: return predicate(geojson);
-	}
-}
-function somePosition(geometry, predicate) {
-	switch (geometry.type) {
-		case "Point": return predicate(geometry.coordinates);
-		case "MultiPoint":
-		case "LineString": return geometry.coordinates.some(predicate);
-		case "MultiLineString":
-		case "Polygon": return geometry.coordinates.some((ring) => ring.some(predicate));
-		case "MultiPolygon": return geometry.coordinates.some((polygon) => polygon.some((ring) => ring.some(predicate)));
-		case "GeometryCollection": return geometry.geometries.some((child) => somePosition(child, predicate));
-		default: return false;
-	}
-}
-function mapGeometryPositions(geometry, mapPosition) {
-	if (!geometry) return geometry;
-	switch (geometry.type) {
-		case "Point": return {
-			...geometry,
-			coordinates: mapPosition(geometry.coordinates)
-		};
-		case "MultiPoint":
-		case "LineString": return {
-			...geometry,
-			coordinates: geometry.coordinates.map(mapPosition)
-		};
-		case "MultiLineString":
-		case "Polygon": return {
-			...geometry,
-			coordinates: geometry.coordinates.map((ring) => ring.map(mapPosition))
-		};
-		case "MultiPolygon": return {
-			...geometry,
-			coordinates: geometry.coordinates.map((polygon) => polygon.map((ring) => ring.map(mapPosition)))
-		};
-		case "GeometryCollection": return {
-			...geometry,
-			geometries: geometry.geometries.map((child) => mapGeometryPositions(child, mapPosition))
-		};
-		default: return geometry;
-	}
-}
-//#endregion
-//#region src/polyline.ts
-/**
-* Pure TypeScript Google Encoded Polyline algorithm codec.
-*
-* Supports arbitrary precision:
-* - precision = 5: Google Maps standard, OSRM, HERE (factor 1e5, ~1.1m precision)
-* - precision = 6: Valhalla, Mapbox, Open Source Routing Machine 6 (factor 1e6, ~0.11m precision)
-*
-* Coordinates are represented as `[lon, lat]` pairs in GeoJSON format.
-*/
-/**
-* Unescapes backslashes in a polyline string.
-*
-* When polyline strings are copied from JSON payloads, log files, or source code,
-* backslashes are frequently double-escaped as `\\` or formatted with escape sequences.
-*
-* @param str - Input string with potentially escaped backslashes.
-* @returns Cleaned polyline string.
-*/
-function unescapePolyline(str) {
-	if (!str || typeof str !== "string") return "";
-	return str.replace(/\\\\/g, "\\").replace(/\\"/g, "\"").replace(/\\'/g, "'");
-}
-/**
-* Decodes an encoded polyline string into an array of `[lon, lat]` coordinates,
-* along with a `complete` flag indicating whether the entire string was consumed
-* as complete coordinate pairs without truncation or malformed characters.
-*
-* @param encoded - The ASCII-encoded polyline string.
-* @param precision - Number of decimal digits (default: 5).
-* @param unescape - Whether to unescape double-escaped backslashes before decoding (default: false).
-* @returns Object with decoded `coordinates` and `complete` boolean status.
-*/
-function decodePolylineDetailed(encoded, precision = 5, unescape = false) {
-	if (!encoded || typeof encoded !== "string") return {
-		coordinates: [],
-		complete: true
-	};
-	const cleanEncoded = unescape ? unescapePolyline(encoded) : encoded;
-	const factor = 10 ** precision;
-	const len = cleanEncoded.length;
-	const coordinates = [];
-	let index = 0;
-	let lat = 0;
-	let lon = 0;
-	while (index < len) {
-		let shift = 0;
-		let result = 0;
-		let byte;
-		let latComplete = false;
-		do {
-			if (index >= len) return {
-				coordinates,
-				complete: false
-			};
-			byte = cleanEncoded.charCodeAt(index++) - 63;
-			if (byte < 0 || byte > 63) return {
-				coordinates,
-				complete: false
-			};
-			if (shift > 30 || shift === 30 && (byte & 31) > 3) return {
-				coordinates,
-				complete: false
-			};
-			result |= (byte & 31) << shift;
-			shift += 5;
-			if (byte < 32) {
-				latComplete = true;
-				break;
-			}
-		} while (byte >= 32);
-		if (!latComplete) return {
-			coordinates,
-			complete: false
-		};
-		lat += result & 1 ? ~(result >>> 1) : result >>> 1;
-		shift = 0;
-		result = 0;
-		let lonComplete = false;
-		do {
-			if (index >= len) return {
-				coordinates,
-				complete: false
-			};
-			byte = cleanEncoded.charCodeAt(index++) - 63;
-			if (byte < 0 || byte > 63) return {
-				coordinates,
-				complete: false
-			};
-			if (shift > 30 || shift === 30 && (byte & 31) > 3) return {
-				coordinates,
-				complete: false
-			};
-			result |= (byte & 31) << shift;
-			shift += 5;
-			if (byte < 32) {
-				lonComplete = true;
-				break;
-			}
-		} while (byte >= 32);
-		if (!lonComplete) return {
-			coordinates,
-			complete: false
-		};
-		lon += result & 1 ? ~(result >>> 1) : result >>> 1;
-		coordinates.push([lon / factor, lat / factor]);
-	}
-	return {
-		coordinates,
-		complete: true
-	};
-}
-/**
-* Decodes an encoded polyline string into an array of `[lon, lat]` coordinates.
-*
-* @param encoded - The ASCII-encoded polyline string.
-* @param precision - Number of decimal digits (default: 5).
-* @param unescape - Whether to unescape double-escaped backslashes before decoding (default: false).
-* @returns Array of `[lon, lat]` coordinate pairs in GeoJSON order.
-*/
-function decodePolyline(encoded, precision = 5, unescape = false) {
-	return decodePolylineDetailed(encoded, precision, unescape).coordinates;
-}
-/**
-* Encodes a single integer delta value into polyline character chunks.
-*/
-function encodeSignedNumber(num) {
-	let sgnNum = num < 0 ? ~(num << 1) : num << 1;
-	let out = "";
-	while (sgnNum >= 32) {
-		out += String.fromCharCode((32 | sgnNum & 31) + 63);
-		sgnNum >>>= 5;
-	}
-	out += String.fromCharCode(sgnNum + 63);
-	return out;
-}
-/**
-* Encodes an array of `[lon, lat]` coordinates into a Google Encoded Polyline string.
-*
-* @param coordinates - Array of `[lon, lat]` coordinate pairs.
-* @param precision - Number of decimal digits (default: 5).
-* @returns The encoded polyline string.
-*/
-function encodePolyline(coordinates, precision = 5) {
-	if (!Array.isArray(coordinates) || coordinates.length === 0) return "";
-	const factor = 10 ** precision;
-	let output = "";
-	let prevLat = 0;
-	let prevLon = 0;
-	for (const [lon, lat] of coordinates) {
-		if (!Number.isFinite(lon) || !Number.isFinite(lat)) continue;
-		const roundLat = Math.round(lat * factor);
-		const roundLon = Math.round(lon * factor);
-		const deltaLat = roundLat - prevLat;
-		const deltaLon = roundLon - prevLon;
-		output += encodeSignedNumber(deltaLat);
-		output += encodeSignedNumber(deltaLon);
-		prevLat = roundLat;
-		prevLon = roundLon;
-	}
-	return output;
-}
-/**
-* Decodes an encoded polyline string into a GeoJSON `Feature<LineString>`.
-*
-* @param encoded - The polyline string.
-* @param precision - Coordinate precision (default: 5).
-* @param properties - Optional feature properties.
-* @returns A GeoJSON LineString Feature.
-*/
-function polylineStrToGeoJSON(encoded, precision = 5, properties = {}) {
-	return {
-		type: "Feature",
-		properties: { ...properties },
-		geometry: {
-			type: "LineString",
-			coordinates: decodePolyline(encoded, precision)
-		}
-	};
-}
-/**
-* Encodes a GeoJSON LineString, MultiLineString, Feature, or FeatureCollection into encoded polyline string(s).
-*
-* @param geojson - The GeoJSON input geometry or feature.
-* @param precision - Coordinate precision (default: 5).
-* @returns An encoded polyline string for LineString, or an array of strings for MultiLineString / FeatureCollection.
-*/
-function geoJSONToPolylineStr(geojson, precision = 5) {
-	if (!geojson) return "";
-	if (geojson.type === "Feature") return geoJSONToPolylineStr(geojson.geometry, precision);
-	if (geojson.type === "FeatureCollection") {
-		const results = [];
-		for (const feature of geojson.features) {
-			const res = geoJSONToPolylineStr(feature.geometry, precision);
-			if (Array.isArray(res)) results.push(...res);
-			else if (res) results.push(res);
-		}
-		return results;
-	}
-	if (geojson.type === "LineString") return encodePolyline(geojson.coordinates, precision);
-	if (geojson.type === "MultiLineString") return geojson.coordinates.map((lineCoords) => encodePolyline(lineCoords, precision));
-	return "";
-}
-/**
-* Parses and batch-decodes multiple polylines from a text block or file content.
-*
-* @param input - Multiline string or delimited text containing encoded polylines.
-* @param options - Decoding and parsing configuration.
-* @returns A FeatureCollection containing LineString (or MultiLineString) features.
-*/
-function batchDecodePolylines(input, options = {}) {
-	if (!input || typeof input !== "string") return {
-		type: "FeatureCollection",
-		features: []
-	};
-	const { precision = 5, unescape = true, delimiter = /\r?\n/, asMultiLine = false, baseProperties = {} } = options;
-	const rawChunks = input.split(delimiter);
-	const validLineCoords = [];
-	const features = [];
-	for (let i = 0; i < rawChunks.length; i++) {
-		const raw = rawChunks[i].trim();
-		if (!raw) continue;
-		const cleaned = raw.replace(/^["']|["']$/g, "").trim();
-		if (!cleaned) continue;
-		const decodeResult = decodePolylineDetailed(cleaned, precision, unescape);
-		if (decodeResult.complete && decodeResult.coordinates.length >= 2) {
-			const coords = decodeResult.coordinates;
-			validLineCoords.push(coords);
-			features.push({
-				type: "Feature",
-				properties: {
-					...baseProperties,
-					line_index: features.length + 1,
-					point_count: coords.length
-				},
-				geometry: {
-					type: "LineString",
-					coordinates: coords
-				}
-			});
-		}
-	}
-	if (asMultiLine && validLineCoords.length > 0) return {
-		type: "FeatureCollection",
-		features: [{
-			type: "Feature",
-			properties: {
-				...baseProperties,
-				line_count: validLineCoords.length,
-				point_count: validLineCoords.reduce((acc, c) => acc + c.length, 0)
-			},
-			geometry: {
-				type: "MultiLineString",
-				coordinates: validLineCoords
-			}
-		}]
-	};
-	return {
-		type: "FeatureCollection",
-		features
-	};
-}
-//#endregion
-//#region src/selection.ts
-/** Selection modes in display order. */
-const SELECTION_MODES = [
-	"new",
-	"add",
-	"remove",
-	"intersect"
-];
-/**
-* The id under which a feature participates in the selection model. Mirrors
-* the convention shared by the attribute table and the map highlight
-* (`String(feature.id ?? index)`): the feature's own `id` when present,
-* otherwise its index in the layer's feature array.
-*/
-function featureSelectionId(feature, index) {
-	return String(feature.id ?? index);
-}
-/**
-* Combines the current selection with a freshly matched id set according to
-* `mode`. The result is deduplicated and order-stable: "new" follows the
-* matched order, "add" appends unseen matches after the current ids, and
-* "remove"/"intersect" preserve the current selection's order.
-*/
-function applySelectionMode(current, matched, mode) {
-	const matchedSet = new Set(matched);
-	switch (mode) {
-		case "new": return Array.from(matchedSet);
-		case "add": {
-			const merged = new Set(current);
-			for (const id of matched) merged.add(id);
-			return Array.from(merged);
-		}
-		case "remove": return Array.from(new Set(current.filter((id) => !matchedSet.has(id))));
-		case "intersect": return Array.from(new Set(current.filter((id) => matchedSet.has(id))));
-	}
-}
-/**
-* The complement of `current` within `allIds` (QGIS "Invert selection"):
-* every feature id not currently selected, in layer order. With an empty
-* selection this selects everything.
-*/
-function invertSelection(allIds, current) {
-	const selected = new Set(current);
-	return allIds.filter((id) => !selected.has(id));
-}
-//#endregion
-//#region src/expressions.ts
-const fn = (name, snippet, docKey) => ({
-	name,
-	snippet,
-	docKey
-});
-/**
-* The curated function reference, grouped by category. Snippets are valid,
-* standalone-compilable MapLibre expressions (enforced by tests) so inserting
-* one into an empty editor always yields a working starting point.
-*/
-const EXPRESSION_FUNCTION_CATEGORIES = [
-	{
-		key: "data",
-		functions: [
-			fn("get", "[\"get\", \"field\"]", "get"),
-			fn("has", "[\"has\", \"field\"]", "has"),
-			fn("id", "[\"id\"]", "id"),
-			fn("properties", "[\"properties\"]", "properties"),
-			fn("geometry-type", "[\"geometry-type\"]", "geometryType"),
-			fn("at", "[\"at\", 0, [\"literal\", [1, 2, 3]]]", "at"),
-			fn("in", "[\"in\", \"value\", [\"get\", \"field\"]]", "in"),
-			fn("index-of", "[\"index-of\", \"value\", [\"get\", \"field\"]]", "indexOf"),
-			fn("length", "[\"length\", [\"get\", \"field\"]]", "length"),
-			fn("literal", "[\"literal\", [\"a\", \"b\"]]", "literal"),
-			fn("typeof", "[\"typeof\", [\"get\", \"field\"]]", "typeofOp")
-		]
-	},
-	{
-		key: "decision",
-		functions: [
-			fn("case", "[\"case\", [\"==\", [\"get\", \"field\"], \"value\"], \"#ff0000\", \"#cccccc\"]", "caseOp"),
-			fn("match", "[\"match\", [\"get\", \"field\"], \"a\", \"#2563eb\", \"b\", \"#16a34a\", \"#94a3b8\"]", "match"),
-			fn("coalesce", "[\"coalesce\", [\"get\", \"field\"], \"fallback\"]", "coalesce"),
-			fn("==", "[\"==\", [\"get\", \"field\"], \"value\"]", "eq"),
-			fn("!=", "[\"!=\", [\"get\", \"field\"], \"value\"]", "neq"),
-			fn(">", "[\">\", [\"get\", \"field\"], 0]", "gt"),
-			fn(">=", "[\">=\", [\"get\", \"field\"], 0]", "gte"),
-			fn("<", "[\"<\", [\"get\", \"field\"], 0]", "lt"),
-			fn("<=", "[\"<=\", [\"get\", \"field\"], 0]", "lte"),
-			fn("all", "[\"all\", [\">\", [\"get\", \"field\"], 0], [\"<\", [\"get\", \"field\"], 100]]", "all"),
-			fn("any", "[\"any\", [\"==\", [\"get\", \"field\"], \"a\"], [\"==\", [\"get\", \"field\"], \"b\"]]", "any"),
-			fn("!", "[\"!\", [\"has\", \"field\"]]", "not")
-		]
-	},
-	{
-		key: "math",
-		functions: [
-			fn("+", "[\"+\", [\"get\", \"field\"], 1]", "add"),
-			fn("-", "[\"-\", [\"get\", \"field\"], 1]", "subtract"),
-			fn("*", "[\"*\", [\"get\", \"field\"], 2]", "multiply"),
-			fn("/", "[\"/\", [\"get\", \"field\"], 2]", "divide"),
-			fn("%", "[\"%\", [\"get\", \"field\"], 2]", "modulo"),
-			fn("^", "[\"^\", [\"get\", \"field\"], 2]", "power"),
-			fn("abs", "[\"abs\", [\"get\", \"field\"]]", "abs"),
-			fn("ceil", "[\"ceil\", [\"get\", \"field\"]]", "ceil"),
-			fn("floor", "[\"floor\", [\"get\", \"field\"]]", "floor"),
-			fn("round", "[\"round\", [\"get\", \"field\"]]", "round"),
-			fn("sqrt", "[\"sqrt\", [\"get\", \"field\"]]", "sqrt"),
-			fn("ln", "[\"ln\", [\"get\", \"field\"]]", "ln"),
-			fn("log10", "[\"log10\", [\"get\", \"field\"]]", "log10"),
-			fn("min", "[\"min\", [\"get\", \"field\"], 0]", "min"),
-			fn("max", "[\"max\", [\"get\", \"field\"], 0]", "max")
-		]
-	},
-	{
-		key: "string",
-		functions: [
-			fn("concat", "[\"concat\", [\"get\", \"field\"], \" suffix\"]", "concat"),
-			fn("upcase", "[\"upcase\", [\"get\", \"field\"]]", "upcase"),
-			fn("downcase", "[\"downcase\", [\"get\", \"field\"]]", "downcase"),
-			fn("slice", "[\"slice\", [\"get\", \"field\"], 0, 3]", "slice"),
-			fn("number-format", "[\"number-format\", [\"get\", \"field\"], {\"locale\": \"en-US\", \"max-fraction-digits\": 2}]", "numberFormat")
-		]
-	},
-	{
-		key: "conversion",
-		functions: [
-			fn("to-number", "[\"to-number\", [\"get\", \"field\"]]", "toNumber"),
-			fn("to-string", "[\"to-string\", [\"get\", \"field\"]]", "toString"),
-			fn("to-boolean", "[\"to-boolean\", [\"get\", \"field\"]]", "toBoolean"),
-			fn("to-color", "[\"to-color\", \"#2563eb\"]", "toColor")
-		]
-	},
-	{
-		key: "camera",
-		functions: [
-			fn("zoom", "[\"zoom\"]", "zoom"),
-			fn("interpolate", "[\"interpolate\", [\"linear\"], [\"zoom\"], 5, [\"to-color\", \"#2563eb\"], 12, [\"to-color\", \"#dc2626\"]]", "interpolate"),
-			fn("step", "[\"step\", [\"zoom\"], \"#2563eb\", 10, \"#dc2626\"]", "step"),
-			fn("rgb", "[\"rgb\", 37, 99, 235]", "rgb"),
-			fn("rgba", "[\"rgba\", 37, 99, 235, 0.5]", "rgba")
-		]
-	}
-];
-/**
-* Strips commas that directly precede a closing bracket/brace outside of
-* strings, so user-typed expressions with trailing commas still parse.
-* Shared by {@link parseJsonExpression} (vector-color) and the builder.
-*/
-function removeTrailingJsonCommas(value) {
-	let result = "";
-	let inString = false;
-	let escaped = false;
-	for (let index = 0; index < value.length; index += 1) {
-		const char = value[index];
-		if (inString) {
-			result += char;
-			if (escaped) escaped = false;
-			else if (char === "\\") escaped = true;
-			else if (char === "\"") inString = false;
-			continue;
-		}
-		if (char === "\"") {
-			inString = true;
-			result += char;
-			continue;
-		}
-		if (char === ",") {
-			const nextSignificant = value.slice(index + 1).match(/\S/)?.[0];
-			if (nextSignificant === "]" || nextSignificant === "}") continue;
-		}
-		result += char;
-	}
-	return result;
-}
-/**
-* The `rootKey` `createExpression` (style-spec v26+) requires as its second
-* argument — a location label it only surfaces when attaching a runtime
-* warning to `console.warn` during evaluation. These expressions come from the
-* Expression Builder dialog, not a style JSON layer, so a generic label is the
-* honest value; it never appears in the parsing errors we report.
-*/
-const EXPRESSION_ROOT_KEY = "expression";
-/**
-* Builds the minimal property spec that makes `createExpression` enforce a
-* result type while still allowing zoom- and feature-dependent input.
-*
-* This mirrors the (unexported) `StylePropertySpecification` shape that
-* `@maplibre/maplibre-gl-style-spec` expects — the cast below means the
-* compiler cannot catch a change to that contract, so whenever the
-* style-spec package is bumped (including Dependabot PRs) re-check that
-* expected-type enforcement still works, and that the property spec is still
-* `createExpression`'s third parameter (v26 inserted a `rootKey` at index 1,
-* shifting it from `[1]` to `[2]`). The "enforces an expected result type"
-* test in `tests/expressions.test.ts` fails if this shape stops being honored.
-*/
-function propertySpecFor(expectedType) {
-	return {
-		type: expectedType,
-		"property-type": "data-driven",
-		expression: { parameters: ["zoom", "feature"] }
-	};
-}
-/**
-* Validates a user-entered MapLibre expression: tolerant JSON parse, shape
-* checks, then a real compile through the MapLibre style spec so operator
-* misuse (wrong arity, unknown operator, type mismatch) is caught in the
-* dialog instead of silently failing on the map. Variables are substituted
-* before compiling (so tokens type-check as their values), and
-* `expectedType` additionally enforces the destination's result type. The
-* returned `parsed` array is the raw, unsubstituted parse. An empty/blank
-* source is valid (surfaces treat it as "no expression").
-*/
-function validateMapExpression(source, options = {}) {
-	return compileMapExpression(source, options).validation;
-}
-/**
-* The single parse + substitute + compile pass shared by validation and
-* preview evaluation, so a preview never compiles the same source twice.
-* `expression` is set only when the validation succeeded on a non-empty
-* source.
-*/
-function compileMapExpression(source, options) {
-	const trimmed = source.trim();
-	if (!trimmed) return { validation: {
-		ok: true,
-		errors: []
-	} };
-	let parsed;
-	try {
-		parsed = JSON.parse(removeTrailingJsonCommas(trimmed));
-	} catch (error) {
-		return { validation: {
-			ok: false,
-			code: "not-json",
-			errors: [error instanceof Error ? error.message : "Invalid JSON"]
-		} };
-	}
-	if (!Array.isArray(parsed)) return { validation: {
-		ok: false,
-		code: "not-array",
-		errors: []
-	} };
-	if (typeof parsed[0] !== "string") return { validation: {
-		ok: false,
-		code: "not-operator",
-		errors: [],
-		parsed
-	} };
-	const substituted = substituteExpressionVariables(parsed, options.variables ?? []);
-	const compiled = createExpression(substituted, EXPRESSION_ROOT_KEY, options.expectedType ? propertySpecFor(options.expectedType) : void 0);
-	if (compiled.result === "error") return { validation: {
-		ok: false,
-		code: "compile",
-		errors: compiled.value.map((issue) => issue.key ? `${issue.key}: ${issue.message}` : issue.message),
-		parsed
-	} };
-	return {
-		validation: {
-			ok: true,
-			errors: [],
-			parsed
-		},
-		expression: compiled.value
-	};
-}
-/**
-* Replaces every string node that exactly matches a known `@token` with that
-* variable's value, returning a new structure (the input is not mutated).
-* Unknown `@` strings are left untouched so field values that happen to start
-* with `@` never get mangled.
-*/
-function substituteExpressionVariables(node, variables) {
-	if (typeof node === "string" && node.startsWith("@")) {
-		const match = variables.find((variable) => variable.token === node);
-		return match ? match.value : node;
-	}
-	if (Array.isArray(node)) return node.map((entry) => substituteExpressionVariables(entry, variables));
-	if (node && typeof node === "object") return Object.fromEntries(Object.entries(node).map(([key, value]) => [key, substituteExpressionVariables(value, variables)]));
-	return node;
-}
-/**
-* Evaluates an expression source against a sample feature for the builder's
-* live preview. Variables are substituted first, then the expression is
-* compiled with the MapLibre style spec and evaluated with the given zoom.
-* Runtime failures (e.g. `to-color` on garbage) come back as errors instead
-* of throwing.
-*/
-function evaluateMapExpression(source, options = {}) {
-	const trimmed = source.trim();
-	if (!trimmed) return { kind: "empty" };
-	const { validation, expression } = compileMapExpression(trimmed, {
-		variables: options.variables,
-		expectedType: options.expectedType
-	});
-	if (!validation.ok || !expression) return {
-		kind: "error",
-		errors: validation.errors
-	};
-	const feature = options.feature ?? null;
-	const geometryType = feature?.geometry?.type ?? "Unknown";
-	try {
-		return {
-			kind: "value",
-			value: expression.evaluateWithoutErrorHandling({ zoom: options.zoom ?? 0 }, {
-				type: geometryType,
-				properties: feature?.properties ?? {},
-				...feature?.id !== void 0 ? { id: feature.id } : {},
-				geometry: feature?.geometry
-			})
-		};
-	} catch (error) {
-		return {
-			kind: "error",
-			errors: [error instanceof Error ? error.message : String(error)]
-		};
-	}
-}
-/**
-* Compiles an expression source once for bulk per-feature evaluation (virtual
-* fields, and any other caller that runs one expression over a whole layer).
-* Unlike {@link evaluateMapExpression} the compile cost is paid once, not per
-* feature. An empty source is reported as a failure with no errors — there is
-* nothing to evaluate.
-*/
-function compileFeatureExpression(source, options = {}) {
-	const trimmed = source.trim();
-	if (!trimmed) return {
-		ok: false,
-		errors: []
-	};
-	const { validation, expression } = compileMapExpression(trimmed, {
-		variables: options.variables,
-		expectedType: options.expectedType
-	});
-	if (!validation.ok || !expression) return {
-		ok: false,
-		errors: validation.errors
-	};
-	const compiledZoom = options.zoom ?? 0;
-	return {
-		ok: true,
-		errors: [],
-		evaluate: (feature, zoom = compiledZoom) => expression.evaluateWithoutErrorHandling({ zoom }, {
-			type: feature.geometry?.type ?? "Unknown",
-			properties: feature.properties ?? {},
-			...feature.id !== void 0 ? { id: feature.id } : {},
-			geometry: feature.geometry
-		})
-	};
-}
-/**
-* Evaluates a boolean expression against every feature and returns the
-* selection ids of the matches (Select by Expression). Unlike
-* {@link evaluateMapExpression} this compiles the source once and reuses the
-* compiled expression across the whole array, so it stays fast on large
-* layers. An empty source is reported as `ok: false` with no errors — there
-* is nothing to select by.
-*/
-function matchFeaturesByExpression(features, source, options = {}) {
-	const trimmed = source.trim();
-	if (!trimmed) return {
-		ok: false,
-		errors: [],
-		ids: [],
-		errorCount: 0
-	};
-	const { validation, expression } = compileMapExpression(trimmed, {
-		variables: options.variables,
-		expectedType: "boolean"
-	});
-	if (!validation.ok || !expression) return {
-		ok: false,
-		errors: validation.errors,
-		ids: [],
-		errorCount: 0
-	};
-	const ids = [];
-	let errorCount = 0;
-	features.forEach((feature, index) => {
-		try {
-			if (expression.evaluateWithoutErrorHandling({ zoom: options.zoom ?? 0 }, {
-				type: feature.geometry?.type ?? "Unknown",
-				properties: feature.properties ?? {},
-				...feature.id !== void 0 ? { id: feature.id } : {},
-				geometry: feature.geometry
-			}) === true) ids.push(featureSelectionId(feature, index));
-		} catch {
-			errorCount += 1;
-		}
-	});
-	return {
-		ok: true,
-		errors: [],
-		ids,
-		errorCount
-	};
-}
-/**
-* True when a preview value is a real style-spec `Color` instance (its
-* evaluated color representation: premultiplied r/g/b/a floats). Shared by
-* the preview formatter and the dialog's color-swatch rendering so the two
-* checks cannot drift apart. An instanceof check (not duck typing) so user
-* attribute data that happens to carry numeric r/g/b/a fields (e.g. via
-* `["properties"]`) is never misclassified as a color.
-*/
-function isStyleSpecColor(value) {
-	return value instanceof Color;
-}
-/**
-* Renders a preview value as a short display string: style-spec Color
-* instances become rgba() strings, plain values render as JSON, and
-* `null`/`undefined` render as "null".
-*/
-function formatExpressionPreviewValue(value) {
-	if (value === null || value === void 0) return "null";
-	if (isStyleSpecColor(value)) {
-		const color = value;
-		const alpha = color.a;
-		const channel = (component) => Math.round((alpha === 0 ? 0 : component / alpha) * 255);
-		return `rgba(${channel(color.r)}, ${channel(color.g)}, ${channel(color.b)}, ${Number(alpha.toFixed(3))})`;
-	}
-	try {
-		return JSON.stringify(value) ?? String(value);
-	} catch {
-		return String(value);
-	}
-}
-/**
-* Infers a display type for each named field by scanning feature properties:
-* a single consistent primitive type wins, disagreements become "mixed", and
-* fields with no non-null values are "unknown".
-*/
-function inferFieldTypes(features, names) {
-	const result = {};
-	for (const name of names) result[name] = "unknown";
-	for (const feature of features) {
-		const properties = feature.properties;
-		if (!properties) continue;
-		for (const name of names) {
-			const value = properties[name];
-			if (value === null || value === void 0) continue;
-			const valueType = typeof value;
-			const fieldType = valueType === "string" || valueType === "number" || valueType === "boolean" ? valueType : "mixed";
-			if (result[name] === "unknown") result[name] = fieldType;
-			else if (result[name] !== fieldType) result[name] = "mixed";
-		}
-	}
-	return result;
-}
-//#endregion
-//#region src/virtual-fields.ts
-/**
-* Virtual fields (QGIS Field Calculator → "Create virtual field", issue
-* #1321): expression-backed columns that recompute live instead of being
-* written once as static values.
-*
-* The engine mirrors the persistent-joins engine (`joins.ts`): computed
-* values are materialized into feature properties, so every consumer of
-* attributes — the attribute table, Expression Builder, data-driven styling,
-* labels, selection, export — sees the column with no further wiring.
-* Idempotency uses the same bookkeeping: each applied field records the
-* column it actually added (`addedField`), applying always strips those
-* first, and an existing column always wins a name collision (the virtual
-* field is skipped entirely), so stripping exactly restores the pre-apply
-* properties.
-*
-* Expressions are declarative MapLibre expressions compiled through the
-* style spec — never arbitrary code — so persisting them in `.geolibre.json`
-* and re-evaluating them on project load is safe (unlike the attribute
-* table's Field Calculator, whose JavaScript evaluator must never run
-* persisted expressions). Fields apply in list order and each sees the
-* columns materialized by earlier fields, so a virtual field can build on
-* another. Zoom-dependent expressions evaluate at zoom 0 and `@` variables
-* are not substituted: a virtual field is a property of the data, not of the
-* current view.
-*
-* Known trade-off, shared with the joins engine (see `joins.ts`): when a
-* layer's data is replaced wholesale, the replacement is stripped with the
-* *previous* bookkeeping. That is required because a replacement can also be
-* a write-back of the derived output (the attribute table round-trips
-* `layer.geojson`), which must not freeze a stale computed value into base
-* data — but it means a replacement dataset's own column whose name matches a
-* previously-materialized virtual column is replaced by the expression's
-* value for that column. Renaming or removing the virtual field first keeps
-* such collisions from arising.
-*/
-/**
-* Remove every column previously added by `fields` (per their `addedField`
-* bookkeeping) from a copy of `features`, restoring the pre-apply properties.
-* Features without any tracked column are returned unchanged (same
-* reference).
-*/
-function stripVirtualFieldColumns(features, fields) {
-	const tracked = /* @__PURE__ */ new Set();
-	for (const field of fields ?? []) if (field.addedField) tracked.add(field.addedField);
-	if (tracked.size === 0) return features;
-	return features.map((feature) => {
-		const props = feature.properties;
-		if (!props) return feature;
-		let hasTracked = false;
-		for (const key of tracked) if (key in props) {
-			hasTracked = true;
-			break;
-		}
-		if (!hasTracked) return feature;
-		const next = {};
-		for (const [key, value] of Object.entries(props)) if (!tracked.has(key)) next[key] = value;
-		return {
-			...feature,
-			properties: next
-		};
-	});
-}
-/**
-* Normalize an evaluated expression value into a property value: `undefined`
-* and non-finite numbers become null (a clean empty cell), style-spec Color
-* instances become their rgba() string (a Color object would neither
-* serialize nor display usefully), everything else passes through.
-*/
-function normalizeComputedValue(value) {
-	if (value === void 0) return null;
-	if (typeof value === "number" && !Number.isFinite(value)) return null;
-	if (isStyleSpecColor(value)) return formatExpressionPreviewValue(value);
-	return value;
-}
-/**
-* Apply `fields` in order to base (already-stripped) `features`, returning
-* new feature objects with each computed column merged into their properties.
-*
-* Semantics per field: a disabled field, an empty/colliding output name, or
-* an expression that fails to compile contributes nothing (with the compile
-* error recorded on the field); a runtime evaluation failure nulls that one
-* feature's cell and increments the field's `errorCount` instead of aborting
-* the column. Fields evaluate sequentially, so a later field's expression
-* can `["get", ...]` an earlier field's column.
-*/
-function applyLayerVirtualFields(features, fields) {
-	const fieldList = fields ?? [];
-	const clearBookkeeping = (field) => ({
-		...field,
-		addedField: void 0,
-		error: void 0,
-		errorCount: void 0
-	});
-	if (fieldList.filter((field) => field.enabled !== false).length === 0) return {
-		features,
-		fields: fieldList.map(clearBookkeeping)
-	};
-	const usedNames = /* @__PURE__ */ new Set();
-	for (const feature of features) for (const key of Object.keys(feature.properties ?? {})) usedNames.add(key);
-	const out = features.map((feature) => ({
-		...feature,
-		properties: { ...feature.properties ?? {} }
-	}));
-	return {
-		features: out,
-		fields: fieldList.map((field) => {
-			if (field.enabled === false) return clearBookkeeping(field);
-			const name = field.name.trim();
-			if (!name || usedNames.has(name)) return clearBookkeeping(field);
-			const compiled = compileFeatureExpression(field.expression);
-			if (!compiled.ok || !compiled.evaluate) return {
-				...clearBookkeeping(field),
-				error: compiled.errors[0] ?? "Invalid expression"
-			};
-			usedNames.add(name);
-			let errorCount = 0;
-			for (const feature of out) {
-				let value = null;
-				try {
-					value = normalizeComputedValue(compiled.evaluate(feature));
-				} catch {
-					errorCount += 1;
-				}
-				feature.properties[name] = value;
-			}
-			return {
-				...clearBookkeeping(field),
-				addedField: name,
-				...errorCount > 0 ? { errorCount } : {}
-			};
-		})
-	};
-}
-//#endregion
-//#region src/joins.ts
-/**
-* Persistent attribute joins (QGIS Layer Properties → Joins), issue #1315.
-*
-* A layer's `joins` are live left joins that materialize columns from another
-* layer's attribute table into this layer's feature properties. Materializing
-* (rather than resolving lazily) means every consumer of attributes — the
-* attribute table, Expression Builder, data-driven styling, labels, diagrams,
-* export — sees the joined columns with no further wiring.
-*
-* Idempotency without a duplicate base copy: each applied join records the
-* output column names it added (`addedFields`), and applying joins always
-* strips those first. Base columns win every name collision (a joined column
-* whose output name already exists is skipped entirely), so stripping the
-* added columns exactly restores the pre-join properties.
-*
-* Known trade-off of that bookkeeping: when a layer's data is replaced
-* wholesale (file reload), the replacement is stripped with the *previous*
-* `addedFields`. That is required because a replacement can also be a
-* write-back of the joined output (the attribute table round-trips
-* `layer.geojson`), which must not freeze stale joined values into base data —
-* but it means a reloaded base column whose name collides with a
-* previously-joined output column is replaced by the join's value for that
-* column. A field-name prefix (the QGIS convention the UI suggests) keeps
-* such collisions from arising.
-*
-* The data is already in memory as JS feature objects, so the join is a plain
-* hash join here rather than the DuckDB-WASM SQL statement sketched in the
-* issue — the result is identical for equality keys and the engine stays
-* synchronous and dependency-free. Key semantics deliberately mirror the
-* Processing → Vector attribute join (and the sidecar's `_attribute_join_key`):
-* empty values never match, and non-empty values compare stringified.
-*/
-/** Canonical JSON for object values (sorted keys), matching the processing engine. */
-function stableStringify(value) {
-	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
-	if (value !== null && typeof value === "object") return `{${Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(",")}}`;
-	return JSON.stringify(value) ?? "null";
-}
-function valueToString(value) {
-	if (typeof value === "boolean") return value ? "true" : "false";
-	if (value !== null && typeof value === "object") return stableStringify(value);
-	return String(value);
-}
-/**
-* Match key for a persistent join: empty values (null/undefined/NaN/empty
-* string) never match a row, mirroring a SQL/pandas NaN join key. Non-empty
-* values are keyed by their string form, so a numeric `5` and the string `"5"`
-* join while a zero-padded code like `"01001"` only matches another `"01001"`.
-* Kept in sync with the Processing attribute join's `attributeJoinKey`.
-*/
-function layerJoinKey(value) {
-	return value === null || value === void 0 || typeof value === "number" && Number.isNaN(value) || valueToString(value) === "" ? null : valueToString(value);
-}
-/** GeoJSON columns are own properties; inherited object members are not data. */
-function fieldValue(properties, field) {
-	return properties && Object.hasOwn(properties, field) ? properties[field] : void 0;
-}
-/**
-* Remove every column previously added by `joins` (per their `addedFields`
-* bookkeeping) from a copy of `features`, restoring the pre-join properties.
-* Features without any tracked column are returned unchanged (same reference).
-*/
-function stripJoinFields(features, joins) {
-	const tracked = /* @__PURE__ */ new Set();
-	for (const join of joins ?? []) for (const field of join.addedFields ?? []) tracked.add(field);
-	if (tracked.size === 0) return features;
-	return features.map((feature) => {
-		const props = feature.properties;
-		if (!props) return feature;
-		let hasTracked = false;
-		for (const key of tracked) if (key in props) {
-			hasTracked = true;
-			break;
-		}
-		if (!hasTracked) return feature;
-		const next = {};
-		for (const [key, value] of Object.entries(props)) if (!tracked.has(key)) next[key] = value;
-		return {
-			...feature,
-			properties: next
-		};
-	});
-}
-/**
-* Apply `joins` in order to base (already-stripped) `features`, returning new
-* feature objects with the joined columns merged into their properties.
-*
-* Semantics per join: left join, first matching join row wins, and joined
-* columns are null-filled on unmatched features so the schema stays
-* consistent. An output name (prefix + field) that collides with an existing
-* column — from the base data or an earlier join — drops that one column;
-* the join's other columns still apply. A disabled join, or one whose source
-* cannot be resolved, contributes nothing and gets empty `addedFields` and no
-* stats.
-*
-* @param features - The layer's base features (strip previous joins first).
-* @param joins - Join definitions in application order.
-* @param resolveSource - Maps a join's `joinLayerId` to that layer's current
-*   feature collection, or `undefined` when the layer is gone (or is the
-*   target itself; self-joins are refused by the caller).
-*/
-function applyLayerJoins(features, joins, resolveSource) {
-	const joinList = joins ?? [];
-	const resolved = /* @__PURE__ */ new Map();
-	const resolveOnce = (joinLayerId) => {
-		if (!resolved.has(joinLayerId)) resolved.set(joinLayerId, resolveSource(joinLayerId));
-		return resolved.get(joinLayerId);
-	};
-	if (joinList.filter((join) => join.enabled !== false && resolveOnce(join.joinLayerId)).length === 0) return {
-		features,
-		joins: joinList.map((join) => ({
-			...join,
-			addedFields: [],
-			stats: void 0
-		}))
-	};
-	const out = features.map((feature) => ({
-		...feature,
-		properties: { ...feature.properties ?? {} }
-	}));
-	const usedNames = /* @__PURE__ */ new Set();
-	for (const feature of features) for (const key of Object.keys(feature.properties ?? {})) usedNames.add(key);
-	return {
-		features: out,
-		joins: joinList.map((join) => {
-			const source = join.enabled === false ? void 0 : resolveOnce(join.joinLayerId);
-			if (!source) return {
-				...join,
-				addedFields: [],
-				stats: void 0
-			};
-			const joinFeatures = (source.features ?? []).filter(Boolean);
-			const joinKeysOrder = [];
-			const joinKeySet = /* @__PURE__ */ new Set();
-			for (const jf of joinFeatures) for (const key of Object.keys(jf.properties ?? {})) if (!joinKeySet.has(key)) {
-				joinKeySet.add(key);
-				joinKeysOrder.push(key);
-			}
-			const requested = join.fields !== void 0 ? join.fields.filter((field) => joinKeySet.has(field)) : joinKeysOrder.filter((key) => key !== join.joinField);
-			const prefix = join.prefix ?? "";
-			const fieldPairs = [];
-			for (const field of requested) {
-				const outputName = prefix + field;
-				if (usedNames.has(outputName)) continue;
-				usedNames.add(outputName);
-				fieldPairs.push([field, outputName]);
-			}
-			const lookup = /* @__PURE__ */ new Map();
-			for (const jf of joinFeatures) {
-				const key = layerJoinKey(fieldValue(jf.properties, join.joinField));
-				if (key === null || lookup.has(key)) continue;
-				lookup.set(key, jf.properties ?? {});
-			}
-			let matched = 0;
-			const targetKeys = /* @__PURE__ */ new Set();
-			for (const feature of out) {
-				const props = feature.properties;
-				const key = layerJoinKey(fieldValue(props, join.targetField));
-				if (key !== null) targetKeys.add(key);
-				const row = key === null ? void 0 : lookup.get(key);
-				if (row) {
-					matched += 1;
-					for (const [field, outputName] of fieldPairs) props[outputName] = fieldValue(row, field) ?? null;
-				} else for (const [, outputName] of fieldPairs) props[outputName] = null;
-			}
-			let unmatchedJoin = 0;
-			for (const jf of joinFeatures) {
-				const key = layerJoinKey(fieldValue(jf.properties, join.joinField));
-				if (key !== null && !targetKeys.has(key)) unmatchedJoin += 1;
-			}
-			return {
-				...join,
-				addedFields: fieldPairs.map(([, outputName]) => outputName),
-				stats: {
-					matchedCount: matched,
-					unmatchedTargetCount: out.length - matched,
-					unmatchedJoinCount: unmatchedJoin
-				}
-			};
-		})
-	};
-}
-/**
-* Strip-and-reapply this layer's derived columns — persistent joins, then
-* virtual fields (so an expression can read joined columns) — resolving join
-* sources from `allLayers`. Pass `nextJoins`/`nextVirtualFields` to replace
-* the definitions (the layer's current bookkeeping still drives the strip, so
-* removed definitions clean up after themselves); omit them to refresh the
-* existing definitions against current data. Layers without a feature
-* collection are returned unchanged.
-*/
-function applyJoinsToLayer(layer, allLayers, nextJoins, nextVirtualFields) {
-	const geojson = layer.geojson;
-	const joins = nextJoins ?? layer.joins ?? [];
-	const virtualFields = nextVirtualFields ?? layer.virtualFields ?? [];
-	if (!geojson) return {
-		...layer,
-		joins: joins.length > 0 ? joins : void 0,
-		virtualFields: virtualFields.length > 0 ? virtualFields : void 0
-	};
-	const applied = applyLayerJoins(stripJoinFields(stripVirtualFieldColumns(geojson.features ?? [], layer.virtualFields), layer.joins), joins, (joinLayerId) => {
-		if (joinLayerId === layer.id) return void 0;
-		return allLayers.find((candidate) => candidate.id === joinLayerId)?.geojson;
-	});
-	const withVirtual = applyLayerVirtualFields(applied.features, virtualFields);
-	return {
-		...layer,
-		geojson: {
-			...geojson,
-			features: withVirtual.features
-		},
-		joins: applied.joins.length > 0 ? applied.joins : void 0,
-		virtualFields: withVirtual.fields.length > 0 ? withVirtual.fields : void 0
-	};
-}
-/**
-* Ids of every layer whose data (directly or transitively) feeds `layerId`'s
-* joins, following `joinLayerId` edges through each source's own joins.
-* Disabled joins count too: re-enabling one must not spring a cycle. The Joins
-* UI uses this to keep a layer that already consumes the target — however
-* indirectly — out of the join-source picker, so circular joins cannot be
-* authored (the refresh cascade still breaks them defensively for hand-edited
-* projects).
-*/
-function collectTransitiveJoinSourceIds(layers, layerId) {
-	const byId = new Map(layers.map((layer) => [layer.id, layer]));
-	const visited = /* @__PURE__ */ new Set();
-	const queue = [layerId];
-	while (queue.length > 0) {
-		const current = byId.get(queue.shift());
-		for (const join of current?.joins ?? []) {
-			if (visited.has(join.joinLayerId)) continue;
-			visited.add(join.joinLayerId);
-			queue.push(join.joinLayerId);
-		}
-	}
-	return visited;
-}
-/**
-* Order `candidates` (layers with joins) so every layer comes after the
-* candidates its joins consume — Kahn's algorithm over "join source → join
-* target" edges within the candidate set. When a cycle blocks progress
-* (possible only in hand-edited projects; the UI refuses circular joins), an
-* actual cycle member is forced through — found by walking unmet-source edges
-* until a node repeats — so consumers *downstream* of the cycle still order
-* after it rather than falling back ahead of it.
-*/
-function topologicalJoinOrder(candidates) {
-	const candidateIds = new Set(candidates.map((layer) => layer.id));
-	const indegree = /* @__PURE__ */ new Map();
-	const dependents = /* @__PURE__ */ new Map();
-	const sourcesOf = /* @__PURE__ */ new Map();
-	for (const layer of candidates) indegree.set(layer.id, 0);
-	for (const layer of candidates) for (const join of layer.joins ?? []) {
-		if (join.enabled === false || join.joinLayerId === layer.id || !candidateIds.has(join.joinLayerId)) continue;
-		indegree.set(layer.id, (indegree.get(layer.id) ?? 0) + 1);
-		const list = dependents.get(join.joinLayerId) ?? [];
-		list.push(layer.id);
-		dependents.set(join.joinLayerId, list);
-		const sources = sourcesOf.get(layer.id) ?? [];
-		sources.push(join.joinLayerId);
-		sourcesOf.set(layer.id, sources);
-	}
-	const order = [];
-	const orderedSet = /* @__PURE__ */ new Set();
-	const queue = candidates.filter((layer) => indegree.get(layer.id) === 0).map((layer) => layer.id);
-	while (order.length < candidates.length) {
-		if (queue.length === 0) {
-			const start = candidates.find((layer) => !orderedSet.has(layer.id));
-			if (!start) break;
-			let cursor = start.id;
-			const walked = /* @__PURE__ */ new Set();
-			while (!walked.has(cursor)) {
-				walked.add(cursor);
-				const next = (sourcesOf.get(cursor) ?? []).find((source) => !orderedSet.has(source));
-				if (next === void 0) break;
-				cursor = next;
-			}
-			queue.push(cursor);
-		}
-		const id = queue.shift();
-		if (orderedSet.has(id)) continue;
-		orderedSet.add(id);
-		order.push(id);
-		for (const dependent of dependents.get(id) ?? []) {
-			const remaining = (indegree.get(dependent) ?? 1) - 1;
-			indegree.set(dependent, remaining);
-			if (remaining === 0 && !orderedSet.has(dependent)) queue.push(dependent);
-		}
-	}
-	return order;
-}
-/**
-* Refresh every layer whose joins (directly or transitively) consume the
-* layer identified by `seedId`, after that layer's data changed — or after it
-* was removed (a gone source resolves to nothing, so its frozen columns strip
-* away). The affected layers re-derive in topological dependency order, so a
-* layer joining two other affected layers sees both of them fresh regardless
-* of their positions in the layer panel. The seed itself is not touched.
-*/
-function cascadeLayerJoinRefresh(layers, seedId) {
-	const affected = /* @__PURE__ */ new Set();
-	const queue = [seedId];
-	while (queue.length > 0) {
-		const sourceId = queue.shift();
-		for (const layer of layers) {
-			if (layer.id === seedId || affected.has(layer.id)) continue;
-			if (layer.joins?.some((join) => join.enabled !== false && join.joinLayerId === sourceId)) {
-				affected.add(layer.id);
-				queue.push(layer.id);
-			}
-		}
-	}
-	if (affected.size === 0) return layers;
-	let current = layers;
-	const order = topologicalJoinOrder(layers.filter((layer) => affected.has(layer.id)));
-	for (const id of order) current = current.map((layer) => layer.id === id ? applyJoinsToLayer(layer, current) : layer);
-	return current;
-}
-/**
-* Re-resolve every layer's persistent joins against the freshly loaded layer
-* set (project open). Layers re-derive in topological order of their join
-* dependencies, so a chain (`C joins A, A joins B`) resolves A before C; a
-* hand-edited cycle is broken by forcing one of its members through first
-* (see {@link topologicalJoinOrder}), so consumers downstream of the cycle
-* still re-derive after it. Layers with virtual fields but no joins re-derive
-* too (their expressions run against the freshly loaded features). Layer sets
-* without joins or virtual fields pass through by reference.
-*/
-function reapplyLayerJoins(layers) {
-	const joined = layers.filter((layer) => layer.joins?.length || layer.virtualFields?.length);
-	if (joined.length === 0) return layers;
-	let current = layers;
-	for (const id of topologicalJoinOrder(joined)) current = current.map((layer) => layer.id === id ? applyJoinsToLayer(layer, current) : layer);
-	return current;
-}
-//#endregion
-export { unescapePolyline as A, PLANET_SWITCHER_OPTIONS as B, invertSelection as C, encodePolyline as D, decodePolylineDetailed as E, EARTH_MEAN_RADIUS_METERS as F, getActiveEllipsoid as G, earthAreaToBody as H, ELLIPSOIDS as I, getEllipsoid as J, getActiveMeanRadiusMeters as K, PLANETARY_BASEMAPS as L, horizontalBbox as M, transformGeojsonElevation as N, geoJSONToPolylineStr as O, DEFAULT_ELLIPSOID_ID as P, setActiveEllipsoidId as Q, PLANETARY_BASEMAP_GROUPS as R, featureSelectionId as S, decodePolyline as T, earthLengthToBody as U, bodyLengthToEarth as V, getActiveBodyRadiusRatio as W, getPlanetaryBasemapByStyleUrl as X, getPlanetaryBasemapById as Y, meanRadiusMeters as Z, removeTrailingJsonCommas as _, layerJoinKey as a, SELECTION_MODES as b, applyLayerVirtualFields as c, compileFeatureExpression as d, evaluateMapExpression as f, matchFeaturesByExpression as g, isStyleSpecColor as h, collectTransitiveJoinSourceIds as i, geojsonHasZCoordinates as j, polylineStrToGeoJSON as k, stripVirtualFieldColumns as l, inferFieldTypes as m, applyLayerJoins as n, reapplyLayerJoins as o, formatExpressionPreviewValue as p, getActiveSemiMajorAxisMeters as q, cascadeLayerJoinRefresh as r, stripJoinFields as s, applyJoinsToLayer as t, EXPRESSION_FUNCTION_CATEGORIES as u, substituteExpressionVariables as v, batchDecodePolylines as w, applySelectionMode as x, validateMapExpression as y, PLANETARY_BASEMAP_SENTINEL_PREFIX as z };
-
-//# sourceMappingURL=joins-CGcRoTpc.mjs.map