@geolibre/core 3.6.1 → 3.8.0

package/dist/{project-diff-RBRpSza4.mjs → project-diff-DJkOd8ff.mjs}

@@ -1,3 +1,4 @@
+import { _ as getPlanetaryBasemapByStyleUrl, h as getEllipsoid, m as getActiveSemiMajorAxisMeters } from "./ellipsoids-DlTLddDu.mjs";
 import { Color, createExpression } from "@maplibre/maplibre-gl-style-spec";
 import { v4 } from "uuid";
 // src/types.ts
@@ -98,6 +99,23 @@ const LAYER_TYPES = [
 	"image"
 ];
 /**
+* The named dash patterns the Style panel offers for {@link LayerStyle.strokeDash},
+* in MapLibre `line-dasharray` units (multiples of the line width). `solid` is
+* the empty pattern. QGIS pen styles map onto the same names.
+*/
+const STROKE_DASH_PRESETS = {
+	solid: [],
+	dashed: [4, 2],
+	dotted: [1, 2],
+	"dash-dot": [
+		4,
+		2,
+		1,
+		2
+	],
+	"long-dash": [8, 3]
+};
+/**
 * Cartographic blend modes offered for {@link LayerStyle.blendMode}.
 *
 * The list is bounded by what WebGL *fixed-function* blending can express --
@@ -142,6 +160,9 @@ const DEFAULT_LAYER_STYLE = {
 	strokeColor: "#1e40af",
 	strokeWidth: 2,
 	strokeWidthUnit: "pixels",
+	strokeOpacity: 1,
+	strokeDash: [],
+	strokeBlur: 0,
 	fillOpacity: .6,
 	circleRadius: 6,
 	textColor: "#111827",
@@ -182,9 +203,13 @@ const DEFAULT_LAYER_STYLE = {
 	extrusionHeightProperty: "height",
 	extrusionHeightScale: 1,
 	extrusionBase: 0,
+	extrusionBaseProperty: "",
+	extrusionBaseScale: 1,
+	extrusionFloorHeight: 0,
 	extrusionAdvancedStyleEnabled: false,
 	extrusionColorExpression: "",
 	extrusionHeightExpression: "",
+	extrusionBaseExpression: "",
 	elevation3dEnabled: false,
 	elevation3dVerticalScale: 1,
 	elevation3dOffset: 0,
@@ -304,6 +329,32 @@ const SQL_QUERY_SOURCE_KIND = "sql-query";
 */
 const NETCDF_IMAGE_SOURCE_KIND = "netcdf-image";
 /**
+* Metadata `sourceKind` marking an ArcGIS ImageServer drawn as a `raster` layer.
+*
+* Defined here so the plugin that adds these layers and `@geolibre/map` (whose
+* Identify reads their pixel values through the service's `/identify`) share
+* one value.
+*/
+const ARCGIS_IMAGE_SERVICE_SOURCE_KIND = "arcgis-image-service";
+/**
+* Metadata `sourceKind` marking a Microsoft Planetary Computer raster layer
+* (one STAC item, or a mosaic of many) drawn by the Planetary Computer panel.
+*
+* Defined here so the plugin that adds these layers, the Layer Library's
+* restore dispatch, and `@geolibre/map` (whose Identify reads their pixel
+* values through the application's raster bridge) share one value.
+*/
+const PLANETARY_COMPUTER_SOURCE_KIND = "planetary-computer-raster";
+/**
+* Whether a layer is a Planetary Computer raster the panel's control draws.
+*
+* @param layer - The layer to test.
+* @returns True for a control-drawn Planetary Computer item or mosaic layer.
+*/
+function isPlanetaryComputerLayer(layer) {
+	return layer.type === "raster" && layer.metadata.sourceKind === "planetary-computer-raster" && layer.metadata.externalNativeLayer === true;
+}
+/**
 * Detect a DuckDB query layer rendered through the plugin's external deck.gl
 * overlay. Shared by `@geolibre/map`, `@geolibre/plugins`, and the desktop
 * app so the detection criteria cannot drift.
@@ -454,499 +505,6 @@ function detectNonGeographicCoordinates(geojson, sampleLimit = 1e3) {
 		maxAbsY
 	} : null;
 }
-// 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"
-	}
-];
 // src/regional-basemaps.ts
 const REGIONAL_BASEMAP_SENTINEL_PREFIX = "geolibre://regional-basemap/";
 const AMAP_ATTRIBUTION = "&copy; <a href=\"https://www.amap.com\">高德地图 Amap</a>";
@@ -969,6 +527,7 @@ const CHINA_BASEMAPS = [
 		id: "amap-street",
 		region: "china",
 		name: "高德地图",
+		provider: "Amap",
 		styleUrl: sentinel("amap-street"),
 		tileUrl: AMAP_STREET_URL,
 		maxZoom: 19,
@@ -979,6 +538,7 @@ const CHINA_BASEMAPS = [
 		id: "amap-satellite",
 		region: "china",
 		name: "高德卫星",
+		provider: "Amap",
 		styleUrl: sentinel("amap-satellite"),
 		tileUrl: AMAP_SATELLITE_URL,
 		maxZoom: 18,
@@ -989,6 +549,7 @@ const CHINA_BASEMAPS = [
 		id: "amap-hybrid",
 		region: "china",
 		name: "高德混合",
+		provider: "Amap",
 		styleUrl: sentinel("amap-hybrid"),
 		tileUrl: AMAP_SATELLITE_URL,
 		overlayTileUrl: AMAP_LABELS_URL,
@@ -1000,6 +561,7 @@ const CHINA_BASEMAPS = [
 		id: "tencent-street",
 		region: "china",
 		name: "腾讯地图",
+		provider: "Tencent Maps",
 		styleUrl: sentinel("tencent-street"),
 		tileUrl: tencentUrl(1),
 		scheme: "tms",
@@ -1011,6 +573,7 @@ const CHINA_BASEMAPS = [
 		id: "tencent-dark",
 		region: "china",
 		name: "腾讯深色",
+		provider: "Tencent Maps",
 		styleUrl: sentinel("tencent-dark"),
 		tileUrl: tencentUrl(4),
 		scheme: "tms",
@@ -1045,6 +608,33 @@ function getRegionalBasemapById(id) {
 function isRegionalBasemapSentinel(styleUrl) {
 	return Boolean(styleUrl?.startsWith(REGIONAL_BASEMAP_SENTINEL_PREFIX));
 }
+/**
+* Decides which basemap a project load actually applies.
+*
+* Only a resolvable regional sentinel is gated. Every other style URL (and an
+* unknown regional id, which the map controller already replaces with the
+* default basemap) passes through untouched.
+*
+* @param styleUrl - The basemap style URL the project requests.
+* @param policy - The store's current {@link RegionalBasemapPolicy}.
+* @param fallbackStyleUrl - The basemap to apply instead (the default basemap).
+* @param trusted - True when the user already chose this basemap in this
+*   session (a template, an undo step, a duplicate), so `"prompt"` does not
+*   apply. `"block"` still does.
+* @returns The style URL to apply and, when it was replaced, why.
+*/
+function gateRegionalBasemap(styleUrl, policy, fallbackStyleUrl, trusted = false) {
+	if (!getRegionalBasemapByStyleUrl(styleUrl)) return { styleUrl };
+	if (policy === "block") return {
+		styleUrl: fallbackStyleUrl,
+		held: "blocked"
+	};
+	if (policy === "prompt" && !trusted) return {
+		styleUrl: fallbackStyleUrl,
+		held: "prompt"
+	};
+	return { styleUrl };
+}
 // src/cesium-imagery.ts
 /**
 * Maps the project's basemap onto imagery the Cesium globe can render.
@@ -1970,35 +1560,563 @@ function mapGeometryPositions(geometry, mapPosition) {
 		default: return geometry;
 	}
 }
-// src/polyline.ts
+// src/color-ramp.ts
+/** The built-in color ramps offered by the style panels. */
+const VECTOR_COLOR_RAMPS = [
+	{
+		value: "viridis",
+		label: "Viridis",
+		colors: [
+			"#440154",
+			"#31688e",
+			"#35b779",
+			"#fde725"
+		]
+	},
+	{
+		value: "plasma",
+		label: "Plasma",
+		colors: [
+			"#0d0887",
+			"#9c179e",
+			"#ed7953",
+			"#f0f921"
+		]
+	},
+	{
+		value: "inferno",
+		label: "Inferno",
+		colors: [
+			"#000004",
+			"#781c6d",
+			"#ed6925",
+			"#fcffa4"
+		]
+	},
+	{
+		value: "magma",
+		label: "Magma",
+		colors: [
+			"#000004",
+			"#721f81",
+			"#f1605d",
+			"#fcfdbf"
+		]
+	},
+	{
+		value: "cividis",
+		label: "Cividis",
+		colors: [
+			"#00204d",
+			"#575d6d",
+			"#a59c74",
+			"#ffea46"
+		]
+	},
+	{
+		value: "turbo",
+		label: "Turbo",
+		colors: [
+			"#30123b",
+			"#4777ef",
+			"#1ccfd0",
+			"#b9e642",
+			"#fb8022",
+			"#7a0403"
+		]
+	},
+	{
+		value: "spectral",
+		label: "Spectral",
+		colors: [
+			"#9e0142",
+			"#f46d43",
+			"#ffffbf",
+			"#66c2a5",
+			"#5e4fa2"
+		]
+	},
+	{
+		value: "blues",
+		label: "Blues",
+		colors: [
+			"#eff6ff",
+			"#93c5fd",
+			"#2563eb",
+			"#1e3a8a"
+		]
+	},
+	{
+		value: "greens",
+		label: "Greens",
+		colors: [
+			"#f0fdf4",
+			"#86efac",
+			"#16a34a",
+			"#14532d"
+		]
+	},
+	{
+		value: "oranges",
+		label: "Oranges",
+		colors: [
+			"#fff7ed",
+			"#fdba74",
+			"#f97316",
+			"#7c2d12"
+		]
+	},
+	{
+		value: "reds",
+		label: "Reds",
+		colors: [
+			"#fff5f0",
+			"#fcae91",
+			"#fb6a4a",
+			"#cb181d",
+			"#67000d"
+		]
+	},
+	{
+		value: "purples",
+		label: "Purples",
+		colors: [
+			"#fcfbfd",
+			"#bcbddc",
+			"#807dba",
+			"#54278f",
+			"#3f007d"
+		]
+	},
+	{
+		value: "terrain",
+		label: "Terrain",
+		colors: [
+			"#333399",
+			"#21bcb3",
+			"#79d05a",
+			"#e8e85a",
+			"#a87b54",
+			"#ffffff"
+		]
+	},
+	{
+		value: "rdylgn",
+		label: "Red-Yellow-Green",
+		colors: [
+			"#a50026",
+			"#f46d43",
+			"#ffffbf",
+			"#66bd63",
+			"#006837"
+		]
+	},
+	{
+		value: "rdylbu",
+		label: "Red-Yellow-Blue",
+		colors: [
+			"#a50026",
+			"#f46d43",
+			"#ffffbf",
+			"#74add1",
+			"#313695"
+		]
+	},
+	{
+		value: "rdbu",
+		label: "Red-Blue",
+		colors: [
+			"#b2182b",
+			"#ef8a62",
+			"#f7f7f7",
+			"#67a9cf",
+			"#2166ac"
+		]
+	},
+	{
+		value: "coolwarm",
+		label: "Cool-Warm",
+		colors: [
+			"#3b4cc0",
+			"#7b9ff9",
+			"#dddcdc",
+			"#f49a7b",
+			"#b40426"
+		]
+	},
+	{
+		value: "jet",
+		label: "Jet",
+		colors: [
+			"#000080",
+			"#0000ff",
+			"#00ffff",
+			"#ffff00",
+			"#ff0000",
+			"#800000"
+		]
+	},
+	{
+		value: "greys",
+		label: "Greys",
+		colors: [
+			"#ffffff",
+			"#bdbdbd",
+			"#636363",
+			"#000000"
+		]
+	},
+	{
+		value: "gray",
+		label: "Grayscale",
+		colors: ["#000000", "#ffffff"]
+	}
+];
 /**
-* Pure TypeScript Google Encoded Polyline algorithm codec.
+* Resolves a ramp definition by name, falling back to the first ramp when the
+* name is unknown.
 *
-* 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)
+* @param value - The ramp `value` (e.g. "viridis").
+* @returns The matching ramp, or the first ramp.
+*/
+function getVectorColorRamp(value) {
+	return VECTOR_COLOR_RAMPS.find((colorRamp) => colorRamp.value === value) ?? VECTOR_COLOR_RAMPS[0];
+}
+/**
+* Samples a ramp into `count` evenly spaced hex colors by linearly
+* interpolating between the ramp's anchor colors.
 *
-* Coordinates are represented as `[lon, lat]` pairs in GeoJSON format.
+* @param colorRamp - The ramp `value`.
+* @param count - Number of colors to produce.
+* @returns An array of `count` hex colors (a single end color when count <= 1).
 */
+function interpolateRampColors(colorRamp, count) {
+	return interpolateColors(getVectorColorRamp(colorRamp).colors, count);
+}
 /**
-* Unescapes backslashes in a polyline string.
+* Samples an explicit list of anchor colors into `count` evenly spaced hex
+* colors by linear interpolation. Backs both the named ramps and user-defined
+* custom ramps, so a list of hex codes is sampled identically to a built-in.
 *
-* 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 colors - The anchor colors (at least one).
+* @param count - Number of colors to produce.
+* @returns An array of `count` hex colors (a single end color when count <= 1).
+*/
+function interpolateColors(colors, count) {
+	const anchors = colors.length > 0 ? colors : ["#000000"];
+	if (count <= 0) return [];
+	if (count === 1) return [anchors[anchors.length - 1]];
+	if (anchors.length === 1) return Array.from({ length: count }, () => anchors[0]);
+	return Array.from({ length: count }, (_, index) => {
+		const scaled = index / (count - 1) * (anchors.length - 1);
+		const lowerIndex = Math.floor(scaled);
+		const upperIndex = Math.min(anchors.length - 1, Math.ceil(scaled));
+		const ratio = scaled - lowerIndex;
+		return interpolateHexColor(anchors[lowerIndex], anchors[upperIndex], ratio);
+	});
+}
+/**
+* Normalizes a single user-entered color token into a canonical `#rrggbb`
+* lowercase hex string, or null when it is not a valid 3- or 6-digit hex
+* color. Accepts values with or without a leading `#` and expands shorthand
+* (`#abc` → `#aabbcc`).
 *
-* @param str - Input string with potentially escaped backslashes.
-* @returns Cleaned polyline string.
+* @param token - A raw color token (e.g. "FF0000", "#f00", " #AaBbCc ").
+* @returns The canonical `#rrggbb` color, or null when invalid.
 */
-function unescapePolyline(str) {
-	if (!str || typeof str !== "string") return "";
-	return str.replace(/\\\\/g, "\\").replace(/\\"/g, "\"").replace(/\\'/g, "'");
+function normalizeHexColor(token) {
+	let value = token.trim().toLowerCase();
+	if (value === "") return null;
+	if (!value.startsWith("#")) value = `#${value}`;
+	if (/^#[0-9a-f]{3}$/.test(value)) value = `#${value.slice(1).split("").map((channel) => channel + channel).join("")}`;
+	return /^#[0-9a-f]{6}$/.test(value) ? value : null;
 }
 /**
-* 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.
+* Parses a free-text list of hex color codes into canonical `#rrggbb` colors,
+* for the custom color-ramp inputs. Tokens may be separated by commas,
+* semicolons, or any whitespace (including newlines); invalid tokens are
+* dropped so a partial paste still yields the colors it can.
 *
-* @param encoded - The ASCII-encoded polyline string.
+* @param input - The raw text the user entered.
+* @returns The valid, normalized colors in input order.
+*/
+function parseHexColorList(input) {
+	return input.split(/[\s,;]+/).map(normalizeHexColor).filter((color) => color !== null);
+}
+/**
+* Linearly interpolates between two hex colors.
+*
+* @param from - Start hex color (e.g. "#440154").
+* @param to - End hex color.
+* @param ratio - Blend factor in [0, 1].
+* @returns The interpolated hex color.
+*/
+function interpolateHexColor(from, to, ratio) {
+	const start = parseHexColor(from);
+	const end = parseHexColor(to);
+	return rgbToHex({
+		r: Math.round(start.r + (end.r - start.r) * ratio),
+		g: Math.round(start.g + (end.g - start.g) * ratio),
+		b: Math.round(start.b + (end.b - start.b) * ratio)
+	});
+}
+/**
+* Parses a `#rrggbb` hex color into its RGB channels.
+*
+* @param value - A `#rrggbb` hex color.
+* @returns The red, green, and blue channels (0-255).
+*/
+function parseHexColor(value) {
+	const numeric = Number.parseInt(value.slice(1), 16);
+	return {
+		r: numeric >> 16 & 255,
+		g: numeric >> 8 & 255,
+		b: numeric & 255
+	};
+}
+/**
+* Formats RGB channels as a `#rrggbb` hex color.
+*
+* @param color - The red, green, and blue channels (0-255).
+* @returns A `#rrggbb` hex color.
+*/
+function rgbToHex(color) {
+	return `#${[
+		color.r,
+		color.g,
+		color.b
+	].map((channel) => channel.toString(16).padStart(2, "0")).join("")}`;
+}
+/**
+* Builds `count` evenly spaced break values across [min, max].
+*
+* @param min - The minimum value.
+* @param max - The maximum value.
+* @param count - Number of breaks to produce.
+* @returns The break values (min..max inclusive when count > 1).
+*/
+function createEqualIntervalBreaks(min, max, count) {
+	return Array.from({ length: count }, (_, index) => {
+		const ratio = count === 1 ? 0 : index / (count - 1);
+		return min + (max - min) * ratio;
+	});
+}
+/**
+* Builds `count` quantile break values from a sample of numeric values.
+*
+* These are ramp *edges* spanning the whole sample (the first break is the
+* minimum, the last the maximum), matching {@link createEqualIntervalBreaks}.
+* Graduated vector classes want class *lower bounds* instead; use
+* {@link createGraduatedClassBreaks}.
+*
+* @param values - The sample values.
+* @param count - Number of breaks to produce.
+* @returns The quantile break values.
+*/
+function createQuantileBreaks(values, count) {
+	if (count <= 0) return [];
+	const sorted = [...values].sort((a, b) => a - b);
+	if (sorted.length === 0) return [];
+	return Array.from({ length: count }, (_, index) => {
+		const position = count === 1 ? 0 : index / (count - 1) * (sorted.length - 1);
+		return quantileAtPosition(sorted, position);
+	});
+}
+/** Linearly interpolated order statistic at a fractional index into `sorted`. */
+function quantileAtPosition(sorted, position) {
+	const lowerIndex = Math.floor(position);
+	const upperIndex = Math.min(sorted.length - 1, Math.ceil(position));
+	const ratio = position - lowerIndex;
+	return sorted[lowerIndex] + (sorted[upperIndex] - sorted[lowerIndex]) * ratio;
+}
+/**
+* Builds the class *lower bounds* for a graduated vector renderer.
+*
+* A graduated renderer's stops are lower bounds, not ramp edges: with N stops
+* sorted ascending, class `i` covers `[stops[i], stops[i + 1])` and the last
+* class is open-ended above. The legend (`≥ value`) and the QML/SLD exporters
+* already read them that way, so the breaks must follow the same convention:
+* `count` classes yield `count` breaks whose first entry is the sample minimum
+* and whose last entry opens the top class. Producing edges instead (ending at
+* the maximum) leaves the top class holding only the single largest feature and
+* puts the interior breaks at the wrong percentiles.
+*
+* The result is strictly ascending: duplicate breaks (a skewed sample can push
+* several quantiles onto the same value) are collapsed, so the caller may get
+* fewer than `count` breaks and must size its colors off `breaks.length`.
+* MapLibre rejects a `step` expression whose inputs are not strictly ascending,
+* so this de-duplication is load-bearing, not cosmetic.
+*
+* Standard deviation and geometric interval derive their breaks from the data,
+* so `count` is a ceiling there: a standard-deviation break that falls outside
+* the sample range is dropped rather than producing an empty class. See
+* {@link standardDeviationClassBreaks} and {@link geometricIntervalClassBreaks}
+* for how each treats its edge cases.
+*
+* @param values - The finite numeric values of the classified property.
+* @param count - Number of classes requested.
+* @param scheme - The classification scheme.
+* @returns Up to `count` strictly ascending class lower bounds.
+*/
+function createGraduatedClassBreaks(values, count, scheme) {
+	if (count <= 0 || values.length === 0) return [];
+	if (scheme === "natural-breaks") return ascendingUnique(naturalClassBreaks(values, count));
+	const sorted = [...values].sort((a, b) => a - b);
+	if (scheme === "quantile") return ascendingUnique(Array.from({ length: count }, (_, index) => quantileAtPosition(sorted, index / count * (sorted.length - 1))));
+	if (scheme === "standard-deviation") return ascendingUnique(standardDeviationClassBreaks(sorted, count));
+	if (scheme === "geometric-interval") {
+		const breaks = geometricIntervalClassBreaks(sorted, count);
+		if (breaks) return ascendingUnique(breaks);
+	}
+	return ascendingUnique(equalIntervalClassBreaks(sorted, count));
+}
+/** Equal-interval lower bounds over the range of an ascending sample. */
+function equalIntervalClassBreaks(sorted, count) {
+	const min = sorted[0];
+	const max = sorted[sorted.length - 1];
+	return Array.from({ length: count }, (_, index) => min + (max - min) * index / count);
+}
+/**
+* Standard-deviation lower bounds: classes one standard deviation wide,
+* centered on the mean. An even `count` puts a break on the mean (classes
+* `[mean - σ, mean)` and `[mean, mean + σ)` meet there); an odd `count` makes
+* the middle class straddle it (`[mean - σ/2, mean + σ/2)`). The first break is
+* the sample minimum, and interior breaks outside `(min, max]` are dropped, so
+* the open-ended bottom and top classes absorb the tails and no class is empty.
+* A constant sample (σ = 0) yields the minimum alone.
+*
+* Uses the population standard deviation, as QGIS and ArcGIS do.
+*/
+function standardDeviationClassBreaks(sorted, count) {
+	const min = sorted[0];
+	const max = sorted[sorted.length - 1];
+	const mean = sorted.reduce((sum, value) => sum + value, 0) / sorted.length;
+	const variance = sorted.reduce((sum, value) => sum + (value - mean) * (value - mean), 0) / sorted.length;
+	const deviation = Math.sqrt(variance);
+	if (!(deviation > 0)) return [min];
+	const interior = [];
+	for (let index = 1; index < count; index += 1) {
+		const value = mean + (index - count / 2) * deviation;
+		if (value > min && value <= max) interior.push(value);
+	}
+	return [min, ...interior];
+}
+/**
+* Geometric-interval lower bounds: class edges growing by a constant ratio
+* from the smallest positive value to the maximum, so each class spans the
+* same multiple of its lower bound. Suits skewed data spanning orders of
+* magnitude (population, income, concentrations).
+*
+* A geometric series cannot start at or below zero, so it starts at the
+* smallest positive value and the first break stays the sample minimum: zero
+* and negative values all fall into the first class. When no value is
+* positive, the result is `null` and the caller falls back to equal interval.
+*/
+function geometricIntervalClassBreaks(sorted, count) {
+	const max = sorted[sorted.length - 1];
+	const lowest = sorted.find((value) => value > 0);
+	if (lowest === void 0) return null;
+	const logLowest = Math.log(lowest);
+	const logStep = (Math.log(max) - logLowest) / count;
+	return [sorted[0], ...Array.from({ length: count - 1 }, (_, index) => Math.exp(logLowest + logStep * (index + 1)))];
+}
+/** Drops non-finite breaks and collapses repeats, keeping ascending order. */
+function ascendingUnique(breaks) {
+	const out = [];
+	for (const value of breaks) {
+		if (!Number.isFinite(value)) continue;
+		if (out.length > 0 && value <= out[out.length - 1]) continue;
+		out.push(value);
+	}
+	return out;
+}
+/** Cap on the Jenks input size; the DP below is roughly O(n^2 * k). */
+const MAX_NATURAL_BREAK_SAMPLES = 1e3;
+/** Evenly thins a sorted array down to at most `maxSamples` entries. */
+function downsampleSortedValues(values, maxSamples) {
+	if (values.length <= maxSamples) return values;
+	const result = [];
+	const step = (values.length - 1) / (maxSamples - 1);
+	for (let index = 0; index < maxSamples; index += 1) result.push(values[Math.round(index * step)]);
+	return result;
+}
+/**
+* Jenks natural breaks: the class lower bounds that minimize the summed
+* within-class variance. Returns the sample minimum first, then the first value
+* of each subsequent class.
+*/
+function naturalClassBreaks(values, count) {
+	const sorted = downsampleSortedValues(Array.from(new Set(values)).sort((a, b) => a - b), MAX_NATURAL_BREAK_SAMPLES);
+	if (sorted.length <= count) return sorted;
+	const lowerClassLimits = Array.from({ length: sorted.length + 1 }, () => Array(count + 1).fill(0));
+	const varianceCombinations = Array.from({ length: sorted.length + 1 }, () => Array(count + 1).fill(Number.POSITIVE_INFINITY));
+	for (let classIndex = 1; classIndex <= count; classIndex += 1) {
+		lowerClassLimits[1][classIndex] = 1;
+		varianceCombinations[1][classIndex] = 0;
+	}
+	for (let valueIndex = 2; valueIndex <= sorted.length; valueIndex += 1) {
+		let sum = 0;
+		let sumSquares = 0;
+		let weight = 0;
+		for (let lowerIndex = 1; lowerIndex <= valueIndex; lowerIndex += 1) {
+			const currentIndex = valueIndex - lowerIndex + 1;
+			const value = sorted[currentIndex - 1];
+			weight += 1;
+			sum += value;
+			sumSquares += value * value;
+			const variance = sumSquares - sum * sum / weight;
+			const previousIndex = currentIndex - 1;
+			if (previousIndex === 0) continue;
+			for (let classIndex = 2; classIndex <= count; classIndex += 1) {
+				const candidate = variance + varianceCombinations[previousIndex][classIndex - 1];
+				if (varianceCombinations[valueIndex][classIndex] >= candidate) {
+					lowerClassLimits[valueIndex][classIndex] = currentIndex;
+					varianceCombinations[valueIndex][classIndex] = candidate;
+				}
+			}
+		}
+		lowerClassLimits[valueIndex][1] = 1;
+		varianceCombinations[valueIndex][1] = sumSquares - sum * sum / Math.max(1, weight);
+	}
+	const breaks = Array(count).fill(sorted[0]);
+	let valueIndex = sorted.length;
+	for (let classIndex = count; classIndex >= 2; classIndex -= 1) {
+		const lowerClassLimit = Math.max(1, lowerClassLimits[valueIndex][classIndex]);
+		breaks[classIndex - 1] = sorted[lowerClassLimit - 1];
+		valueIndex = lowerClassLimit - 1;
+	}
+	breaks[0] = sorted[0];
+	return breaks;
+}
+// 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.
@@ -2664,188 +2782,1157 @@ function compileMapExpression(source, options) {
 	};
 }
 /**
-* 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.
+* 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;
+}
+// src/vector-color.ts
+/** Whether a color value is a data-driven expression rather than a flat color. */
+function isVectorColorExpression(value) {
+	return Array.isArray(value);
+}
+/**
+* Whether a string is a 6-digit hex color (`#rrggbb`), the form the vector
+* renderer treats as valid. Exported so the symbology exporters can apply the
+* same validity check the live `match`/`case` expressions use rather than
+* re-deriving the regex.
+*/
+function isHexColor(value) {
+	return typeof value === "string" && /^#[0-9a-f]{6}$/i.test(value.trim());
+}
+/** A 3- or 6-digit hex color, as emitted by the simplestyle spec. */
+function isSimpleStyleColor(value) {
+	return /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.test(value.trim());
+}
+/**
+* simplestyle-spec color and numeric property names. Color keys carry CSS hex
+* colors; numeric keys carry plain numbers. See
+* https://github.com/mapbox/simplestyle-spec.
+*/
+const SIMPLE_STYLE_COLOR_KEYS = [
+	"fill",
+	"stroke",
+	"marker-color"
+];
+const SIMPLE_STYLE_NUMBER_KEYS = [
+	"fill-opacity",
+	"stroke-width",
+	"stroke-opacity",
+	"marker-opacity"
+];
+function isSimpleStyleEnabled(style) {
+	return styleValue(style, "simpleStyleEnabled") === true;
+}
+/**
+* Wrap a resolved color value so a per-feature simplestyle property takes
+* precedence when {@link LayerStyle.simpleStyleEnabled} is set. Returns the base
+* value unchanged when the feature lacks the property or the mode is off.
+*
+* @param style - The layer style.
+* @param property - The simplestyle property name (e.g. `fill`, `stroke`).
+* @param base - The flat color or expression to fall back to.
+* @returns A `coalesce` expression, or the base value when disabled.
+*/
+function withSimpleStyleColor(style, property, base) {
+	if (!isSimpleStyleEnabled(style)) return base;
+	return mapZoomStepOutputs(base, (value) => [
+		"coalesce",
+		["get", property],
+		value
+	]);
+}
+/**
+* Apply a per-feature transform to a value, descending into the outputs of a
+* top-level `["step", ["zoom"], …]` expression (as produced by the rule-based
+* per-rule zoom compilation) so the zoom step stays outermost. MapLibre
+* rejects any expression where `["zoom"]` is not the input of a top-level
+* `step`/`interpolate`, so wrappers (simplestyle coalesce, opacity folds)
+* must be pushed inside the step's outputs rather than wrapped around it.
+* Non-step values are transformed directly.
+*/
+function mapZoomStepOutputs(value, transform) {
+	if (Array.isArray(value) && value[0] === "step" && Array.isArray(value[1]) && value[1][0] === "zoom") {
+		const out = [
+			"step",
+			value[1],
+			transform(value[2])
+		];
+		for (let index = 3; index < value.length; index += 2) out.push(value[index], transform(value[index + 1]));
+		return out;
+	}
+	return transform(value);
+}
+/**
+* Resolve a numeric paint value, letting a per-feature simplestyle property
+* override the layer value when {@link LayerStyle.simpleStyleEnabled} is set.
+*
+* The lookup is wrapped in a `coalesce` rather than leaning on `to-number`'s
+* own fallback argument, because that fallback only fires when a value fails
+* to convert — and a *missing* property does not fail, it converts to 0. Since
+* simplestyle is enabled for the whole layer as soon as any feature carries any
+* one of these keys, features that carry only some of them (an ArcGIS KML
+* export writes `fill`/`fill-opacity` but no `marker-opacity`, for instance)
+* would otherwise be painted at opacity 0 or width 0 — present in the layer,
+* invisible on the map (#1552).
+*
+* @param style - The layer style.
+* @param property - The simplestyle property name (e.g. `stroke-width`).
+* @param base - The layer-level fallback value.
+* @returns A `to-number` expression, or `base` when disabled.
+*/
+function simpleStyleNumberValue(style, property, base) {
+	if (!isSimpleStyleEnabled(style)) return base;
+	return [
+		"to-number",
+		[
+			"coalesce",
+			["get", property],
+			base
+		],
+		base
+	];
+}
+/** Whether `node` is `["get", key]` for one of `keys`, returning the key. */
+function simpleStyleGet(node, keys) {
+	if (!Array.isArray(node) || node.length !== 2 || node[0] !== "get") return null;
+	return keys.includes(node[1]) ? node[1] : null;
+}
+/**
+* Read back the per-feature color lookup {@link withSimpleStyleColor} writes,
+* `["coalesce", ["get", key], base]` with a simplestyle color key, so a style
+* importer recognizes exactly what the exporter emits.
+*
+* @param node - A paint value or a node inside one.
+* @returns The simplestyle key and the layer-level base, or `null` when the
+*   node is not that lookup.
+*/
+function readSimpleStyleColorLookup(node) {
+	if (!Array.isArray(node) || node.length !== 3 || node[0] !== "coalesce") return null;
+	const property = simpleStyleGet(node[1], SIMPLE_STYLE_COLOR_KEYS);
+	return property ? {
+		property,
+		base: node[2]
+	} : null;
+}
+/**
+* Read back the per-feature number lookup {@link simpleStyleNumberValue}
+* writes, `["to-number", ["coalesce", ["get", key], base], base]` with a
+* simplestyle number key and a numeric base.
+*
+* @param node - A paint value or a node inside one.
+* @returns The simplestyle key and the layer-level base, or `null` when the
+*   node is not that lookup.
+*/
+function readSimpleStyleNumberLookup(node) {
+	if (!Array.isArray(node) || node.length !== 3 || node[0] !== "to-number") return null;
+	const inner = node[1];
+	if (!Array.isArray(inner) || inner.length !== 3 || inner[0] !== "coalesce") return null;
+	const property = simpleStyleGet(inner[1], SIMPLE_STYLE_NUMBER_KEYS);
+	const base = node[2];
+	if (!property || typeof base !== "number" || !Number.isFinite(base) || inner[2] !== base) return null;
+	return {
+		property,
+		base
+	};
+}
+/**
+* Whether a paint value reads per-feature simplestyle properties the way the
+* GeoLibre exporter writes them, anywhere inside it (a lookup can sit inside a
+* zoom step, a per-rule `case` or an opacity multiplication).
+*
+* @param value - A paint value.
+* @returns `true` when a color or number lookup is found.
+*/
+function readsSimpleStyleProperties(value) {
+	if (!Array.isArray(value)) return false;
+	if (readSimpleStyleColorLookup(value) || readSimpleStyleNumberLookup(value)) return true;
+	return value.some(readsSimpleStyleProperties);
+}
+/**
+* Ground resolution (meters per pixel) at MapLibre zoom 0 on the equator, for
+* the Web Mercator projection: earth circumference (2*pi*6378137) over the
+* 512px world at zoom 0. Resolution halves with every zoom level. Exported so
+* the Mapbox-style importer can reverse {@link metersWidthExpression} without a
+* second copy of the magic number.
+*/
+const MERCATOR_METERS_PER_PIXEL_AT_ZOOM_0 = 2 * Math.PI * 6378137 / 512;
+/**
+* Same ground resolution as {@link MERCATOR_METERS_PER_PIXEL_AT_ZOOM_0} but for
+* the project's active body: its circumference over the 512px zoom-0 world. On
+* Earth this equals the constant; on the Moon/Mars it uses that body's radius so
+* a stroke width given in ground meters renders at the correct on-screen size.
+* Exported so the Mapbox-style importer can reverse {@link metersWidthExpression}
+* with the same ellipsoid-aware factor the exporter used (keeping the round trip
+* correct on non-Earth projects), rather than the Earth-only constant.
+*/
+function mercatorMetersPerPixelAtZoom0() {
+	return 2 * Math.PI * getActiveSemiMajorAxisMeters() / 512;
+}
+const MAX_MERCATOR_ZOOM = 24;
+/**
+* Build a zoom-driven width expression that keeps a stroke proportional to the
+* map scale, so a width given in ground meters renders thicker when zoomed in
+* and thinner when zoomed out (QGIS "map units" behavior).
+*
+* In Web Mercator the pixels-per-meter ratio doubles with each zoom level, so
+* an `["exponential", 2]` interpolation between two stops one zoom apart is
+* exact across the whole range. The conversion is referenced to the equator;
+* because Mercator stretches distances toward the poles, the on-screen width at
+* higher latitudes is correspondingly larger, matching how the underlying map
+* is itself stretched.
+*
+* Typed maplibre-agnostically (`unknown[]`); consumers cast to the concrete
+* `PropertyValueSpecification<number>` where the MapLibre types are in scope.
+*
+* @param meters - The stroke width in ground meters.
+* @returns A MapLibre `interpolate` expression array.
+*/
+function metersWidthExpression(meters) {
+	const widthAtZoom0 = meters / mercatorMetersPerPixelAtZoom0();
+	return [
+		"interpolate",
+		["exponential", 2],
+		["zoom"],
+		0,
+		widthAtZoom0,
+		MAX_MERCATOR_ZOOM,
+		widthAtZoom0 * 2 ** MAX_MERCATOR_ZOOM
+	];
+}
+/**
+* Resolve the `line-width` paint value for a layer style, honoring the
+* {@link LayerStyle.strokeWidthUnit}:
+*
+* - `"meters"`: a zoom-driven {@link metersWidthExpression} from the flat
+*   `strokeWidth`, so the stroke scales with the map. A per-feature pixel
+*   `stroke-width` override no longer applies in this mode.
+* - `"pixels"` (default): the constant pixel width, still honoring any
+*   per-feature simplestyle `stroke-width`.
+*
+* Shared by the map style-mapper and the geo-editor plugin so the Sketches
+* store layer and Geoman's interaction display layers render an identical
+* width.
+*
+* @param style - The layer style.
+* @returns A number (constant pixels) or a MapLibre expression array.
+*/
+function lineWidthValue(style) {
+	const proportionalWidth = proportionalRadiusExpression(style);
+	if (proportionalWidth) return vectorStrokeWidthValue(style, proportionalWidth);
+	if (styleValue(style, "strokeWidthUnit") === "meters") return metersWidthExpression(styleValue(style, "strokeWidth"));
+	return vectorStrokeWidthValue(style, simpleStyleNumberValue(style, "stroke-width", styleValue(style, "strokeWidth")));
+}
+/**
+* The layer's stroke opacity, clamped to [0, 1]. A missing or non-finite value
+* (an older project, a hand-edited file) reads as fully opaque.
+*
+* @param style - The layer style.
+* @returns The stroke opacity.
+*/
+function strokeOpacityValue(style) {
+	const value = styleValue(style, "strokeOpacity");
+	return typeof value === "number" && Number.isFinite(value) ? Math.min(1, Math.max(0, value)) : 1;
+}
+/**
+* A stroke opacity paint value: the layer's {@link LayerStyle.strokeOpacity},
+* which a per-feature simplestyle `stroke-opacity` replaces when
+* {@link LayerStyle.simpleStyleEnabled} is set.
+*
+* @param style - The layer style.
+* @returns A number, or the simplestyle lookup expression.
+*/
+function strokeOpacityPaintValue(style) {
+	return simpleStyleNumberValue(style, "stroke-opacity", strokeOpacityValue(style));
+}
+/**
+* Whether a value is a usable dash pattern: finite, non-negative lengths with
+* at least one dash longer than zero. Exported so the style sanitizer and the
+* importers apply the same rule the renderer does.
+*
+* @param value - The candidate pattern.
+* @returns True when the value can be drawn as a dash pattern.
+*/
+function isStrokeDashPattern(value) {
+	return Array.isArray(value) && value.length > 0 && value.every((length) => typeof length === "number" && Number.isFinite(length) && length >= 0) && value.some((length) => length > 0);
+}
+/**
+* The `line-dasharray` for the layer, or `null` for a solid line. `null` is
+* what MapLibre's `setPaintProperty` takes to reset a property, so returning it
+* (rather than leaving the key out) clears a dash when the user goes back to
+* solid.
+*
+* @param style - The layer style.
+* @returns The dash pattern, or `null` when the line is solid.
+*/
+function strokeDashValue(style) {
+	const dash = styleValue(style, "strokeDash");
+	return isStrokeDashPattern(dash) ? [...dash] : null;
+}
+/**
+* The {@link STROKE_DASH_PRESETS} name matching a pattern, or `"custom"` when
+* none does. An empty or unusable pattern is `"solid"`.
+*
+* @param dash - A dash pattern.
+* @returns The preset name, or `"custom"`.
+*/
+function strokeDashPresetName(dash) {
+	if (!isStrokeDashPattern(dash)) return "solid";
+	for (const [name, pattern] of Object.entries(STROKE_DASH_PRESETS)) if (pattern.length === dash.length && pattern.every((length, index) => length === dash[index])) return name;
+	return "custom";
+}
+/**
+* The layer's line blur in pixels; a missing, negative or non-finite value is 0.
+*
+* @param style - The layer style.
+* @returns The blur in pixels.
+*/
+function strokeBlurValue(style) {
+	const value = styleValue(style, "strokeBlur");
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+/**
+* Whether a FeatureCollection carries per-feature simplestyle-spec properties
+* worth honoring: at least one feature with a valid hex color in a color key
+* (`fill`/`stroke`/`marker-color`) or a finite number in a numeric key
+* (`fill-opacity`/`stroke-width`/`stroke-opacity`). The scan is capped so very
+* large collections do not pay a full pass.
+*
+* @param geojson - The collection to inspect (may be undefined).
+* @returns `true` when simplestyle rendering should be enabled for the layer.
+*/
+function hasSimpleStyleProperties(geojson) {
+	const features = geojson?.features;
+	if (!features?.length) return false;
+	const limit = Math.min(features.length, 1e3);
+	for (let index = 0; index < limit; index += 1) {
+		const properties = features[index]?.properties;
+		if (!properties) continue;
+		for (const key of SIMPLE_STYLE_COLOR_KEYS) {
+			const value = properties[key];
+			if (typeof value === "string" && isSimpleStyleColor(value)) return true;
+		}
+		for (const key of SIMPLE_STYLE_NUMBER_KEYS) {
+			const value = properties[key];
+			if (typeof value === "number" && Number.isFinite(value)) return true;
+		}
+	}
+	return false;
+}
+/**
+* Parses a user-entered MapLibre expression string into an expression array,
+* tolerating trailing commas. Returns null when the text is empty or not a
+* JSON array.
+*/
+function parseJsonExpression(expression) {
+	const trimmed = expression.trim();
+	if (!trimmed) return null;
+	try {
+		const parsed = JSON.parse(removeTrailingJsonCommas(trimmed));
+		if (!Array.isArray(parsed)) return null;
+		return parsed;
+	} catch {
+		return null;
+	}
+}
+/**
+* Builds the data-driven color value for a vector layer's current style mode.
+* `single` (or any mode that cannot produce a valid expression) returns the
+* flat fallback color; `categorized` returns a `match` expression, `graduated`
+* a `step` expression, and `expression` the parsed user expression.
+*
+* Graduated stops are class lower bounds (see
+* {@link createGraduatedClassBreaks}), so the classes are discrete: the map
+* paints exactly one color per class, which is what the legend (`≥ value`) and
+* the QML/SLD exporters already describe. Rendering them as a continuous
+* `interpolate` instead blends a shade per feature, so a 4-class layer draws in
+* many more than 4 colors and stops matching its own legend (#1384).
+*
+* @param style - The layer style.
+* @param fallbackColor - The flat color used for `single` mode and as the
+*   expression fallback.
+* @returns A flat color string or a MapLibre color expression.
+*/
+function vectorColorExpression(style, fallbackColor) {
+	const mode = styleValue(style, "vectorStyleMode");
+	if (mode === "single") return fallbackColor;
+	if (mode === "expression") return parseJsonExpression(styleValue(style, "vectorStyleExpression")) ?? fallbackColor;
+	if (mode === "rule-based") return ruleBasedColorExpression(style, fallbackColor);
+	const property = styleValue(style, "vectorStyleProperty").trim();
+	if (!property) return fallbackColor;
+	if (mode === "categorized") {
+		const stops = styleValue(style, "vectorStyleStops").filter((stop) => String(stop.value).trim().length > 0 && isHexColor(stop.color));
+		if (stops.length === 0) return fallbackColor;
+		return [
+			"match",
+			["to-string", ["get", property]],
+			...stops.flatMap((stop) => [String(stop.value).trim(), stop.color]),
+			fallbackColor
+		];
+	}
+	const stops = graduatedStops(style);
+	if (stops.length < 2) return fallbackColor;
+	return [
+		"step",
+		[
+			"to-number",
+			["get", property],
+			stops[0].value
+		],
+		stops[0].color,
+		...stops.slice(1).flatMap((stop) => [stop.value, stop.color])
+	];
+}
+/**
+* The graduated stops of a style, cleaned for rendering: non-numeric values and
+* invalid colors dropped, sorted ascending, and de-duplicated. MapLibre rejects
+* a `step` expression whose inputs are not strictly ascending, and stops reach
+* here from hand-edited projects and style imports as well as the Style panel,
+* so repeats are dropped rather than trusted away.
+*/
+function graduatedStops(style) {
+	const sorted = styleValue(style, "vectorStyleStops").map((stop) => ({
+		color: stop.color,
+		value: typeof stop.value === "number" ? stop.value : Number.parseFloat(stop.value)
+	})).filter((stop) => Number.isFinite(stop.value) && isHexColor(stop.color)).sort((a, b) => a.value - b.value);
+	return sorted.filter((stop, index) => index === 0 || stop.value > sorted[index - 1].value);
+}
+/** A finite per-rule zoom bound, or undefined when unset/invalid. */
+function ruleZoom(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+/**
+* Resolve the layer's rule tree into the drawable leaf rules (see
+* {@link EffectiveVectorRule}) plus the catch-all else rule. Disabled rules
+* (and every descendant of a disabled group), rules with an invalid color or
+* filter, subtrees under a group whose non-blank filter does not parse, and
+* rules whose intersected zoom range is empty are all dropped. Cycles in
+* `parentId` are treated as broken chains and dropped rather than looping.
+*
+* @param style - The layer style (reads {@link LayerStyle.vectorRules}).
+* @returns The ordered drawable rules and the enabled else rule, if any.
+*/
+function effectiveVectorRules(style) {
+	const all = styleValue(style, "vectorRules");
+	const elseRule = all.find((rule) => rule.isElse && rule.enabled !== false) ?? null;
+	const byId = /* @__PURE__ */ new Map();
+	for (const rule of all) if (!rule.isElse) byId.set(rule.id, rule);
+	const groupIds = /* @__PURE__ */ new Set();
+	for (const rule of byId.values()) if (rule.parentId && rule.parentId !== rule.id && byId.has(rule.parentId)) groupIds.add(rule.parentId);
+	const rules = [];
+	for (const rule of all) {
+		if (rule.isElse || groupIds.has(rule.id)) continue;
+		if (rule.enabled === false || !isHexColor(rule.color)) continue;
+		const own = parseJsonExpression(rule.filter);
+		if (!own || typeof own[0] !== "string") continue;
+		const filters = [own];
+		let minZoom = ruleZoom(rule.minZoom);
+		let maxZoom = ruleZoom(rule.maxZoom);
+		let dropped = false;
+		const seen = /* @__PURE__ */ new Set([rule.id]);
+		let parent = rule.parentId && rule.parentId !== rule.id ? byId.get(rule.parentId) : void 0;
+		while (parent) {
+			if (seen.has(parent.id) || parent.enabled === false) {
+				dropped = true;
+				break;
+			}
+			seen.add(parent.id);
+			if (parent.filter.trim()) {
+				const parentFilter = parseJsonExpression(parent.filter);
+				if (!parentFilter || typeof parentFilter[0] !== "string") {
+					dropped = true;
+					break;
+				}
+				filters.unshift(parentFilter);
+			}
+			const parentMin = ruleZoom(parent.minZoom);
+			const parentMax = ruleZoom(parent.maxZoom);
+			if (parentMin !== void 0) minZoom = minZoom === void 0 ? parentMin : Math.max(minZoom, parentMin);
+			if (parentMax !== void 0) maxZoom = maxZoom === void 0 ? parentMax : Math.min(maxZoom, parentMax);
+			parent = parent.parentId && parent.parentId !== parent.id ? byId.get(parent.parentId) : void 0;
+		}
+		if (dropped) continue;
+		if (minZoom !== void 0 && maxZoom !== void 0 && minZoom >= maxZoom) continue;
+		rules.push({
+			id: rule.id,
+			label: rule.label,
+			color: rule.color,
+			filter: filters.length === 1 ? filters[0] : ["all", ...filters],
+			...minZoom !== void 0 ? { minZoom } : {},
+			...maxZoom !== void 0 ? { maxZoom } : {},
+			...isHexColor(rule.strokeColor) ? { strokeColor: rule.strokeColor } : {},
+			...typeof rule.strokeWidth === "number" && Number.isFinite(rule.strokeWidth) ? { strokeWidth: rule.strokeWidth } : {},
+			...typeof rule.fillOpacity === "number" && Number.isFinite(rule.fillOpacity) ? { fillOpacity: rule.fillOpacity } : {},
+			...typeof rule.circleRadius === "number" && Number.isFinite(rule.circleRadius) ? { circleRadius: rule.circleRadius } : {}
+		});
+	}
+	return {
+		rules,
+		elseRule
+	};
+}
+/**
+* A rule's match condition as a MapLibre filter: its (ancestor-combined)
+* attribute filter, with any scale range folded in as `["zoom"]` comparisons.
+* The zoom window is half-open (`min <= zoom < max`), matching how
+* {@link zoomWrappedRuleValue} activates rules per zoom segment. MapLibre only
+* re-evaluates `["zoom"]` in filters at integer zoom levels, so a scale-ranged
+* rule's features appear/disappear on whole zooms — the paint expressions keep
+* the fractional-zoom precision.
+*/
+function ruleMatchFilter(rule) {
+	const conditions = [rule.filter];
+	if (rule.minZoom !== void 0) conditions.push([
+		">=",
+		["zoom"],
+		rule.minZoom
+	]);
+	if (rule.maxZoom !== void 0) conditions.push([
+		"<",
+		["zoom"],
+		rule.maxZoom
+	]);
+	return conditions.length === 1 ? rule.filter : ["all", ...conditions];
+}
+const visibilityFilterCache = /* @__PURE__ */ new WeakMap();
+/**
+* The MapLibre filter that hides features matching no rule, for a rule-based
+* layer whose catch-all else rule has been switched off. Returns `null` — and
+* callers then leave their geometry filters untouched — unless the layer is in
+* `"rule-based"` mode AND carries an else record explicitly disabled
+* (`enabled: false`). An absent else record keeps the historical fallback
+* rendering, so projects saved before the toggle existed are unaffected.
+*
+* With the else rule off, the returned `["any", filter1, filter2, …]` keeps
+* only features matched by a drawable rule (see {@link effectiveVectorRules});
+* with no drawable rules it returns the vacuous `["any"]`, which matches
+* nothing, so every feature hides. Sub-layers combine it with their geometry
+* filters, which also drops unmatched features from labels and hit-testing —
+* mirroring QGIS, where features matching no rule are simply not drawn.
+*
+* @param style - The layer style (reads {@link LayerStyle.vectorRules}).
+* @returns The filter to `["all", …]`-combine into each sub-layer, or `null`.
+*/
+function ruleBasedVisibilityFilter(style) {
+	if (styleValue(style, "vectorStyleMode") !== "rule-based") return null;
+	const all = styleValue(style, "vectorRules");
+	const cached = visibilityFilterCache.get(all);
+	if (cached !== void 0) return cached;
+	const elseRecord = all.find((rule) => rule.isElse);
+	const filter = !elseRecord || elseRecord.enabled !== false ? null : ["any", ...effectiveVectorRules(style).rules.map(ruleMatchFilter)];
+	visibilityFilterCache.set(all, filter);
+	return filter;
+}
+/**
+* Wrap a per-zoom-segment value builder in a `["step", ["zoom"], …]` expression
+* when any rule carries a zoom bound. MapLibre only allows `["zoom"]` as the
+* top-level input of a `step`/`interpolate` in paint properties (not inside a
+* `case` condition), so per-rule scale ranges compile by splitting the zoom
+* axis at every rule bound and rebuilding the `case` expression per segment
+* with only the rules active in that segment. With no zoom bounds the builder
+* runs once and its plain value is returned unchanged, keeping the historical
+* `case` shape (which the Mapbox-style importer recognizes).
+*/
+function zoomWrappedRuleValue(rules, build) {
+	const bounds = /* @__PURE__ */ new Set();
+	for (const rule of rules) {
+		if (rule.minZoom !== void 0) bounds.add(rule.minZoom);
+		if (rule.maxZoom !== void 0) bounds.add(rule.maxZoom);
+	}
+	if (bounds.size === 0) return build(rules);
+	const breaks = [...bounds].sort((a, b) => a - b);
+	const activeAt = (segmentStart) => rules.filter((rule) => (rule.minZoom ?? -Infinity) <= segmentStart && segmentStart < (rule.maxZoom ?? Infinity));
+	const expression = [
+		"step",
+		["zoom"],
+		build(activeAt(-Infinity))
+	];
+	for (const zoom of breaks) expression.push(zoom, build(activeAt(zoom)));
+	return expression;
+}
+/**
+* Compiles the `"rule-based"` renderer's ordered rules into a MapLibre `case`
+* color expression: `["case", filter1, color1, filter2, color2, …, elseColor]`.
+* Rules are evaluated top to bottom; the first matching filter wins. Disabled
+* rules and rules with an invalid filter JSON or a non-hex color are skipped;
+* nested rules AND their ancestors' filters (see {@link effectiveVectorRules}).
+* When any rule carries a zoom range the `case` is rebuilt per zoom segment
+* inside a `["step", ["zoom"], …]` wrapper. The catch-all (`isElse`) rule
+* supplies the trailing fallback; when absent or invalid the layer
+* `fallbackColor` is used. With no usable rules the flat fallback color is
+* returned.
+*
+* @param style - The layer style (reads {@link LayerStyle.vectorRules}).
+* @param fallbackColor - The color used when no else rule defines one.
+* @returns A MapLibre expression, or a flat color when no rule applies.
+*/
+function ruleBasedColorExpression(style, fallbackColor) {
+	const { rules, elseRule } = effectiveVectorRules(style);
+	const elseColor = elseRule && isHexColor(elseRule.color) ? elseRule.color : fallbackColor;
+	if (rules.length === 0) return elseColor;
+	return zoomWrappedRuleValue(rules, (active) => {
+		if (active.length === 0) return elseColor;
+		return [
+			"case",
+			...active.flatMap((rule) => [rule.filter, rule.color]),
+			elseColor
+		];
+	});
+}
+/**
+* Build a paint value honoring per-rule symbol overrides for one field: a
+* `case` expression (zoom-wrapped when rules carry scale ranges) where each
+* drawable rule's branch yields its override, or the layer fallback when that
+* rule does not override the field. Returns the fallback unchanged when the
+* layer is not in rule-based mode or no rule (including the else rule)
+* overrides the field, so simple styles keep their flat paint values.
+*
+* First-match semantics are preserved: every drawable rule contributes a
+* branch (even without an override) so a feature matched by an earlier rule
+* never picks up a later rule's override.
+*/
+function ruleOverrideValue(style, key, fallback) {
+	if (styleValue(style, "vectorStyleMode") !== "rule-based") return fallback;
+	const { rules, elseRule } = effectiveVectorRules(style);
+	const elseOverride = readRuleOverride(elseRule ?? void 0, key);
+	if (elseOverride === void 0 && !rules.some((rule) => rule[key] !== void 0)) return fallback;
+	const elseValue = elseOverride ?? fallback;
+	return zoomWrappedRuleValue(rules, (active) => {
+		if (active.length === 0) return elseValue;
+		return [
+			"case",
+			...active.flatMap((rule) => [rule.filter, rule[key] ?? fallback]),
+			elseValue
+		];
+	});
+}
+/** A validated override read straight off a (possibly else) {@link VectorRule}. */
+function readRuleOverride(rule, key) {
+	const value = rule?.[key];
+	if (key === "strokeColor") return isHexColor(value) ? value : void 0;
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+/**
+* The stroke/outline color for polygon outlines and circle strokes, honoring
+* per-rule {@link VectorRule.strokeColor} overrides in rule-based mode.
+* Falls back to the flat layer stroke color.
+*/
+function vectorOutlineColorValue(style) {
+	return ruleOverrideValue(style, "strokeColor", styleValue(style, "strokeColor"));
+}
+/**
+* A stroke-width paint value honoring per-rule {@link VectorRule.strokeWidth}
+* overrides in rule-based mode; `fallback` is the layer-level width (a number
+* or an already-built expression such as the meters-based interpolation).
+*/
+function vectorStrokeWidthValue(style, fallback) {
+	return ruleOverrideValue(style, "strokeWidth", fallback);
+}
+/**
+* A fill/circle opacity paint value honoring per-rule
+* {@link VectorRule.fillOpacity} overrides in rule-based mode; `fallback` is
+* the layer-level opacity value (number or expression).
+*/
+function vectorFillOpacityValue(style, fallback) {
+	return ruleOverrideValue(style, "fillOpacity", fallback);
+}
+/**
+* The color-ramp colors a density heatmap paints with.
+*
+* {@link getVectorColorRamp} falls back to the *first* ramp ("viridis") for an
+* unknown name, which is not the heatmap default ("turbo"). Both the map paint
+* (`heatmapPaint` in `@geolibre/map`) and the auto-legend gradient resolve the
+* ramp here so a stale or hand-edited `heatmapColorRamp` cannot make the legend
+* and the rendered heatmap disagree about which ramp is in use.
+*
+* @param style - The layer style.
+* @returns The ramp's colors, or the default ramp's colors for an unknown name.
+*/
+function heatmapRampColors(style) {
+	const value = styleValue(style, "heatmapColorRamp");
+	const ramp = getVectorColorRamp(value);
+	return (ramp.value === value ? ramp : getVectorColorRamp(DEFAULT_LAYER_STYLE.heatmapColorRamp)).colors;
+}
+/**
+* The proportional-size configuration, or `null` when proportional sizing
+* does not apply: disabled, no field chosen, non-finite or degenerate
+* (`maxValue <= minValue`) value range, or non-finite radii. This is the
+* single validation chain for every proportional consumer — circle radius,
+* line width, and marker icon-size (`@geolibre/map`) — so their notion of
+* "active" can never drift apart.
+*
+* @param style - The layer style.
+* @returns The validated range, or `null` when proportional sizing is off.
+*/
+function proportionalSizeRange(style) {
+	if (!styleValue(style, "proportionalSizeEnabled")) return null;
+	return validatedSizeRange(styleValue(style, "proportionalSizeProperty"), styleValue(style, "proportionalSizeMinValue"), styleValue(style, "proportionalSizeMaxValue"), styleValue(style, "proportionalSizeMinRadius"), styleValue(style, "proportionalSizeMaxRadius"));
+}
+/**
+* The validation every field-driven size range shares: a chosen field, a
+* finite non-degenerate value span, and finite radii. Kept in one place so a
+* future tightening (rejecting negative radii, say) cannot land on the
+* layer-wide proportional renderer without also landing on the geometry
+* generator's centroids.
+*/
+function validatedSizeRange(rawProperty, minValue, maxValue, minRadius, maxRadius) {
+	const property = rawProperty.trim();
+	if (!property) return null;
+	if (!(Number.isFinite(minValue) && Number.isFinite(maxValue))) return null;
+	if (maxValue <= minValue) return null;
+	if (!(Number.isFinite(minRadius) && Number.isFinite(maxRadius))) return null;
+	return {
+		property,
+		minValue,
+		maxValue,
+		minRadius,
+		maxRadius
+	};
+}
+/**
+* The proportional `interpolate` expression mapping
+* `proportionalSizeMinValue..proportionalSizeMaxValue` onto
+* `proportionalSizeMinRadius..proportionalSizeMaxRadius`, or `null` when
+* proportional sizing does not apply (see {@link proportionalSizeRange}).
+*
+* @param style - The layer style.
+* @returns The `interpolate` expression, or `null`.
+*/
+function proportionalRadiusExpression(style) {
+	const range = proportionalSizeRange(style);
+	return range ? radiusInterpolateExpression(range) : null;
+}
+/**
+* The `interpolate` that maps a validated range's value span onto its radius
+* span. Shared by the layer-wide proportional renderer and the geometry
+* generator's centroid sizing so both scale identically (linear, with the
+* value clamped to the range's ends by `interpolate`'s own stop behavior).
 */
-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;
+function radiusInterpolateExpression(range) {
+	return [
+		"interpolate",
+		["linear"],
+		[
+			"to-number",
+			["get", range.property],
+			range.minValue
+		],
+		range.minValue,
+		Math.max(0, range.minRadius),
+		range.maxValue,
+		Math.max(0, range.maxRadius)
+	];
 }
 /**
-* 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.
+* The geometry generator's centroid-size configuration, or `null` when the
+* generated points should all take the flat
+* {@link LayerStyle.geometryGeneratorCircleRadius}: no field chosen, non-finite
+* or degenerate (`maxValue <= minValue`) value range, or non-finite radii.
+* Mirrors {@link proportionalSizeRange} against the generator's own keys.
+*
+* @param style - The layer style.
+* @returns The validated range, or `null` when field-driven sizing is off.
 */
-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)]
-		};
-	}
+function generatorSizeRange(style) {
+	return validatedSizeRange(styleValue(style, "geometryGeneratorSizeProperty"), styleValue(style, "geometryGeneratorSizeMinValue"), styleValue(style, "geometryGeneratorSizeMaxValue"), styleValue(style, "geometryGeneratorSizeMinRadius"), styleValue(style, "geometryGeneratorSizeMaxRadius"));
 }
 /**
-* 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.
+* Builds the `circle-radius` paint value for the geometry generator's derived
+* centroid points: an `interpolate` over
+* {@link LayerStyle.geometryGeneratorSizeProperty} when field-driven sizing
+* applies (see {@link generatorSizeRange}), otherwise the flat
+* {@link LayerStyle.geometryGeneratorCircleRadius}.
+*
+* The flat fallback keeps the 1px floor the generator has always applied; the
+* interpolate is left as authored, so a 0px min radius still hides the
+* smallest symbols on purpose.
+*
+* @param style - The layer style.
+* @returns A constant radius (pixels) or a MapLibre `interpolate` expression.
 */
-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
-		})
-	};
+function generatorCircleRadiusValue(style) {
+	const range = generatorSizeRange(style);
+	if (range) return radiusInterpolateExpression(range);
+	return Math.max(1, styleValue(style, "geometryGeneratorCircleRadius"));
 }
 /**
-* 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.
+* Builds the `circle-radius` paint value, honoring proportional (graduated)
+* symbol sizing. When {@link LayerStyle.proportionalSizeEnabled} is set with a
+* chosen numeric field and a valid value range, returns an `interpolate` that
+* maps `proportionalSizeMinValue..proportionalSizeMaxValue` onto
+* `proportionalSizeMinRadius..proportionalSizeMaxRadius`; otherwise the constant
+* {@link LayerStyle.circleRadius}.
+*
+* @param style - The layer style.
+* @returns A constant radius (pixels) or a MapLibre `interpolate` expression.
 */
-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
-	};
+function circleRadiusValue(style) {
+	return ruleOverrideValue(style, "circleRadius", baseCircleRadiusValue(style));
+}
+/** The layer-level circle radius before per-rule overrides. */
+function baseCircleRadiusValue(style) {
+	return proportionalRadiusExpression(style) ?? styleValue(style, "circleRadius");
+}
+/** Fill color value for a polygon layer (fallback: the layer fill color). */
+function vectorFillColorValue(style) {
+	return withSimpleStyleColor(style, "fill", vectorColorExpression(style, styleValue(style, "fillColor")));
 }
 /**
-* 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.
+* Circle color value for a point layer. Intentionally identical to
+* `vectorFillColorValue`: GeoLibre has no separate point-fill color, so point
+* circles share the polygon fill color (matching `circlePaint` in the map
+* package). Kept as its own function so the per-geometry callers read in
+* parallel and a future dedicated circle color stays a one-line change here.
 */
-function isStyleSpecColor(value) {
-	return value instanceof Color;
+function vectorCircleColorValue(style) {
+	return withSimpleStyleColor(style, "marker-color", vectorColorExpression(style, styleValue(style, "fillColor")));
 }
 /**
-* 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".
+* Line color value for line geometry and polygon outlines (fallback: the
+* layer stroke color). For non-`expression` modes the data-driven color is
+* applied to line geometry only, while polygon outlines keep the flat stroke
+* color, matching the polygon-fill-only behavior of categorized/graduated
+* styling.
 */
-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);
+function vectorLineColorValue(style) {
+	const strokeColor = styleValue(style, "strokeColor");
+	if (styleValue(style, "vectorStyleMode") === "rule-based") return withSimpleStyleColor(style, "stroke", ruleBasedLineColorExpression(style));
+	const vectorColor = vectorColorExpression(style, strokeColor);
+	return withSimpleStyleColor(style, "stroke", vectorColor === strokeColor ? strokeColor : styleValue(style, "vectorStyleMode") === "expression" ? vectorColor : [
+		"case",
+		[
+			"==",
+			["geometry-type"],
+			"Polygon"
+		],
+		strokeColor,
+		vectorColor
+	]);
+}
+/**
+* The line color for the rule-based renderer: line geometry takes the rule
+* color, polygon outlines take the per-rule stroke color override (falling
+* back to the flat layer stroke). Both channels are built inside one shared
+* zoom wrapper, since composing two independently zoom-stepped expressions in
+* a single `case` would nest `["zoom"]` below the top level, which MapLibre
+* rejects.
+*/
+function ruleBasedLineColorExpression(style) {
+	const strokeColor = styleValue(style, "strokeColor");
+	const { rules, elseRule } = effectiveVectorRules(style);
+	const elseColor = elseRule && isHexColor(elseRule.color) ? elseRule.color : strokeColor;
+	const elseOutline = readRuleOverride(elseRule ?? void 0, "strokeColor") ?? strokeColor;
+	const hasOutlineOverride = rules.some((rule) => rule.strokeColor !== void 0) || elseOutline !== strokeColor;
+	if (rules.length === 0 && elseColor === strokeColor && !hasOutlineOverride) return strokeColor;
+	return zoomWrappedRuleValue(rules, (active) => {
+		const colorValue = active.length === 0 ? elseColor : [
+			"case",
+			...active.flatMap((rule) => [rule.filter, rule.color]),
+			elseColor
+		];
+		const outlineValue = !hasOutlineOverride ? strokeColor : active.length === 0 ? elseOutline : [
+			"case",
+			...active.flatMap((rule) => [rule.filter, rule.strokeColor ?? strokeColor]),
+			elseOutline
+		];
+		if (colorValue === strokeColor && outlineValue === strokeColor) return strokeColor;
+		return [
+			"case",
+			[
+				"==",
+				["geometry-type"],
+				"Polygon"
+			],
+			outlineValue,
+			colorValue
+		];
+	});
+}
+/**
+* Resolves the 3D-extrusion height (the roof's altitude) for a layer style
+* into a MapLibre value: a plain meters number, or a data-driven expression.
+* With a positive `extrusionFloorHeight` the roof sits that far above the
+* base (`extrusionBaseValue`, clamped to the ground as MapLibre clamps
+* `fill-extrusion-base`), whatever the height settings say. Otherwise, in
+* advanced mode a valid `extrusionHeightExpression` wins; else the height is
+* the chosen property scaled by `extrusionHeightScale` (`["*", ["to-number",
+* ["get", prop], 0], scale]`), or a flat `0` when no property is set (so the
+* layer renders flat rather than erroring). Shared by the map's
+* fill-extrusion paint and the Add Vector Layer control's extrusion mapping
+* so both extrude identically.
+*
+* @param style - The layer style.
+* @returns The extrusion height as a number or a MapLibre expression array.
+*/
+function extrusionHeightValue(style) {
+	const floorHeight = extrusionFloorHeightValue(style);
+	if (floorHeight > 0) {
+		const base = extrusionBaseValue(style);
+		return typeof base === "number" ? Math.max(0, base) + floorHeight : [
+			"+",
+			[
+				"max",
+				0,
+				base
+			],
+			floorHeight
+		];
 	}
+	const advancedExpression = parseJsonExpression(styleValue(style, "extrusionAdvancedStyleEnabled") ? styleValue(style, "extrusionHeightExpression") : "");
+	if (advancedExpression) return advancedExpression;
+	const property = styleValue(style, "extrusionHeightProperty").trim();
+	if (!property) return 0;
+	const scale = styleValue(style, "extrusionHeightScale");
+	return [
+		"*",
+		[
+			"to-number",
+			["get", property],
+			0
+		],
+		scale
+	];
 }
 /**
-* 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".
+* The layer's floor height in metres: a finite `extrusionFloorHeight` above
+* 0, else 0 (the height is then the roof's altitude). Also 0 for a project
+* saved before the field existed.
+*
+* @param style - The layer style.
+* @returns The floor height, or 0 when it is off.
+*/
+function extrusionFloorHeightValue(style) {
+	const value = styleValue(style, "extrusionFloorHeight");
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+/**
+* Resolves the 3D-extrusion base for a layer style into a MapLibre value: a
+* plain meters number, or a data-driven expression. In advanced mode a valid
+* `extrusionBaseExpression` wins; otherwise, with `extrusionBaseProperty` set,
+* the base is `extrusionBase` plus the property scaled by `extrusionBaseScale`
+* (so floors stack from a `level` field), else the flat `extrusionBase`. Like
+* {@link extrusionHeightValue} it is an altitude: MapLibre draws a feature
+* only where its height is above its base.
+*
+* @param style - The layer style.
+* @returns The extrusion base as a number or a MapLibre expression array.
+*/
+function extrusionBaseValue(style) {
+	const advancedExpression = parseJsonExpression(styleValue(style, "extrusionAdvancedStyleEnabled") ? styleValue(style, "extrusionBaseExpression") : "");
+	if (advancedExpression) return advancedExpression;
+	const rawOffset = styleValue(style, "extrusionBase");
+	const offset = Number.isFinite(rawOffset) ? rawOffset : 0;
+	const property = styleValue(style, "extrusionBaseProperty").trim();
+	if (!property) return offset;
+	const scale = styleValue(style, "extrusionBaseScale");
+	const scaled = [
+		"*",
+		[
+			"to-number",
+			["get", property],
+			0
+		],
+		Number.isFinite(scale) ? scale : 1
+	];
+	return offset === 0 ? scaled : [
+		"+",
+		scaled,
+		offset
+	];
+}
+/**
+* Resolves the 3D-extrusion color for a layer style: a data-driven expression
+* when the layer's symbology mode produces one (categorized/graduated/rule/
+* expression) or an advanced `extrusionColorExpression` is set, otherwise the
+* flat `extrusionColor`. Mirrors the fill-color contract so an extruded layer
+* honors the same attribute-driven styling.
+*
+* @param style - The layer style.
+* @returns A flat color string or a MapLibre color expression array.
 */
-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;
+function extrusionColorValue(style) {
+	const flat = styleValue(style, "extrusionColor");
+	const vectorExpression = vectorColorExpression(style, flat);
+	if (vectorExpression !== flat) return vectorExpression;
+	return parseJsonExpression(styleValue(style, "extrusionAdvancedStyleEnabled") ? styleValue(style, "extrusionColorExpression") : "") ?? flat;
 }
 // src/layer-descriptive-metadata.ts
 /** STAC specification version the Item export targets. */
@@ -4669,6 +5756,8 @@ const DEFAULT_PRINT_LAYOUT = {
 	customHeight: 720,
 	customUnit: "px",
 	pageMargin: "normal",
+	pageBackground: "#ffffff",
+	panelTheme: "light",
 	showPageBorder: false,
 	pageBorderColor: "#111827",
 	pageBorderWidth: 2,
@@ -4758,6 +5847,10 @@ function createDefaultPrintLayout() {
 function str(value, fallback) {
 	return typeof value === "string" ? value : fallback;
 }
+/** A `#RGB` / `#RRGGBB` colour, or `fallback` for anything else. */
+function hexColor(value, fallback) {
+	return typeof value === "string" && /^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/i.test(value.trim()) ? value.trim() : fallback;
+}
 function bool(value, fallback) {
 	return typeof value === "boolean" ? value : fallback;
 }
@@ -4859,6 +5952,8 @@ function normalizePrintLayoutConfig(value) {
 			"narrow",
 			"none"
 		], d.pageMargin),
+		pageBackground: hexColor(raw.pageBackground, d.pageBackground),
+		panelTheme: oneOf(raw.panelTheme, ["light", "dark"], d.panelTheme),
 		showPageBorder: bool(raw.showPageBorder, d.showPageBorder),
 		pageBorderColor: str(raw.pageBorderColor, d.pageBorderColor),
 		pageBorderWidth: num(raw.pageBorderWidth, d.pageBorderWidth, 1, 20),
@@ -5047,6 +6142,9 @@ const SYMBOL_STYLE_KEYS = [
 	"strokeColor",
 	"strokeWidth",
 	"strokeWidthUnit",
+	"strokeOpacity",
+	"strokeDash",
+	"strokeBlur",
 	"fillOpacity",
 	"circleRadius",
 	"fillPattern",
@@ -5246,7 +6344,9 @@ function sanitizeLayerStylePatch(value) {
 					...circleRadius !== void 0 ? { circleRadius } : {}
 				}];
 			});
-			else out[key] = given;
+			else if (key === "strokeDash") {
+				if (given.length === 0 || isStrokeDashPattern(given)) out[key] = given;
+			} else out[key] = given;
 			continue;
 		}
 		if (typeof given !== typeof fallback) continue;
@@ -6524,6 +7624,7 @@ function redactUrlCredentials(value) {
 	}
 	const keptQuery = query === void 0 ? void 0 : redactParameterString(query);
 	const keptFragment = fragment === void 0 || !fragment.includes("=") ? fragment : redactParameterString(fragment);
+	if (base === (queryIndex === -1 ? beforeHash : beforeHash.slice(0, queryIndex)) && keptQuery === query && keptFragment === fragment) return value;
 	return base + (keptQuery ? `?${keptQuery}` : "") + (keptFragment ? `#${keptFragment}` : "");
 }
 function isPlainObject$2(value) {
@@ -6648,13 +7749,17 @@ function redactProjectCredentials(project) {
 	const mapboxStyleUrl = project.preferences?.map?.mapboxStyleUrl;
 	const redactedMapboxStyleUrl = typeof mapboxStyleUrl === "string" ? redactUrlCredentials(mapboxStyleUrl) : mapboxStyleUrl;
 	if (redactedMapboxStyleUrl !== mapboxStyleUrl) recordRedaction(accumulator, "preferences.map.mapboxStyleUrl", mapboxStyleUrl);
+	const terrainSource = project.preferences?.map?.terrainSource;
+	const redactedTerrainSource = typeof terrainSource === "string" ? redactUrlCredentials(terrainSource) : terrainSource;
+	if (redactedTerrainSource !== terrainSource) recordRedaction(accumulator, "preferences.map.terrainSource", terrainSource);
 	const preferences = project.preferences ? {
 		...project.preferences,
 		environmentVariables: (project.preferences.environmentVariables ?? []).filter((variable) => variable.secret === false),
 		geocoding,
-		...redactedMapboxStyleUrl !== mapboxStyleUrl ? { map: {
+		...redactedMapboxStyleUrl !== mapboxStyleUrl || redactedTerrainSource !== terrainSource ? { map: {
 			...project.preferences.map,
-			mapboxStyleUrl: redactedMapboxStyleUrl
+			mapboxStyleUrl: redactedMapboxStyleUrl,
+			terrainSource: redactedTerrainSource
 		} } : {}
 	} : project.preferences;
 	const populatedEnvironmentVariables = project.preferences?.environmentVariables?.filter((variable) => variable.secret !== false && variable.value !== "") ?? [];
@@ -6846,6 +7951,50 @@ var GeocoderUnsupportedError = class extends Error {
 		this.name = "GeocoderUnsupportedError";
 	}
 };
+/**
+* Whether a raw coordinate is a number or a numeric-looking string
+* (Nominatim's form). `Number()` would also turn `null`, `true`, a blank string
+* or a one-element array into a coordinate, so those are rejected first.
+*/
+function isCoordinateValue(value) {
+	return typeof value === "number" || typeof value === "string" && value.trim() !== "";
+}
+/**
+* Validate a west/south/east/north extent: every edge finite and on Earth,
+* south not above north. Returns null otherwise, so a malformed box falls back
+* to the match's point instead of sending the camera somewhere odd.
+*
+* @param west - Western longitude.
+* @param south - Southern latitude.
+* @param east - Eastern longitude.
+* @param north - Northern latitude.
+* @returns The extent, or null when it is not a usable one.
+*/
+function normalizeGeocodeBbox(west, south, east, north) {
+	if (![
+		west,
+		south,
+		east,
+		north
+	].every(isCoordinateValue)) return null;
+	const box = [
+		Number(west),
+		Number(south),
+		Number(east),
+		Number(north)
+	];
+	if (!box.every(Number.isFinite)) return null;
+	const [w, s, e, n] = box;
+	if (w < -180 || w > 180 || e < -180 || e > 180) return null;
+	if (s < -90 || n > 90 || s > n) return null;
+	return box;
+}
+/** A GeoJSON feature's own `bbox` member (`[west, south, east, north]`), or null. */
+function geojsonFeatureBbox(feature) {
+	const bbox = feature.bbox;
+	if (!Array.isArray(bbox) || bbox.length !== 4) return null;
+	return normalizeGeocodeBbox(bbox[0], bbox[1], bbox[2], bbox[3]);
+}
 function coerceScore(value) {
 	if (value === void 0 || value === null || value === "") return null;
 	const num = Number(value);
@@ -6905,11 +8054,14 @@ function nominatimForwardResultToMatch(result) {
 	const lat = Number(result.lat);
 	const lon = Number(result.lon);
 	if (!Number.isFinite(lat) || !Number.isFinite(lon)) return null;
+	const box = Array.isArray(result.boundingbox) ? result.boundingbox : null;
+	const bbox = box?.length === 4 ? normalizeGeocodeBbox(box[2], box[0], box[3], box[1]) : null;
 	return {
 		lat,
 		lon,
 		displayName: result.display_name ?? "",
-		score: coerceScore(result.importance)
+		score: coerceScore(result.importance),
+		...bbox ? { bbox } : {}
 	};
 }
 /**
@@ -7049,11 +8201,13 @@ const peliasProvider = {
 		const coords = pointCoords(feature);
 		if (!coords) return null;
 		const props = feature.properties ?? {};
+		const bbox = geojsonFeatureBbox(feature);
 		return {
 			lon: coords[0],
 			lat: coords[1],
 			displayName: readString(props, "label") ?? "",
-			score: coerceScore(props.confidence)
+			score: coerceScore(props.confidence),
+			...bbox ? { bbox } : {}
 		};
 	}).filter((m) => m !== null),
 	buildReverseUrl: (config, lon, lat) => {
@@ -7155,6 +8309,33 @@ function arcgisCandidatePosition(x, y, wkid) {
 	};
 }
 /**
+* A candidate's `extent` (`xmin`/`ymin`/`xmax`/`ymax`, in the response's
+* spatial reference) as a west/south/east/north box in degrees, or null when it
+* is missing, malformed, or in a spatial reference that cannot be unprojected.
+*
+* @param extent - The candidate's `extent` member.
+* @param wkid - The response's spatial reference, or null when it reports none.
+* @returns The extent in degrees, or null.
+*/
+function arcgisCandidateExtent(extent, wkid) {
+	if (!extent || typeof extent !== "object") return null;
+	const e = extent;
+	if (![
+		e.xmin,
+		e.ymin,
+		e.xmax,
+		e.ymax
+	].every(isCoordinateValue)) return null;
+	try {
+		const sw = arcgisCandidatePosition(Number(e.xmin), Number(e.ymin), wkid);
+		const ne = arcgisCandidatePosition(Number(e.xmax), Number(e.ymax), wkid);
+		if (!sw || !ne) return null;
+		return normalizeGeocodeBbox(sw.lon, sw.lat, ne.lon, ne.lat);
+	} catch {
+		return null;
+	}
+}
+/**
 * A candidate's attributes worth keeping: plain values that are not empty.
 * The shape and the location fields the match already carries are dropped.
 */
@@ -7188,11 +8369,13 @@ function parseArcGISCandidates(data) {
 		const position = arcgisCandidatePosition(Number(location?.x), Number(location?.y), wkid);
 		if (!position) return null;
 		const attributes = candidateAttributes(candidate.attributes);
+		const bbox = arcgisCandidateExtent(candidate.extent, wkid);
 		return {
 			...position,
 			displayName: readString(candidate, "address") ?? "",
 			score: coerceScore(candidate.score),
-			...attributes ? { attributes } : {}
+			...attributes ? { attributes } : {},
+			...bbox ? { bbox } : {}
 		};
 	}).filter((m) => m !== null);
 }
@@ -7397,11 +8580,13 @@ const mapboxProvider = {
 		}
 		coords ??= pointCoords(feature);
 		if (!coords) return null;
+		const bbox = geojsonFeatureBbox(feature);
 		return {
 			lon: coords[0],
 			lat: coords[1],
 			displayName: readString(feature, "place_name") ?? "",
-			score: coerceScore(feature.relevance)
+			score: coerceScore(feature.relevance),
+			...bbox ? { bbox } : {}
 		};
 	}).filter((m) => m !== null),
 	buildReverseUrl: (config, lon, lat) => {
@@ -7473,15 +8658,19 @@ const googleProvider = {
 /** Map a Google Geocoding API `results` array onto normalized matches. */
 function parseGoogleResults(data) {
 	return (data && typeof data === "object" && Array.isArray(data.results) ? data.results : []).map((result) => {
-		const location = result.geometry?.location;
+		const geometry = result.geometry;
+		const location = geometry?.location;
 		const lat = Number(location?.lat);
 		const lon = Number(location?.lng);
 		if (!Number.isFinite(lat) || !Number.isFinite(lon)) return null;
+		const viewport = geometry?.viewport;
+		const bbox = viewport ? normalizeGeocodeBbox(viewport.southwest?.lng, viewport.southwest?.lat, viewport.northeast?.lng, viewport.northeast?.lat) : null;
 		return {
 			lat,
 			lon,
 			displayName: readString(result, "formatted_address") ?? "",
-			score: null
+			score: null,
+			...bbox ? { bbox } : {}
 		};
 	}).filter((m) => m !== null);
 }
@@ -9161,6 +10350,8 @@ function normalizeProjectPreferences(preferences) {
 			cesiumBasemap: normalizeCesiumBasemap(map.cesiumBasemap),
 			terrainEnabled: normalizeBoolean(map.terrainEnabled, DEFAULT_PROJECT_PREFERENCES.map.terrainEnabled),
 			terrainIonAssetId: parseCesiumIonAssetId(map.terrainIonAssetId) ?? void 0,
+			terrainExaggeration: normalizeTerrainExaggeration(map.terrainExaggeration),
+			terrainSource: normalizeTerrainSource(map.terrainSource),
 			coordinateFormat: typeof map.coordinateFormat === "string" ? map.coordinateFormat : DEFAULT_PROJECT_PREFERENCES.map.coordinateFormat,
 			coordinateEpsgCode: normalizeEpsgCode(map.coordinateEpsgCode),
 			zoomToNewLayers: normalizeBoolean(map.zoomToNewLayers, DEFAULT_PROJECT_PREFERENCES.map.zoomToNewLayers)
@@ -9239,6 +10430,34 @@ function normalizeBounds(bounds) {
 	}
 	return DEFAULT_PROJECT_PREFERENCES.map.bounds;
 }
+/**
+* Keep a saved terrain exaggeration only when it is a finite, non-negative
+* number; anything else falls back to the renderer default.
+*
+* Args:
+*   value: The raw `terrainExaggeration` from a project file.
+*
+* Returns:
+*   The exaggeration, or `undefined` for the default.
+*/
+function normalizeTerrainExaggeration(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+/**
+* Keep a saved terrain DEM only when it is an HTTP(S) URL, the one kind of
+* source a project can reopen on another device.
+*
+* Args:
+*   value: The raw `terrainSource` from a project file.
+*
+* Returns:
+*   The trimmed URL, or `undefined` for the built-in global terrain.
+*/
+function normalizeTerrainSource(value) {
+	if (typeof value !== "string") return void 0;
+	const trimmed = value.trim();
+	return /^https?:\/\//i.test(trimmed) ? trimmed : void 0;
+}
 function normalizeNumber(value, fallback) {
 	return Number.isFinite(value) ? Number(value) : fallback;
 }
@@ -9375,8 +10594,63 @@ function withoutRuntimeGeoArrow(layer) {
 function portableLayer(layer) {
 	return withoutRuntimeGeoArrow(withoutZarrHeaders(withoutLocalRasterBytes(layer)));
 }
+/**
+* The path of a URL, or `""` when it does not parse (not a loadable URL). A
+* protocol-relative URL (`//host/...`) is read against https.
+*/
+function urlPath(url) {
+	try {
+		return new URL(url.trim(), "https://geolibre.invalid").pathname;
+	} catch {
+		return "";
+	}
+}
+/** Source kind of an ArcGIS I3S scene layer (`arcgis-i3s-tiles.ts` in the plugins). */
+const ARCGIS_I3S_SOURCE_KIND = "arcgis-i3s";
+/**
+* The path of an ArcGIS scene service or one of its layers:
+* `.../SceneServer`, `.../SceneServer/layers/<n>`, or a Building Scene Layer's
+* `.../layers/<n>/sublayers/<m>`. Narrower than the 3D Tiles
+* panel's `isArcgisI3sSceneLayerUrl` on purpose: a `tileset.json` stored under
+* a `SceneServer` folder, or a query that mentions one, stays a tileset.
+*/
+const I3S_SCENE_SERVER_PATH_RE = /\/SceneServer(\/layers\/\d+(\/sublayers\/\d+)?)?\/?$/i;
+/**
+* Re-file a 3D Tiles record whose URL is an ArcGIS scene service as an I3S
+* scene layer (issue #3377).
+*
+* The app draws a scene layer only when its source kind is `arcgis-i3s`. The
+* Python `add_3d_tiles()` used to write a SceneServer URL as a plain tileset
+* (`3d-tiles-url`), which the 3D Tiles control then loads as a `tileset.json`,
+* so nothing drew. This gives such a record the shape the app's 3D Tiles panel
+* writes (`createArcgisI3sStoreLayer`), keeping its id, name and settings.
+*
+* @param layer - A layer from a project file.
+* @returns The layer, re-filed as an I3S scene layer when it is a misfiled one.
+*/
+function withI3sSceneLayerKind(layer) {
+	const url = layer.source?.url;
+	if (layer.type !== "3d-tiles" || layer.metadata?.sourceKind !== "3d-tiles-url" || typeof url !== "string" || !I3S_SCENE_SERVER_PATH_RE.test(urlPath(url))) return layer;
+	const { status: _status, panelCollapsed: _panelCollapsed, ...metadata } = layer.metadata;
+	return {
+		...layer,
+		source: {
+			...layer.source,
+			type: ARCGIS_I3S_SOURCE_KIND
+		},
+		metadata: {
+			...metadata,
+			customLayerType: ARCGIS_I3S_SOURCE_KIND,
+			externalDeckLayer: true,
+			externalNativeLayer: true,
+			identifiable: false,
+			nativeLayerIds: [`${layer.id}-deck`],
+			sourceKind: ARCGIS_I3S_SOURCE_KIND
+		}
+	};
+}
 function normalizeLayer(layer) {
-	layer = withRasterSourceDefaults(withoutLocalRasterBytes(layer));
+	layer = withI3sSceneLayerKind(withRasterSourceDefaults(withoutLocalRasterBytes(layer)));
 	const { capabilities: rawCapabilities, filterExpression: rawFilterExpression, descriptiveMetadata: rawDescriptiveMetadata, geoarrow: _rawGeoarrow, ...rest } = layer;
 	const capabilities = normalizeLayerCapabilities(rawCapabilities);
 	const descriptiveMetadata = normalizeLayerDescriptiveMetadata(rawDescriptiveMetadata);
@@ -9809,6 +11083,7 @@ const LAYER_GROUPED_KEYS = /* @__PURE__ */ new Set([
 	"geojson",
 	"filterExpression",
 	"quickFilters",
+	"levelFilter",
 	"source",
 	"sourcePath",
 	"beforeId"
@@ -10159,10 +11434,12 @@ function diffLayer(beforeProject, afterProject, a, b, maxLength) {
 	}
 	diffRecords({
 		filterExpression: a.filterExpression,
-		quickFilters: a.quickFilters
+		quickFilters: a.quickFilters,
+		levelFilter: a.levelFilter
 	}, {
 		filterExpression: b.filterExpression,
-		quickFilters: b.quickFilters
+		quickFilters: b.quickFilters,
+		levelFilter: b.levelFilter
 	}, {
 		depth: 0,
 		maxLength
@@ -10426,6 +11703,6 @@ function metadataRank(path) {
 	if (path === "description") return 1;
 	return 2;
 }
-export { GEOCODING_PROVIDERS as $, getEllipsoid as $i, groupMemberIndices as $n, getBuildEnvironment as $r, CESIUM_BING_AERIAL_ASSET_ID as $t, normalizeSecondaryMapViews as A, shouldUseTiledRendering as Aa, normalizeCesiumBasemap as Ai, createStyleLibraryEntryId as An, isValidMetadataDate as Ar, selectedGeocodingLocator as At, storyMapHasContent as B, EARTH_MEAN_RADIUS_METERS as Bi, normalizePrintLayoutConfig as Bn, evaluateMapExpression as Br, PROJECT_CREDENTIAL_FIELDS as Bt, normalizeModelGraph as C, NETCDF_IMAGE_SOURCE_KIND as Ca, normalizeMapCrs as Ci, isGeoArrowBatch as Cn, reapplyLayerJoins as Cr, normalizeArcGISLocatorUrl as Ct, normalizeProcessingHistory as D, SQL_QUERY_SOURCE_KIND as Da, CESIUM_BASEMAPS as Di, STYLE_LIBRARY_BUNDLE_TYPE as Dn, STAC_PROCESSING_EXTENSION as Dr, parseArcGISSuggestions as Dt, normalizePrimaryRenderer as E, PROTOMAPS_BASEMAPS as Ea, normalizeArcgisWkid as Ei, RAMP_STYLE_KEYS as En, stripVirtualFieldColumns as Er, parseArcGISLocatorInfo as Et, projectFromStore as F, REGIONAL_BASEMAP_SENTINEL_PREFIX as Fi, sanitizeLayerStylePatch as Fn, parseMetadataKeywords as Fr, DEFAULT_STORY_CHAPTER_DURATION_SECONDS as Ft, DEFAULT_REVERSE_GEOCODE_ENDPOINT as G, PLANET_SWITCHER_OPTIONS as Gi, scrubCommentsForRemovedLayers as Gn, removeTrailingJsonCommas as Gr, redactCredentials as Gt, CARTOCIUDAD_PUBLIC_HOST as H, PLANETARY_BASEMAPS as Hi, scrubPrintLayoutForLayers as Hn, inferFieldTypes as Hr, isCredentialFieldName as Ht, resolveMapGrid as I, getRegionalBasemapById as Ii, serializeStyleLibrary as In, stacAssetMediaType as Ir, MAX_STORY_CHAPTER_DURATION_SECONDS as It, GEOCODE_LAT_KEY as J, earthLengthToBody as Ji, DEFAULT_LAYER_GROUP_OPACITY as Jn, SELECTION_MODES as Jr, setRegistryPublishableSettings as Jt, GEOCODE_ATTRIBUTE_PREFIX as K, bodyLengthToEarth as Ki, scrubLegendForRemovedLayers as Kn, substituteExpressionVariables as Kr, redactProjectCredentials as Kt, serializeProject as L, getRegionalBasemapByStyleUrl as Li, DEFAULT_PRINT_LAYOUT as Ln, validateLayerDescriptiveMetadata as Lr, MIN_STORY_CHAPTER_DURATION_SECONDS as Lt, normalizeWidgets as M, CHINA_BASEMAPS as Mi, isStyleLibraryTargetLayer as Mn, isValidMetadataUrl as Mr, setGeocodingTokenProvider as Mt, parseProject as N, REGIONAL_BASEMAPS as Ni, normalizeStyleLibraryEntries as Nn, metadataDateToRfc3339 as Nr, shouldThrottle as Nt, normalizeProjectComments as O, detectNonGeographicCoordinates as Oa, availableCesiumBasemap as Oi, STYLE_LIBRARY_BUNDLE_VERSION as On, STAC_VERSION as Or, resolveGeocoderConfig as Ot, portableWmsTileUrl as P, REGIONAL_BASEMAP_GROUPS as Pi, parseStyleLibrary as Pn, normalizeLayerDescriptiveMetadata as Pr, unmatchedGeocodeFeature as Pt, GEOCODE_STATUS_KEY as Q, getActiveSemiMajorAxisMeters as Qi, effectiveLayerRenderState as Qn, getArcgisApiKey as Qr, resolveHeaderReferences as Qt, serializeProjectWithLayerCache as R, isRegionalBasemapSentinel as Ri, createDefaultPrintLayout as Rn, EXPRESSION_FUNCTION_CATEGORIES as Rr, normalizeStoryChapterDurationSeconds as Rt, normalizeMapViewState as S, MIN_DASHBOARD_COLUMNS as Sa, mapCrsPreferencePatch as Si, geoArrowToFeatureCollection as Sn, layerJoinKey as Sr, nominatimReverseResultToDisplay as St, normalizeObiaWorkbench as T, PROJECT_VERSION as Ta, ARCGIS_PROJECTION_PRESETS as Ti, BUILT_IN_STYLE_PRESETS as Tn, applyLayerVirtualFields as Tr, normalizeGeocodingProviderId as Tt, DEFAULT_FORWARD_GEOCODE_ENDPOINT as U, PLANETARY_BASEMAP_GROUPS as Ui, scrubPrintLayoutForRemovedLayers as Un, isStyleSpecColor as Ur, isCredentialUrlParam as Ut, CARTOCIUDAD_MIN_INTERVAL_MS as V, ELLIPSOIDS as Vi, printLayoutConfigsEqual as Vn, formatExpressionPreviewValue as Vr, PUBLISHABLE_PLUGIN_SETTINGS as Vt, DEFAULT_GEOCODING_PROVIDER_ID as W, PLANETARY_BASEMAP_SENTINEL_PREFIX as Wi, removedLayerIdSet as Wn, matchFeaturesByExpression as Wr, redactConfigurationCredentials as Wt, GEOCODE_PROVIDER_KEY as X, getActiveEllipsoid as Xi, buildLayerPanelUnits as Xn, featureSelectionId as Xr, hasHeaderReferences as Xt, GEOCODE_LON_KEY as Y, getActiveBodyRadiusRatio as Yi, applyGroupEffects as Yn, applySelectionMode as Yr, allowsCredentialHeaders as Yt, GEOCODE_SCORE_KEY as Z, getActiveMeanRadiusMeters as Zi, buildLayerTree as Zn, invertSelection as Zr, isHeaderReferenceOnly as Zt, normalizeBookmarkGroups as _, LARGE_VECTOR_FEATURE_THRESHOLD as _a, MAP_CRS_CHANGE_EVENT as _i, czmlSource as _n, resolveRolePrivileges as _r, geocoderSupportsSuggest as _t, DEFAULT_PROJECT_NAME as a, BLEND_MODES as aa, getRuntimeEnvironment as ai, cesiumIonAssetKind as an, reorderLayerGroupInPanel as ar, arcgisLocatorInputField as at, normalizeLegendConfig as b, MAX_MAP_GRID_DIM as ba, deriveTileMatrixSet as bi, computeGeoArrowBBox as bn, cascadeLayerJoinRefresh as br, nextDelayMs as bt, createDefaultMapView as c, DEFAULT_DASHBOARD_COLUMNS as ca, decodePolyline as ci, isCesiumOnlyLayer as cn, ROLE_PRIVILEGES as cr, csvRowsToGeocodeRequests as ct, createProjectTemplate as d, DEFAULT_MAP_GRID_LAYOUT as da, geoJSONToPolylineStr as di, cesiumKmlSource as dn, hasAppPrivilege as dr, geocodeMatchToFeature as dt, getPlanetaryBasemapById as ea, getCesiumIonToken as ei, CESIUM_GOOGLE_PHOTOREALISTIC_ASSET_ID as en, layerGroupDepth as er, GeocoderServiceError as et, detachProjectCopy as f, DEFAULT_PRIMARY_RENDERER as fa, polylineStrToGeoJSON as fi, createCesiumKmlLayer as fn, inferLayerCapabilities as fr, geocodeReverse as ft, normalizeBlankBackgroundColor as g, DUCKDB_VECTOR_ROUTE_BYTES as ga, transformGeojsonElevation as gi, createCzmlLayer as gn, resolveLayerCapabilities as gr, geocoderSupportsReverse as gt, isSessionOnlyLayer as h, DUCKDB_VECTOR_FEATURE_WARN_COUNT as ha, horizontalBbox as hi, CZML_SOURCE_KIND as hn, normalizeLayerCapabilities as hr, geocoderNeedsApiKey as ht, previewValue as i, BLANK_BASEMAP as ia, getProtomapsStyleUrl as ii, cesiumIonAssetId as in, normalizeGroupContiguity as ir, PUBLIC_GEOCODE_ROW_CAP as it, normalizeStoryMap as j, styleValue as ja, sameCesiumImagery as ji, extractStyleLibraryStyle as jn, isValidMetadataEmail as jr, setGeocodingFetch as jt, normalizeProjectInteraction as k, isDuckDBQueryLayer as ka, basemapToCesiumImagery as ki, SYMBOL_STYLE_KEYS as kn, buildLayerStacItem as kr, rowCap as kt, createEmptyProject as l, DEFAULT_LAYER_STYLE as la, decodePolylineDetailed as li, parseCesiumIonAssetId as ln, appPrivilegeReason as lr, fetchArcGISLocatorInfo as lt, isAllowedPluginManifestUrl as m, DEFAULT_STORY_MAP as ma, geojsonHasZCoordinates as mi, CZML_QUICK_PICKS as mn, normalizeAppPrivileges as mr, geocoderMinIntervalMs as mt, diffProjects as n, meanRadiusMeters as na, getMapboxAccessToken as ni, CESIUM_ION_SOURCE_KIND as nn, layerGroupSortability as nr, NOMINATIM_MIN_INTERVAL_MS as nt, MAX_PROJECT_BOOKMARKS as o, DEFAULT_BASEMAP as oa, getSpatialExtensionPath as oi, createCesiumIonLayer as on, sortLayerGroupInPanel as or, buildForwardGeocodeUrl as ot, hydrateProjectLayer as p, DEFAULT_PROJECT_PREFERENCES as pa, unescapePolyline as pi, isCesiumKmlLayer as pn, intersectPrivileges as pr, geocodeSuggest as pt, GEOCODE_DISPLAY_NAME_KEY as q, earthAreaToBody as qi, scrubWidgetsForRemovedLayers as qn, validateMapExpression as qr, redactUrlCredentials as qt, jsonValuesEqual as r, setActiveEllipsoidId as ra, getProtomapsApiKey as ri, CESIUM_OSM_BUILDINGS_ASSET_ID as rn, layerPanelGroupHeaders as rr, NOMINATIM_PUBLIC_HOST as rt, applyProjectToStore as s, DEFAULT_BLEND_MODE as sa, batchDecodePolylines as si, isCesiumIonLayer as sn, ALL_APP_PRIVILEGES as sr, buildReverseGeocodeUrl as st, diffFeatureCollections as t, getPlanetaryBasemapByStyleUrl as ta, getGoogleMapsApiKey as ti, CESIUM_ION_QUICK_PICKS as tn, layerGroupMoveability as tr, GeocoderUnsupportedError as tt, createProjectLayerSerializationCache as u, DEFAULT_LEGEND_CONFIG as ua, encodePolyline as ui, CESIUM_KML_SOURCE_KIND as un, createDefaultAppCapabilities as ur, geocodeForward as ut, normalizeBookmarks as v, LAYER_TYPES as va, MAP_CRS_PRESETS as vi, isCzmlLayer as vn, applyJoinsToLayer as vr, getGeocoderConfig as vt, normalizeModels as w, OPENFREEMAP_BASEMAPS as wa, parseMapCrsEpsgCode as wi, withRasterSourceDefaults as wn, stripJoinFields as wr, normalizeGeocodingLocator as wt, normalizeMapLayout as x, MAX_PROCESSING_HISTORY as xa, getMapCrsPreset as xi, featureCollectionToGeoArrow as xn, collectTransitiveJoinSourceIds as xr, nominatimResultToFeature as xt, normalizeDashboardColumns as y, MAX_DASHBOARD_COLUMNS as ya, adaptBboxTemplateToCrs as yi, parseCzml as yn, applyLayerJoins as yr, getGeocodingProvider as yt, serializeProjectWithLayerCacheAsync as z, DEFAULT_ELLIPSOID_ID as zi, isDefaultPrintLayout as zn, compileFeatureExpression as zr, MAX_REDACT_DEPTH as zt };
+export { GEOCODE_STATUS_KEY as $, LAYER_TYPES as $a, unescapePolyline as $i, buildLayerTree as $n, isVectorColorExpression as $r, isHeaderReferenceOnly as $t, normalizeSecondaryMapViews as A, CHINA_BASEMAPS as Aa, matchFeaturesByExpression as Ai, STYLE_LIBRARY_BUNDLE_VERSION as An, STAC_VERSION as Ar, resolveGeocoderConfig as At, storyMapHasContent as B, BLEND_MODES as Ba, getCesiumIonToken as Bi, createDefaultPrintLayout as Bn, MERCATOR_METERS_PER_PIXEL_AT_ZOOM_0 as Br, normalizeStoryChapterDurationSeconds as Bt, normalizeModelGraph as C, ARCGIS_PROJECTION_PRESETS as Ca, vectorStrokeWidthValue as Ci, featureCollectionToGeoArrow as Cn, collectTransitiveJoinSourceIds as Cr, nominatimReverseResultToDisplay as Ct, normalizeProcessingHistory as D, basemapToCesiumImagery as Da, formatExpressionPreviewValue as Di, BUILT_IN_STYLE_PRESETS as Dn, applyLayerVirtualFields as Dr, normalizeGeocodingProviderId as Dt, normalizePrimaryRenderer as E, availableCesiumBasemap as Ea, evaluateMapExpression as Ei, withRasterSourceDefaults as En, stripJoinFields as Er, normalizeGeocodingLocator as Et, projectFromStore as F, getRegionalBasemapById as Fa, applySelectionMode as Fi, normalizeStyleLibraryEntries as Fn, metadataDateToRfc3339 as Fr, shouldThrottle as Ft, DEFAULT_GEOCODING_PROVIDER_ID as G, DEFAULT_LEGEND_CONFIG as Ga, getRuntimeEnvironment as Gi, scrubPrintLayoutForRemovedLayers as Gn, extrusionFloorHeightValue as Gr, isCredentialUrlParam as Gt, CARTOCIUDAD_MIN_INTERVAL_MS as H, DEFAULT_BLEND_MODE as Ha, getMapboxAccessToken as Hi, normalizePrintLayoutConfig as Hn, effectiveVectorRules as Hr, PROJECT_CREDENTIAL_FIELDS as Ht, resolveMapGrid as I, getRegionalBasemapByStyleUrl as Ia, featureSelectionId as Ii, parseStyleLibrary as In, normalizeLayerDescriptiveMetadata as Ir, unmatchedGeocodeFeature as It, GEOCODE_DISPLAY_NAME_KEY as J, DEFAULT_PROJECT_PREFERENCES as Ja, decodePolyline as Ji, scrubLegendForRemovedLayers as Jn, generatorSizeRange as Jr, redactProjectCredentials as Jt, DEFAULT_REVERSE_GEOCODE_ENDPOINT as K, DEFAULT_MAP_GRID_LAYOUT as Ka, getSpatialExtensionPath as Ki, removedLayerIdSet as Kn, extrusionHeightValue as Kr, redactConfigurationCredentials as Kt, serializeProject as L, isRegionalBasemapSentinel as La, invertSelection as Li, sanitizeLayerStylePatch as Ln, parseMetadataKeywords as Lr, DEFAULT_STORY_CHAPTER_DURATION_SECONDS as Lt, normalizeWidgets as M, REGIONAL_BASEMAP_GROUPS as Ma, substituteExpressionVariables as Mi, createStyleLibraryEntryId as Mn, isValidMetadataDate as Mr, selectedGeocodingLocator as Mt, parseProject as N, REGIONAL_BASEMAP_SENTINEL_PREFIX as Na, validateMapExpression as Ni, extractStyleLibraryStyle as Nn, isValidMetadataEmail as Nr, setGeocodingFetch as Nt, normalizeProjectComments as O, normalizeCesiumBasemap as Oa, inferFieldTypes as Oi, RAMP_STYLE_KEYS as On, stripVirtualFieldColumns as Or, parseArcGISLocatorInfo as Ot, portableWmsTileUrl as P, gateRegionalBasemap as Pa, SELECTION_MODES as Pi, isStyleLibraryTargetLayer as Pn, isValidMetadataUrl as Pr, setGeocodingTokenProvider as Pt, GEOCODE_SCORE_KEY as Q, LARGE_VECTOR_FEATURE_THRESHOLD as Qa, polylineStrToGeoJSON as Qi, buildLayerPanelUnits as Qn, isStrokeDashPattern as Qr, hasHeaderReferences as Qt, serializeProjectWithLayerCache as R, ARCGIS_IMAGE_SERVICE_SOURCE_KIND as Ra, getArcgisApiKey as Ri, serializeStyleLibrary as Rn, stacAssetMediaType as Rr, MAX_STORY_CHAPTER_DURATION_SECONDS as Rt, normalizeMapViewState as S, parseMapCrsEpsgCode as Sa, vectorOutlineColorValue as Si, computeGeoArrowBBox as Sn, cascadeLayerJoinRefresh as Sr, nominatimResultToFeature as St, normalizeObiaWorkbench as T, CESIUM_BASEMAPS as Ta, compileFeatureExpression as Ti, isGeoArrowBatch as Tn, reapplyLayerJoins as Tr, normalizeGeocodeBbox as Tt, CARTOCIUDAD_PUBLIC_HOST as U, DEFAULT_DASHBOARD_COLUMNS as Ua, getProtomapsApiKey as Ui, printLayoutConfigsEqual as Un, extrusionBaseValue as Ur, PUBLISHABLE_PLUGIN_SETTINGS as Ut, withI3sSceneLayerKind as V, DEFAULT_BASEMAP as Va, getGoogleMapsApiKey as Vi, isDefaultPrintLayout as Vn, circleRadiusValue as Vr, MAX_REDACT_DEPTH as Vt, DEFAULT_FORWARD_GEOCODE_ENDPOINT as W, DEFAULT_LAYER_STYLE as Wa, getProtomapsStyleUrl as Wi, scrubPrintLayoutForLayers as Wn, extrusionColorValue as Wr, isCredentialFieldName as Wt, GEOCODE_LON_KEY as X, DUCKDB_VECTOR_FEATURE_WARN_COUNT as Xa, encodePolyline as Xi, DEFAULT_LAYER_GROUP_OPACITY as Xn, heatmapRampColors as Xr, setRegistryPublishableSettings as Xt, GEOCODE_LAT_KEY as Y, DEFAULT_STORY_MAP as Ya, decodePolylineDetailed as Yi, scrubWidgetsForRemovedLayers as Yn, hasSimpleStyleProperties as Yr, redactUrlCredentials as Yt, GEOCODE_PROVIDER_KEY as Z, DUCKDB_VECTOR_ROUTE_BYTES as Za, geoJSONToPolylineStr as Zi, applyGroupEffects as Zn, isHexColor as Zr, allowsCredentialHeaders as Zt, normalizeBookmarkGroups as _, adaptBboxTemplateToCrs as _a, vectorCircleColorValue as _i, CZML_SOURCE_KIND as _n, normalizeLayerCapabilities as _r, geocoderSupportsReverse as _t, DEFAULT_PROJECT_NAME as a, interpolateColors as aa, proportionalRadiusExpression as ai, CESIUM_OSM_BUILDINGS_ASSET_ID as an, OPENFREEMAP_BASEMAPS as ao, layerPanelGroupHeaders as ar, PUBLIC_GEOCODE_ROW_CAP as at, normalizeLegendConfig as b, mapCrsPreferencePatch as ba, vectorFillOpacityValue as bi, isCzmlLayer as bn, applyJoinsToLayer as br, getGeocodingProvider as bt, createDefaultMapView as c, normalizeHexColor as ca, readsSimpleStyleProperties as ci, createCesiumIonLayer as cn, PROTOMAPS_BASEMAPS as co, sortLayerGroupInPanel as cr, buildReverseGeocodeUrl as ct, createProjectTemplate as d, rgbToHex as da, simpleStyleNumberValue as di, parseCesiumIonAssetId as dn, detectNonGeographicCoordinates as do, appPrivilegeReason as dr, geocodeForward as dt, VECTOR_COLOR_RAMPS as ea, lineWidthValue as ei, resolveHeaderReferences as en, MAX_DASHBOARD_COLUMNS as eo, effectiveLayerRenderState as er, GEOCODING_PROVIDERS as et, detachProjectCopy as f, geojsonHasZCoordinates as fa, strokeBlurValue as fi, CESIUM_KML_SOURCE_KIND as fn, isDuckDBQueryLayer as fo, createDefaultAppCapabilities as fr, geocodeMatchToFeature as ft, normalizeBlankBackgroundColor as g, MAP_CRS_PRESETS as ga, strokeOpacityValue as gi, CZML_QUICK_PICKS as gn, normalizeAppPrivileges as gr, geocoderNeedsApiKey as gt, isSessionOnlyLayer as h, MAP_CRS_CHANGE_EVENT as ha, strokeOpacityPaintValue as hi, isCesiumKmlLayer as hn, styleValue as ho, intersectPrivileges as hr, geocoderMinIntervalMs as ht, previewValue as i, getVectorColorRamp as ia, parseJsonExpression as ii, CESIUM_ION_SOURCE_KIND as in, NETCDF_IMAGE_SOURCE_KIND as io, layerGroupSortability as ir, NOMINATIM_PUBLIC_HOST as it, normalizeStoryMap as j, REGIONAL_BASEMAPS as ja, removeTrailingJsonCommas as ji, SYMBOL_STYLE_KEYS as jn, buildLayerStacItem as jr, rowCap as jt, normalizeProjectInteraction as k, sameCesiumImagery as ka, isStyleSpecColor as ki, STYLE_LIBRARY_BUNDLE_TYPE as kn, STAC_PROCESSING_EXTENSION as kr, parseArcGISSuggestions as kt, createEmptyProject as l, parseHexColor as la, ruleBasedColorExpression as li, isCesiumIonLayer as ln, SQL_QUERY_SOURCE_KIND as lo, ALL_APP_PRIVILEGES as lr, csvRowsToGeocodeRequests as lt, isAllowedPluginManifestUrl as m, transformGeojsonElevation as ma, strokeDashValue as mi, createCesiumKmlLayer as mn, shouldUseTiledRendering as mo, inferLayerCapabilities as mr, geocodeSuggest as mt, diffProjects as n, createGraduatedClassBreaks as na, mercatorMetersPerPixelAtZoom0 as ni, CESIUM_GOOGLE_PHOTOREALISTIC_ASSET_ID as nn, MAX_PROCESSING_HISTORY as no, layerGroupDepth as nr, GeocoderUnsupportedError as nt, MAX_PROJECT_BOOKMARKS as o, interpolateHexColor as oa, proportionalSizeRange as oi, cesiumIonAssetId as on, PLANETARY_COMPUTER_SOURCE_KIND as oo, normalizeGroupContiguity as or, arcgisLocatorInputField as ot, hydrateProjectLayer as p, horizontalBbox as pa, strokeDashPresetName as pi, cesiumKmlSource as pn, isPlanetaryComputerLayer as po, hasAppPrivilege as pr, geocodeReverse as pt, GEOCODE_ATTRIBUTE_PREFIX as q, DEFAULT_PRIMARY_RENDERER as qa, batchDecodePolylines as qi, scrubCommentsForRemovedLayers as qn, generatorCircleRadiusValue as qr, redactCredentials as qt, jsonValuesEqual as r, createQuantileBreaks as ra, metersWidthExpression as ri, CESIUM_ION_QUICK_PICKS as rn, MIN_DASHBOARD_COLUMNS as ro, layerGroupMoveability as rr, NOMINATIM_MIN_INTERVAL_MS as rt, applyProjectToStore as s, interpolateRampColors as sa, readSimpleStyleNumberLookup as si, cesiumIonAssetKind as sn, PROJECT_VERSION as so, reorderLayerGroupInPanel as sr, buildForwardGeocodeUrl as st, diffFeatureCollections as t, createEqualIntervalBreaks as ta, mapZoomStepOutputs as ti, CESIUM_BING_AERIAL_ASSET_ID as tn, MAX_MAP_GRID_DIM as to, groupMemberIndices as tr, GeocoderServiceError as tt, createProjectLayerSerializationCache as u, parseHexColorList as ua, ruleBasedVisibilityFilter as ui, isCesiumOnlyLayer as un, STROKE_DASH_PRESETS as uo, ROLE_PRIVILEGES as ur, fetchArcGISLocatorInfo as ut, normalizeBookmarks as v, deriveTileMatrixSet as va, vectorColorExpression as vi, createCzmlLayer as vn, resolveLayerCapabilities as vr, geocoderSupportsSuggest as vt, normalizeModels as w, normalizeArcgisWkid as wa, EXPRESSION_FUNCTION_CATEGORIES as wi, geoArrowToFeatureCollection as wn, layerJoinKey as wr, normalizeArcGISLocatorUrl as wt, normalizeMapLayout as x, normalizeMapCrs as xa, vectorLineColorValue as xi, parseCzml as xn, applyLayerJoins as xr, nextDelayMs as xt, normalizeDashboardColumns as y, getMapCrsPreset as ya, vectorFillColorValue as yi, czmlSource as yn, resolveRolePrivileges as yr, getGeocoderConfig as yt, serializeProjectWithLayerCacheAsync as z, BLANK_BASEMAP as za, getBuildEnvironment as zi, DEFAULT_PRINT_LAYOUT as zn, validateLayerDescriptiveMetadata as zr, MIN_STORY_CHAPTER_DURATION_SECONDS as zt };
 
-//# sourceMappingURL=project-diff-RBRpSza4.mjs.map
+//# sourceMappingURL=project-diff-DJkOd8ff.mjs.map