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

package/dist/index.d.ts

@@ -1498,39 +1498,52 @@ declare class Collator {
 	compare(lhs: string, rhs: string): number;
 	resolvedLocale(): string;
 }
-declare class ImageIdWithOptions {
-	id: string;
-	options: RasterizationOptions;
-	constructor(id: string, options?: RasterizationOptions);
-	static deserializeId(serialized: string): string;
-	static deserializeFromString(serialized: string): ImageIdWithOptions;
-	scaleSelf(factor: number): this;
-	serialize(): string;
+type Brand<T, U> = T & {
+	__brand: U;
+};
+type ImageIdSpec = {
+	name: string;
+	iconsetId?: string;
+};
+type StringifiedImageId = Brand<string, "ImageId">;
+declare class ImageId {
+	name: string;
+	iconsetId?: string;
+	constructor(id: string | ImageId | ImageIdSpec);
+	static from(id: string | ImageId | ImageIdSpec): ImageId;
+	static toString(id: ImageId | ImageIdSpec): StringifiedImageId;
+	static parse(str: StringifiedImageId): ImageId | null;
+	static isEqual(a: ImageId | ImageIdSpec, b: ImageId | ImageIdSpec): boolean;
+	toString(): StringifiedImageId;
+	serialize(): ImageIdSpec;
 }
+type StringifiedImageVariant = Brand<string, "ImageVariant">;
 type RasterizationOptions = {
-	params: Record<string, Color>;
+	params?: Record<string, Color>;
 	transform?: DOMMatrix;
 };
-type ResolvedImageOptions = {
-	namePrimary: string;
-	optionsPrimary: RasterizationOptions | null | undefined;
-	nameSecondary: string | null | undefined;
-	optionsSecondary: RasterizationOptions | null | undefined;
-	available: boolean;
-};
+declare class ImageVariant {
+	id: ImageId;
+	options: RasterizationOptions;
+	constructor(id: string | ImageIdSpec, options?: RasterizationOptions);
+	toString(): StringifiedImageVariant;
+	static parse(str: StringifiedImageVariant): ImageVariant | null;
+	scaleSelf(factor: number): this;
+}
 declare class ResolvedImage {
-	namePrimary: string;
-	optionsPrimary: RasterizationOptions | null | undefined;
-	nameSecondary: string | null | undefined;
-	optionsSecondary: RasterizationOptions | null | undefined;
+	primaryId: ImageId;
+	primaryOptions?: RasterizationOptions;
+	secondaryId?: ImageId;
+	secondaryOptions?: RasterizationOptions;
 	available: boolean;
-	constructor(options: ResolvedImageOptions);
+	constructor(primaryId: string | ImageIdSpec, primaryOptions?: RasterizationOptions, secondaryId?: string | ImageIdSpec, secondaryOptions?: RasterizationOptions, available?: boolean);
 	toString(): string;
-	getPrimary(): ImageIdWithOptions;
-	getSerializedPrimary(): string;
-	getSecondary(): ImageIdWithOptions | null;
+	hasPrimary(): boolean;
+	getPrimary(): ImageVariant;
+	hasSecondary(): boolean;
+	getSecondary(): ImageVariant | null;
 	static from(image: string | ResolvedImage): ResolvedImage;
-	static build(namePrimary: string, nameSecondary?: string | null, optionsPrimary?: RasterizationOptions | null, optionsSecondary?: RasterizationOptions | null): ResolvedImage | null;
+	static build(primaryId: string | ImageIdSpec, secondaryId?: string | ImageIdSpec, primaryOptions?: RasterizationOptions, secondaryOptions?: RasterizationOptions): ResolvedImage | null;
 }
 declare class FormattedSection {
 	text: string;
@@ -1656,7 +1669,7 @@ declare class EvaluationContext {
 	feature: Feature | null | undefined;
 	featureState: FeatureState | null | undefined;
 	formattedSection: FormattedSection | null | undefined;
-	availableImages: Array<string> | null | undefined;
+	availableImages: ImageId[] | null | undefined;
 	canonical: null | CanonicalTileID;
 	featureTileCoord: Point | null | undefined;
 	featureDistanceData: FeatureDistanceData | null | undefined;
@@ -1737,8 +1750,8 @@ declare class StyleExpression {
 	};
 	configDependencies: Set<string>;
 	constructor(expression: Expression, propertySpec?: StylePropertySpecification, scope?: string, options?: ConfigOptions);
-	evaluateWithoutErrorHandling(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection, featureTileCoord?: Point, featureDistanceData?: FeatureDistanceData): any;
-	evaluate(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection, featureTileCoord?: Point, featureDistanceData?: FeatureDistanceData): any;
+	evaluateWithoutErrorHandling(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: ImageId[], formattedSection?: FormattedSection, featureTileCoord?: Point, featureDistanceData?: FeatureDistanceData): any;
+	evaluate(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: ImageId[], formattedSection?: FormattedSection, featureTileCoord?: Point, featureDistanceData?: FeatureDistanceData): any;
 }
 declare function isExpression(expression: unknown): boolean;
 declare function createExpression(expression: unknown, propertySpec?: StylePropertySpecification | null, scope?: string | null, options?: ConfigOptions | null): Result<StyleExpression, Array<ParsingError$1>>;
@@ -1750,8 +1763,8 @@ declare class ZoomConstantExpression<Kind extends EvaluationKind> {
 	isLightConstant: boolean | null | undefined;
 	isLineProgressConstant: boolean | null | undefined;
 	constructor(kind: Kind, expression: StyleExpression, isLightConstant?: boolean | null, isLineProgressConstant?: boolean | null);
-	evaluateWithoutErrorHandling(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection): any;
-	evaluate(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection): any;
+	evaluateWithoutErrorHandling(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: ImageId[], formattedSection?: FormattedSection): any;
+	evaluate(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: ImageId[], formattedSection?: FormattedSection): any;
 }
 declare class ZoomDependentExpression<Kind extends EvaluationKind> {
 	kind: Kind;
@@ -1763,14 +1776,14 @@ declare class ZoomDependentExpression<Kind extends EvaluationKind> {
 	_styleExpression: StyleExpression;
 	interpolationType: InterpolationType | null | undefined;
 	constructor(kind: Kind, expression: StyleExpression, zoomStops: Array<number>, interpolationType?: InterpolationType, isLightConstant?: boolean | null, isLineProgressConstant?: boolean | null);
-	evaluateWithoutErrorHandling(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection): any;
-	evaluate(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection): any;
+	evaluateWithoutErrorHandling(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: ImageId[], formattedSection?: FormattedSection): any;
+	evaluate(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: ImageId[], formattedSection?: FormattedSection): any;
 	interpolationFactor(input: number, lower: number, upper: number): number;
 }
 type ConstantExpression = {
 	kind: "constant";
 	configDependencies: Set<string>;
-	readonly evaluate: (globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>) => any;
+	readonly evaluate: (globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: ImageId[]) => any;
 };
 type SourceExpression = {
 	kind: "source";
@@ -1778,13 +1791,13 @@ type SourceExpression = {
 	isLightConstant: boolean | null | undefined;
 	isLineProgressConstant: boolean | null | undefined;
 	configDependencies: Set<string>;
-	readonly evaluate: (globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection) => any;
+	readonly evaluate: (globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: ImageId[], formattedSection?: FormattedSection) => any;
 };
 type CameraExpression = {
 	kind: "camera";
 	isStateDependent: boolean;
 	configDependencies: Set<string>;
-	readonly evaluate: (globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>) => any;
+	readonly evaluate: (globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: ImageId[]) => any;
 	readonly interpolationFactor: (input: number, lower: number, upper: number) => number;
 	zoomStops: Array<number>;
 	interpolationType: InterpolationType | null | undefined;
@@ -1795,7 +1808,7 @@ interface CompositeExpression {
 	isLightConstant: boolean | null | undefined;
 	isLineProgressConstant: boolean | null | undefined;
 	configDependencies: Set<string>;
-	readonly evaluate: (globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection) => any;
+	readonly evaluate: (globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: ImageId[], formattedSection?: FormattedSection) => any;
 	readonly interpolationFactor: (input: number, lower: number, upper: number) => number;
 	zoomStops: Array<number>;
 	interpolationType: InterpolationType | null | undefined;

package/dist/index.es.js

@@ -3917,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": {
@@ -12441,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) {
@@ -12459,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;
             }
@@ -12485,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,
@@ -12499,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,
@@ -12510,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);
     }
 }
 
@@ -12987,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) {
@@ -13016,7 +13075,7 @@ class ImageExpression {
                 }
                 imageExpression.push({
                     image: imageName,
-                    options: void 0
+                    options: {}
                 });
                 return true;
             }
@@ -13024,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;
             }
@@ -13093,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]);
                     }
                 }
             }
@@ -13125,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;