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

package/dist/index.es.js

@@ -1294,6 +1294,24 @@ var modelNodeOverride = {
 		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",
@@ -1364,6 +1382,11 @@ var modelSourceModel = {
 		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,
@@ -6521,13 +6544,6 @@ var camera = {
 				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",
@@ -10936,6 +10952,7 @@ var v8 = {
 	source_video: source_video,
 	source_image: source_image,
 	modelNodeOverride: modelNodeOverride,
+	modelLightOverrides: modelLightOverrides,
 	modelNodeOverrides: modelNodeOverrides,
 	modelMaterialOverride: modelMaterialOverride,
 	modelMaterialOverrides: modelMaterialOverrides,
@@ -13980,7 +13997,7 @@ class CompoundExpression {
       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;
       }
@@ -14743,485 +14760,6 @@ class Within {
   }
 }
 
-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;
@@ -15295,6 +14833,77 @@ class TinyQueue {
 
 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;
 }
@@ -15360,7 +14969,7 @@ function getPolygonBBox(polygon) {
   }
   return bbox;
 }
-function bboxToBBoxDistance(bbox1, bbox2, ruler) {
+function bboxToBBoxDistance(bbox1, bbox2, kx, ky) {
   if (isDefaultBBOX(bbox1) || isDefaultBBOX(bbox2)) {
     return NaN;
   }
@@ -15378,7 +14987,7 @@ function bboxToBBoxDistance(bbox1, bbox2, ruler) {
   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);
@@ -15393,30 +15002,30 @@ function getLngLatPoints(coordinates, canonical) {
   }
   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;
   }
@@ -15424,24 +15033,24 @@ function lineToLineDistance(line1, range1, line2, range2, ruler) {
   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,
@@ -15456,13 +15065,13 @@ function pointToPolygonDistance(point, polygon, ruler) {
       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;
   }
@@ -15479,7 +15088,7 @@ function lineToPolygonDistance(line, range, polygon, ruler) {
     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));
       }
     }
   }
@@ -15498,10 +15107,10 @@ function polygonIntersect(polygon1, polygon2) {
   }
   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)) {
@@ -15515,20 +15124,20 @@ function polygonToPolygonDistance(polygon1, polygon2, ruler, currentMiniDist = I
       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,
@@ -15545,30 +15154,30 @@ function pointSetToPolygonDistance(pointSets, isLine, polygon, ruler, currentMin
     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,
@@ -15588,52 +15197,52 @@ function pointSetsDistance(pointSet1, isLine1, pointSet2, isLine2, ruler, curren
         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;
     }
@@ -15647,25 +15256,27 @@ function pointsToGeometryDistance(originGeometry, canonical, geometry) {
       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;
@@ -15679,19 +15290,20 @@ function linesToGeometryDistance(originGeometry, canonical, geometry) {
     }
     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;
     }
@@ -15704,7 +15316,8 @@ function linesToGeometryDistance(originGeometry, canonical, geometry) {
         lngLatLines[i],
         true,
         geometry.type === "Polygon" ? [geometry.coordinates] : geometry.coordinates,
-        ruler,
+        kx,
+        ky,
         dist
       );
       if (isNaN(tempDist)) return tempDist;
@@ -15723,19 +15336,20 @@ function polygonsToGeometryDistance(originGeometry, canonical, geometry) {
     }
     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;
     }
@@ -15745,7 +15359,8 @@ function polygonsToGeometryDistance(originGeometry, canonical, geometry) {
     return polygonsToPolygonsDistance(
       geometry.type === "Polygon" ? [geometry.coordinates] : geometry.coordinates,
       lngLatPolygons,
-      ruler
+      kx,
+      ky
     );
   }
   return null;
@@ -15857,18 +15472,21 @@ function isStateConstant(e) {
   });
   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) {
@@ -16035,16 +15653,12 @@ class ParsingContext {
     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
@@ -16055,7 +15669,17 @@ class ParsingContext {
    */
   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);
   }
@@ -16068,21 +15692,23 @@ class ParsingContext {
    * @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", []].`);
@@ -16131,9 +15757,10 @@ class ParsingContext {
    * @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,
@@ -16145,6 +15772,24 @@ class ParsingContext {
       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
@@ -16166,6 +15811,30 @@ class ParsingContext {
     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);
@@ -16192,7 +15861,7 @@ function isConstant(expression) {
   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) {
@@ -16957,24 +16626,23 @@ class Match {
       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;
       }
@@ -16987,7 +16655,7 @@ class Match {
     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);
@@ -17245,12 +16913,12 @@ function makeComparison(op, compareBasic, compareWithCollator) {
       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)}'.`);
@@ -18205,7 +17873,7 @@ function createFunction(parameters, propertySpec) {
   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])];
@@ -19864,11 +19532,12 @@ function validateImport(options) {
     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`));
@@ -19889,7 +19558,8 @@ 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;
-  return validateObject(Object.assign({}, options, {
+  return validateObject({
+    ...options,
     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     valueSpec: styleSpec.option,
     objectElementValidators: declaredType ? {
@@ -19897,11 +19567,9 @@ function validateOption(options) {
       // 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) {
@@ -20290,11 +19958,12 @@ function validateEnum(options) {
 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);
   }
@@ -20491,8 +20160,8 @@ function validateAppearance(options) {
     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) {
@@ -20512,15 +20181,15 @@ function validateProperties(options) {
       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;
@@ -20642,7 +20311,7 @@ function validateLayer(options) {
         });
       },
       filter(options2) {
-        return validateFilter(Object.assign({ layerType: type }, options2));
+        return validateFilter({ layerType: type, ...options2 });
       },
       layout(options2) {
         return validateObject({
@@ -20654,7 +20323,7 @@ function validateLayer(options) {
           styleSpec: options2.styleSpec,
           objectElementValidators: {
             "*"(options3) {
-              return validateLayoutProperty(Object.assign({ layerType: type }, options3));
+              return validateLayoutProperty({ layerType: type, ...options3 });
             }
           }
         });
@@ -20669,7 +20338,7 @@ function validateLayer(options) {
           styleSpec: options2.styleSpec,
           objectElementValidators: {
             "*"(options3) {
-              return validatePaintProperty(Object.assign({ layerType: type, layer }, options3));
+              return validatePaintProperty({ layerType: type, layer, ...options3 });
             }
           }
         });
@@ -20681,7 +20350,7 @@ function validateLayer(options) {
           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();
@@ -21243,10 +20912,11 @@ function validate(options, arrayAsExpression = false) {
     }
     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;
 }
 
@@ -21322,12 +20992,11 @@ function validateStyle$2(style, styleSpec = v8, options = {}) {
     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: {