@geolibre/core 3.6.0 → 3.7.0

package/dist/{project-diff-CSG1AgSK.mjs → project-diff-DPGO-zCS.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,
@@ -454,499 +479,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 +501,7 @@ const CHINA_BASEMAPS = [
 		id: "amap-street",
 		region: "china",
 		name: "高德地图",
+		provider: "Amap",
 		styleUrl: sentinel("amap-street"),
 		tileUrl: AMAP_STREET_URL,
 		maxZoom: 19,
@@ -979,6 +512,7 @@ const CHINA_BASEMAPS = [
 		id: "amap-satellite",
 		region: "china",
 		name: "高德卫星",
+		provider: "Amap",
 		styleUrl: sentinel("amap-satellite"),
 		tileUrl: AMAP_SATELLITE_URL,
 		maxZoom: 18,
@@ -989,6 +523,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 +535,7 @@ const CHINA_BASEMAPS = [
 		id: "tencent-street",
 		region: "china",
 		name: "腾讯地图",
+		provider: "Tencent Maps",
 		styleUrl: sentinel("tencent-street"),
 		tileUrl: tencentUrl(1),
 		scheme: "tms",
@@ -1011,6 +547,7 @@ const CHINA_BASEMAPS = [
 		id: "tencent-dark",
 		region: "china",
 		name: "腾讯深色",
+		provider: "Tencent Maps",
 		styleUrl: sentinel("tencent-dark"),
 		tileUrl: tencentUrl(4),
 		scheme: "tms",
@@ -1045,6 +582,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.
@@ -1689,6 +1253,24 @@ function normalizeMapCrs(value) {
 	return MAP_CRS_PRESETS.find((preset) => preset.code === epsg)?.id ?? epsg;
 }
 /**
+* The map preferences that draw a map in a CRS, as a Settings choice writes them.
+*
+* Args:
+*   mapCrs: A normalized map CRS, or `null` for the default map.
+*
+* Returns:
+*   The preferences to merge. A CRS brings the body it maps, so measurements
+*   follow it (the EPSG tables describe Earth); the default map leaves the body
+*   alone.
+*/
+function mapCrsPreferencePatch(mapCrs) {
+	if (mapCrs === null) return { mapCrs: void 0 };
+	return {
+		mapCrs,
+		ellipsoidId: getMapCrsPreset(mapCrs)?.ellipsoidId ?? "earth"
+	};
+}
+/**
 * Point a Web Mercator WMS or ArcGIS export template at a map CRS.
 *
 * GeoLibre's WMS layers request `BBOX={bbox-epsg-3857}` in `EPSG:3857`. On a
@@ -1952,6 +1534,534 @@ function mapGeometryPositions(geometry, mapPosition) {
 		default: return geometry;
 	}
 }
+// 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"]
+	}
+];
+/**
+* Resolves a ramp definition by name, falling back to the first ramp when the
+* name is unknown.
+*
+* @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.
+*
+* @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);
+}
+/**
+* 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.
+*
+* @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 token - A raw color token (e.g. "FF0000", "#f00", " #AaBbCc ").
+* @returns The canonical `#rrggbb` color, or null when invalid.
+*/
+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;
+}
+/**
+* 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 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.
@@ -2829,6 +2939,975 @@ function inferFieldTypes(features, names) {
 	}
 	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 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)
+	];
+}
+/**
+* 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 generatorSizeRange(style) {
+	return validatedSizeRange(styleValue(style, "geometryGeneratorSizeProperty"), styleValue(style, "geometryGeneratorSizeMinValue"), styleValue(style, "geometryGeneratorSizeMaxValue"), styleValue(style, "geometryGeneratorSizeMinRadius"), styleValue(style, "geometryGeneratorSizeMaxRadius"));
+}
+/**
+* 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 generatorCircleRadiusValue(style) {
+	const range = generatorSizeRange(style);
+	if (range) return radiusInterpolateExpression(range);
+	return Math.max(1, styleValue(style, "geometryGeneratorCircleRadius"));
+}
+/**
+* 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 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")));
+}
+/**
+* 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 vectorCircleColorValue(style) {
+	return withSimpleStyleColor(style, "marker-color", vectorColorExpression(style, styleValue(style, "fillColor")));
+}
+/**
+* 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 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
+	];
+}
+/**
+* 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 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. */
 const STAC_VERSION = "1.0.0";
@@ -4651,6 +5730,8 @@ const DEFAULT_PRINT_LAYOUT = {
 	customHeight: 720,
 	customUnit: "px",
 	pageMargin: "normal",
+	pageBackground: "#ffffff",
+	panelTheme: "light",
 	showPageBorder: false,
 	pageBorderColor: "#111827",
 	pageBorderWidth: 2,
@@ -4740,6 +5821,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;
 }
@@ -4841,6 +5926,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),
@@ -5029,6 +6116,9 @@ const SYMBOL_STYLE_KEYS = [
 	"strokeColor",
 	"strokeWidth",
 	"strokeWidthUnit",
+	"strokeOpacity",
+	"strokeDash",
+	"strokeBlur",
 	"fillOpacity",
 	"circleRadius",
 	"fillPattern",
@@ -5228,7 +6318,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;
@@ -9791,6 +10883,7 @@ const LAYER_GROUPED_KEYS = /* @__PURE__ */ new Set([
 	"geojson",
 	"filterExpression",
 	"quickFilters",
+	"levelFilter",
 	"source",
 	"sourcePath",
 	"beforeId"
@@ -10141,10 +11234,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
@@ -10408,6 +11503,6 @@ function metadataRank(path) {
 	if (path === "description") return 1;
 	return 2;
 }
-export { GEOCODING_PROVIDERS as $, getPlanetaryBasemapById as $i, groupMemberIndices as $n, getBuildEnvironment as $r, CESIUM_BING_AERIAL_ASSET_ID as $t, normalizeSecondaryMapViews as A, styleValue as Aa, sameCesiumImagery as Ai, createStyleLibraryEntryId as An, isValidMetadataDate as Ar, selectedGeocodingLocator as At, storyMapHasContent as B, ELLIPSOIDS as Bi, normalizePrintLayoutConfig as Bn, evaluateMapExpression as Br, PROJECT_CREDENTIAL_FIELDS as Bt, normalizeModelGraph as C, OPENFREEMAP_BASEMAPS as Ca, parseMapCrsEpsgCode as Ci, isGeoArrowBatch as Cn, reapplyLayerJoins as Cr, normalizeArcGISLocatorUrl as Ct, normalizeProcessingHistory as D, detectNonGeographicCoordinates as Da, availableCesiumBasemap as Di, STYLE_LIBRARY_BUNDLE_TYPE as Dn, STAC_PROCESSING_EXTENSION as Dr, parseArcGISSuggestions as Dt, normalizePrimaryRenderer as E, SQL_QUERY_SOURCE_KIND as Ea, CESIUM_BASEMAPS as Ei, RAMP_STYLE_KEYS as En, stripVirtualFieldColumns as Er, parseArcGISLocatorInfo as Et, projectFromStore as F, getRegionalBasemapById as Fi, sanitizeLayerStylePatch as Fn, parseMetadataKeywords as Fr, DEFAULT_STORY_CHAPTER_DURATION_SECONDS as Ft, DEFAULT_REVERSE_GEOCODE_ENDPOINT as G, bodyLengthToEarth as Gi, scrubCommentsForRemovedLayers as Gn, removeTrailingJsonCommas as Gr, redactCredentials as Gt, CARTOCIUDAD_PUBLIC_HOST as H, PLANETARY_BASEMAP_GROUPS as Hi, scrubPrintLayoutForLayers as Hn, inferFieldTypes as Hr, isCredentialFieldName as Ht, resolveMapGrid as I, getRegionalBasemapByStyleUrl as Ii, serializeStyleLibrary as In, stacAssetMediaType as Ir, MAX_STORY_CHAPTER_DURATION_SECONDS as It, GEOCODE_LAT_KEY as J, getActiveBodyRadiusRatio as Ji, DEFAULT_LAYER_GROUP_OPACITY as Jn, SELECTION_MODES as Jr, setRegistryPublishableSettings as Jt, GEOCODE_ATTRIBUTE_PREFIX as K, earthAreaToBody as Ki, scrubLegendForRemovedLayers as Kn, substituteExpressionVariables as Kr, redactProjectCredentials as Kt, serializeProject as L, isRegionalBasemapSentinel as Li, DEFAULT_PRINT_LAYOUT as Ln, validateLayerDescriptiveMetadata as Lr, MIN_STORY_CHAPTER_DURATION_SECONDS as Lt, normalizeWidgets as M, REGIONAL_BASEMAPS as Mi, isStyleLibraryTargetLayer as Mn, isValidMetadataUrl as Mr, setGeocodingTokenProvider as Mt, parseProject as N, REGIONAL_BASEMAP_GROUPS as Ni, normalizeStyleLibraryEntries as Nn, metadataDateToRfc3339 as Nr, shouldThrottle as Nt, normalizeProjectComments as O, isDuckDBQueryLayer as Oa, basemapToCesiumImagery as Oi, STYLE_LIBRARY_BUNDLE_VERSION as On, STAC_VERSION as Or, resolveGeocoderConfig as Ot, portableWmsTileUrl as P, REGIONAL_BASEMAP_SENTINEL_PREFIX as Pi, parseStyleLibrary as Pn, normalizeLayerDescriptiveMetadata as Pr, unmatchedGeocodeFeature as Pt, GEOCODE_STATUS_KEY as Q, getEllipsoid as Qi, effectiveLayerRenderState as Qn, getArcgisApiKey as Qr, resolveHeaderReferences as Qt, serializeProjectWithLayerCache as R, DEFAULT_ELLIPSOID_ID as Ri, createDefaultPrintLayout as Rn, EXPRESSION_FUNCTION_CATEGORIES as Rr, normalizeStoryChapterDurationSeconds as Rt, normalizeMapViewState as S, NETCDF_IMAGE_SOURCE_KIND as Sa, normalizeMapCrs as Si, geoArrowToFeatureCollection as Sn, layerJoinKey as Sr, nominatimReverseResultToDisplay as St, normalizeObiaWorkbench as T, PROTOMAPS_BASEMAPS as Ta, normalizeArcgisWkid as Ti, BUILT_IN_STYLE_PRESETS as Tn, applyLayerVirtualFields as Tr, normalizeGeocodingProviderId as Tt, DEFAULT_FORWARD_GEOCODE_ENDPOINT as U, PLANETARY_BASEMAP_SENTINEL_PREFIX as Ui, scrubPrintLayoutForRemovedLayers as Un, isStyleSpecColor as Ur, isCredentialUrlParam as Ut, CARTOCIUDAD_MIN_INTERVAL_MS as V, PLANETARY_BASEMAPS as Vi, printLayoutConfigsEqual as Vn, formatExpressionPreviewValue as Vr, PUBLISHABLE_PLUGIN_SETTINGS as Vt, DEFAULT_GEOCODING_PROVIDER_ID as W, PLANET_SWITCHER_OPTIONS as Wi, removedLayerIdSet as Wn, matchFeaturesByExpression as Wr, redactConfigurationCredentials as Wt, GEOCODE_PROVIDER_KEY as X, getActiveMeanRadiusMeters as Xi, buildLayerPanelUnits as Xn, featureSelectionId as Xr, hasHeaderReferences as Xt, GEOCODE_LON_KEY as Y, getActiveEllipsoid as Yi, applyGroupEffects as Yn, applySelectionMode as Yr, allowsCredentialHeaders as Yt, GEOCODE_SCORE_KEY as Z, getActiveSemiMajorAxisMeters as Zi, buildLayerTree as Zn, invertSelection as Zr, isHeaderReferenceOnly as Zt, normalizeBookmarkGroups as _, LAYER_TYPES as _a, MAP_CRS_CHANGE_EVENT as _i, czmlSource as _n, resolveRolePrivileges as _r, geocoderSupportsSuggest as _t, DEFAULT_PROJECT_NAME as a, DEFAULT_BASEMAP as aa, getRuntimeEnvironment as ai, cesiumIonAssetKind as an, reorderLayerGroupInPanel as ar, arcgisLocatorInputField as at, normalizeLegendConfig as b, MAX_PROCESSING_HISTORY as ba, deriveTileMatrixSet as bi, computeGeoArrowBBox as bn, cascadeLayerJoinRefresh as br, nextDelayMs as bt, createDefaultMapView as c, DEFAULT_LAYER_STYLE as ca, decodePolyline as ci, isCesiumOnlyLayer as cn, ROLE_PRIVILEGES as cr, csvRowsToGeocodeRequests as ct, createProjectTemplate as d, DEFAULT_PRIMARY_RENDERER as da, geoJSONToPolylineStr as di, cesiumKmlSource as dn, hasAppPrivilege as dr, geocodeMatchToFeature as dt, getPlanetaryBasemapByStyleUrl as ea, getCesiumIonToken as ei, CESIUM_GOOGLE_PHOTOREALISTIC_ASSET_ID as en, layerGroupDepth as er, GeocoderServiceError as et, detachProjectCopy as f, DEFAULT_PROJECT_PREFERENCES as fa, polylineStrToGeoJSON as fi, createCesiumKmlLayer as fn, inferLayerCapabilities as fr, geocodeReverse as ft, normalizeBlankBackgroundColor as g, LARGE_VECTOR_FEATURE_THRESHOLD as ga, transformGeojsonElevation as gi, createCzmlLayer as gn, resolveLayerCapabilities as gr, geocoderSupportsReverse as gt, isSessionOnlyLayer as h, DUCKDB_VECTOR_ROUTE_BYTES as ha, horizontalBbox as hi, CZML_SOURCE_KIND as hn, normalizeLayerCapabilities as hr, geocoderNeedsApiKey as ht, previewValue as i, BLEND_MODES as ia, getProtomapsStyleUrl as ii, cesiumIonAssetId as in, normalizeGroupContiguity as ir, PUBLIC_GEOCODE_ROW_CAP as it, normalizeStoryMap as j, CHINA_BASEMAPS as ji, extractStyleLibraryStyle as jn, isValidMetadataEmail as jr, setGeocodingFetch as jt, normalizeProjectInteraction as k, shouldUseTiledRendering as ka, normalizeCesiumBasemap as ki, SYMBOL_STYLE_KEYS as kn, buildLayerStacItem as kr, rowCap as kt, createEmptyProject as l, DEFAULT_LEGEND_CONFIG as la, decodePolylineDetailed as li, parseCesiumIonAssetId as ln, appPrivilegeReason as lr, fetchArcGISLocatorInfo as lt, isAllowedPluginManifestUrl as m, DUCKDB_VECTOR_FEATURE_WARN_COUNT as ma, geojsonHasZCoordinates as mi, CZML_QUICK_PICKS as mn, normalizeAppPrivileges as mr, geocoderMinIntervalMs as mt, diffProjects as n, setActiveEllipsoidId 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_BLEND_MODE as oa, getSpatialExtensionPath as oi, createCesiumIonLayer as on, sortLayerGroupInPanel as or, buildForwardGeocodeUrl as ot, hydrateProjectLayer as p, DEFAULT_STORY_MAP as pa, unescapePolyline as pi, isCesiumKmlLayer as pn, intersectPrivileges as pr, geocodeSuggest as pt, GEOCODE_DISPLAY_NAME_KEY as q, earthLengthToBody as qi, scrubWidgetsForRemovedLayers as qn, validateMapExpression as qr, redactUrlCredentials as qt, jsonValuesEqual as r, BLANK_BASEMAP as ra, getProtomapsApiKey as ri, CESIUM_OSM_BUILDINGS_ASSET_ID as rn, layerPanelGroupHeaders as rr, NOMINATIM_PUBLIC_HOST as rt, applyProjectToStore as s, DEFAULT_DASHBOARD_COLUMNS as sa, batchDecodePolylines as si, isCesiumIonLayer as sn, ALL_APP_PRIVILEGES as sr, buildReverseGeocodeUrl as st, diffFeatureCollections as t, meanRadiusMeters as ta, getGoogleMapsApiKey as ti, CESIUM_ION_QUICK_PICKS as tn, layerGroupMoveability as tr, GeocoderUnsupportedError as tt, createProjectLayerSerializationCache as u, DEFAULT_MAP_GRID_LAYOUT as ua, encodePolyline as ui, CESIUM_KML_SOURCE_KIND as un, createDefaultAppCapabilities as ur, geocodeForward as ut, normalizeBookmarks as v, MAX_DASHBOARD_COLUMNS as va, MAP_CRS_PRESETS as vi, isCzmlLayer as vn, applyJoinsToLayer as vr, getGeocoderConfig as vt, normalizeModels as w, PROJECT_VERSION as wa, ARCGIS_PROJECTION_PRESETS as wi, withRasterSourceDefaults as wn, stripJoinFields as wr, normalizeGeocodingLocator as wt, normalizeMapLayout as x, MIN_DASHBOARD_COLUMNS as xa, getMapCrsPreset as xi, featureCollectionToGeoArrow as xn, collectTransitiveJoinSourceIds as xr, nominatimResultToFeature as xt, normalizeDashboardColumns as y, MAX_MAP_GRID_DIM as ya, adaptBboxTemplateToCrs as yi, parseCzml as yn, applyLayerJoins as yr, getGeocodingProvider as yt, serializeProjectWithLayerCacheAsync as z, EARTH_MEAN_RADIUS_METERS as zi, isDefaultPrintLayout as zn, compileFeatureExpression as zr, MAX_REDACT_DEPTH as zt };
+export { GEOCODING_PROVIDERS as $, MAX_PROCESSING_HISTORY as $a, createEqualIntervalBreaks as $i, groupMemberIndices as $n, mapZoomStepOutputs as $r, CESIUM_BING_AERIAL_ASSET_ID as $t, normalizeSecondaryMapViews as A, REGIONAL_BASEMAP_GROUPS as Aa, substituteExpressionVariables as Ai, createStyleLibraryEntryId as An, isValidMetadataDate as Ar, selectedGeocodingLocator as At, storyMapHasContent as B, DEFAULT_DASHBOARD_COLUMNS as Ba, getMapboxAccessToken as Bi, normalizePrintLayoutConfig as Bn, effectiveVectorRules as Br, PROJECT_CREDENTIAL_FIELDS as Bt, normalizeModelGraph as C, CESIUM_BASEMAPS as Ca, compileFeatureExpression as Ci, isGeoArrowBatch as Cn, reapplyLayerJoins as Cr, normalizeArcGISLocatorUrl as Ct, normalizeProcessingHistory as D, sameCesiumImagery as Da, isStyleSpecColor as Di, STYLE_LIBRARY_BUNDLE_TYPE as Dn, STAC_PROCESSING_EXTENSION as Dr, parseArcGISSuggestions as Dt, normalizePrimaryRenderer as E, normalizeCesiumBasemap as Ea, inferFieldTypes as Ei, RAMP_STYLE_KEYS as En, stripVirtualFieldColumns as Er, parseArcGISLocatorInfo as Et, projectFromStore as F, isRegionalBasemapSentinel as Fa, invertSelection as Fi, sanitizeLayerStylePatch as Fn, parseMetadataKeywords as Fr, DEFAULT_STORY_CHAPTER_DURATION_SECONDS as Ft, DEFAULT_REVERSE_GEOCODE_ENDPOINT as G, DEFAULT_PROJECT_PREFERENCES as Ga, batchDecodePolylines as Gi, scrubCommentsForRemovedLayers as Gn, generatorCircleRadiusValue as Gr, redactCredentials as Gt, CARTOCIUDAD_PUBLIC_HOST as H, DEFAULT_LEGEND_CONFIG as Ha, getProtomapsStyleUrl as Hi, scrubPrintLayoutForLayers as Hn, extrusionColorValue as Hr, isCredentialFieldName as Ht, resolveMapGrid as I, BLANK_BASEMAP as Ia, getArcgisApiKey as Ii, serializeStyleLibrary as In, stacAssetMediaType as Ir, MAX_STORY_CHAPTER_DURATION_SECONDS as It, GEOCODE_LAT_KEY as J, DUCKDB_VECTOR_ROUTE_BYTES as Ja, encodePolyline as Ji, DEFAULT_LAYER_GROUP_OPACITY as Jn, heatmapRampColors as Jr, setRegistryPublishableSettings as Jt, GEOCODE_ATTRIBUTE_PREFIX as K, DEFAULT_STORY_MAP as Ka, decodePolyline as Ki, scrubLegendForRemovedLayers as Kn, generatorSizeRange as Kr, redactProjectCredentials as Kt, serializeProject as L, BLEND_MODES as La, getBuildEnvironment as Li, DEFAULT_PRINT_LAYOUT as Ln, validateLayerDescriptiveMetadata as Lr, MIN_STORY_CHAPTER_DURATION_SECONDS as Lt, normalizeWidgets as M, gateRegionalBasemap as Ma, SELECTION_MODES as Mi, isStyleLibraryTargetLayer as Mn, isValidMetadataUrl as Mr, setGeocodingTokenProvider as Mt, parseProject as N, getRegionalBasemapById as Na, applySelectionMode as Ni, normalizeStyleLibraryEntries as Nn, metadataDateToRfc3339 as Nr, shouldThrottle as Nt, normalizeProjectComments as O, CHINA_BASEMAPS as Oa, matchFeaturesByExpression as Oi, STYLE_LIBRARY_BUNDLE_VERSION as On, STAC_VERSION as Or, resolveGeocoderConfig as Ot, portableWmsTileUrl as P, getRegionalBasemapByStyleUrl as Pa, featureSelectionId as Pi, parseStyleLibrary as Pn, normalizeLayerDescriptiveMetadata as Pr, unmatchedGeocodeFeature as Pt, GEOCODE_STATUS_KEY as Q, MAX_MAP_GRID_DIM as Qa, VECTOR_COLOR_RAMPS as Qi, effectiveLayerRenderState as Qn, lineWidthValue as Qr, resolveHeaderReferences as Qt, serializeProjectWithLayerCache as R, DEFAULT_BASEMAP as Ra, getCesiumIonToken as Ri, createDefaultPrintLayout as Rn, MERCATOR_METERS_PER_PIXEL_AT_ZOOM_0 as Rr, normalizeStoryChapterDurationSeconds as Rt, normalizeMapViewState as S, normalizeArcgisWkid as Sa, EXPRESSION_FUNCTION_CATEGORIES as Si, geoArrowToFeatureCollection as Sn, layerJoinKey as Sr, nominatimReverseResultToDisplay as St, normalizeObiaWorkbench as T, basemapToCesiumImagery as Ta, formatExpressionPreviewValue as Ti, BUILT_IN_STYLE_PRESETS as Tn, applyLayerVirtualFields as Tr, normalizeGeocodingProviderId as Tt, DEFAULT_FORWARD_GEOCODE_ENDPOINT as U, DEFAULT_MAP_GRID_LAYOUT as Ua, getRuntimeEnvironment as Ui, scrubPrintLayoutForRemovedLayers as Un, extrusionFloorHeightValue as Ur, isCredentialUrlParam as Ut, CARTOCIUDAD_MIN_INTERVAL_MS as V, DEFAULT_LAYER_STYLE as Va, getProtomapsApiKey as Vi, printLayoutConfigsEqual as Vn, extrusionBaseValue as Vr, PUBLISHABLE_PLUGIN_SETTINGS as Vt, DEFAULT_GEOCODING_PROVIDER_ID as W, DEFAULT_PRIMARY_RENDERER as Wa, getSpatialExtensionPath as Wi, removedLayerIdSet as Wn, extrusionHeightValue as Wr, redactConfigurationCredentials as Wt, GEOCODE_PROVIDER_KEY as X, LAYER_TYPES as Xa, polylineStrToGeoJSON as Xi, buildLayerPanelUnits as Xn, isStrokeDashPattern as Xr, hasHeaderReferences as Xt, GEOCODE_LON_KEY as Y, LARGE_VECTOR_FEATURE_THRESHOLD as Ya, geoJSONToPolylineStr as Yi, applyGroupEffects as Yn, isHexColor as Yr, allowsCredentialHeaders as Yt, GEOCODE_SCORE_KEY as Z, MAX_DASHBOARD_COLUMNS as Za, unescapePolyline as Zi, buildLayerTree as Zn, isVectorColorExpression as Zr, isHeaderReferenceOnly as Zt, normalizeBookmarkGroups as _, getMapCrsPreset as _a, vectorFillColorValue as _i, czmlSource as _n, resolveRolePrivileges as _r, geocoderSupportsSuggest as _t, DEFAULT_PROJECT_NAME as a, interpolateRampColors as aa, readSimpleStyleNumberLookup as ai, cesiumIonAssetKind as an, SQL_QUERY_SOURCE_KIND as ao, reorderLayerGroupInPanel as ar, arcgisLocatorInputField as at, normalizeLegendConfig as b, parseMapCrsEpsgCode as ba, vectorOutlineColorValue as bi, computeGeoArrowBBox as bn, cascadeLayerJoinRefresh as br, nextDelayMs as bt, createDefaultMapView as c, parseHexColorList as ca, ruleBasedVisibilityFilter as ci, isCesiumOnlyLayer as cn, isDuckDBQueryLayer as co, ROLE_PRIVILEGES as cr, csvRowsToGeocodeRequests as ct, createProjectTemplate as d, horizontalBbox as da, strokeDashPresetName as di, cesiumKmlSource as dn, hasAppPrivilege as dr, geocodeMatchToFeature as dt, createGraduatedClassBreaks as ea, mercatorMetersPerPixelAtZoom0 as ei, CESIUM_GOOGLE_PHOTOREALISTIC_ASSET_ID as en, MIN_DASHBOARD_COLUMNS as eo, layerGroupDepth as er, GeocoderServiceError as et, detachProjectCopy as f, transformGeojsonElevation as fa, strokeDashValue as fi, createCesiumKmlLayer as fn, inferLayerCapabilities as fr, geocodeReverse as ft, normalizeBlankBackgroundColor as g, deriveTileMatrixSet as ga, vectorColorExpression as gi, createCzmlLayer as gn, resolveLayerCapabilities as gr, geocoderSupportsReverse as gt, isSessionOnlyLayer as h, adaptBboxTemplateToCrs as ha, vectorCircleColorValue as hi, CZML_SOURCE_KIND as hn, normalizeLayerCapabilities as hr, geocoderNeedsApiKey as ht, previewValue as i, interpolateHexColor as ia, proportionalSizeRange as ii, cesiumIonAssetId as in, PROTOMAPS_BASEMAPS as io, normalizeGroupContiguity as ir, PUBLIC_GEOCODE_ROW_CAP as it, normalizeStoryMap as j, REGIONAL_BASEMAP_SENTINEL_PREFIX as ja, validateMapExpression as ji, extractStyleLibraryStyle as jn, isValidMetadataEmail as jr, setGeocodingFetch as jt, normalizeProjectInteraction as k, REGIONAL_BASEMAPS as ka, removeTrailingJsonCommas as ki, SYMBOL_STYLE_KEYS as kn, buildLayerStacItem as kr, rowCap as kt, createEmptyProject as l, rgbToHex as la, simpleStyleNumberValue as li, parseCesiumIonAssetId as ln, shouldUseTiledRendering as lo, appPrivilegeReason as lr, fetchArcGISLocatorInfo as lt, isAllowedPluginManifestUrl as m, MAP_CRS_PRESETS as ma, strokeOpacityValue as mi, CZML_QUICK_PICKS as mn, normalizeAppPrivileges as mr, geocoderMinIntervalMs as mt, diffProjects as n, getVectorColorRamp as na, parseJsonExpression as ni, CESIUM_ION_SOURCE_KIND as nn, OPENFREEMAP_BASEMAPS as no, layerGroupSortability as nr, NOMINATIM_MIN_INTERVAL_MS as nt, MAX_PROJECT_BOOKMARKS as o, normalizeHexColor as oa, readsSimpleStyleProperties as oi, createCesiumIonLayer as on, STROKE_DASH_PRESETS as oo, sortLayerGroupInPanel as or, buildForwardGeocodeUrl as ot, hydrateProjectLayer as p, MAP_CRS_CHANGE_EVENT as pa, strokeOpacityPaintValue as pi, isCesiumKmlLayer as pn, intersectPrivileges as pr, geocodeSuggest as pt, GEOCODE_DISPLAY_NAME_KEY as q, DUCKDB_VECTOR_FEATURE_WARN_COUNT as qa, decodePolylineDetailed as qi, scrubWidgetsForRemovedLayers as qn, hasSimpleStyleProperties as qr, redactUrlCredentials as qt, jsonValuesEqual as r, interpolateColors as ra, proportionalRadiusExpression as ri, CESIUM_OSM_BUILDINGS_ASSET_ID as rn, PROJECT_VERSION as ro, layerPanelGroupHeaders as rr, NOMINATIM_PUBLIC_HOST as rt, applyProjectToStore as s, parseHexColor as sa, ruleBasedColorExpression as si, isCesiumIonLayer as sn, detectNonGeographicCoordinates as so, ALL_APP_PRIVILEGES as sr, buildReverseGeocodeUrl as st, diffFeatureCollections as t, createQuantileBreaks as ta, metersWidthExpression as ti, CESIUM_ION_QUICK_PICKS as tn, NETCDF_IMAGE_SOURCE_KIND as to, layerGroupMoveability as tr, GeocoderUnsupportedError as tt, createProjectLayerSerializationCache as u, geojsonHasZCoordinates as ua, strokeBlurValue as ui, CESIUM_KML_SOURCE_KIND as un, styleValue as uo, createDefaultAppCapabilities as ur, geocodeForward as ut, normalizeBookmarks as v, mapCrsPreferencePatch as va, vectorFillOpacityValue as vi, isCzmlLayer as vn, applyJoinsToLayer as vr, getGeocoderConfig as vt, normalizeModels as w, availableCesiumBasemap as wa, evaluateMapExpression as wi, withRasterSourceDefaults as wn, stripJoinFields as wr, normalizeGeocodingLocator as wt, normalizeMapLayout as x, ARCGIS_PROJECTION_PRESETS as xa, vectorStrokeWidthValue as xi, featureCollectionToGeoArrow as xn, collectTransitiveJoinSourceIds as xr, nominatimResultToFeature as xt, normalizeDashboardColumns as y, normalizeMapCrs as ya, vectorLineColorValue as yi, parseCzml as yn, applyLayerJoins as yr, getGeocodingProvider as yt, serializeProjectWithLayerCacheAsync as z, DEFAULT_BLEND_MODE as za, getGoogleMapsApiKey as zi, isDefaultPrintLayout as zn, circleRadiusValue as zr, MAX_REDACT_DEPTH as zt };
 
-//# sourceMappingURL=project-diff-CSG1AgSK.mjs.map
+//# sourceMappingURL=project-diff-DPGO-zCS.mjs.map