@mapbox/mapbox-gl-style-spec 14.25.0-rc.1 → 14.26.0-rc.1

package/dist/index.cjs

@@ -1300,6 +1300,24 @@
   		doc: "Override the orientation of the model node in euler angles [x, y, z]."
   	}
   };
+  var modelLightOverrides = {
+  	"light-ambient-color": {
+  		type: "color",
+  		doc: "Override the color of ambient lights."
+  	},
+  	"light-ambient-intensity": {
+  		type: "number",
+  		doc: "Override the intensity of light-ambient-color (on a scale from 0 to 1)."
+  	},
+  	"light-directional-color": {
+  		type: "color",
+  		doc: "Override the color of directional lights."
+  	},
+  	"light-directional-intensity": {
+  		type: "number",
+  		doc: "Override the intensity of light-directional-color (on a scale from 0 to 1)."
+  	}
+  };
   var modelNodeOverrides = {
   	"*": {
   		type: "modelNodeOverride",
@@ -1370,6 +1388,11 @@
   		units: "degrees",
   		doc: "Orientation of the model in euler angles [x, y, z]."
   	},
+  	lightOverrides: {
+  		type: "modelLightOverrides",
+  		required: false,
+  		doc: "A collection of light overrides."
+  	},
   	nodeOverrides: {
   		type: "modelNodeOverrides",
   		required: false,
@@ -6527,13 +6550,6 @@
   				doc: "Projection where objects are of the same scale regardless of whether they are far away or near to the camera. Parallel lines remains parallel and there is no vanishing point."
   			}
   		},
-  		transition: true,
-  		expression: {
-  			interpolated: true,
-  			parameters: [
-  				"zoom"
-  			]
-  		},
   		"sdk-support": {
   			"basic functionality": {
   				js: "3.0.0",
@@ -10522,29 +10538,6 @@
   		},
   		transition: true
   	},
-  	"model-lightmap-intensity": {
-  		type: "number",
-  		"default": 0,
-  		minimum: 0,
-  		doc: "Controls the intensity of the model lightmap contribution. Values less than or equal to 0.001 are treated as off.",
-  		"private": true,
-  		experimental: true,
-  		expression: {
-  			interpolated: true,
-  			parameters: [
-  				"zoom"
-  			]
-  		},
-  		"sdk-support": {
-  			"basic functionality": {
-  				js: "3.25.0",
-  				android: "11.25.0",
-  				ios: "11.25.0"
-  			}
-  		},
-  		"property-type": "data-constant",
-  		transition: true
-  	},
   	"model-type": {
   		type: "enum",
   		values: {
@@ -10965,6 +10958,7 @@
   	source_video: source_video,
   	source_image: source_image,
   	modelNodeOverride: modelNodeOverride,
+  	modelLightOverrides: modelLightOverrides,
   	modelNodeOverrides: modelNodeOverrides,
   	modelMaterialOverride: modelMaterialOverride,
   	modelMaterialOverrides: modelMaterialOverrides,
@@ -14009,7 +14003,7 @@
         overloadParams.push(params);
         overloadIndex++;
         if (signatureContext === null) {
-          signatureContext = new ParsingContext(context.registry, context.path, null, context.scope, [], context._scope, context.options, context.iconImageUseTheme);
+          signatureContext = context._forkForSignature();
         } else {
           signatureContext.errors.length = 0;
         }
@@ -14772,485 +14766,6 @@
     }
   }
 
-  const factors = {
-      kilometers: 1,
-      miles: 1000 / 1609.344,
-      nauticalmiles: 1000 / 1852,
-      meters: 1000,
-      metres: 1000,
-      yards: 1000 / 0.9144,
-      feet: 1000 / 0.3048,
-      inches: 1000 / 0.0254
-  };
-
-  // Values that define WGS84 ellipsoid model of the Earth
-  const RE = 6378.137; // equatorial radius
-  const FE = 1 / 298.257223563; // flattening
-
-  const E2 = FE * (2 - FE);
-  const RAD = Math.PI / 180;
-
-  /**
-   * A collection of very fast approximations to common geodesic measurements. Useful for performance-sensitive code that measures things on a city scale.
-   */
-  class CheapRuler {
-      /**
-       * Creates a ruler object from tile coordinates (y and z).
-       *
-       * @param {number} y
-       * @param {number} z
-       * @param {keyof typeof factors} [units='kilometers']
-       * @returns {CheapRuler}
-       * @example
-       * const ruler = cheapRuler.fromTile(1567, 12);
-       * //=ruler
-       */
-      static fromTile(y, z, units) {
-          const n = Math.PI * (1 - 2 * (y + 0.5) / Math.pow(2, z));
-          const lat = Math.atan(0.5 * (Math.exp(n) - Math.exp(-n))) / RAD;
-          return new CheapRuler(lat, units);
-      }
-
-      /**
-       * Multipliers for converting between units.
-       *
-       * @example
-       * // convert 50 meters to yards
-       * 50 * CheapRuler.units.yards / CheapRuler.units.meters;
-       */
-      static get units() {
-          return factors;
-      }
-
-      /**
-       * Creates a ruler instance for very fast approximations to common geodesic measurements around a certain latitude.
-       *
-       * @param {number} lat latitude
-       * @param {keyof typeof factors} [units='kilometers']
-       * @example
-       * const ruler = cheapRuler(35.05, 'miles');
-       * //=ruler
-       */
-      constructor(lat, units) {
-          if (lat === undefined) throw new Error('No latitude given.');
-          if (units && !factors[units]) throw new Error(`Unknown unit ${  units  }. Use one of: ${  Object.keys(factors).join(', ')}`);
-
-          // Curvature formulas from https://en.wikipedia.org/wiki/Earth_radius#Meridional
-          const m = RAD * RE * (units ? factors[units] : 1);
-          const coslat = Math.cos(lat * RAD);
-          const w2 = 1 / (1 - E2 * (1 - coslat * coslat));
-          const w = Math.sqrt(w2);
-
-          // multipliers for converting longitude and latitude degrees into distance
-          this.kx = m * w * coslat;        // based on normal radius of curvature
-          this.ky = m * w * w2 * (1 - E2); // based on meridonal radius of curvature
-      }
-
-      /**
-       * Given two points of the form [longitude, latitude], returns the distance.
-       *
-       * @param {[number, number]} a point [longitude, latitude]
-       * @param {[number, number]} b point [longitude, latitude]
-       * @returns {number} distance
-       * @example
-       * const distance = ruler.distance([30.5, 50.5], [30.51, 50.49]);
-       * //=distance
-       */
-      distance(a, b) {
-          const dx = wrap(a[0] - b[0]) * this.kx;
-          const dy = (a[1] - b[1]) * this.ky;
-          return Math.sqrt(dx * dx + dy * dy);
-      }
-
-      /**
-       * Returns the bearing between two points in angles.
-       *
-       * @param {[number, number]} a point [longitude, latitude]
-       * @param {[number, number]} b point [longitude, latitude]
-       * @returns {number} bearing
-       * @example
-       * const bearing = ruler.bearing([30.5, 50.5], [30.51, 50.49]);
-       * //=bearing
-       */
-      bearing(a, b) {
-          const dx = wrap(b[0] - a[0]) * this.kx;
-          const dy = (b[1] - a[1]) * this.ky;
-          return Math.atan2(dx, dy) / RAD;
-      }
-
-      /**
-       * Returns a new point given distance and bearing from the starting point.
-       *
-       * @param {[number, number]} p point [longitude, latitude]
-       * @param {number} dist distance
-       * @param {number} bearing
-       * @returns {[number, number]} point [longitude, latitude]
-       * @example
-       * const point = ruler.destination([30.5, 50.5], 0.1, 90);
-       * //=point
-       */
-      destination(p, dist, bearing) {
-          const a = bearing * RAD;
-          return this.offset(p,
-              Math.sin(a) * dist,
-              Math.cos(a) * dist);
-      }
-
-      /**
-       * Returns a new point given easting and northing offsets (in ruler units) from the starting point.
-       *
-       * @param {[number, number]} p point [longitude, latitude]
-       * @param {number} dx easting
-       * @param {number} dy northing
-       * @returns {[number, number]} point [longitude, latitude]
-       * @example
-       * const point = ruler.offset([30.5, 50.5], 10, 10);
-       * //=point
-       */
-      offset(p, dx, dy) {
-          return [
-              p[0] + dx / this.kx,
-              p[1] + dy / this.ky
-          ];
-      }
-
-      /**
-       * Given a line (an array of points), returns the total line distance.
-       *
-       * @param {[number, number][]} points [longitude, latitude]
-       * @returns {number} total line distance
-       * @example
-       * const length = ruler.lineDistance([
-       *     [-67.031, 50.458], [-67.031, 50.534],
-       *     [-66.929, 50.534], [-66.929, 50.458]
-       * ]);
-       * //=length
-       */
-      lineDistance(points) {
-          let total = 0;
-          for (let i = 0; i < points.length - 1; i++) {
-              total += this.distance(points[i], points[i + 1]);
-          }
-          return total;
-      }
-
-      /**
-       * Given a polygon (an array of rings, where each ring is an array of points), returns the area.
-       *
-       * @param {[number, number][][]} polygon
-       * @returns {number} area value in the specified units (square kilometers by default)
-       * @example
-       * const area = ruler.area([[
-       *     [-67.031, 50.458], [-67.031, 50.534], [-66.929, 50.534],
-       *     [-66.929, 50.458], [-67.031, 50.458]
-       * ]]);
-       * //=area
-       */
-      area(polygon) {
-          let sum = 0;
-
-          for (let i = 0; i < polygon.length; i++) {
-              const ring = polygon[i];
-
-              for (let j = 0, len = ring.length, k = len - 1; j < len; k = j++) {
-                  sum += wrap(ring[j][0] - ring[k][0]) * (ring[j][1] + ring[k][1]) * (i ? -1 : 1);
-              }
-          }
-
-          return (Math.abs(sum) / 2) * this.kx * this.ky;
-      }
-
-      /**
-       * Returns the point at a specified distance along the line.
-       *
-       * @param {[number, number][]} line
-       * @param {number} dist distance
-       * @returns {[number, number]} point [longitude, latitude]
-       * @example
-       * const point = ruler.along(line, 2.5);
-       * //=point
-       */
-      along(line, dist) {
-          let sum = 0;
-
-          if (dist <= 0) return line[0];
-
-          for (let i = 0; i < line.length - 1; i++) {
-              const p0 = line[i];
-              const p1 = line[i + 1];
-              const d = this.distance(p0, p1);
-              sum += d;
-              if (sum > dist) return interpolate$1(p0, p1, (dist - (sum - d)) / d);
-          }
-
-          return line[line.length - 1];
-      }
-
-      /**
-       * Returns the distance from a point `p` to a line segment `a` to `b`.
-       *
-       * @pointToSegmentDistance
-       * @param {[number, number]} p point [longitude, latitude]
-       * @param {[number, number]} a segment point 1 [longitude, latitude]
-       * @param {[number, number]} b segment point 2 [longitude, latitude]
-       * @returns {number} distance
-       * @example
-       * const distance = ruler.pointToSegmentDistance([-67.04, 50.5], [-67.05, 50.57], [-67.03, 50.54]);
-       * //=distance
-       */
-      pointToSegmentDistance(p, a, b) {
-          let [x, y] = a;
-          let dx = wrap(b[0] - x) * this.kx;
-          let dy = (b[1] - y) * this.ky;
-
-          if (dx !== 0 || dy !== 0) {
-              const t = (wrap(p[0] - x) * this.kx * dx + (p[1] - y) * this.ky * dy) / (dx * dx + dy * dy);
-
-              if (t > 1) {
-                  x = b[0];
-                  y = b[1];
-
-              } else if (t > 0) {
-                  x += (dx / this.kx) * t;
-                  y += (dy / this.ky) * t;
-              }
-          }
-
-          dx = wrap(p[0] - x) * this.kx;
-          dy = (p[1] - y) * this.ky;
-
-          return Math.sqrt(dx * dx + dy * dy);
-      }
-
-      /**
-       * Returns an object of the form {point, index, t}, where point is closest point on the line
-       * from the given point, index is the start index of the segment with the closest point,
-       * and t is a parameter from 0 to 1 that indicates where the closest point is on that segment.
-       *
-       * @param {[number, number][]} line
-       * @param {[number, number]} p point [longitude, latitude]
-       * @returns {{point: [number, number], index: number, t: number}} {point, index, t}
-       * @example
-       * const point = ruler.pointOnLine(line, [-67.04, 50.5]).point;
-       * //=point
-       */
-      pointOnLine(line, p) {
-          let minDist = Infinity;
-          let minX = line[0][0];
-          let minY = line[0][1];
-          let minI = 0;
-          let minT = 0;
-
-          for (let i = 0; i < line.length - 1; i++) {
-
-              let x = line[i][0];
-              let y = line[i][1];
-              let dx = wrap(line[i + 1][0] - x) * this.kx;
-              let dy = (line[i + 1][1] - y) * this.ky;
-              let t = 0;
-
-              if (dx !== 0 || dy !== 0) {
-                  t = (wrap(p[0] - x) * this.kx * dx + (p[1] - y) * this.ky * dy) / (dx * dx + dy * dy);
-
-                  if (t > 1) {
-                      x = line[i + 1][0];
-                      y = line[i + 1][1];
-
-                  } else if (t > 0) {
-                      x += (dx / this.kx) * t;
-                      y += (dy / this.ky) * t;
-                  }
-              }
-
-              dx = wrap(p[0] - x) * this.kx;
-              dy = (p[1] - y) * this.ky;
-
-              const sqDist = dx * dx + dy * dy;
-              if (sqDist < minDist) {
-                  minDist = sqDist;
-                  minX = x;
-                  minY = y;
-                  minI = i;
-                  minT = t;
-              }
-          }
-
-          return {
-              point: [minX, minY],
-              index: minI,
-              t: Math.max(0, Math.min(1, minT))
-          };
-      }
-
-      /**
-       * Returns a part of the given line between the start and the stop points (or their closest points on the line).
-       *
-       * @param {[number, number]} start point [longitude, latitude]
-       * @param {[number, number]} stop point [longitude, latitude]
-       * @param {[number, number][]} line
-       * @returns {[number, number][]} line part of a line
-       * @example
-       * const line2 = ruler.lineSlice([-67.04, 50.5], [-67.05, 50.56], line1);
-       * //=line2
-       */
-      lineSlice(start, stop, line) {
-          let p1 = this.pointOnLine(line, start);
-          let p2 = this.pointOnLine(line, stop);
-
-          if (p1.index > p2.index || (p1.index === p2.index && p1.t > p2.t)) {
-              const tmp = p1;
-              p1 = p2;
-              p2 = tmp;
-          }
-
-          const slice = [p1.point];
-
-          const l = p1.index + 1;
-          const r = p2.index;
-
-          if (!equals(line[l], slice[0]) && l <= r)
-              slice.push(line[l]);
-
-          for (let i = l + 1; i <= r; i++) {
-              slice.push(line[i]);
-          }
-
-          if (!equals(line[r], p2.point))
-              slice.push(p2.point);
-
-          return slice;
-      }
-
-      /**
-       * Returns a part of the given line between the start and the stop points indicated by distance along the line.
-       *
-       * @param {number} start start distance
-       * @param {number} stop stop distance
-       * @param {[number, number][]} line
-       * @returns {[number, number][]} part of a line
-       * @example
-       * const line2 = ruler.lineSliceAlong(10, 20, line1);
-       * //=line2
-       */
-      lineSliceAlong(start, stop, line) {
-          let sum = 0;
-          const slice = [];
-
-          for (let i = 0; i < line.length - 1; i++) {
-              const p0 = line[i];
-              const p1 = line[i + 1];
-              const d = this.distance(p0, p1);
-
-              sum += d;
-
-              if (sum > start && slice.length === 0) {
-                  slice.push(interpolate$1(p0, p1, (start - (sum - d)) / d));
-              }
-
-              if (sum >= stop) {
-                  slice.push(interpolate$1(p0, p1, (stop - (sum - d)) / d));
-                  return slice;
-              }
-
-              if (sum > start) slice.push(p1);
-          }
-
-          return slice;
-      }
-
-      /**
-       * Given a point, returns a bounding box object ([w, s, e, n]) created from the given point buffered by a given distance.
-       *
-       * @param {[number, number]} p point [longitude, latitude]
-       * @param {number} buffer
-       * @returns {[number, number, number, number]} bbox ([w, s, e, n])
-       * @example
-       * const bbox = ruler.bufferPoint([30.5, 50.5], 0.01);
-       * //=bbox
-       */
-      bufferPoint(p, buffer) {
-          const v = buffer / this.ky;
-          const h = buffer / this.kx;
-          return [
-              p[0] - h,
-              p[1] - v,
-              p[0] + h,
-              p[1] + v
-          ];
-      }
-
-      /**
-       * Given a bounding box, returns the box buffered by a given distance.
-       *
-       * @param {[number, number, number, number]} bbox ([w, s, e, n])
-       * @param {number} buffer
-       * @returns {[number, number, number, number]} bbox ([w, s, e, n])
-       * @example
-       * const bbox = ruler.bufferBBox([30.5, 50.5, 31, 51], 0.2);
-       * //=bbox
-       */
-      bufferBBox(bbox, buffer) {
-          const v = buffer / this.ky;
-          const h = buffer / this.kx;
-          return [
-              bbox[0] - h,
-              bbox[1] - v,
-              bbox[2] + h,
-              bbox[3] + v
-          ];
-      }
-
-      /**
-       * Returns true if the given point is inside in the given bounding box, otherwise false.
-       *
-       * @param {[number, number]} p point [longitude, latitude]
-       * @param {[number, number, number, number]} bbox ([w, s, e, n])
-       * @returns {boolean}
-       * @example
-       * const inside = ruler.insideBBox([30.5, 50.5], [30, 50, 31, 51]);
-       * //=inside
-       */
-      insideBBox(p, bbox) { // eslint-disable-line
-          return wrap(p[0] - bbox[0]) >= 0 &&
-                 wrap(p[0] - bbox[2]) <= 0 &&
-                 p[1] >= bbox[1] &&
-                 p[1] <= bbox[3];
-      }
-  }
-
-  /**
-   * @param {[number, number]} a
-   * @param {[number, number]} b
-   */
-  function equals(a, b) {
-      return a[0] === b[0] && a[1] === b[1];
-  }
-
-  /**
-   * @param {[number, number]} a
-   * @param {[number, number]} b
-   * @param {number} t
-   * @returns {[number, number]}
-   */
-  function interpolate$1(a, b, t) {
-      const dx = wrap(b[0] - a[0]);
-      const dy = b[1] - a[1];
-      return [
-          a[0] + dx * t,
-          a[1] + dy * t
-      ];
-  }
-
-  /**
-   * normalize a degree value into [-180..180] range
-   * @param {number} deg
-   */
-  function wrap(deg) {
-      while (deg < -180) deg += 360;
-      while (deg > 180) deg -= 360;
-      return deg;
-  }
-
   class TinyQueue {
       constructor(data = [], compare = (a, b) => (a < b ? -1 : a > b ? 1 : 0)) {
           this.data = data;
@@ -15324,6 +14839,77 @@
 
   var EXTENT = 8192;
 
+  const RE = 6378.137;
+  const FE = 1 / 298.257223563;
+  const E2 = FE * (2 - FE);
+  const RAD = Math.PI / 180;
+  function lngLatScale(lat) {
+    const m = RAD * RE * 1e3;
+    const coslat = Math.cos(lat * RAD);
+    const w2 = 1 / (1 - E2 * (1 - coslat * coslat));
+    const w = Math.sqrt(w2);
+    return [m * w * coslat, m * w * w2 * (1 - E2)];
+  }
+  function wrapLng(deg) {
+    while (deg < -180) deg += 360;
+    while (deg > 180) deg -= 360;
+    return deg;
+  }
+  function rulerDistance(a, b, kx, ky) {
+    const dx = wrapLng(a[0] - b[0]) * kx;
+    const dy = (a[1] - b[1]) * ky;
+    return Math.sqrt(dx * dx + dy * dy);
+  }
+  function rulerPointToSegmentDistance(p, a, b, kx, ky) {
+    let x = a[0];
+    let y = a[1];
+    let dx = wrapLng(b[0] - x) * kx;
+    let dy = (b[1] - y) * ky;
+    if (dx !== 0 || dy !== 0) {
+      const t = (wrapLng(p[0] - x) * kx * dx + (p[1] - y) * ky * dy) / (dx * dx + dy * dy);
+      if (t > 1) {
+        x = b[0];
+        y = b[1];
+      } else if (t > 0) {
+        x += dx / kx * t;
+        y += dy / ky * t;
+      }
+    }
+    dx = wrapLng(p[0] - x) * kx;
+    dy = (p[1] - y) * ky;
+    return Math.sqrt(dx * dx + dy * dy);
+  }
+  function rulerPointOnLine(line, p, kx, ky) {
+    let minDist = Infinity;
+    let minX = line[0][0];
+    let minY = line[0][1];
+    for (let i = 0; i < line.length - 1; i++) {
+      let x = line[i][0];
+      let y = line[i][1];
+      let dx = wrapLng(line[i + 1][0] - x) * kx;
+      let dy = (line[i + 1][1] - y) * ky;
+      let t = 0;
+      if (dx !== 0 || dy !== 0) {
+        t = (wrapLng(p[0] - x) * kx * dx + (p[1] - y) * ky * dy) / (dx * dx + dy * dy);
+        if (t > 1) {
+          x = line[i + 1][0];
+          y = line[i + 1][1];
+        } else if (t > 0) {
+          x += dx / kx * t;
+          y += dy / ky * t;
+        }
+      }
+      dx = wrapLng(p[0] - x) * kx;
+      dy = (p[1] - y) * ky;
+      const sqDist = dx * dx + dy * dy;
+      if (sqDist < minDist) {
+        minDist = sqDist;
+        minX = x;
+        minY = y;
+      }
+    }
+    return [minX, minY];
+  }
   function compareMax(a, b) {
     return b.dist - a.dist;
   }
@@ -15389,7 +14975,7 @@
     }
     return bbox;
   }
-  function bboxToBBoxDistance(bbox1, bbox2, ruler) {
+  function bboxToBBoxDistance(bbox1, bbox2, kx, ky) {
     if (isDefaultBBOX(bbox1) || isDefaultBBOX(bbox2)) {
       return NaN;
     }
@@ -15407,7 +14993,7 @@
     if (bbox1[3] < bbox2[1]) {
       dy = bbox2[1] - bbox1[3];
     }
-    return ruler.distance([0, 0], [dx, dy]);
+    return rulerDistance([0, 0], [dx, dy], kx, ky);
   }
   function getLngLatPoint(coord, canonical, extent = EXTENT) {
     const tilesAtZoom = Math.pow(2, canonical.z);
@@ -15422,30 +15008,30 @@
     }
     return coords;
   }
-  function pointToLineDistance(point, line, ruler) {
-    const nearestPoint = ruler.pointOnLine(line, point).point;
-    return ruler.distance(point, nearestPoint);
+  function pointToLineDistance(point, line, kx, ky) {
+    const nearestPoint = rulerPointOnLine(line, point, kx, ky);
+    return rulerDistance(point, nearestPoint, kx, ky);
   }
-  function pointsToLineDistance(points, rangeA, line, rangeB, ruler) {
+  function pointsToLineDistance(points, rangeA, line, rangeB, kx, ky) {
     const subLine = line.slice(rangeB[0], rangeB[1] + 1);
     let dist = Infinity;
     for (let i = rangeA[0]; i <= rangeA[1]; ++i) {
-      if ((dist = Math.min(dist, pointToLineDistance(points[i], subLine, ruler))) === 0) return 0;
+      if ((dist = Math.min(dist, pointToLineDistance(points[i], subLine, kx, ky))) === 0) return 0;
     }
     return dist;
   }
-  function segmentToSegmentDistance(p1, p2, q1, q2, ruler) {
+  function segmentToSegmentDistance(p1, p2, q1, q2, kx, ky) {
     const dist1 = Math.min(
-      ruler.pointToSegmentDistance(p1, q1, q2),
-      ruler.pointToSegmentDistance(p2, q1, q2)
+      rulerPointToSegmentDistance(p1, q1, q2, kx, ky),
+      rulerPointToSegmentDistance(p2, q1, q2, kx, ky)
     );
     const dist2 = Math.min(
-      ruler.pointToSegmentDistance(q1, p1, p2),
-      ruler.pointToSegmentDistance(q2, p1, p2)
+      rulerPointToSegmentDistance(q1, p1, p2, kx, ky),
+      rulerPointToSegmentDistance(q2, p1, p2, kx, ky)
     );
     return Math.min(dist1, dist2);
   }
-  function lineToLineDistance(line1, range1, line2, range2, ruler) {
+  function lineToLineDistance(line1, range1, line2, range2, kx, ky) {
     if (!isRangeSafe(range1, line1.length) || !isRangeSafe(range2, line2.length)) {
       return NaN;
     }
@@ -15453,24 +15039,24 @@
     for (let i = range1[0]; i < range1[1]; ++i) {
       for (let j = range2[0]; j < range2[1]; ++j) {
         if (segmentIntersectSegment(line1[i], line1[i + 1], line2[j], line2[j + 1])) return 0;
-        dist = Math.min(dist, segmentToSegmentDistance(line1[i], line1[i + 1], line2[j], line2[j + 1], ruler));
+        dist = Math.min(dist, segmentToSegmentDistance(line1[i], line1[i + 1], line2[j], line2[j + 1], kx, ky));
       }
     }
     return dist;
   }
-  function pointsToPointsDistance(pointSet1, range1, pointSet2, range2, ruler) {
+  function pointsToPointsDistance(pointSet1, range1, pointSet2, range2, kx, ky) {
     if (!isRangeSafe(range1, pointSet1.length) || !isRangeSafe(range2, pointSet2.length)) {
       return NaN;
     }
     let dist = Infinity;
     for (let i = range1[0]; i <= range1[1]; ++i) {
       for (let j = range2[0]; j <= range2[1]; ++j) {
-        if ((dist = Math.min(dist, ruler.distance(pointSet1[i], pointSet2[j]))) === 0) return dist;
+        if ((dist = Math.min(dist, rulerDistance(pointSet1[i], pointSet2[j], kx, ky))) === 0) return dist;
       }
     }
     return dist;
   }
-  function pointToPolygonDistance(point, polygon, ruler) {
+  function pointToPolygonDistance(point, polygon, kx, ky) {
     if (pointWithinPolygon(
       point,
       polygon,
@@ -15485,13 +15071,13 @@
         return NaN;
       }
       if (ring[0] !== ring[ringLen - 1]) {
-        if ((dist = Math.min(dist, ruler.pointToSegmentDistance(point, ring[ringLen - 1], ring[0]))) === 0) return dist;
+        if ((dist = Math.min(dist, rulerPointToSegmentDistance(point, ring[ringLen - 1], ring[0], kx, ky))) === 0) return dist;
       }
-      if ((dist = Math.min(dist, pointToLineDistance(point, ring, ruler))) === 0) return dist;
+      if ((dist = Math.min(dist, pointToLineDistance(point, ring, kx, ky))) === 0) return dist;
     }
     return dist;
   }
-  function lineToPolygonDistance(line, range, polygon, ruler) {
+  function lineToPolygonDistance(line, range, polygon, kx, ky) {
     if (!isRangeSafe(range, line.length)) {
       return NaN;
     }
@@ -15508,7 +15094,7 @@
       for (const ring of polygon) {
         for (let j = 0, len = ring.length, k = len - 1; j < len; k = j++) {
           if (segmentIntersectSegment(line[i], line[i + 1], ring[k], ring[j])) return 0;
-          dist = Math.min(dist, segmentToSegmentDistance(line[i], line[i + 1], ring[k], ring[j], ruler));
+          dist = Math.min(dist, segmentToSegmentDistance(line[i], line[i + 1], ring[k], ring[j], kx, ky));
         }
       }
     }
@@ -15527,10 +15113,10 @@
     }
     return false;
   }
-  function polygonToPolygonDistance(polygon1, polygon2, ruler, currentMiniDist = Infinity) {
+  function polygonToPolygonDistance(polygon1, polygon2, kx, ky, currentMiniDist = Infinity) {
     const bbox1 = getPolygonBBox(polygon1);
     const bbox2 = getPolygonBBox(polygon2);
-    if (currentMiniDist !== Infinity && bboxToBBoxDistance(bbox1, bbox2, ruler) >= currentMiniDist) {
+    if (currentMiniDist !== Infinity && bboxToBBoxDistance(bbox1, bbox2, kx, ky) >= currentMiniDist) {
       return currentMiniDist;
     }
     if (boxWithinBox(bbox1, bbox2)) {
@@ -15544,20 +15130,20 @@
         for (const ring2 of polygon2) {
           for (let j = 0, len2 = ring2.length, k = len2 - 1; j < len2; k = j++) {
             if (segmentIntersectSegment(ring1[l], ring1[i], ring2[k], ring2[j])) return 0;
-            dist = Math.min(dist, segmentToSegmentDistance(ring1[l], ring1[i], ring2[k], ring2[j], ruler));
+            dist = Math.min(dist, segmentToSegmentDistance(ring1[l], ring1[i], ring2[k], ring2[j], kx, ky));
           }
         }
       }
     }
     return dist;
   }
-  function updateQueue(distQueue, miniDist, ruler, pointSet1, pointSet2, r1, r2) {
+  function updateQueue(distQueue, miniDist, kx, ky, pointSet1, pointSet2, r1, r2) {
     if (r1 === null || r2 === null) return;
-    const tempDist = bboxToBBoxDistance(getBBox(pointSet1, r1), getBBox(pointSet2, r2), ruler);
+    const tempDist = bboxToBBoxDistance(getBBox(pointSet1, r1), getBBox(pointSet2, r2), kx, ky);
     if (tempDist < miniDist) distQueue.push({ dist: tempDist, range1: r1, range2: r2 });
   }
-  function pointSetToPolygonDistance(pointSets, isLine, polygon, ruler, currentMiniDist = Infinity) {
-    let miniDist = Math.min(ruler.distance(pointSets[0], polygon[0][0]), currentMiniDist);
+  function pointSetToPolygonDistance(pointSets, isLine, polygon, kx, ky, currentMiniDist = Infinity) {
+    let miniDist = Math.min(rulerDistance(pointSets[0], polygon[0][0], kx, ky), currentMiniDist);
     if (miniDist === 0) return miniDist;
     const initialDistPair = {
       dist: 0,
@@ -15574,30 +15160,30 @@
       if (getRangeSize(range) <= setThreshold) {
         if (!isRangeSafe(range, pointSets.length)) return NaN;
         if (isLine) {
-          const tempDist = lineToPolygonDistance(pointSets, range, polygon, ruler);
+          const tempDist = lineToPolygonDistance(pointSets, range, polygon, kx, ky);
           if ((miniDist = Math.min(miniDist, tempDist)) === 0) return miniDist;
         } else {
           for (let i = range[0]; i <= range[1]; ++i) {
-            const tempDist = pointToPolygonDistance(pointSets[i], polygon, ruler);
+            const tempDist = pointToPolygonDistance(pointSets[i], polygon, kx, ky);
             if ((miniDist = Math.min(miniDist, tempDist)) === 0) return miniDist;
           }
         }
       } else {
         const newRanges = splitRange(range, isLine);
         if (newRanges[0] !== null) {
-          const tempDist = bboxToBBoxDistance(getBBox(pointSets, newRanges[0]), polyBBox, ruler);
+          const tempDist = bboxToBBoxDistance(getBBox(pointSets, newRanges[0]), polyBBox, kx, ky);
           if (tempDist < miniDist) distQueue.push({ dist: tempDist, range1: newRanges[0], range2: [0, 0] });
         }
         if (newRanges[1] !== null) {
-          const tempDist = bboxToBBoxDistance(getBBox(pointSets, newRanges[1]), polyBBox, ruler);
+          const tempDist = bboxToBBoxDistance(getBBox(pointSets, newRanges[1]), polyBBox, kx, ky);
           if (tempDist < miniDist) distQueue.push({ dist: tempDist, range1: newRanges[1], range2: [0, 0] });
         }
       }
     }
     return miniDist;
   }
-  function pointSetsDistance(pointSet1, isLine1, pointSet2, isLine2, ruler, currentMiniDist = Infinity) {
-    let miniDist = Math.min(currentMiniDist, ruler.distance(pointSet1[0], pointSet2[0]));
+  function pointSetsDistance(pointSet1, isLine1, pointSet2, isLine2, kx, ky, currentMiniDist = Infinity) {
+    let miniDist = Math.min(currentMiniDist, rulerDistance(pointSet1[0], pointSet2[0], kx, ky));
     if (miniDist === 0) return miniDist;
     const initialDistPair = {
       dist: 0,
@@ -15617,52 +15203,52 @@
           return NaN;
         }
         if (isLine1 && isLine2) {
-          miniDist = Math.min(miniDist, lineToLineDistance(pointSet1, rangeA, pointSet2, rangeB, ruler));
+          miniDist = Math.min(miniDist, lineToLineDistance(pointSet1, rangeA, pointSet2, rangeB, kx, ky));
         } else if (!isLine1 && !isLine2) {
-          miniDist = Math.min(miniDist, pointsToPointsDistance(pointSet1, rangeA, pointSet2, rangeB, ruler));
+          miniDist = Math.min(miniDist, pointsToPointsDistance(pointSet1, rangeA, pointSet2, rangeB, kx, ky));
         } else if (isLine1 && !isLine2) {
-          miniDist = Math.min(miniDist, pointsToLineDistance(pointSet2, rangeB, pointSet1, rangeA, ruler));
+          miniDist = Math.min(miniDist, pointsToLineDistance(pointSet2, rangeB, pointSet1, rangeA, kx, ky));
         } else if (!isLine1 && isLine2) {
-          miniDist = Math.min(miniDist, pointsToLineDistance(pointSet1, rangeA, pointSet2, rangeB, ruler));
+          miniDist = Math.min(miniDist, pointsToLineDistance(pointSet1, rangeA, pointSet2, rangeB, kx, ky));
         }
         if (miniDist === 0) return miniDist;
       } else {
         const newRangesA = splitRange(rangeA, isLine1);
         const newRangesB = splitRange(rangeB, isLine2);
-        updateQueue(distQueue, miniDist, ruler, pointSet1, pointSet2, newRangesA[0], newRangesB[0]);
-        updateQueue(distQueue, miniDist, ruler, pointSet1, pointSet2, newRangesA[0], newRangesB[1]);
-        updateQueue(distQueue, miniDist, ruler, pointSet1, pointSet2, newRangesA[1], newRangesB[0]);
-        updateQueue(distQueue, miniDist, ruler, pointSet1, pointSet2, newRangesA[1], newRangesB[1]);
+        updateQueue(distQueue, miniDist, kx, ky, pointSet1, pointSet2, newRangesA[0], newRangesB[0]);
+        updateQueue(distQueue, miniDist, kx, ky, pointSet1, pointSet2, newRangesA[0], newRangesB[1]);
+        updateQueue(distQueue, miniDist, kx, ky, pointSet1, pointSet2, newRangesA[1], newRangesB[0]);
+        updateQueue(distQueue, miniDist, kx, ky, pointSet1, pointSet2, newRangesA[1], newRangesB[1]);
       }
     }
     return miniDist;
   }
-  function pointSetToLinesDistance(pointSet, isLine, lines, ruler, currentMiniDist = Infinity) {
+  function pointSetToLinesDistance(pointSet, isLine, lines, kx, ky, currentMiniDist = Infinity) {
     let dist = currentMiniDist;
     const bbox1 = getBBox(pointSet, [0, pointSet.length - 1]);
     for (const line of lines) {
-      if (dist !== Infinity && bboxToBBoxDistance(bbox1, getBBox(line, [0, line.length - 1]), ruler) >= dist) continue;
-      dist = Math.min(dist, pointSetsDistance(pointSet, isLine, line, true, ruler, dist));
+      if (dist !== Infinity && bboxToBBoxDistance(bbox1, getBBox(line, [0, line.length - 1]), kx, ky) >= dist) continue;
+      dist = Math.min(dist, pointSetsDistance(pointSet, isLine, line, true, kx, ky, dist));
       if (dist === 0) return dist;
     }
     return dist;
   }
-  function pointSetToPolygonsDistance(points, isLine, polygons, ruler, currentMiniDist = Infinity) {
+  function pointSetToPolygonsDistance(points, isLine, polygons, kx, ky, currentMiniDist = Infinity) {
     let dist = currentMiniDist;
     const bbox1 = getBBox(points, [0, points.length - 1]);
     for (const polygon of polygons) {
-      if (dist !== Infinity && bboxToBBoxDistance(bbox1, getPolygonBBox(polygon), ruler) >= dist) continue;
-      const tempDist = pointSetToPolygonDistance(points, isLine, polygon, ruler, dist);
+      if (dist !== Infinity && bboxToBBoxDistance(bbox1, getPolygonBBox(polygon), kx, ky) >= dist) continue;
+      const tempDist = pointSetToPolygonDistance(points, isLine, polygon, kx, ky, dist);
       if (isNaN(tempDist)) return tempDist;
       if ((dist = Math.min(dist, tempDist)) === 0) return dist;
     }
     return dist;
   }
-  function polygonsToPolygonsDistance(polygons1, polygons2, ruler) {
+  function polygonsToPolygonsDistance(polygons1, polygons2, kx, ky) {
     let dist = Infinity;
     for (const polygon1 of polygons1) {
       for (const polygon2 of polygons2) {
-        const tempDist = polygonToPolygonDistance(polygon1, polygon2, ruler, dist);
+        const tempDist = polygonToPolygonDistance(polygon1, polygon2, kx, ky, dist);
         if (isNaN(tempDist)) return tempDist;
         if ((dist = Math.min(dist, tempDist)) === 0) return dist;
       }
@@ -15676,25 +15262,27 @@
         lngLatPoints.push(getLngLatPoint(point, canonical));
       }
     }
-    const ruler = new CheapRuler(lngLatPoints[0][1], "meters");
+    const [kx, ky] = lngLatScale(lngLatPoints[0][1]);
     if (geometry.type === "Point" || geometry.type === "MultiPoint" || geometry.type === "LineString") {
       return pointSetsDistance(
         lngLatPoints,
         false,
         geometry.type === "Point" ? [geometry.coordinates] : geometry.coordinates,
         geometry.type === "LineString",
-        ruler
+        kx,
+        ky
       );
     }
     if (geometry.type === "MultiLineString") {
-      return pointSetToLinesDistance(lngLatPoints, false, geometry.coordinates, ruler);
+      return pointSetToLinesDistance(lngLatPoints, false, geometry.coordinates, kx, ky);
     }
     if (geometry.type === "Polygon" || geometry.type === "MultiPolygon") {
       return pointSetToPolygonsDistance(
         lngLatPoints,
         false,
         geometry.type === "Polygon" ? [geometry.coordinates] : geometry.coordinates,
-        ruler
+        kx,
+        ky
       );
     }
     return null;
@@ -15708,19 +15296,20 @@
       }
       lngLatLines.push(lngLatLine);
     }
-    const ruler = new CheapRuler(lngLatLines[0][0][1], "meters");
+    const [kx, ky] = lngLatScale(lngLatLines[0][0][1]);
     if (geometry.type === "Point" || geometry.type === "MultiPoint" || geometry.type === "LineString") {
       return pointSetToLinesDistance(
         geometry.type === "Point" ? [geometry.coordinates] : geometry.coordinates,
         geometry.type === "LineString",
         lngLatLines,
-        ruler
+        kx,
+        ky
       );
     }
     if (geometry.type === "MultiLineString") {
       let dist = Infinity;
       for (let i = 0; i < geometry.coordinates.length; i++) {
-        const tempDist = pointSetToLinesDistance(geometry.coordinates[i], true, lngLatLines, ruler, dist);
+        const tempDist = pointSetToLinesDistance(geometry.coordinates[i], true, lngLatLines, kx, ky, dist);
         if (isNaN(tempDist)) return tempDist;
         if ((dist = Math.min(dist, tempDist)) === 0) return dist;
       }
@@ -15733,7 +15322,8 @@
           lngLatLines[i],
           true,
           geometry.type === "Polygon" ? [geometry.coordinates] : geometry.coordinates,
-          ruler,
+          kx,
+          ky,
           dist
         );
         if (isNaN(tempDist)) return tempDist;
@@ -15752,19 +15342,20 @@
       }
       lngLatPolygons.push(lngLatPolygon);
     }
-    const ruler = new CheapRuler(lngLatPolygons[0][0][0][1], "meters");
+    const [kx, ky] = lngLatScale(lngLatPolygons[0][0][0][1]);
     if (geometry.type === "Point" || geometry.type === "MultiPoint" || geometry.type === "LineString") {
       return pointSetToPolygonsDistance(
         geometry.type === "Point" ? [geometry.coordinates] : geometry.coordinates,
         geometry.type === "LineString",
         lngLatPolygons,
-        ruler
+        kx,
+        ky
       );
     }
     if (geometry.type === "MultiLineString") {
       let dist = Infinity;
       for (let i = 0; i < geometry.coordinates.length; i++) {
-        const tempDist = pointSetToPolygonsDistance(geometry.coordinates[i], true, lngLatPolygons, ruler, dist);
+        const tempDist = pointSetToPolygonsDistance(geometry.coordinates[i], true, lngLatPolygons, kx, ky, dist);
         if (isNaN(tempDist)) return tempDist;
         if ((dist = Math.min(dist, tempDist)) === 0) return dist;
       }
@@ -15774,7 +15365,8 @@
       return polygonsToPolygonsDistance(
         geometry.type === "Polygon" ? [geometry.coordinates] : geometry.coordinates,
         lngLatPolygons,
-        ruler
+        kx,
+        ky
       );
     }
     return null;
@@ -15886,18 +15478,21 @@
     });
     return result;
   }
-  function isGlobalPropertyConstant(e, properties) {
-    if (e instanceof CompoundExpression && properties.includes(e.name)) {
+  function isGlobalPropertyConstantSet(e, properties) {
+    if (e instanceof CompoundExpression && properties.has(e.name)) {
       return false;
     }
     let result = true;
     e.eachChild((arg) => {
-      if (result && !isGlobalPropertyConstant(arg, properties)) {
+      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) {
@@ -16064,16 +15659,12 @@
       this.iconImageUseTheme = iconImageUseTheme;
     }
     get key() {
-      if (this._key === void 0) {
-        const path = this.path;
-        let key = "";
-        for (let i = 0; i < path.length; i++) {
-          const part = path[i];
-          key += typeof part === "string" ? `['${part}']` : `[${part}]`;
-        }
-        this._key = key;
+      let key = "";
+      for (let i = 0; i < this.path.length; i++) {
+        const part = this.path[i];
+        key += typeof part === "string" ? `['${part}']` : `[${part}]`;
       }
-      return this._key;
+      return key;
     }
     /**
      * @param expr the JSON expression to parse
@@ -16084,7 +15675,17 @@
      */
     parse(expr, index, expectedType, bindings, options = {}) {
       if (index || expectedType) {
-        return this.concat(index, null, expectedType, bindings)._parse(expr, options);
+        const prevExpectedType = this.expectedType;
+        const prevScope = this.scope;
+        if (bindings) this.scope = this.scope.concat(bindings);
+        this.expectedType = expectedType || null;
+        const pushed = typeof index === "number";
+        if (pushed) this.path.push(index);
+        const result = this._parse(expr, options);
+        if (pushed) this.path.pop();
+        this.expectedType = prevExpectedType;
+        this.scope = prevScope;
+        return result;
       }
       return this._parse(expr, options);
     }
@@ -16097,21 +15698,23 @@
      * @private
      */
     parseObjectValue(expr, index, key, expectedType, bindings, options = {}) {
-      return this.concat(index, key, expectedType, bindings)._parse(expr, options);
+      const prevExpectedType = this.expectedType;
+      const prevScope = this.scope;
+      if (bindings) this.scope = this.scope.concat(bindings);
+      this.expectedType = expectedType || null;
+      this.path.push(index);
+      this.path.push(key);
+      const result = this._parse(expr, options);
+      this.path.pop();
+      this.path.pop();
+      this.expectedType = prevExpectedType;
+      this.scope = prevScope;
+      return result;
     }
     _parse(expr, options) {
       if (expr === null || typeof expr === "string" || typeof expr === "boolean" || typeof expr === "number") {
         expr = ["literal", expr];
       }
-      function annotate(parsed, type, typeAnnotation) {
-        if (typeAnnotation === "assert") {
-          return new Assertion(type, [parsed]);
-        } else if (typeAnnotation === "coerce") {
-          return new Coercion(type, [parsed]);
-        } else {
-          return parsed;
-        }
-      }
       if (Array.isArray(expr)) {
         if (expr.length === 0) {
           return this.error(`Expected an array with at least one element. If you wanted a literal array, use ["literal", []].`);
@@ -16160,9 +15763,10 @@
      * @private
      */
     concat(index, key, expectedType, bindings) {
-      let path = typeof index === "number" ? this.path.concat(index) : this.path;
-      path = typeof key === "string" ? path.concat(key) : path;
       const scope = bindings ? this.scope.concat(bindings) : this.scope;
+      const path = this.path.slice();
+      if (typeof index === "number") path.push(index);
+      if (typeof key === "string") path.push(key);
       return new ParsingContext(
         this.registry,
         path,
@@ -16174,6 +15778,24 @@
         this.iconImageUseTheme
       );
     }
+    /**
+     * Returns a fresh context that shares the same path position as this one
+     * but has an empty errors array. Used by CompoundExpression to probe
+     * overload signatures without polluting the parent errors list.
+     * @private
+     */
+    _forkForSignature() {
+      return new ParsingContext(
+        this.registry,
+        this.path.slice(),
+        null,
+        this.scope,
+        [],
+        this._scope,
+        this.options,
+        this.iconImageUseTheme
+      );
+    }
     /**
      * Push a parsing (or type checking) error into the `this.errors`
      * @param error The message
@@ -16195,6 +15817,30 @@
       return error;
     }
   }
+  const CONSTANT_FOLD_EXCLUDED_GLOBALS = /* @__PURE__ */ new Set([
+    "zoom",
+    "heatmap-density",
+    "worldview",
+    "line-progress",
+    "raster-value",
+    "sky-radial-progress",
+    "accumulated",
+    "is-supported-script",
+    "pitch",
+    "distance-from-center",
+    "measure-light",
+    "raster-particle-speed",
+    "is-active-floor"
+  ]);
+  function annotate(parsed, type, typeAnnotation) {
+    if (typeAnnotation === "assert") {
+      return new Assertion(type, [parsed]);
+    } else if (typeAnnotation === "coerce") {
+      return new Coercion(type, [parsed]);
+    } else {
+      return parsed;
+    }
+  }
   function isConstant(expression) {
     if (expression instanceof Var) {
       return isConstant(expression.boundExpression);
@@ -16221,7 +15867,7 @@
     if (!childrenConstant) {
       return false;
     }
-    return isFeatureConstant(expression) && isGlobalPropertyConstant(expression, ["zoom", "heatmap-density", "worldview", "line-progress", "raster-value", "sky-radial-progress", "accumulated", "is-supported-script", "pitch", "distance-from-center", "measure-light", "raster-particle-speed", "is-active-floor"]);
+    return isFeatureConstant(expression) && isGlobalPropertyConstantSet(expression, CONSTANT_FOLD_EXCLUDED_GLOBALS);
   }
 
   function findStopLessThanOrEqualTo(stops, input) {
@@ -16986,24 +16632,23 @@
         if (!Array.isArray(labels)) {
           labels = [labels];
         }
-        const labelContext = context.concat(i);
         if (labels.length === 0) {
-          return labelContext.error("Expected at least one branch label.");
+          return context.error("Expected at least one branch label.", i);
         }
         for (const label of labels) {
           if (typeof label !== "number" && typeof label !== "string") {
-            return labelContext.error(`Branch labels must be numbers or strings.`);
+            return context.error(`Branch labels must be numbers or strings.`, i);
           } else if (typeof label === "number" && Math.abs(label) > Number.MAX_SAFE_INTEGER) {
-            return labelContext.error(`Branch labels must be integers no larger than ${Number.MAX_SAFE_INTEGER}.`);
+            return context.error(`Branch labels must be integers no larger than ${Number.MAX_SAFE_INTEGER}.`, i);
           } else if (typeof label === "number" && Math.floor(label) !== label) {
-            return labelContext.error(`Numeric branch labels must be integer values.`);
+            return context.error(`Numeric branch labels must be integer values.`, i);
           } else if (!inputType) {
             inputType = typeOf(label);
-          } else if (labelContext.checkSubtype(inputType, typeOf(label))) {
+          } else if (context.checkSubtype(inputType, typeOf(label), i)) {
             return null;
           }
           if (typeof cases[String(label)] !== "undefined") {
-            return labelContext.error("Branch labels must be unique.");
+            return context.error("Branch labels must be unique.", i);
           }
           cases[String(label)] = outputs.length;
         }
@@ -17016,7 +16661,7 @@
       if (!input) return null;
       const otherwise = context.parse(args.at(-1), args.length - 1, outputType);
       if (!otherwise) return null;
-      if (input.type.kind !== "value" && context.concat(1).checkSubtype(inputType, input.type)) {
+      if (input.type.kind !== "value" && context.checkSubtype(inputType, input.type, 1)) {
         return null;
       }
       return new Match(inputType, outputType, input, cases, outputs, otherwise);
@@ -17274,12 +16919,12 @@
         let lhs = context.parse(args[1], 1, ValueType);
         if (!lhs) return null;
         if (!isComparableType(op2, lhs.type)) {
-          return context.concat(1).error(`"${op2}" comparisons are not supported for type '${toString$1(lhs.type)}'.`);
+          return context.error(`"${op2}" comparisons are not supported for type '${toString$1(lhs.type)}'.`, 1);
         }
         let rhs = context.parse(args[2], 2, ValueType);
         if (!rhs) return null;
         if (!isComparableType(op2, rhs.type)) {
-          return context.concat(2).error(`"${op2}" comparisons are not supported for type '${toString$1(rhs.type)}'.`);
+          return context.error(`"${op2}" comparisons are not supported for type '${toString$1(rhs.type)}'.`, 2);
         }
         if (lhs.type.kind !== rhs.type.kind && lhs.type.kind !== "value" && rhs.type.kind !== "value") {
           return context.error(`Cannot compare types '${toString$1(lhs.type)}' and '${toString$1(rhs.type)}'.`);
@@ -18234,7 +17879,7 @@
     const zoomDependent = zoomAndFeatureDependent || !featureDependent;
     const type = parameters.type || (supportsInterpolation(propertySpec) ? "exponential" : "interval");
     if (isColor) {
-      parameters = Object.assign({}, parameters);
+      parameters = { ...parameters };
       if (parameters.stops) {
         parameters.stops = parameters.stops.map((stop) => {
           return [stop[0], Color.parse(stop[1])];
@@ -19893,11 +19538,12 @@ ${JSON.stringify(filterExp, null, 2)}
       value: value.__line__,
       enumerable: false
     });
-    let errors = validateObject(Object.assign({}, options, {
+    let errors = validateObject({
+      ...options,
       value: importSpec,
       // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
       valueSpec: styleSpec.import
-    }));
+    });
     if (unbundle(importSpec.id) === "") {
       const key2 = `${options.key}.id`;
       errors.push(new ValidationError(key2, importSpec, `import id can't be an empty string`));
@@ -19918,7 +19564,8 @@ ${JSON.stringify(filterExp, null, 2)}
     const optionValue = options.value;
     const isArrayOption = isObject(optionValue) && unbundle(optionValue.array) === true;
     const declaredType = !isArrayOption && isObject(optionValue) ? unbundle(optionValue.type) : void 0;
-    return validateObject(Object.assign({}, options, {
+    return validateObject({
+      ...options,
       // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
       valueSpec: styleSpec.option,
       objectElementValidators: declaredType ? {
@@ -19926,11 +19573,9 @@ ${JSON.stringify(filterExp, null, 2)}
         // 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(Object.assign({}, elementOptions, {
-          valueSpec: Object.assign({}, elementOptions.valueSpec, { type: declaredType })
-        })) : validate(elementOptions)
+        default: (elementOptions) => Array.isArray(elementOptions.value) ? validate({ ...elementOptions, valueSpec: { ...elementOptions.valueSpec, type: declaredType } }) : validate(elementOptions)
       } : void 0
-    }));
+    });
   }
 
   function validateArray(options) {
@@ -20319,11 +19964,12 @@ ${JSON.stringify(filterExp, null, 2)}
   function validateFilter(options) {
     if (isExpressionFilter(deepUnbundle(options.value))) {
       const layerType = options.layerType || "fill";
-      return validateExpression(Object.assign({}, options, {
+      return validateExpression({
+        ...options,
         expressionContext: "filter",
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         valueSpec: options.styleSpec[`filter_${layerType}`]
-      }));
+      });
     } else {
       return validateNonExpressionFilter(options);
     }
@@ -20520,8 +20166,8 @@ Use an identity property function instead: ${example}.`
       style: options.style,
       styleSpec: options.styleSpec,
       objectElementValidators: {
-        condition: (options2) => validateCondition(Object.assign({ layer, layerType }, options2)),
-        properties: (options2) => validateProperties(Object.assign({ layer, layerType }, options2))
+        condition: (options2) => validateCondition({ ...options2 }),
+        properties: (options2) => validateProperties({ layer, layerType, ...options2 })
       }
     });
     if (name !== "hidden" && condition === void 0) {
@@ -20541,15 +20187,15 @@ Use an identity property function instead: ${example}.`
         errors.push(new ValidationError(options.key, propertyKey, `unknown property "${propertyKey}" for layer type "${layerType}"`));
         continue;
       }
-      const propertyValidationOptions = Object.assign({}, options, {
+      const propertyValidationOptions = {
+        ...options,
         key: `${options.key}.${propertyKey}`,
-        object: properties,
         objectKey: propertyKey,
         layer,
         layerType,
         value: properties[propertyKey],
         valueSpec: propertyType === "paint" ? paintProperties[propertyKey] : layoutProperties[propertyKey]
-      });
+      };
       errors.push(...validateProperty(propertyValidationOptions, propertyType));
     }
     return errors;
@@ -20671,7 +20317,7 @@ Use an identity property function instead: ${example}.`
           });
         },
         filter(options2) {
-          return validateFilter(Object.assign({ layerType: type }, options2));
+          return validateFilter({ layerType: type, ...options2 });
         },
         layout(options2) {
           return validateObject({
@@ -20683,7 +20329,7 @@ Use an identity property function instead: ${example}.`
             styleSpec: options2.styleSpec,
             objectElementValidators: {
               "*"(options3) {
-                return validateLayoutProperty(Object.assign({ layerType: type }, options3));
+                return validateLayoutProperty({ layerType: type, ...options3 });
               }
             }
           });
@@ -20698,7 +20344,7 @@ Use an identity property function instead: ${example}.`
             styleSpec: options2.styleSpec,
             objectElementValidators: {
               "*"(options3) {
-                return validatePaintProperty(Object.assign({ layerType: type, layer }, options3));
+                return validatePaintProperty({ layerType: type, layer, ...options3 });
               }
             }
           });
@@ -20710,7 +20356,7 @@ Use an identity property function instead: ${example}.`
             valueSpec: options2.valueSpec,
             style: options2.style,
             styleSpec: options2.styleSpec,
-            arrayElementValidator: (options3) => validateAppearance(Object.assign({ layerType: type, layer }, options3))
+            arrayElementValidator: (options3) => validateAppearance({ layerType: type, layer, ...options3 })
           });
           const appearances = Array.isArray(options2.value) ? options2.value : [];
           const dedupedNames = /* @__PURE__ */ new Set();
@@ -21272,10 +20918,11 @@ Use an identity property function instead: ${example}.`
       }
       return errors2;
     }
-    const errors = validateObject(Object.assign({}, options, {
+    const errors = validateObject({
+      ...options,
       // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
       valueSpec: valueSpec.type ? styleSpec[valueSpec.type] : valueSpec
-    }));
+    });
     return errors;
   }
 
@@ -21351,12 +20998,11 @@ Use an identity property function instead: ${example}.`
       key: options.key || "",
       value: style,
       // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-      valueSpec: Object.assign(
-        {},
-        styleSpec.$root,
+      valueSpec: {
+        ...styleSpec.$root,
         // Skip validation of the root properties that are not defined in the style spec (e.g. 'owner').
-        { "*": { type: "*" } }
-      ),
+        "*": { type: "*" }
+      },
       styleSpec,
       style,
       objectElementValidators: {