@mapbox/mapbox-gl-style-spec 14.28.0 → 14.29.0

package/dist/index.es.js

@@ -369,6 +369,16 @@ var option = {
 			},
 			color: {
 				doc: "The result will be coerced to a color."
+			},
+			object: {
+				doc: "The result will be coerced to an object.",
+				"sdk-support": {
+					"basic functionality": {
+						js: "3.29.0",
+						android: "11.29.0",
+						ios: "11.29.0"
+					}
+				}
 			}
 		}
 	},
@@ -3000,6 +3010,7 @@ var layout_symbol = {
 		experimental: true,
 		"sdk-support": {
 			"basic functionality": {
+				js: "3.7.0",
 				android: "11.9.0",
 				ios: "11.9.0"
 			}
@@ -5473,13 +5484,18 @@ var expression_name = {
 			}
 		},
 		distance: {
-			doc: "Returns the shortest distance in meters between the evaluated feature and the input geometry. The input value can be a valid GeoJSON of type `Point`, `MultiPoint`, `LineString`, `MultiLineString`, `Polygon`, `MultiPolygon`, `Feature`, or `FeatureCollection`. Distance values returned may vary in precision due to loss in precision from encoding geometries, particularly below zoom level 13.",
+			doc: "Returns the shortest distance in meters between the evaluated feature and the input geometry. The input value can be a valid GeoJSON of type `Point`, `MultiPoint`, `LineString`, `MultiLineString`, `Polygon`, `MultiPolygon`, `Feature`, or `FeatureCollection`, or expression that returns a valid GeoJSON. Distance values returned may vary in precision due to loss in precision from encoding geometries, particularly below zoom level 13.",
 			group: "Math",
 			"sdk-support": {
 				"basic functionality": {
 					js: "3.0.0",
 					android: "9.2.0",
 					ios: "5.9.0"
+				},
+				"expressions support": {
+					js: "3.29.0",
+					android: "11.29.0",
+					ios: "11.29.0"
 				}
 			}
 		},
@@ -8255,6 +8271,29 @@ var paint_line = {
 			]
 		},
 		"property-type": "data-constant"
+	},
+	"line-cutout-depth": {
+		type: "number",
+		"default": 0,
+		minimum: 0,
+		units: "meters",
+		doc: "Depth offset along the camera, in meters. When set to a non-zero value, applied cutout opacity is 0.",
+		experimental: true,
+		"private": true,
+		transition: true,
+		"sdk-support": {
+			"basic functionality": {
+				android: "11.29.0",
+				ios: "11.29.0"
+			}
+		},
+		expression: {
+			interpolated: true,
+			parameters: [
+				"zoom"
+			]
+		},
+		"property-type": "data-constant"
 	}
 };
 var paint_circle = {
@@ -9449,7 +9488,6 @@ var paint_symbol = {
 		"default": 0,
 		minimum: 0,
 		transition: true,
-		experimental: true,
 		appearance: true,
 		"sdk-support": {
 			"basic functionality": {
@@ -9503,7 +9541,7 @@ var paint_raster = {
 	},
 	"raster-color": {
 		type: "color",
-		doc: "Defines a color map by which to colorize a raster layer, parameterized by the `[\"raster-value\"]` expression and evaluated at 256 uniformly spaced steps over the range specified by `raster-color-range`.",
+		doc: "Defines the color ramp used to colorize a raster layer, parameterized by the `[\"raster-value\"]` expression and evaluated over the range specified by `raster-color-range`. Raster values are spaced evenly across the range by default.",
 		"use-theme": true,
 		transition: false,
 		"sdk-support": {
@@ -9544,7 +9582,7 @@ var paint_raster = {
 				"zoom"
 			]
 		},
-		doc: "When `raster-color` is active, specifies the combination of source RGB channels used to compute the raster value. Computed using the equation `mix.r * src.r + mix.g * src.g + mix.b * src.b + mix.a`. The first three components specify the mix of source red, green, and blue channels, respectively. The fourth component serves as a constant offset and is *not* multipled by source alpha. Source alpha is instead carried through and applied as opacity to the colorized result. Default value corresponds to RGB luminosity.",
+		doc: "When `raster-color` is active, specifies how the raster value is computed from a non-`rasterarray` source's channels, using the equation `mix.r * src.r + mix.g * src.g + mix.b * src.b + mix.a`. The first three components weight the source's red, green, and blue channels; the fourth is a constant offset and is not multiplied by source alpha. Source alpha is carried through and applied as opacity to the colorized result. The default corresponds to RGB luminosity. `rasterarray` sources ignore this property, as their raster value is decoded directly from the source data.",
 		example: [
 			0.2126,
 			0.7152,
@@ -9574,7 +9612,7 @@ var paint_raster = {
 				"zoom"
 			]
 		},
-		doc: "When `raster-color` is active, specifies the range over which `raster-color` is tabulated. Units correspond to the computed raster value via `raster-color-mix`. For `rasterarray` sources, if `raster-color-range` is unspecified, the source's stated data range is used.",
+		doc: "When `raster-color` is active, specifies the range of raster values mapped onto the color ramp, from the start of the ramp (low bound) to its end (high bound). For `rasterarray` sources the raster value is the decoded source data in the source's own units, and the source's stated data range is used when this property is unspecified. For other raster sources the raster value is computed from the source's channels via `raster-color-mix`. Defaults to `[0, 1]` when no range is otherwise available.",
 		example: [
 			0.5,
 			10
@@ -9587,6 +9625,37 @@ var paint_raster = {
 			}
 		}
 	},
+	"raster-color-scale": {
+		type: "enum",
+		doc: "When `raster-color` is active, specifies how raster values are distributed across the color ramp over the range specified by `raster-color-range`.",
+		values: {
+			linear: {
+				doc: "Raster values are spaced evenly across the color ramp."
+			},
+			log: {
+				doc: "Raster values are spaced logarithmically, giving more of the color ramp to smaller values. Useful for data concentrated near the low end of a wide range."
+			}
+		},
+		"default": "linear",
+		requires: [
+			"raster-color",
+			{
+				source: "raster-array"
+			}
+		],
+		expression: {
+			interpolated: false,
+			parameters: [
+			]
+		},
+		"property-type": "data-constant",
+		experimental: true,
+		"sdk-support": {
+			"basic functionality": {
+				js: "3.29.0"
+			}
+		}
+	},
 	"raster-hue-rotate": {
 		type: "number",
 		"default": 0,
@@ -9840,6 +9909,21 @@ var paint_raster = {
 			interpolated: false
 		},
 		"property-type": "data-constant"
+	},
+	"raster-allow-draping": {
+		type: "boolean",
+		"default": true,
+		experimental: true,
+		doc: "Whether the raster layer is allowed to drape over terrain and globe. When disabled, the layer is rendered after all draped layers, which can change its position in the layer order. Disabling draping has a performance cost, since the terrain/globe geometry must be rendered again for each such layer.",
+		transition: false,
+		"property-type": "data-constant",
+		"sdk-support": {
+			"basic functionality": {
+				js: "3.28.0",
+				android: "11.28.0",
+				ios: "11.28.0"
+			}
+		}
 	}
 };
 var paint_hillshade = {
@@ -14875,6 +14959,189 @@ class TinyQueue {
 
 var EXTENT = 8192;
 
+const FQIDSeparator = "";
+function makeConfigFQID(id, ownScope, contextScope) {
+  return [id, ownScope, contextScope].filter(Boolean).join(FQIDSeparator);
+}
+function coerceValue(type, value) {
+  switch (type) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    case "string":
+      return toString(value);
+    case "number":
+      return +value;
+    case "boolean":
+      return !!value;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    case "color":
+      return Color.parse(value);
+    case "formatted": {
+      return Formatted.fromString(toString(value));
+    }
+    case "resolvedImage": {
+      return ResolvedImage.build(toString(value));
+    }
+  }
+  return value;
+}
+function clampToAllowedNumber(value, min, max, step) {
+  if (step !== void 0) {
+    value = step * Math.round(value / step);
+  }
+  if (min !== void 0 && value < min) {
+    value = min;
+  }
+  if (max !== void 0 && value > max) {
+    value = max;
+  }
+  return value;
+}
+class Config {
+  constructor(type, key, scope, featureConstant = false) {
+    this.type = type;
+    this.key = key;
+    this.scope = scope;
+    this.featureConstant = featureConstant;
+  }
+  static parse(args, context) {
+    let type = context.expectedType;
+    type ?? (type = ValueType);
+    if (args.length < 2 || args.length > 3) {
+      return context.error(`Invalid number of arguments for 'config' expression.`);
+    }
+    const configKey = context.parse(args[1], 1);
+    if (!(configKey instanceof Literal)) {
+      return context.error(`Key name of 'config' expression must be a string literal.`);
+    }
+    let featureConstant = true;
+    let configScopeValue;
+    const configKeyValue = toString(configKey.value);
+    if (args.length >= 3) {
+      const configScope = context.parse(args[2], 2);
+      if (!(configScope instanceof Literal)) {
+        return context.error(`Scope of 'config' expression must be a string literal.`);
+      }
+      configScopeValue = toString(configScope.value);
+    }
+    if (context.options) {
+      const fqid = makeConfigFQID(configKeyValue, configScopeValue, context._scope);
+      const config = context.options.get(fqid);
+      if (config) {
+        featureConstant = isFeatureConstant(config.value || config.default);
+      }
+    }
+    return new Config(type, configKeyValue, configScopeValue, featureConstant);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  evaluate(ctx) {
+    const fqid = makeConfigFQID(this.key, this.scope, ctx.scope);
+    const config = ctx.getConfig(fqid);
+    if (!config) return null;
+    const { type, value, values, minValue, maxValue, stepValue } = config;
+    const defaultValue = config.default.evaluate(ctx);
+    let result = defaultValue;
+    if (value) {
+      const originalScope = ctx.scope;
+      ctx.scope = (originalScope || "").split(FQIDSeparator).slice(1).join(FQIDSeparator);
+      result = value.evaluate(ctx);
+      ctx.scope = originalScope;
+    }
+    if (type) {
+      result = coerceValue(type, result);
+    }
+    if (result !== void 0 && (minValue !== void 0 || maxValue !== void 0 || stepValue !== void 0)) {
+      if (typeof result === "number") {
+        result = clampToAllowedNumber(result, minValue, maxValue, stepValue);
+      } else if (Array.isArray(result)) {
+        result = result.map((item) => typeof item === "number" ? clampToAllowedNumber(item, minValue, maxValue, stepValue) : item);
+      }
+    }
+    if (value !== void 0 && result !== void 0 && values && !values.includes(result)) {
+      result = defaultValue;
+      if (type) {
+        result = coerceValue(type, result);
+      }
+    }
+    if (type && type !== this.type || result !== void 0 && !typeEquals(typeOf(result), this.type)) {
+      result = coerceValue(this.type.kind, result);
+    }
+    return result;
+  }
+  eachChild() {
+  }
+  outputDefined() {
+    return false;
+  }
+  serialize() {
+    const res = ["config", this.key];
+    if (this.scope) {
+      res.concat(this.scope);
+    }
+    return res;
+  }
+}
+
+function isFeatureConstant(e) {
+  if (e instanceof CompoundExpression) {
+    if (e.name === "get" && e.args.length === 1) {
+      return false;
+    } else if (e.name === "feature-state") {
+      return false;
+    } else if (e.name === "has" && e.args.length === 1) {
+      return false;
+    } else if (e.name === "properties" || e.name === "geometry-type" || e.name === "id") {
+      return false;
+    } else if (e.name.startsWith("filter-")) {
+      return false;
+    }
+  }
+  if (e instanceof Within) {
+    return false;
+  }
+  if (e instanceof Distance) {
+    return false;
+  }
+  if (e instanceof Config) {
+    return e.featureConstant;
+  }
+  let result = true;
+  e.eachChild((arg) => {
+    if (result && !isFeatureConstant(arg)) {
+      result = false;
+    }
+  });
+  return result;
+}
+function isStateConstant(e) {
+  if (e instanceof CompoundExpression) {
+    if (e.name === "feature-state") {
+      return false;
+    }
+  }
+  let result = true;
+  e.eachChild((arg) => {
+    if (result && !isStateConstant(arg)) {
+      result = false;
+    }
+  });
+  return result;
+}
+function isGlobalPropertyConstantSet(e, properties) {
+  if (e instanceof CompoundExpression && properties.has(e.name)) {
+    return false;
+  }
+  let result = true;
+  e.eachChild((arg) => {
+    if (result && !isGlobalPropertyConstantSet(arg, properties)) {
+      result = false;
+    }
+  });
+  return result;
+}
+function isGlobalPropertyConstant(e, properties) {
+  return isGlobalPropertyConstantSet(e, new Set(properties));
+}
+
 const RE = 6378.137;
 const FE = 1 / 298.257223563;
 const E2 = FE * (2 - FE);
@@ -15410,245 +15677,94 @@ function polygonsToGeometryDistance(originGeometry, canonical, geometry) {
 function isTypeValid(type) {
   return type === "Point" || type === "MultiPoint" || type === "LineString" || type === "MultiLineString" || type === "Polygon" || type === "MultiPolygon";
 }
-class Distance {
-  constructor(geojson, geometries) {
-    this.type = NumberType;
-    this.geojson = geojson;
-    this.geometries = geometries;
-  }
-  static parse(args, context) {
-    if (args.length !== 2) {
-      return context.error(`'distance' expression requires either one argument, but found ' ${args.length - 1} instead.`);
-    }
-    if (isValue(args[1])) {
-      const geojson = args[1];
-      if (geojson.type === "FeatureCollection") {
-        for (let i = 0; i < geojson.features.length; ++i) {
-          if (isTypeValid(geojson.features[i].geometry.type)) {
-            return new Distance(geojson, geojson.features[i].geometry);
-          }
-        }
-      } else if (geojson.type === "Feature") {
-        if (isTypeValid(geojson.geometry.type)) {
-          return new Distance(geojson, geojson.geometry);
-        }
-      } else if (isTypeValid(geojson.type)) {
-        return new Distance(geojson, geojson);
-      }
-    }
-    return context.error(
-      "'distance' expression needs to be an array with format ['Distance', GeoJSONObj]."
-    );
-  }
-  evaluate(ctx) {
-    const geometry = ctx.geometry();
-    const canonical = ctx.canonicalID();
-    if (geometry != null && canonical != null) {
-      if (ctx.geometryType() === "Point") {
-        return pointsToGeometryDistance(geometry, canonical, this.geometries);
-      }
-      if (ctx.geometryType() === "LineString") {
-        return linesToGeometryDistance(geometry, canonical, this.geometries);
-      }
-      if (ctx.geometryType() === "Polygon") {
-        return polygonsToGeometryDistance(geometry, canonical, this.geometries);
-      }
-      console.warn("Distance Expression: currently only evaluates valid Point/LineString/Polygon geometries.");
-    } else {
-      console.warn("Distance Expression: requires valid feature and canonical information.");
-    }
+function extractDistanceGeometry(value) {
+  if (!isValue(value) || typeof value !== "object" || value === null || Array.isArray(value)) {
     return null;
   }
-  eachChild() {
-  }
-  outputDefined() {
-    return true;
-  }
-  serialize() {
-    return ["distance", this.geojson];
-  }
-}
-
-function isFeatureConstant(e) {
-  if (e instanceof CompoundExpression) {
-    if (e.name === "get" && e.args.length === 1) {
-      return false;
-    } else if (e.name === "feature-state") {
-      return false;
-    } else if (e.name === "has" && e.args.length === 1) {
-      return false;
-    } else if (e.name === "properties" || e.name === "geometry-type" || e.name === "id") {
-      return false;
-    } else if (e.name.startsWith("filter-")) {
-      return false;
-    }
-  }
-  if (e instanceof Within) {
-    return false;
-  }
-  if (e instanceof Distance) {
-    return false;
-  }
-  if (e instanceof Config) {
-    return e.featureConstant;
-  }
-  let result = true;
-  e.eachChild((arg) => {
-    if (result && !isFeatureConstant(arg)) {
-      result = false;
-    }
-  });
-  return result;
-}
-function isStateConstant(e) {
-  if (e instanceof CompoundExpression) {
-    if (e.name === "feature-state") {
-      return false;
-    }
-  }
-  let result = true;
-  e.eachChild((arg) => {
-    if (result && !isStateConstant(arg)) {
-      result = false;
-    }
-  });
-  return result;
-}
-function isGlobalPropertyConstantSet(e, properties) {
-  if (e instanceof CompoundExpression && properties.has(e.name)) {
-    return false;
-  }
-  let result = true;
-  e.eachChild((arg) => {
-    if (result && !isGlobalPropertyConstantSet(arg, properties)) {
-      result = false;
-    }
-  });
-  return result;
-}
-function isGlobalPropertyConstant(e, properties) {
-  return isGlobalPropertyConstantSet(e, new Set(properties));
-}
-
-const FQIDSeparator = "";
-function makeConfigFQID(id, ownScope, contextScope) {
-  return [id, ownScope, contextScope].filter(Boolean).join(FQIDSeparator);
-}
-function coerceValue(type, value) {
-  switch (type) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-    case "string":
-      return toString(value);
-    case "number":
-      return +value;
-    case "boolean":
-      return !!value;
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-    case "color":
-      return Color.parse(value);
-    case "formatted": {
-      return Formatted.fromString(toString(value));
+  const geojson = value;
+  if (geojson.type === "FeatureCollection") {
+    if (geojson.features.length === 0) return null;
+    const geometries = [];
+    for (const feature of geojson.features) {
+      if (!isTypeValid(feature.geometry.type)) return null;
+      geometries.push(feature.geometry);
     }
-    case "resolvedImage": {
-      return ResolvedImage.build(toString(value));
-    }
-  }
-  return value;
-}
-function clampToAllowedNumber(value, min, max, step) {
-  if (step !== void 0) {
-    value = step * Math.round(value / step);
+    return geometries;
   }
-  if (min !== void 0 && value < min) {
-    value = min;
+  if (geojson.type === "Feature") {
+    return isTypeValid(geojson.geometry.type) ? [geojson.geometry] : null;
   }
-  if (max !== void 0 && value > max) {
-    value = max;
+  if (isTypeValid(geojson.type)) {
+    return [geojson];
   }
-  return value;
+  return null;
 }
-class Config {
-  constructor(type, key, scope, featureConstant = false) {
-    this.type = type;
-    this.key = key;
-    this.scope = scope;
-    this.featureConstant = featureConstant;
+class Distance {
+  constructor(geojson) {
+    this.type = NumberType;
+    this.geojson = geojson;
   }
   static parse(args, context) {
-    let type = context.expectedType;
-    type ?? (type = ValueType);
-    if (args.length < 2 || args.length > 3) {
-      return context.error(`Invalid number of arguments for 'config' expression.`);
-    }
-    const configKey = context.parse(args[1], 1);
-    if (!(configKey instanceof Literal)) {
-      return context.error(`Key name of 'config' expression must be a string literal.`);
+    if (args.length !== 2) {
+      return context.error(`'distance' expression requires either one argument, but found ' ${args.length - 1} instead.`);
     }
-    let featureConstant = true;
-    let configScopeValue;
-    const configKeyValue = toString(configKey.value);
-    if (args.length >= 3) {
-      const configScope = context.parse(args[2], 2);
-      if (!(configScope instanceof Literal)) {
-        return context.error(`Scope of 'config' expression must be a string literal.`);
+    const arg = args[1];
+    const isBareGeoJSON = isValue(arg) && !Array.isArray(arg);
+    const parsed = context.parse(isBareGeoJSON ? ["literal", arg] : arg, 1, ValueType);
+    if (!parsed) return null;
+    for (const [globalProperties, name] of [
+      [["measure-light"], "brightness"],
+      [["pitch"], "pitch"],
+      [["distance-from-center"], "distance-from-center"]
+    ]) {
+      if (!isGlobalPropertyConstant(parsed, globalProperties)) {
+        return context.error(`'distance' expression may not depend on ${name}.`);
       }
-      configScopeValue = toString(configScope.value);
     }
-    if (context.options) {
-      const fqid = makeConfigFQID(configKeyValue, configScopeValue, context._scope);
-      const config = context.options.get(fqid);
-      if (config) {
-        featureConstant = isFeatureConstant(config.value || config.default);
-      }
+    if (!isStateConstant(parsed)) {
+      return context.error(`'distance' expression may not depend on feature-state.`);
     }
-    return new Config(type, configKeyValue, configScopeValue, featureConstant);
+    if (parsed instanceof Literal && !extractDistanceGeometry(parsed.value)) {
+      return context.error(
+        "'distance' expression needs to be an array with format ['Distance', GeoJSONObj]."
+      );
+    }
+    return new Distance(parsed);
   }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   evaluate(ctx) {
-    const fqid = makeConfigFQID(this.key, this.scope, ctx.scope);
-    const config = ctx.getConfig(fqid);
-    if (!config) return null;
-    const { type, value, values, minValue, maxValue, stepValue } = config;
-    const defaultValue = config.default.evaluate(ctx);
-    let result = defaultValue;
-    if (value) {
-      const originalScope = ctx.scope;
-      ctx.scope = (originalScope || "").split(FQIDSeparator).slice(1).join(FQIDSeparator);
-      result = value.evaluate(ctx);
-      ctx.scope = originalScope;
-    }
-    if (type) {
-      result = coerceValue(type, result);
+    const geometries = extractDistanceGeometry(this.geojson.evaluate(ctx));
+    if (!geometries) {
+      console.warn("Distance Expression: could not resolve a valid Point/LineString/Polygon GeoJSON geometry.");
+      return null;
     }
-    if (result !== void 0 && (minValue !== void 0 || maxValue !== void 0 || stepValue !== void 0)) {
-      if (typeof result === "number") {
-        result = clampToAllowedNumber(result, minValue, maxValue, stepValue);
-      } else if (Array.isArray(result)) {
-        result = result.map((item) => typeof item === "number" ? clampToAllowedNumber(item, minValue, maxValue, stepValue) : item);
-      }
+    const geometry = ctx.geometry();
+    const canonical = ctx.canonicalID();
+    if (geometry == null || canonical == null) {
+      console.warn("Distance Expression: requires valid feature and canonical information.");
+      return null;
     }
-    if (value !== void 0 && result !== void 0 && values && !values.includes(result)) {
-      result = defaultValue;
-      if (type) {
-        result = coerceValue(type, result);
-      }
+    const geometryType = ctx.geometryType();
+    const distanceTo = geometryType === "Point" ? pointsToGeometryDistance : geometryType === "LineString" ? linesToGeometryDistance : geometryType === "Polygon" ? polygonsToGeometryDistance : null;
+    if (!distanceTo) {
+      console.warn("Distance Expression: currently only evaluates valid Point/LineString/Polygon geometries.");
+      return null;
     }
-    if (type && type !== this.type || result !== void 0 && !typeEquals(typeOf(result), this.type)) {
-      result = coerceValue(this.type.kind, result);
+    let dist = Infinity;
+    for (const g of geometries) {
+      const tempDist = distanceTo(geometry, canonical, g);
+      if (tempDist == null || isNaN(tempDist)) return tempDist;
+      if ((dist = Math.min(dist, tempDist)) === 0) break;
     }
-    return result;
+    return dist;
   }
-  eachChild() {
+  eachChild(fn) {
+    fn(this.geojson);
   }
   outputDefined() {
-    return false;
+    return true;
   }
   serialize() {
-    const res = ["config", this.key];
-    if (this.scope) {
-      res.concat(this.scope);
-    }
-    return res;
+    return ["distance", this.geojson.serialize()];
   }
 }
 
@@ -17886,7 +18002,7 @@ function createFunction(parameters, propertySpec) {
       kind: "composite",
       interpolationType,
       interpolationFactor: Interpolate.interpolationFactor.bind(void 0, interpolationType),
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
       zoomStops: featureFunctionStops.map((s) => s[0]),
       evaluate({ zoom }, properties) {
         return evaluateExponentialFunction({
@@ -18017,15 +18133,16 @@ class StyleExpression {
     this.isIndoorDependent = isIndoorDependent(expression);
   }
   evaluateWithoutErrorHandling(globals, feature, featureState, canonical, availableImages, formattedSection, featureTileCoord, featureDistanceData) {
-    this._evaluator.globals = globals;
-    this._evaluator.feature = feature;
-    this._evaluator.featureState = featureState;
-    this._evaluator.canonical = canonical || null;
-    this._evaluator.availableImages = availableImages || null;
-    this._evaluator.formattedSection = formattedSection;
-    this._evaluator.featureTileCoord = featureTileCoord || null;
-    this._evaluator.featureDistanceData = featureDistanceData || null;
-    return this.expression.evaluate(this._evaluator);
+    const evaluator = this._evaluator;
+    evaluator.globals = globals;
+    evaluator.feature = feature;
+    evaluator.featureState = featureState;
+    evaluator.canonical = canonical || null;
+    evaluator.availableImages = availableImages || null;
+    evaluator.formattedSection = formattedSection;
+    evaluator.featureTileCoord = featureTileCoord || null;
+    evaluator.featureDistanceData = featureDistanceData || null;
+    return this.expression.evaluate(evaluator);
   }
   evaluate(globals, feature, featureState, canonical, availableImages, formattedSection, featureTileCoord, featureDistanceData, iconImageUseTheme) {
     if (!this._evaluator) {
@@ -18243,7 +18360,8 @@ function getExpectedType(spec) {
     enum: StringType,
     boolean: BooleanType,
     formatted: FormattedType,
-    resolvedImage: ResolvedImageType
+    resolvedImage: ResolvedImageType,
+    object: ObjectType
   };
   if (spec.type === "array") {
     return array$1(types[spec.value] || ValueType, spec.length);
@@ -19507,17 +19625,23 @@ function validateOption(options) {
   const optionValue = options.value;
   const isArrayOption = isObject(optionValue) && unbundle(optionValue.array) === true;
   const declaredType = !isArrayOption && isObject(optionValue) ? unbundle(optionValue.type) : void 0;
+  const validateDefault = (elementOptions) => {
+    const defaultValue = elementOptions.value;
+    if (isObject(defaultValue)) {
+      return validate({ ...elementOptions, valueSpec: { ...elementOptions.valueSpec, type: "*", expression: void 0 } });
+    }
+    if (declaredType && Array.isArray(defaultValue)) {
+      return validate({ ...elementOptions, valueSpec: { ...elementOptions.valueSpec, type: declaredType } });
+    }
+    return validate(elementOptions);
+  };
   return validateObject({
     ...options,
     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     valueSpec: styleSpec.option,
-    objectElementValidators: declaredType ? {
-      // Only propagate the declared type when the default is an
-      // expression (array-form). Primitive defaults keep the previous
-      // permissive validation, mirroring the runtime parser's narrowing
-      // in style.ts/parser.cpp.
-      default: (elementOptions) => Array.isArray(elementOptions.value) ? validate({ ...elementOptions, valueSpec: { ...elementOptions.valueSpec, type: declaredType } }) : validate(elementOptions)
-    } : void 0
+    objectElementValidators: {
+      default: validateDefault
+    }
   });
 }