@mapbox/mapbox-gl-style-spec 14.10.0 → 14.11.0-beta.2

package/dist/index.es.js

@@ -142,6 +142,17 @@ var $root = {
 			}
 		}
 	},
+	iconsets: {
+		experimental: true,
+		type: "iconsets",
+		doc: "A collection of icon sets",
+		"sdk-support": {
+			"basic functionality": {
+				android: "11.11.0",
+				ios: "11.11.0"
+			}
+		}
+	},
 	schema: {
 		type: "schema",
 		doc: "Definition of the schema for configuration options.",
@@ -683,6 +694,51 @@ var properties_light_flat = {
 		}
 	}
 };
+var iconsets = {
+	"*": {
+		type: "iconset",
+		doc: "Specification of an icon set. For sprite icon set, a URL must be provided. For `raster-array` source icon set, a source name must be provided."
+	}
+};
+var iconset = [
+	"iconset_sprite",
+	"iconset_source"
+];
+var iconset_sprite = {
+	type: {
+		required: true,
+		type: "enum",
+		values: {
+			sprite: {
+				doc: "A sprite icon set."
+			}
+		},
+		doc: "The type of the icon set."
+	},
+	url: {
+		required: true,
+		type: "string",
+		doc: "A base URL for retrieving the icon set and metadata. The extension `.pbf` will be automatically appended. The URL must be absolute, containing the [scheme, authority and path components](https://en.wikipedia.org/wiki/URL#Syntax).",
+		example: "mapbox://sprites/mapbox/bright"
+	}
+};
+var iconset_source = {
+	type: {
+		required: true,
+		type: "enum",
+		values: {
+			source: {
+				doc: "A source icon set."
+			}
+		},
+		doc: "The type of the icon set."
+	},
+	source: {
+		required: true,
+		type: "string",
+		doc: "Name of a source of `raster-array` type to be used for the icon set."
+	}
+};
 var sources = {
 	"*": {
 		type: "source",
@@ -1663,6 +1719,32 @@ var layout_fill = {
 			interpolated: false
 		},
 		"property-type": "data-constant"
+	},
+	"fill-construct-bridge-guard-rail": {
+		type: "boolean",
+		doc: "Determines whether bridge guard rails are added for elevated roads.",
+		"default": "true",
+		transition: false,
+		experimental: true,
+		"private": true,
+		"sdk-support": {
+			"basic functionality": {
+				android: "11.11.0",
+				ios: "11.11.0"
+			},
+			"data-driven styling": {
+				android: "11.11.0",
+				ios: "11.11.0"
+			}
+		},
+		expression: {
+			interpolated: false,
+			parameters: [
+				"zoom",
+				"feature"
+			]
+		},
+		"property-type": "data-driven"
 	}
 };
 var layout_circle = {
@@ -3835,7 +3917,7 @@ var expression_name = {
 			}
 		},
 		config: {
-			doc: "Retrieves the configuration value for the given option.",
+			doc: "Retrieves the configuration value for the given option. Returns null if the requested option is missing.",
 			group: "Lookup",
 			"sdk-support": {
 				"basic functionality": {
@@ -3878,6 +3960,17 @@ var expression_name = {
 				}
 			}
 		},
+		"at-interpolated": {
+			doc: "Retrieves an item from an array. If the array contains numeric values and the provided index is non-integer, the expression returns an interpolated value between adjacent items.",
+			group: "Lookup",
+			"sdk-support": {
+				"basic functionality": {
+					js: "3.11.0",
+					android: "11.12.0",
+					ios: "11.12.0"
+				}
+			}
+		},
 		"in": {
 			doc: "Determines whether an item exists in an array or a substring exists in a string. In the specific case when the second and third arguments are string literals, you must wrap at least one of them in a [`literal`](#types-literal) expression to hint correct interpretation to the [type system](#type-system).",
 			group: "Lookup",
@@ -4522,7 +4615,7 @@ var expression_name = {
 			}
 		},
 		sin: {
-			doc: "Returns the sine of the input.",
+			doc: "Returns the sine of the input, interpreted as radians.",
 			group: "Math",
 			"sdk-support": {
 				"basic functionality": {
@@ -4533,7 +4626,7 @@ var expression_name = {
 			}
 		},
 		cos: {
-			doc: "Returns the cosine of the input.",
+			doc: "Returns the cosine of the input, interpreted as radians.",
 			group: "Math",
 			"sdk-support": {
 				"basic functionality": {
@@ -4544,7 +4637,7 @@ var expression_name = {
 			}
 		},
 		tan: {
-			doc: "Returns the tangent of the input.",
+			doc: "Returns the tangent of the input, interpreted as radians.",
 			group: "Math",
 			"sdk-support": {
 				"basic functionality": {
@@ -4555,7 +4648,7 @@ var expression_name = {
 			}
 		},
 		asin: {
-			doc: "Returns the arcsine of the input.",
+			doc: "Returns the arcsine of the input, in radians between −π/2 and π/2.",
 			group: "Math",
 			"sdk-support": {
 				"basic functionality": {
@@ -4566,7 +4659,7 @@ var expression_name = {
 			}
 		},
 		acos: {
-			doc: "Returns the arccosine of the input.",
+			doc: "Returns the arccosine of the input, in radians between −π/2 and π/2.",
 			group: "Math",
 			"sdk-support": {
 				"basic functionality": {
@@ -4577,7 +4670,7 @@ var expression_name = {
 			}
 		},
 		atan: {
-			doc: "Returns the arctangent of the input.",
+			doc: "Returns the arctangent of the input, in radians between −π/2 and π/2.",
 			group: "Math",
 			"sdk-support": {
 				"basic functionality": {
@@ -6267,6 +6360,60 @@ var paint_fill = {
 			]
 		},
 		"property-type": "data-driven"
+	},
+	"fill-bridge-guard-rail-color": {
+		type: "color",
+		"default": "rgba(241, 236, 225, 255)",
+		doc: "The color of bridge guard rail.",
+		experimental: true,
+		"private": true,
+		transition: true,
+		"sdk-support": {
+			"basic functionality": {
+				android: "11.11.0",
+				ios: "11.11.0"
+			},
+			"data-driven styling": {
+				android: "11.11.0",
+				ios: "11.11.0"
+			}
+		},
+		expression: {
+			interpolated: true,
+			parameters: [
+				"zoom",
+				"measure-light",
+				"feature"
+			]
+		},
+		"property-type": "data-driven"
+	},
+	"fill-tunnel-structure-color": {
+		type: "color",
+		"default": "rgba(241, 236, 225, 255)",
+		doc: "The color of tunnel structures (tunnel entrance and tunnel walls).",
+		transition: true,
+		experimental: true,
+		"private": true,
+		"sdk-support": {
+			"basic functionality": {
+				android: "11.11.0",
+				ios: "11.11.0"
+			},
+			"data-driven styling": {
+				android: "11.11.0",
+				ios: "11.11.0"
+			}
+		},
+		expression: {
+			interpolated: true,
+			parameters: [
+				"zoom",
+				"measure-light",
+				"feature"
+			]
+		},
+		"property-type": "data-driven"
 	}
 };
 var paint_line = {
@@ -9421,6 +9568,10 @@ var v8 = {
 	properties_light_directional: properties_light_directional,
 	properties_light_ambient: properties_light_ambient,
 	properties_light_flat: properties_light_flat,
+	iconsets: iconsets,
+	iconset: iconset,
+	iconset_sprite: iconset_sprite,
+	iconset_source: iconset_source,
 	sources: sources,
 	source: source,
 	source_vector: source_vector,
@@ -12290,7 +12441,13 @@ class Formatted {
     isEmpty() {
         if (this.sections.length === 0)
             return true;
-        return !this.sections.some(section => section.text.length !== 0 || section.image && section.image.namePrimary);
+        return !this.sections.some(section => {
+            if (section.text.length !== 0)
+                return true;
+            if (!section.image)
+                return false;
+            return section.image.hasPrimary();
+        });
     }
     static factory(text) {
         if (text instanceof Formatted) {
@@ -12308,9 +12465,10 @@ class Formatted {
         const serialized = ['format'];
         for (const section of this.sections) {
             if (section.image) {
+                const primaryId = section.image.getPrimary().id.toString();
                 serialized.push([
                     'image',
-                    section.image.namePrimary
+                    primaryId
                 ]);
                 continue;
             }
@@ -12334,11 +12492,57 @@ class Formatted {
     }
 }
 
-class ImageIdWithOptions {
-    constructor(id, options) {
-        this.id = id;
-        this.options = options || { params: {} };
-        if (!this.options.transform) {
+class ImageId {
+    constructor(id) {
+        if (typeof id === 'string') {
+            this.name = id;
+        } else {
+            this.name = id.name;
+            this.iconsetId = id.iconsetId;
+        }
+    }
+    static from(id) {
+        return new ImageId(id);
+    }
+    static toString(id) {
+        return JSON.stringify({
+            name: id.name,
+            iconsetId: id.iconsetId
+        });
+    }
+    static parse(str) {
+        try {
+            const {name, iconsetId} = JSON.parse(str);
+            return new ImageId({
+                name,
+                iconsetId
+            });
+        } catch (e) {
+            return null;
+        }
+    }
+    static isEqual(a, b) {
+        return a.name === b.name && a.iconsetId === b.iconsetId;
+    }
+    toString() {
+        return JSON.stringify({
+            name: this.name,
+            iconsetId: this.iconsetId
+        });
+    }
+    serialize() {
+        return {
+            name: this.name,
+            iconsetId: this.iconsetId
+        };
+    }
+}
+
+class ImageVariant {
+    constructor(id, options = {}) {
+        this.id = ImageId.from(id);
+        this.options = Object.assign({}, options);
+        if (!options.transform) {
             this.options.transform = new DOMMatrix([
                 1,
                 0,
@@ -12348,7 +12552,7 @@ class ImageIdWithOptions {
                 0
             ]);
         } else {
-            const {a, b, c, d, e, f} = this.options.transform;
+            const {a, b, c, d, e, f} = options.transform;
             this.options.transform = new DOMMatrix([
                 a,
                 b,
@@ -12359,90 +12563,93 @@ class ImageIdWithOptions {
             ]);
         }
     }
-    static deserializeId(serialized) {
-        return JSON.parse(serialized).id;
+    toString() {
+        const {a, b, c, d, e, f} = this.options.transform;
+        const serialized = {
+            name: this.id.name,
+            iconsetId: this.id.iconsetId,
+            params: this.options.params,
+            transform: {
+                a,
+                b,
+                c,
+                d,
+                e,
+                f
+            }
+        };
+        return JSON.stringify(serialized);
     }
-    static deserializeFromString(serialized) {
-        const deserializedObject = JSON.parse(serialized);
-        ({ params: deserializedObject.options.params });
-        const {a, b, c, d, e, f} = deserializedObject.options.transform;
-        new DOMMatrix([
-            a,
-            b,
-            c,
-            d,
-            e,
-            f
-        ]);
-        return new ImageIdWithOptions(deserializedObject.id, deserializedObject.options);
+    static parse(str) {
+        let name, iconsetId, params, transform;
+        try {
+            ({name, iconsetId, params, transform} = JSON.parse(str) || {});
+        } catch (e2) {
+            return null;
+        }
+        if (!name)
+            return null;
+        const {a, b, c, d, e, f} = transform || {};
+        return new ImageVariant({
+            name,
+            iconsetId
+        }, {
+            params,
+            transform: new DOMMatrix([
+                a,
+                b,
+                c,
+                d,
+                e,
+                f
+            ])
+        });
     }
     scaleSelf(factor) {
-        this.options.transform = this.options.transform.scale(factor);
+        this.options.transform.scaleSelf(factor);
         return this;
     }
-    serialize() {
-        const serialisedObject = { id: this.id };
-        if (this.options) {
-            serialisedObject.options = this.options;
-        }
-        const {a, b, c, d, e, f} = this.options.transform;
-        serialisedObject.options.transform = {
-            a,
-            b,
-            c,
-            d,
-            e,
-            f
-        };
-        return JSON.stringify(serialisedObject);
-    }
 }
 
 class ResolvedImage {
-    constructor(options) {
-        this.namePrimary = options.namePrimary;
-        if (options.nameSecondary) {
-            this.nameSecondary = options.nameSecondary;
-        }
-        if (options.optionsPrimary) {
-            this.optionsPrimary = options.optionsPrimary;
-        }
-        if (options.optionsSecondary) {
-            this.optionsSecondary = options.optionsSecondary;
-        }
-        this.available = options.available;
+    constructor(primaryId, primaryOptions, secondaryId, secondaryOptions, available = false) {
+        this.primaryId = ImageId.from(primaryId);
+        this.primaryOptions = primaryOptions;
+        if (secondaryId)
+            this.secondaryId = ImageId.from(secondaryId);
+        this.secondaryOptions = secondaryOptions;
+        this.available = available;
     }
     toString() {
-        if (this.namePrimary && this.nameSecondary) {
-            return `[${ this.namePrimary },${ this.nameSecondary }]`;
+        if (this.primaryId && this.secondaryId) {
+            const primaryName = this.primaryId.name;
+            const secondaryName = this.secondaryId.name;
+            return `[${ primaryName },${ secondaryName }]`;
         }
-        return this.namePrimary;
+        return this.primaryId.name;
+    }
+    hasPrimary() {
+        return !!this.primaryId;
     }
     getPrimary() {
-        return new ImageIdWithOptions(this.namePrimary, { params: this.optionsPrimary ? this.optionsPrimary.params || {} : {} });
+        return new ImageVariant(this.primaryId, this.primaryOptions);
     }
-    getSerializedPrimary() {
-        return this.getPrimary().serialize();
+    hasSecondary() {
+        return !!this.secondaryId;
     }
     getSecondary() {
-        if (this.nameSecondary) {
-            return new ImageIdWithOptions(this.nameSecondary, { params: this.optionsSecondary ? this.optionsSecondary.params || {} : {} });
+        if (!this.secondaryId) {
+            return null;
         }
-        return null;
+        return new ImageVariant(this.secondaryId, this.secondaryOptions);
     }
     static from(image) {
-        return typeof image === 'string' ? ResolvedImage.build(image) : image;
+        return typeof image === 'string' ? ResolvedImage.build({ name: image }) : image;
     }
-    static build(namePrimary, nameSecondary, optionsPrimary, optionsSecondary) {
-        if (!namePrimary)
+    static build(primaryId, secondaryId, primaryOptions, secondaryOptions) {
+        if (!primaryId || typeof primaryId === 'object' && !('name' in primaryId))
             return null;
-        return new ResolvedImage({
-            namePrimary,
-            nameSecondary,
-            optionsPrimary,
-            optionsSecondary,
-            available: false
-        });
+        return new ResolvedImage(primaryId, primaryOptions, secondaryId, secondaryOptions);
     }
 }
 
@@ -12836,19 +13043,22 @@ class FormatExpression {
 }
 
 function isImageOptions(value) {
-    if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
-        return true;
-    }
-    return false;
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 class ImageExpression {
-    constructor(inputPrimary, inputSecondary, inputPrimaryParams, inputSecondaryParams) {
+    constructor(inputPrimary, inputSecondary, inputPrimaryOptions, inputSecondaryOptions) {
         this._imageWarnHistory = {};
         this.type = ResolvedImageType;
-        this.inputPrimary = inputPrimary;
-        this.inputSecondary = inputSecondary;
-        this.inputPrimaryParams = inputPrimaryParams;
-        this.inputSecondaryParams = inputSecondaryParams;
+        this.namePrimary = inputPrimary;
+        this.nameSecondary = inputSecondary;
+        if (inputPrimaryOptions) {
+            this.paramsPrimary = inputPrimaryOptions.params;
+            this.iconsetIdPrimary = inputPrimaryOptions.iconset ? inputPrimaryOptions.iconset.id : void 0;
+        }
+        if (inputSecondaryOptions) {
+            this.paramsSecondary = inputSecondaryOptions.params;
+            this.iconsetIdSecondary = inputSecondaryOptions.iconset ? inputSecondaryOptions.iconset.id : void 0;
+        }
     }
     static parse(args, context) {
         if (args.length < 2) {
@@ -12865,7 +13075,7 @@ class ImageExpression {
                 }
                 imageExpression.push({
                     image: imageName,
-                    options: void 0
+                    options: {}
                 });
                 return true;
             }
@@ -12873,33 +13083,48 @@ class ImageExpression {
         }
         function tryParseOptions() {
             if (nextArgId < args.length) {
-                if (!isImageOptions(args[nextArgId])) {
+                const options = args[nextArgId];
+                if (!isImageOptions(options)) {
                     return true;
                 }
-                const params = args[nextArgId].params;
+                const params = options.params;
+                const iconset = options.iconset;
                 const optionsContext = context.concat(nextArgId);
-                if (!params) {
+                if (!params && !iconset) {
                     nextArgId++;
                     return true;
                 }
-                if (typeof params !== 'object' || params.constructor !== Object) {
-                    optionsContext.error(`Image options "params" should be an object`);
-                    return false;
+                if (params) {
+                    if (typeof params !== 'object' || params.constructor !== Object) {
+                        optionsContext.error(`Image options "params" should be an object`);
+                        return false;
+                    }
+                    const parsedParams = {};
+                    const childContext = optionsContext.concat(void 0, 'params');
+                    for (const key in params) {
+                        if (!key) {
+                            childContext.error(`Image parameter name should be non-empty`);
+                            return false;
+                        }
+                        const value = childContext.concat(void 0, key).parse(params[key], void 0, ColorType, void 0, { typeAnnotation: 'coerce' });
+                        if (!value) {
+                            return false;
+                        }
+                        parsedParams[key] = value;
+                    }
+                    imageExpression[imageExpression.length - 1].options.params = parsedParams;
                 }
-                const parsed = {};
-                const childContext = optionsContext.concat(void 0, 'params');
-                for (const key in params) {
-                    if (!key) {
-                        childContext.error(`Image parameter name should be non-empty`);
+                if (iconset) {
+                    if (typeof iconset !== 'object' || iconset.constructor !== Object) {
+                        optionsContext.error(`Image options "iconset" should be an object`);
                         return false;
                     }
-                    const value = childContext.concat(void 0, key).parse(params[key], void 0, ColorType, void 0, { typeAnnotation: 'coerce' });
-                    if (!value) {
+                    if (!iconset.id) {
+                        optionsContext.error(`Image options "iconset" should have an "id" property`);
                         return false;
                     }
-                    parsed[key] = value;
+                    imageExpression[imageExpression.length - 1].options.iconset = iconset;
                 }
-                imageExpression[imageExpression.length - 1].options = parsed;
                 nextArgId++;
                 return true;
             }
@@ -12942,30 +13167,41 @@ class ImageExpression {
         return { params: result };
     }
     evaluate(ctx) {
-        const value = ResolvedImage.build(this.inputPrimary.evaluate(ctx), this.inputSecondary ? this.inputSecondary.evaluate(ctx) : void 0, this.inputPrimaryParams ? this.evaluateParams(ctx, this.inputPrimaryParams) : void 0, this.inputSecondaryParams ? this.evaluateParams(ctx, this.inputSecondaryParams) : void 0);
+        const primaryId = {
+            name: this.namePrimary.evaluate(ctx),
+            iconsetId: this.iconsetIdPrimary
+        };
+        const secondaryId = this.nameSecondary ? {
+            name: this.nameSecondary.evaluate(ctx),
+            iconsetId: this.iconsetIdSecondary
+        } : void 0;
+        const value = ResolvedImage.build(primaryId, secondaryId, this.paramsPrimary ? this.evaluateParams(ctx, this.paramsPrimary) : void 0, this.paramsSecondary ? this.evaluateParams(ctx, this.paramsSecondary) : void 0);
         if (value && ctx.availableImages) {
-            value.available = ctx.availableImages.indexOf(value.namePrimary) > -1;
-            if (value.nameSecondary && value.available && ctx.availableImages) {
-                value.available = ctx.availableImages.indexOf(value.nameSecondary) > -1;
+            const primaryId2 = value.getPrimary().id;
+            value.available = ctx.availableImages.some(id => ImageId.isEqual(id, primaryId2));
+            if (value.available) {
+                const secondaryId2 = value.getSecondary() ? value.getSecondary().id : null;
+                if (secondaryId2)
+                    value.available = ctx.availableImages.some(id => ImageId.isEqual(id, secondaryId2));
             }
         }
         return value;
     }
     eachChild(fn) {
-        fn(this.inputPrimary);
-        if (this.inputPrimaryParams) {
-            for (const key in this.inputPrimaryParams) {
-                if (this.inputPrimaryParams[key]) {
-                    fn(this.inputPrimaryParams[key]);
+        fn(this.namePrimary);
+        if (this.paramsPrimary) {
+            for (const key in this.paramsPrimary) {
+                if (this.paramsPrimary[key]) {
+                    fn(this.paramsPrimary[key]);
                 }
             }
         }
-        if (this.inputSecondary) {
-            fn(this.inputSecondary);
-            if (this.inputSecondaryParams) {
-                for (const key in this.inputSecondaryParams) {
-                    if (this.inputSecondaryParams[key]) {
-                        fn(this.inputSecondaryParams[key]);
+        if (this.nameSecondary) {
+            fn(this.nameSecondary);
+            if (this.paramsSecondary) {
+                for (const key in this.paramsSecondary) {
+                    if (this.paramsSecondary[key]) {
+                        fn(this.paramsSecondary[key]);
                     }
                 }
             }
@@ -12974,31 +13210,37 @@ class ImageExpression {
     outputDefined() {
         return false;
     }
-    serializeParams(params) {
+    serializeOptions(params, iconsetId) {
         const result = {};
+        if (iconsetId) {
+            result.iconset = { id: iconsetId };
+        }
         if (params) {
+            result.params = {};
             for (const key in params) {
                 if (params[key]) {
-                    result[key] = params[key].serialize();
+                    result.params[key] = params[key].serialize();
                 }
             }
-        } else {
-            return void 0;
         }
-        return { params: result };
+        return Object.keys(result).length > 0 ? result : void 0;
     }
     serialize() {
         const serialized = [
             'image',
-            this.inputPrimary.serialize()
+            this.namePrimary.serialize()
         ];
-        if (this.inputPrimaryParams) {
-            serialized.push(this.serializeParams(this.inputPrimaryParams));
+        if (this.paramsPrimary || this.iconsetIdPrimary) {
+            const options = this.serializeOptions(this.paramsPrimary, this.iconsetIdPrimary);
+            if (options)
+                serialized.push(options);
         }
-        if (this.inputSecondary) {
-            serialized.push(this.inputSecondary.serialize());
-            if (this.inputSecondaryParams) {
-                serialized.push(this.serializeParams(this.inputSecondaryParams));
+        if (this.nameSecondary) {
+            serialized.push(this.nameSecondary.serialize());
+            if (this.paramsSecondary || this.iconsetIdSecondary) {
+                const options = this.serializeOptions(this.paramsSecondary, this.iconsetIdSecondary);
+                if (options)
+                    serialized.push(options);
             }
         }
         return serialized;
@@ -14436,12 +14678,8 @@ function pointsToLineDistance(points, rangeA, line, rangeB, ruler) {
     return dist;
 }
 function segmentToSegmentDistance(p1, p2, q1, q2, ruler) {
-    const dist1 = Math.min(// @ts-expect-error - TS2345 - Argument of type 'Position' is not assignable to parameter of type 'Point'.
-    ruler.pointToSegmentDistance(p1, q1, q2), // @ts-expect-error - TS2345 - Argument of type 'Position' is not assignable to parameter of type 'Point'.
-    ruler.pointToSegmentDistance(p2, q1, q2));
-    const dist2 = Math.min(// @ts-expect-error - TS2345 - Argument of type 'Position' is not assignable to parameter of type 'Point'.
-    ruler.pointToSegmentDistance(q1, p1, p2), // @ts-expect-error - TS2345 - Argument of type 'Position' is not assignable to parameter of type 'Point'.
-    ruler.pointToSegmentDistance(q2, p1, p2));
+    const dist1 = Math.min(ruler.pointToSegmentDistance(p1, q1, q2), ruler.pointToSegmentDistance(p2, q1, q2));
+    const dist2 = Math.min(ruler.pointToSegmentDistance(q1, p1, p2), ruler.pointToSegmentDistance(q2, p1, p2));
     return Math.min(dist1, dist2);
 }
 function lineToLineDistance(line1, range1, line2, range2, ruler) {
@@ -15541,12 +15779,11 @@ var colorSpaces = /*#__PURE__*/Object.freeze({
 });
 
 class Interpolate {
-    constructor(type, operator, interpolation, input, dynamicStops, stops) {
+    constructor(type, operator, interpolation, input, stops) {
         this.type = type;
         this.operator = operator;
         this.interpolation = interpolation;
         this.input = input;
-        this.dynamicStops = dynamicStops;
         this.labels = [];
         this.outputs = [];
         for (const [label, expression] of stops) {
@@ -15594,8 +15831,8 @@ class Interpolate {
         } else {
             return context.error(`Unknown interpolation type ${ String(interpolation[0]) }`, 1, 0);
         }
-        if (args.length - 1 < 3) {
-            return context.error(`Expected at least 3 arguments, but found only ${ args.length - 1 }.`);
+        if (args.length - 1 < 4) {
+            return context.error(`Expected at least 4 arguments, but found only ${ args.length - 1 }.`);
         }
         if (args.length - 1 > 3 && (args.length - 1) % 2 !== 0) {
             return context.error(`Expected an even number of arguments.`);
@@ -15610,12 +15847,6 @@ class Interpolate {
         } else if (context.expectedType && context.expectedType.kind !== 'value') {
             outputType = context.expectedType;
         }
-        if (args.length - 1 === 3) {
-            const dynamicStops = context.parse(rest[0], 3, ValueType);
-            if (!dynamicStops)
-                return null;
-            return new Interpolate(outputType, operator, interpolation, input, dynamicStops, stops);
-        }
         for (let i = 0; i < rest.length; i += 2) {
             const label = rest[i];
             const value = rest[i + 1];
@@ -15639,34 +15870,11 @@ class Interpolate {
         if (outputType.kind !== 'number' && outputType.kind !== 'color' && !(outputType.kind === 'array' && outputType.itemType.kind === 'number' && typeof outputType.N === 'number')) {
             return context.error(`Type ${ toString$1(outputType) } is not interpolatable.`);
         }
-        return new Interpolate(outputType, operator, interpolation, input, null, stops);
+        return new Interpolate(outputType, operator, interpolation, input, stops);
     }
     evaluate(ctx) {
-        let labels = this.labels;
-        let outputs = this.outputs;
-        if (this.dynamicStops) {
-            const dynamicStopsValue = this.dynamicStops.evaluate(ctx);
-            if (dynamicStopsValue.length % 2 !== 0) {
-                throw new RuntimeError('Expected an even number of arguments.');
-            }
-            labels = [];
-            outputs = [];
-            for (let i = 0; i < dynamicStopsValue.length; i += 2) {
-                const label = dynamicStopsValue[i];
-                const output = new Literal(NumberType, dynamicStopsValue[i + 1]);
-                if (typeof label !== 'number') {
-                    throw new RuntimeError('Input/output pairs for "interpolate" expressions must be defined using literal numeric values (not computed expressions) for the input values.');
-                }
-                if (labels.length && labels[labels.length - 1] >= label) {
-                    throw new RuntimeError('Input/output pairs for "interpolate" expressions must be arranged with input values in strictly ascending order.');
-                }
-                labels.push(label);
-                outputs.push(output);
-            }
-            if (labels.length === 0) {
-                throw new RuntimeError('Expected at least one input/output pair.');
-            }
-        }
+        const labels = this.labels;
+        const outputs = this.outputs;
         if (labels.length === 1) {
             return outputs[0].evaluate(ctx);
         }
@@ -15715,19 +15923,18 @@ class Interpolate {
                 ];
             }
         } else {
-            interpolation = ['cubic-bezier'].concat(this.interpolation.controlPoints);
+            interpolation = [
+                'cubic-bezier',
+                ...this.interpolation.controlPoints
+            ];
         }
         const serialized = [
             this.operator,
             interpolation,
             this.input.serialize()
         ];
-        if (this.dynamicStops) {
-            serialized.push(this.dynamicStops.serialize());
-        } else {
-            for (let i = 0; i < this.labels.length; i++) {
-                serialized.push(this.labels[i], this.outputs[i].serialize());
-            }
+        for (let i = 0; i < this.labels.length; i++) {
+            serialized.push(this.labels[i], this.outputs[i].serialize());
         }
         return serialized;
     }
@@ -15874,6 +16081,52 @@ class At {
         const t = input.type;
         return new At(t.itemType, index, input);
     }
+    evaluate(ctx) {
+        const index = this.index.evaluate(ctx);
+        const array2 = this.input.evaluate(ctx);
+        if (index < 0) {
+            throw new RuntimeError(`Array index out of bounds: ${ index } < 0.`);
+        }
+        if (index >= array2.length) {
+            throw new RuntimeError(`Array index out of bounds: ${ index } > ${ array2.length - 1 }.`);
+        }
+        if (index !== Math.floor(index)) {
+            throw new RuntimeError(`Array index must be an integer, but found ${ index } instead. Use at-interpolated to retrieve interpolated result with a fractional index.`);
+        }
+        return array2[index];
+    }
+    eachChild(fn) {
+        fn(this.index);
+        fn(this.input);
+    }
+    outputDefined() {
+        return false;
+    }
+    serialize() {
+        return [
+            'at',
+            this.index.serialize(),
+            this.input.serialize()
+        ];
+    }
+}
+
+class AtInterpolated {
+    constructor(type, index, input) {
+        this.type = type;
+        this.index = index;
+        this.input = input;
+    }
+    static parse(args, context) {
+        if (args.length !== 3)
+            return context.error(`Expected 2 arguments, but found ${ args.length - 1 } instead.`);
+        const index = context.parse(args[1], 1, NumberType);
+        const input = context.parse(args[2], 2, array$1(context.expectedType || ValueType));
+        if (!index || !input)
+            return null;
+        const t = input.type;
+        return new AtInterpolated(t.itemType, index, input);
+    }
     evaluate(ctx) {
         const index = this.index.evaluate(ctx);
         const array2 = this.input.evaluate(ctx);
@@ -15905,7 +16158,7 @@ class At {
     }
     serialize() {
         return [
-            'at',
+            'at-interpolated',
             this.index.serialize(),
             this.input.serialize()
         ];
@@ -16607,6 +16860,7 @@ const expressions = {
     '<=': LessThanOrEqual,
     'array': Assertion,
     'at': At,
+    'at-interpolated': AtInterpolated,
     'boolean': Assertion,
     'case': Case,
     'coalesce': Coalesce,
@@ -17641,14 +17895,10 @@ function createPropertyExpression(expression, propertySpec, scope, options) {
         return error([new ParsingError$1('', '"interpolate" expressions cannot be used with this property')]);
     }
     if (!zoomCurve) {
-        return success(isFeatureConstant$1 && isLineProgressConstant ? // @ts-expect-error - TS2339 - Property 'value' does not exist on type 'unknown'.
-        new ZoomConstantExpression('constant', expression.value, isLightConstant, isLineProgressConstant) : // @ts-expect-error - TS2339 - Property 'value' does not exist on type 'unknown'.
-        new ZoomConstantExpression('source', expression.value, isLightConstant, isLineProgressConstant));
+        return success(isFeatureConstant$1 && isLineProgressConstant ? new ZoomConstantExpression('constant', expression.value, isLightConstant, isLineProgressConstant) : new ZoomConstantExpression('source', expression.value, isLightConstant, isLineProgressConstant));
     }
     const interpolationType = zoomCurve instanceof Interpolate ? zoomCurve.interpolation : void 0;
-    return success(isFeatureConstant$1 && isLineProgressConstant ? // @ts-expect-error - TS2339 - Property 'value' does not exist on type 'unknown'.
-    new ZoomDependentExpression('camera', expression.value, zoomCurve.labels, interpolationType, isLightConstant, isLineProgressConstant) : // @ts-expect-error - TS2339 - Property 'value' does not exist on type 'unknown'.
-    new ZoomDependentExpression('composite', expression.value, zoomCurve.labels, interpolationType, isLightConstant, isLineProgressConstant));
+    return success(isFeatureConstant$1 && isLineProgressConstant ? new ZoomDependentExpression('camera', expression.value, zoomCurve.labels, interpolationType, isLightConstant, isLineProgressConstant) : new ZoomDependentExpression('composite', expression.value, zoomCurve.labels, interpolationType, isLightConstant, isLineProgressConstant));
 }
 class StylePropertyFunction {
     constructor(parameters, specification) {
@@ -19987,7 +20237,6 @@ function validateLayer(options) {
                     valueSpec: styleSpec.layer.type,
                     style: options.style,
                     styleSpec: options.styleSpec,
-                    // @ts-expect-error - TS2353 - Object literal may only specify known properties, and 'object' does not exist in type 'ValidationOptions'.
                     object: layer,
                     objectKey: 'type'
                 });
@@ -19997,7 +20246,6 @@ function validateLayer(options) {
             },
             layout(options2) {
                 return validateObject({
-                    // @ts-expect-error - TS2353 - Object literal may only specify known properties, and 'layer' does not exist in type 'Options'.
                     layer,
                     key: options2.key,
                     value: options2.value,
@@ -20013,7 +20261,6 @@ function validateLayer(options) {
             },
             paint(options2) {
                 return validateObject({
-                    // @ts-expect-error - TS2353 - Object literal may only specify known properties, and 'layer' does not exist in type 'Options'.
                     layer,
                     key: options2.key,
                     value: options2.value,
@@ -20509,6 +20756,35 @@ function validateProjection(options) {
     return errors;
 }
 
+function validateIconset(options) {
+    const iconset = options.value;
+    const key = options.key;
+    const styleSpec = options.styleSpec;
+    const style = options.style;
+    if (!iconset.type) {
+        return [new ValidationError(key, iconset, '"type" is required')];
+    }
+    const type = unbundle(iconset.type);
+    let errors = [];
+    errors = errors.concat(validateObject({
+        key,
+        value: iconset,
+        valueSpec: styleSpec[`iconset_${ type }`],
+        style,
+        styleSpec
+    }));
+    if (type === 'source' && iconset.source) {
+        const source = style.sources && style.sources[iconset.source];
+        const sourceType = source && unbundle(source.type);
+        if (!source) {
+            errors.push(new ValidationError(key, iconset.source, `source "${ iconset.source }" not found`));
+        } else if (sourceType !== 'raster-array') {
+            errors.push(new ValidationError(key, iconset.source, `iconset cannot be used with a source of type ${ String(sourceType) }, it only be used with a "raster-array" source type`));
+        }
+    }
+    return errors;
+}
+
 const VALIDATORS = {
     '*'() {
         return [];
@@ -20532,7 +20808,8 @@ const VALIDATORS = {
     'formatted': validateFormatted,
     'resolvedImage': validateImage,
     'projection': validateProjection,
-    'import': validateImport
+    'import': validateImport,
+    'iconset': validateIconset
 };
 function validate(options, arrayAsExpression = false) {
     const value = options.value;
@@ -20577,7 +20854,6 @@ function validateStyle$2(style, styleSpec = v8, options = {}) {
         valueSpec: styleSpec.$root,
         styleSpec,
         style,
-        // @ts-expect-error - TS2353 - Object literal may only specify known properties, and 'objectElementValidators' does not exist in type 'ValidationOptions'.
         objectElementValidators: {
             glyphs: validateGlyphsURL,
             '*': () => []