@versatiles/png-renderer 2.5.0 → 2.6.0

package/dist/index.js

@@ -9830,6 +9830,21 @@ var v8_default = {
 			},
 			"property-type": "data-constant"
 		},
+		"raster-layer-blend": {
+			"type": "enum",
+			"values": {
+				"normal": {},
+				"multiply": {},
+				"color": {},
+				"luminosity": {},
+				"plus-lighter": {},
+				"screen": {},
+				"overlay": {}
+			},
+			"default": "normal",
+			"property-type": "constant",
+			"transition": false
+		},
 		"raster-hue-rotate": {
 			"type": "number",
 			"default": 0,
@@ -10193,6 +10208,40 @@ var v8_default = {
 // src/reference/latest.ts
 const latest = v8_default;
 
+// src/expression/parsing_error.ts
+var ExpressionParsingError = class extends Error {
+	constructor(key, message) {
+		super(message);
+		this.message = message;
+		this.key = key;
+	}
+};
+
+// src/expression/scope.ts
+/**
+* Tracks `let` bindings during expression parsing.
+* @private
+*/
+var Scope = class Scope {
+	constructor(parent, bindings = []) {
+		this.parent = parent;
+		this.bindings = {};
+		for (const [name, expression] of bindings) this.bindings[name] = expression;
+	}
+	concat(bindings) {
+		return new Scope(this, bindings);
+	}
+	get(name) {
+		if (this.bindings[name]) return this.bindings[name];
+		if (this.parent) return this.parent.get(name);
+		throw new Error(`${name} not found in scope.`);
+	}
+	has(name) {
+		if (this.bindings[name]) return true;
+		return this.parent ? this.parent.has(name) : false;
+	}
+};
+
 // src/expression/types.ts
 const NullType = { kind: "null" };
 const NumberType = { kind: "number" };
@@ -11464,6 +11513,25 @@ var Color$1 = class Color {
 	}
 };
 
+// src/expression/types/collator.ts
+var Collator = class {
+	constructor(caseSensitive, diacriticSensitive, locale) {
+		if (caseSensitive) this.sensitivity = diacriticSensitive ? "variant" : "case";
+		else this.sensitivity = diacriticSensitive ? "accent" : "base";
+		this.locale = locale;
+		this.collator = new Intl.Collator(this.locale ? this.locale : [], {
+			sensitivity: this.sensitivity,
+			usage: "search"
+		});
+	}
+	compare(lhs, rhs) {
+		return this.collator.compare(lhs, rhs);
+	}
+	resolvedLocale() {
+		return new Intl.Collator(this.locale ? this.locale : []).resolvedOptions().locale;
+	}
+};
+
 // src/expression/types/formatted.ts
 const VERTICAL_ALIGN_OPTIONS = [
 	"bottom",
@@ -11742,25 +11810,6 @@ var ProjectionDefinition = class ProjectionDefinition {
 	}
 };
 
-// src/expression/types/collator.ts
-var Collator = class {
-	constructor(caseSensitive, diacriticSensitive, locale) {
-		if (caseSensitive) this.sensitivity = diacriticSensitive ? "variant" : "case";
-		else this.sensitivity = diacriticSensitive ? "accent" : "base";
-		this.locale = locale;
-		this.collator = new Intl.Collator(this.locale ? this.locale : [], {
-			sensitivity: this.sensitivity,
-			usage: "search"
-		});
-	}
-	compare(lhs, rhs) {
-		return this.collator.compare(lhs, rhs);
-	}
-	resolvedLocale() {
-		return new Intl.Collator(this.locale ? this.locale : []).resolvedOptions().locale;
-	}
-};
-
 // src/expression/values.ts
 function validateRGBA(r, g, b, a) {
 	if (!(typeof r === "number" && r >= 0 && r <= 255 && typeof g === "number" && g >= 0 && g <= 255 && typeof b === "number" && b >= 0 && b <= 255)) return `Invalid rgba value [${(typeof a === "number" ? [
@@ -11852,539 +11901,100 @@ var Literal = class Literal {
 	}
 };
 
-// src/expression/evaluation_context.ts
-const geometryTypes = [
-	"Unknown",
-	"Point",
-	"LineString",
-	"Polygon"
-];
-var EvaluationContext = class {
-	constructor() {
-		this.globals = null;
-		this.feature = null;
-		this.featureState = null;
-		this.formattedSection = null;
-		this._parseColorCache = /* @__PURE__ */ new Map();
-		this.availableImages = null;
-		this.canonical = null;
-	}
-	id() {
-		return this.feature && "id" in this.feature ? this.feature.id : null;
-	}
-	geometryType() {
-		return this.feature ? typeof this.feature.type === "number" ? geometryTypes[this.feature.type] : this.feature.type : null;
+// src/expression/definitions/assertion.ts
+const types$1 = {
+	string: StringType,
+	number: NumberType,
+	boolean: BooleanType,
+	object: ObjectType
+};
+var Assertion = class Assertion {
+	constructor(type, args, key) {
+		this.type = type;
+		this.args = args;
+		this.key = key;
 	}
-	geometry() {
-		return this.feature && "geometry" in this.feature ? this.feature.geometry : null;
+	static parse(args, context) {
+		if (args.length < 2) return context.error("Expected at least one argument.");
+		let i = 1;
+		let type;
+		const name = args[0];
+		if (name === "array") {
+			let itemType;
+			if (args.length > 2) {
+				const type = args[1];
+				if (typeof type !== "string" || !(type in types$1) || type === "object") return context.error("The item type argument of \"array\" must be one of string, number, boolean", 1);
+				itemType = types$1[type];
+				i++;
+			} else itemType = ValueType;
+			let N;
+			if (args.length > 3) {
+				if (args[2] !== null && (typeof args[2] !== "number" || args[2] < 0 || args[2] !== Math.floor(args[2]))) return context.error("The length argument to \"array\" must be a positive integer literal", 2);
+				N = args[2];
+				i++;
+			}
+			type = array(itemType, N);
+		} else {
+			if (!types$1[name]) throw new Error(`Types doesn't contain name = ${name}`);
+			type = types$1[name];
+		}
+		const parsed = [];
+		for (; i < args.length; i++) {
+			const input = context.parse(args[i], i, ValueType);
+			if (!input) return null;
+			parsed.push(input);
+		}
+		return new Assertion(type, parsed, context.key);
 	}
-	canonicalID() {
-		return this.canonical;
+	evaluate(ctx) {
+		for (let i = 0; i < this.args.length; i++) {
+			const value = this.args[i].evaluate(ctx);
+			if (!checkSubtype(this.type, typeOf(value))) return value;
+			else if (i === this.args.length - 1) throw new RuntimeError(`Expected value to be of type ${typeToString(this.type)}, but found ${typeToString(typeOf(value))} instead.`, this.key);
+		}
+		throw new Error();
 	}
-	properties() {
-		return this.feature && this.feature.properties || {};
+	eachChild(fn) {
+		this.args.forEach(fn);
 	}
-	parseColor(input) {
-		let cached = this._parseColorCache.get(input);
-		if (!cached) {
-			cached = Color$1.parse(input);
-			this._parseColorCache.set(input, cached);
-		}
-		return cached;
+	outputDefined() {
+		return this.args.every((arg) => arg.outputDefined());
 	}
 };
 
-// src/expression/stops.ts
+// src/expression/definitions/coercion.ts
+const types = {
+	"to-boolean": BooleanType,
+	"to-color": ColorType,
+	"to-number": NumberType,
+	"to-string": StringType
+};
 /**
-* Returns the index of the last stop <= input, or 0 if it doesn't exist.
+* Special form for error-coalescing coercion expressions "to-number",
+* "to-color".  Since these coercions can fail at runtime, they accept multiple
+* arguments, only evaluating one at a time until one succeeds.
+*
 * @private
 */
-function findStopLessThanOrEqualTo(stops, input, key) {
-	const lastIndex = stops.length - 1;
-	let lowerIndex = 0;
-	let upperIndex = lastIndex;
-	let currentIndex = 0;
-	let currentValue, nextValue;
-	while (lowerIndex <= upperIndex) {
-		currentIndex = Math.floor((lowerIndex + upperIndex) / 2);
-		currentValue = stops[currentIndex];
-		nextValue = stops[currentIndex + 1];
-		if (currentValue <= input) {
-			if (currentIndex === lastIndex || input < nextValue) return currentIndex;
-			lowerIndex = currentIndex + 1;
-		} else if (currentValue > input) upperIndex = currentIndex - 1;
-		else throw new RuntimeError("Input is not a number.", key);
-	}
-	return 0;
-}
-
-// src/expression/definitions/step.ts
-var Step = class Step {
-	constructor(type, input, stops, key) {
+var Coercion = class Coercion {
+	constructor(type, args, key) {
 		this.type = type;
-		this.input = input;
+		this.args = args;
 		this.key = key;
-		this.labels = [];
-		this.outputs = [];
-		for (const [label, expression] of stops) {
-			this.labels.push(label);
-			this.outputs.push(expression);
-		}
 	}
 	static parse(args, context) {
-		if (args.length - 1 < 4) return context.error(`Expected at least 4 arguments, but found only ${args.length - 1}.`);
-		if ((args.length - 1) % 2 !== 0) return context.error("Expected an even number of arguments.");
-		const input = context.parse(args[1], 1, NumberType);
-		if (!input) return null;
-		const stops = [];
-		let outputType = null;
-		if (context.expectedType && context.expectedType.kind !== "value") outputType = context.expectedType;
-		for (let i = 1; i < args.length; i += 2) {
-			const label = i === 1 ? -Infinity : args[i];
-			const value = args[i + 1];
-			const labelKey = i;
-			const valueKey = i + 1;
-			if (typeof label !== "number") return context.error("Input/output pairs for \"step\" expressions must be defined using literal numeric values (not computed expressions) for the input values.", labelKey);
-			if (stops.length && stops[stops.length - 1][0] >= label) return context.error("Input/output pairs for \"step\" expressions must be arranged with input values in strictly ascending order.", labelKey);
-			const parsed = context.parse(value, valueKey, outputType);
-			if (!parsed) return null;
-			outputType = outputType || parsed.type;
-			stops.push([label, parsed]);
+		if (args.length < 2) return context.error("Expected at least one argument.");
+		const name = args[0];
+		if (!types[name]) throw new Error(`Can't parse ${name} as it is not part of the known types`);
+		if ((name === "to-boolean" || name === "to-string") && args.length !== 2) return context.error("Expected one argument.");
+		const type = types[name];
+		const parsed = [];
+		for (let i = 1; i < args.length; i++) {
+			const input = context.parse(args[i], i, ValueType);
+			if (!input) return null;
+			parsed.push(input);
 		}
-		return new Step(outputType, input, stops, context.key);
-	}
-	evaluate(ctx) {
-		const labels = this.labels;
-		const outputs = this.outputs;
-		if (labels.length === 1) return outputs[0].evaluate(ctx);
-		const value = this.input.evaluate(ctx);
-		if (value <= labels[0]) return outputs[0].evaluate(ctx);
-		const stopCount = labels.length;
-		if (value >= labels[stopCount - 1]) return outputs[stopCount - 1].evaluate(ctx);
-		return outputs[findStopLessThanOrEqualTo(labels, value, this.key)].evaluate(ctx);
-	}
-	eachChild(fn) {
-		fn(this.input);
-		for (const expression of this.outputs) fn(expression);
-	}
-	outputDefined() {
-		return this.outputs.every((out) => out.outputDefined());
-	}
-};
-
-// node_modules/@mapbox/unitbezier/index.js
-function unitBezier(p1x, p1y, p2x, p2y) {
-	const cx = 3 * p1x;
-	const bx = 3 * (p2x - p1x) - cx;
-	const ax = 1 - cx - bx;
-	const cy = 3 * p1y;
-	const by = 3 * (p2y - p1y) - cy;
-	const ay = 1 - cy - by;
-	return function solve(x, epsilon = 1e-6) {
-		if (x <= 0) return 0;
-		if (x >= 1) return 1;
-		let t = x;
-		for (let i = 0; i < 8; i++) {
-			const x2 = ((ax * t + bx) * t + cx) * t - x;
-			if (Math.abs(x2) < epsilon) return ((ay * t + by) * t + cy) * t;
-			const d2 = (3 * ax * t + 2 * bx) * t + cx;
-			if (Math.abs(d2) < 1e-6) break;
-			t -= x2 / d2;
-		}
-		let t0 = 0;
-		let t1 = 1;
-		t = x;
-		for (let i = 0; i < 20; i++) {
-			const x2 = ((ax * t + bx) * t + cx) * t;
-			if (Math.abs(x2 - x) < epsilon) break;
-			if (x > x2) t0 = t;
-			else t1 = t;
-			t = (t0 + t1) * .5;
-		}
-		return ((ay * t + by) * t + cy) * t;
-	};
-}
-
-// src/expression/definitions/interpolate.ts
-var Interpolate = class Interpolate {
-	constructor(type, operator, interpolation, input, stops, key) {
-		this.type = type;
-		this.operator = operator;
-		this.interpolation = interpolation;
-		this.input = input;
-		this.key = key;
-		this.labels = [];
-		this.outputs = [];
-		for (const [label, expression] of stops) {
-			this.labels.push(label);
-			this.outputs.push(expression);
-		}
-	}
-	static interpolationFactor(interpolation, input, lower, upper) {
-		let t = 0;
-		if (interpolation.name === "exponential") t = exponentialInterpolation(input, interpolation.base, lower, upper);
-		else if (interpolation.name === "linear") t = exponentialInterpolation(input, 1, lower, upper);
-		else if (interpolation.name === "cubic-bezier") {
-			const c = interpolation.controlPoints;
-			t = unitBezier(c[0], c[1], c[2], c[3])(exponentialInterpolation(input, 1, lower, upper));
-		}
-		return t;
-	}
-	static parse(args, context) {
-		let [operator, interpolation, input, ...rest] = args;
-		if (!Array.isArray(interpolation) || interpolation.length === 0) return context.error("Expected an interpolation type expression.", 1);
-		if (interpolation[0] === "linear") interpolation = { name: "linear" };
-		else if (interpolation[0] === "exponential") {
-			const base = interpolation[1];
-			if (typeof base !== "number") return context.error("Exponential interpolation requires a numeric base.", 1, 1);
-			interpolation = {
-				name: "exponential",
-				base
-			};
-		} else if (interpolation[0] === "cubic-bezier") {
-			const controlPoints = interpolation.slice(1);
-			if (controlPoints.length !== 4 || controlPoints.some((t) => typeof t !== "number" || t < 0 || t > 1)) return context.error("Cubic bezier interpolation requires four numeric arguments with values between 0 and 1.", 1);
-			interpolation = {
-				name: "cubic-bezier",
-				controlPoints
-			};
-		} else return context.error(`Unknown interpolation type ${String(interpolation[0])}`, 1, 0);
-		if (args.length - 1 < 4) return context.error(`Expected at least 4 arguments, but found only ${args.length - 1}.`);
-		if ((args.length - 1) % 2 !== 0) return context.error("Expected an even number of arguments.");
-		input = context.parse(input, 2, NumberType);
-		if (!input) return null;
-		const stops = [];
-		let outputType = null;
-		if ((operator === "interpolate-hcl" || operator === "interpolate-lab") && context.expectedType != ColorArrayType) outputType = ColorType;
-		else if (context.expectedType && context.expectedType.kind !== "value") outputType = context.expectedType;
-		for (let i = 0; i < rest.length; i += 2) {
-			const label = rest[i];
-			const value = rest[i + 1];
-			const labelKey = i + 3;
-			const valueKey = i + 4;
-			if (typeof label !== "number") return context.error("Input/output pairs for \"interpolate\" expressions must be defined using literal numeric values (not computed expressions) for the input values.", labelKey);
-			if (stops.length && stops[stops.length - 1][0] >= label) return context.error("Input/output pairs for \"interpolate\" expressions must be arranged with input values in strictly ascending order.", labelKey);
-			const parsed = context.parse(value, valueKey, outputType);
-			if (!parsed) return null;
-			outputType = outputType || parsed.type;
-			stops.push([label, parsed]);
-		}
-		if (!verifyType(outputType, NumberType) && !verifyType(outputType, ProjectionDefinitionType) && !verifyType(outputType, ColorType) && !verifyType(outputType, PaddingType) && !verifyType(outputType, NumberArrayType) && !verifyType(outputType, ColorArrayType) && !verifyType(outputType, VariableAnchorOffsetCollectionType) && !verifyType(outputType, array(NumberType))) return context.error(`Type ${typeToString(outputType)} is not interpolatable.`);
-		return new Interpolate(outputType, operator, interpolation, input, stops, context.key);
-	}
-	evaluate(ctx) {
-		const labels = this.labels;
-		const outputs = this.outputs;
-		if (labels.length === 1) return outputs[0].evaluate(ctx);
-		const value = this.input.evaluate(ctx);
-		if (value <= labels[0]) return outputs[0].evaluate(ctx);
-		const stopCount = labels.length;
-		if (value >= labels[stopCount - 1]) return outputs[stopCount - 1].evaluate(ctx);
-		const index = findStopLessThanOrEqualTo(labels, value, this.key);
-		const lower = labels[index];
-		const upper = labels[index + 1];
-		const t = Interpolate.interpolationFactor(this.interpolation, value, lower, upper);
-		const outputLower = outputs[index].evaluate(ctx);
-		const outputUpper = outputs[index + 1].evaluate(ctx);
-		switch (this.operator) {
-			case "interpolate": switch (this.type.kind) {
-				case "number": return interpolateNumber(outputLower, outputUpper, t);
-				case "color": return Color$1.interpolate(outputLower, outputUpper, t);
-				case "padding": return Padding.interpolate(outputLower, outputUpper, t);
-				case "colorArray": return ColorArray.interpolate(outputLower, outputUpper, t);
-				case "numberArray": return NumberArray.interpolate(outputLower, outputUpper, t);
-				case "variableAnchorOffsetCollection": return VariableAnchorOffsetCollection.interpolate(outputLower, outputUpper, t, this.key);
-				case "array": return interpolateArray(outputLower, outputUpper, t);
-				case "projectionDefinition": return ProjectionDefinition.interpolate(outputLower, outputUpper, t);
-			}
-			case "interpolate-hcl": switch (this.type.kind) {
-				case "color": return Color$1.interpolate(outputLower, outputUpper, t, "hcl");
-				case "colorArray": return ColorArray.interpolate(outputLower, outputUpper, t, "hcl");
-			}
-			case "interpolate-lab": switch (this.type.kind) {
-				case "color": return Color$1.interpolate(outputLower, outputUpper, t, "lab");
-				case "colorArray": return ColorArray.interpolate(outputLower, outputUpper, t, "lab");
-			}
-		}
-	}
-	eachChild(fn) {
-		fn(this.input);
-		for (const expression of this.outputs) fn(expression);
-	}
-	outputDefined() {
-		return this.outputs.every((out) => out.outputDefined());
-	}
-};
-/**
-* Returns a ratio that can be used to interpolate between exponential function
-* stops.
-* How it works: Two consecutive stop values define a (scaled and shifted) exponential function `f(x) = a * base^x + b`, where `base` is the user-specified base,
-* and `a` and `b` are constants affording sufficient degrees of freedom to fit
-* the function to the given stops.
-*
-* Here's a bit of algebra that lets us compute `f(x)` directly from the stop
-* values without explicitly solving for `a` and `b`:
-*
-* First stop value: `f(x0) = y0 = a * base^x0 + b`
-* Second stop value: `f(x1) = y1 = a * base^x1 + b`
-* => `y1 - y0 = a(base^x1 - base^x0)`
-* => `a = (y1 - y0)/(base^x1 - base^x0)`
-*
-* Desired value: `f(x) = y = a * base^x + b`
-* => `f(x) = y0 + a * (base^x - base^x0)`
-*
-* From the above, we can replace the `a` in `a * (base^x - base^x0)` and do a
-* little algebra:
-* ```
-* a * (base^x - base^x0) = (y1 - y0)/(base^x1 - base^x0) * (base^x - base^x0)
-*                     = (y1 - y0) * (base^x - base^x0) / (base^x1 - base^x0)
-* ```
-*
-* If we let `(base^x - base^x0) / (base^x1 base^x0)`, then we have
-* `f(x) = y0 + (y1 - y0) * ratio`.  In other words, `ratio` may be treated as
-* an interpolation factor between the two stops' output values.
-*
-* (Note: a slightly different form for `ratio`,
-* `(base^(x-x0) - 1) / (base^(x1-x0) - 1) `, is equivalent, but requires fewer
-* expensive `Math.pow()` operations.)
-*
-* @private
-*/
-function exponentialInterpolation(input, base, lowerValue, upperValue) {
-	const difference = upperValue - lowerValue;
-	const progress = input - lowerValue;
-	if (difference === 0) return 0;
-	else if (base === 1) return progress / difference;
-	else return (Math.pow(base, progress) - 1) / (Math.pow(base, difference) - 1);
-}
-const interpolateFactory = {
-	color: Color$1.interpolate,
-	number: interpolateNumber,
-	padding: Padding.interpolate,
-	numberArray: NumberArray.interpolate,
-	colorArray: ColorArray.interpolate,
-	variableAnchorOffsetCollection: VariableAnchorOffsetCollection.interpolate,
-	array: interpolateArray
-};
-
-// src/expression/definitions/format.ts
-var FormatExpression = class FormatExpression {
-	constructor(sections) {
-		this.type = FormattedType;
-		this.sections = sections;
-	}
-	static parse(args, context) {
-		if (args.length < 2) return context.error("Expected at least one argument.");
-		const firstArg = args[1];
-		if (!Array.isArray(firstArg) && typeof firstArg === "object") return context.error("First argument must be an image or text section.");
-		const sections = [];
-		let nextTokenMayBeObject = false;
-		for (let i = 1; i <= args.length - 1; ++i) {
-			const arg = args[i];
-			if (nextTokenMayBeObject && typeof arg === "object" && !Array.isArray(arg)) {
-				nextTokenMayBeObject = false;
-				let scale = null;
-				if (arg["font-scale"]) {
-					scale = context.parse(arg["font-scale"], 1, NumberType);
-					if (!scale) return null;
-				}
-				let font = null;
-				if (arg["text-font"]) {
-					font = context.parse(arg["text-font"], 1, array(StringType));
-					if (!font) return null;
-				}
-				let textColor = null;
-				if (arg["text-color"]) {
-					textColor = context.parse(arg["text-color"], 1, ColorType);
-					if (!textColor) return null;
-				}
-				let verticalAlign = null;
-				if (arg["vertical-align"]) {
-					if (typeof arg["vertical-align"] === "string" && !VERTICAL_ALIGN_OPTIONS.includes(arg["vertical-align"])) return context.error(`'vertical-align' must be one of: 'bottom', 'center', 'top' but found '${arg["vertical-align"]}' instead.`);
-					verticalAlign = context.parse(arg["vertical-align"], 1, StringType);
-					if (!verticalAlign) return null;
-				}
-				const lastExpression = sections[sections.length - 1];
-				lastExpression.scale = scale;
-				lastExpression.font = font;
-				lastExpression.textColor = textColor;
-				lastExpression.verticalAlign = verticalAlign;
-			} else {
-				const content = context.parse(args[i], 1, ValueType);
-				if (!content) return null;
-				const kind = content.type.kind;
-				if (kind !== "string" && kind !== "value" && kind !== "null" && kind !== "resolvedImage") return context.error("Formatted text type must be 'string', 'value', 'image' or 'null'.");
-				nextTokenMayBeObject = true;
-				sections.push({
-					content,
-					scale: null,
-					font: null,
-					textColor: null,
-					verticalAlign: null
-				});
-			}
-		}
-		return new FormatExpression(sections);
-	}
-	evaluate(ctx) {
-		const evaluateSection = (section) => {
-			const evaluatedContent = section.content.evaluate(ctx);
-			if (typeOf(evaluatedContent) === ResolvedImageType) return new FormattedSection("", evaluatedContent, null, null, null, section.verticalAlign ? section.verticalAlign.evaluate(ctx) : null);
-			return new FormattedSection(valueToString(evaluatedContent), null, section.scale ? section.scale.evaluate(ctx) : null, section.font ? section.font.evaluate(ctx).join(",") : null, section.textColor ? section.textColor.evaluate(ctx) : null, section.verticalAlign ? section.verticalAlign.evaluate(ctx) : null);
-		};
-		return new Formatted(this.sections.map(evaluateSection));
-	}
-	eachChild(fn) {
-		for (const section of this.sections) {
-			fn(section.content);
-			if (section.scale) fn(section.scale);
-			if (section.font) fn(section.font);
-			if (section.textColor) fn(section.textColor);
-			if (section.verticalAlign) fn(section.verticalAlign);
-		}
-	}
-	outputDefined() {
-		return false;
-	}
-};
-
-// src/util/classify_rings.ts
-/**
-* Classifies an array of rings into polygons with outer rings and holes
-* @param rings - the rings to classify
-* @param maxRings - the maximum number of rings to include in a polygon, use 0 to include all rings
-* @returns an array of polygons with internal rings as holes
-*/
-function classifyRings$1(rings, maxRings) {
-	if (rings.length <= 1) return [rings];
-	const polygons = [];
-	let polygon;
-	let ccw;
-	for (const ring of rings) {
-		const area = calculateSignedArea(ring);
-		if (area === 0) continue;
-		ring.area = Math.abs(area);
-		if (ccw === void 0) ccw = area < 0;
-		if (ccw === area < 0) {
-			if (polygon) polygons.push(polygon);
-			polygon = [ring];
-		} else polygon.push(ring);
-	}
-	if (polygon) polygons.push(polygon);
-	return polygons;
-}
-/**
-* Returns the signed area for the polygon ring.  Positive areas are exterior rings and
-* have a clockwise winding.  Negative areas are interior rings and have a counter clockwise
-* ordering.
-*
-* @param ring - Exterior or interior ring
-* @returns Signed area
-*/
-function calculateSignedArea(ring) {
-	let sum = 0;
-	for (let i = 0, len = ring.length, j = len - 1, p1, p2; i < len; j = i++) {
-		p1 = ring[i];
-		p2 = ring[j];
-		sum += (p2.x - p1.x) * (p1.y + p2.y);
-	}
-	return sum;
-}
-
-// src/expression/definitions/assertion.ts
-const types$1 = {
-	string: StringType,
-	number: NumberType,
-	boolean: BooleanType,
-	object: ObjectType
-};
-var Assertion = class Assertion {
-	constructor(type, args, key) {
-		this.type = type;
-		this.args = args;
-		this.key = key;
-	}
-	static parse(args, context) {
-		if (args.length < 2) return context.error("Expected at least one argument.");
-		let i = 1;
-		let type;
-		const name = args[0];
-		if (name === "array") {
-			let itemType;
-			if (args.length > 2) {
-				const type = args[1];
-				if (typeof type !== "string" || !(type in types$1) || type === "object") return context.error("The item type argument of \"array\" must be one of string, number, boolean", 1);
-				itemType = types$1[type];
-				i++;
-			} else itemType = ValueType;
-			let N;
-			if (args.length > 3) {
-				if (args[2] !== null && (typeof args[2] !== "number" || args[2] < 0 || args[2] !== Math.floor(args[2]))) return context.error("The length argument to \"array\" must be a positive integer literal", 2);
-				N = args[2];
-				i++;
-			}
-			type = array(itemType, N);
-		} else {
-			if (!types$1[name]) throw new Error(`Types doesn't contain name = ${name}`);
-			type = types$1[name];
-		}
-		const parsed = [];
-		for (; i < args.length; i++) {
-			const input = context.parse(args[i], i, ValueType);
-			if (!input) return null;
-			parsed.push(input);
-		}
-		return new Assertion(type, parsed, context.key);
-	}
-	evaluate(ctx) {
-		for (let i = 0; i < this.args.length; i++) {
-			const value = this.args[i].evaluate(ctx);
-			if (!checkSubtype(this.type, typeOf(value))) return value;
-			else if (i === this.args.length - 1) throw new RuntimeError(`Expected value to be of type ${typeToString(this.type)}, but found ${typeToString(typeOf(value))} instead.`, this.key);
-		}
-		throw new Error();
-	}
-	eachChild(fn) {
-		this.args.forEach(fn);
-	}
-	outputDefined() {
-		return this.args.every((arg) => arg.outputDefined());
-	}
-};
-
-// src/expression/definitions/coercion.ts
-const types = {
-	"to-boolean": BooleanType,
-	"to-color": ColorType,
-	"to-number": NumberType,
-	"to-string": StringType
-};
-/**
-* Special form for error-coalescing coercion expressions "to-number",
-* "to-color".  Since these coercions can fail at runtime, they accept multiple
-* arguments, only evaluating one at a time until one succeeds.
-*
-* @private
-*/
-var Coercion = class Coercion {
-	constructor(type, args, key) {
-		this.type = type;
-		this.args = args;
-		this.key = key;
-	}
-	static parse(args, context) {
-		if (args.length < 2) return context.error("Expected at least one argument.");
-		const name = args[0];
-		if (!types[name]) throw new Error(`Can't parse ${name} as it is not part of the known types`);
-		if ((name === "to-boolean" || name === "to-string") && args.length !== 2) return context.error("Expected one argument.");
-		const type = types[name];
-		const parsed = [];
-		for (let i = 1; i < args.length; i++) {
-			const input = context.parse(args[i], i, ValueType);
-			if (!input) return null;
-			parsed.push(input);
-		}
-		return new Coercion(type, parsed, context.key);
+		return new Coercion(type, parsed, context.key);
 	}
 	evaluate(ctx) {
 		switch (this.type.kind) {
@@ -12467,8 +12077,172 @@ var Coercion = class Coercion {
 	eachChild(fn) {
 		this.args.forEach(fn);
 	}
-	outputDefined() {
-		return this.args.every((arg) => arg.outputDefined());
+	outputDefined() {
+		return this.args.every((arg) => arg.outputDefined());
+	}
+};
+
+// src/expression/evaluation_context.ts
+const geometryTypes = [
+	"Unknown",
+	"Point",
+	"LineString",
+	"Polygon"
+];
+var EvaluationContext = class {
+	constructor() {
+		this.globals = null;
+		this.feature = null;
+		this.featureState = null;
+		this.formattedSection = null;
+		this._parseColorCache = /* @__PURE__ */ new Map();
+		this.availableImages = null;
+		this.canonical = null;
+	}
+	id() {
+		return this.feature && "id" in this.feature ? this.feature.id : null;
+	}
+	geometryType() {
+		return this.feature ? typeof this.feature.type === "number" ? geometryTypes[this.feature.type] : this.feature.type : null;
+	}
+	geometry() {
+		return this.feature && "geometry" in this.feature ? this.feature.geometry : null;
+	}
+	canonicalID() {
+		return this.canonical;
+	}
+	properties() {
+		return this.feature && this.feature.properties || {};
+	}
+	parseColor(input) {
+		let cached = this._parseColorCache.get(input);
+		if (!cached) {
+			cached = Color$1.parse(input);
+			this._parseColorCache.set(input, cached);
+		}
+		return cached;
+	}
+};
+
+// src/expression/parsing_context.ts
+/**
+* State associated parsing at a given point in an expression tree.
+* @private
+*/
+var ParsingContext = class ParsingContext {
+	constructor(registry, isConstantFunc, path = [], expectedType, scope = new Scope(), errors = []) {
+		this.registry = registry;
+		this.path = path;
+		this.key = path.map((part) => `[${part}]`).join("");
+		this.scope = scope;
+		this.errors = errors;
+		this.expectedType = expectedType;
+		this._isConstant = isConstantFunc;
+	}
+	/**
+	* @param expr the JSON expression to parse
+	* @param index the optional argument index if this expression is an argument of a parent expression that's being parsed
+	* @param options
+	* @param options.omitTypeAnnotations set true to omit inferred type annotations.  Caller beware: with this option set, the parsed expression's type will NOT satisfy `expectedType` if it would normally be wrapped in an inferred annotation.
+	* @private
+	*/
+	parse(expr, index, expectedType, bindings, options = {}) {
+		if (index != null) return this.concat(index, expectedType, bindings)._parse(expr, options);
+		return this._parse(expr, options);
+	}
+	_parse(expr, options) {
+		if (expr === null || typeof expr === "string" || typeof expr === "boolean" || typeof expr === "number") expr = ["literal", expr];
+		const key = this.key;
+		function annotate(parsed, type, typeAnnotation) {
+			if (typeAnnotation === "assert") return new Assertion(type, [parsed], key);
+			else if (typeAnnotation === "coerce") return new Coercion(type, [parsed], key);
+			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\", []].");
+			const op = expr[0];
+			if (typeof op !== "string") {
+				this.error(`Expression name must be a string, but found ${typeof op} instead. If you wanted a literal array, use ["literal", [...]].`, 0);
+				return null;
+			}
+			const Expr = this.registry[op];
+			if (Expr) {
+				let parsed = Expr.parse(expr, this);
+				if (!parsed) return null;
+				if (this.expectedType) {
+					const expected = this.expectedType;
+					const actual = parsed.type;
+					if ((expected.kind === "string" || expected.kind === "number" || expected.kind === "boolean" || expected.kind === "object" || expected.kind === "array") && actual.kind === "value") parsed = annotate(parsed, expected, options.typeAnnotation || "assert");
+					else if ("projectionDefinition" === expected.kind && [
+						"string",
+						"array",
+						"value"
+					].includes(actual.kind) || [
+						"color",
+						"formatted",
+						"resolvedImage"
+					].includes(expected.kind) && ["value", "string"].includes(actual.kind) || ["padding", "numberArray"].includes(expected.kind) && [
+						"value",
+						"number",
+						"array"
+					].includes(actual.kind) || "colorArray" === expected.kind && [
+						"value",
+						"string",
+						"array"
+					].includes(actual.kind) || "variableAnchorOffsetCollection" === expected.kind && ["value", "array"].includes(actual.kind)) parsed = annotate(parsed, expected, options.typeAnnotation || "coerce");
+					else if (this.checkSubtype(expected, actual)) return null;
+				}
+				if (!(parsed instanceof Literal) && parsed.type.kind !== "resolvedImage" && this._isConstant(parsed)) {
+					const ec = new EvaluationContext();
+					try {
+						parsed = new Literal(parsed.type, parsed.evaluate(ec));
+					} catch (e) {
+						this.error(e.message);
+						return null;
+					}
+				}
+				return parsed;
+			}
+			return this.error(`Unknown expression "${op}". If you wanted a literal array, use ["literal", [...]].`, 0);
+		} else if (typeof expr === "undefined") return this.error("'undefined' value invalid. Use null instead.");
+		else if (typeof expr === "object") return this.error("Bare objects invalid. Use [\"literal\", {...}] instead.");
+		else return this.error(`Expected an array, but found ${typeof expr} instead.`);
+	}
+	/**
+	* Returns a copy of this context suitable for parsing the subexpression at
+	* index `index`, optionally appending to 'let' binding map.
+	*
+	* Note that `errors` property, intended for collecting errors while
+	* parsing, is copied by reference rather than cloned.
+	* @private
+	*/
+	concat(index, expectedType, bindings) {
+		const path = typeof index === "number" ? this.path.concat(index) : this.path;
+		const scope = bindings ? this.scope.concat(bindings) : this.scope;
+		return new ParsingContext(this.registry, this._isConstant, path, expectedType || null, scope, this.errors);
+	}
+	/**
+	* Push a parsing (or type checking) error into the `this.errors`
+	* @param error The message
+	* @param keys Optionally specify the source of the error at a child
+	* of the current expression at `this.key`.
+	* @private
+	*/
+	error(error, ...keys) {
+		const key = `${this.key}${keys.map((k) => `[${k}]`).join("")}`;
+		this.errors.push(new ExpressionParsingError(key, error));
+	}
+	/**
+	* Returns null if `t` is a subtype of `expected`; otherwise returns an
+	* error message and also pushes it to `this.errors`.
+	* @param expected The expected type
+	* @param t The actual type
+	* @returns null if `t` is a subtype of `expected`; otherwise returns an error message
+	*/
+	checkSubtype(expected, t) {
+		const error = checkSubtype(expected, t);
+		if (error) this.error(error);
+		return error;
 	}
 };
 
@@ -12740,70 +12514,343 @@ var Case = class Case {
 			branches.push([test, result]);
 			outputType = outputType || result.type;
 		}
-		const otherwise = context.parse(args[args.length - 1], args.length - 1, outputType);
-		if (!otherwise) return null;
-		if (!outputType) throw new Error("Can't infer output type");
-		return new Case(outputType, branches, otherwise);
+		const otherwise = context.parse(args[args.length - 1], args.length - 1, outputType);
+		if (!otherwise) return null;
+		if (!outputType) throw new Error("Can't infer output type");
+		return new Case(outputType, branches, otherwise);
+	}
+	evaluate(ctx) {
+		for (const [test, expression] of this.branches) if (test.evaluate(ctx)) return expression.evaluate(ctx);
+		return this.otherwise.evaluate(ctx);
+	}
+	eachChild(fn) {
+		for (const [test, expression] of this.branches) {
+			fn(test);
+			fn(expression);
+		}
+		fn(this.otherwise);
+	}
+	outputDefined() {
+		return this.branches.every(([_, out]) => out.outputDefined()) && this.otherwise.outputDefined();
+	}
+};
+
+// src/expression/definitions/slice.ts
+var Slice = class Slice {
+	constructor(type, input, beginIndex, key, endIndex) {
+		this.type = type;
+		this.input = input;
+		this.beginIndex = beginIndex;
+		this.key = key;
+		this.endIndex = endIndex;
+	}
+	static parse(args, context) {
+		if (args.length <= 2 || args.length >= 5) return context.error(`Expected 2 or 3 arguments, but found ${args.length - 1} instead.`);
+		const input = context.parse(args[1], 1, ValueType);
+		const beginIndex = context.parse(args[2], 2, NumberType);
+		if (!input || !beginIndex) return null;
+		if (!isValidType(input.type, [
+			array(ValueType),
+			StringType,
+			ValueType
+		])) return context.error(`Expected first argument to be of type array or string, but found ${typeToString(input.type)} instead`);
+		if (args.length === 4) {
+			const endIndex = context.parse(args[3], 3, NumberType);
+			if (!endIndex) return null;
+			return new Slice(input.type, input, beginIndex, context.key, endIndex);
+		} else return new Slice(input.type, input, beginIndex, context.key);
+	}
+	evaluate(ctx) {
+		const input = this.input.evaluate(ctx);
+		const beginIndex = this.beginIndex.evaluate(ctx);
+		let endIndex;
+		if (this.endIndex) endIndex = this.endIndex.evaluate(ctx);
+		if (isValidNativeType(input, ["string"])) return [...input].slice(beginIndex, endIndex).join("");
+		else if (isValidNativeType(input, ["array"])) return input.slice(beginIndex, endIndex);
+		else throw new RuntimeError(`Expected first argument to be of type array or string, but found ${typeToString(typeOf(input))} instead.`, this.key);
+	}
+	eachChild(fn) {
+		fn(this.input);
+		fn(this.beginIndex);
+		if (this.endIndex) fn(this.endIndex);
+	}
+	outputDefined() {
+		return false;
+	}
+};
+
+// src/expression/stops.ts
+/**
+* Returns the index of the last stop <= input, or 0 if it doesn't exist.
+* @private
+*/
+function findStopLessThanOrEqualTo(stops, input, key) {
+	const lastIndex = stops.length - 1;
+	let lowerIndex = 0;
+	let upperIndex = lastIndex;
+	let currentIndex = 0;
+	let currentValue, nextValue;
+	while (lowerIndex <= upperIndex) {
+		currentIndex = Math.floor((lowerIndex + upperIndex) / 2);
+		currentValue = stops[currentIndex];
+		nextValue = stops[currentIndex + 1];
+		if (currentValue <= input) {
+			if (currentIndex === lastIndex || input < nextValue) return currentIndex;
+			lowerIndex = currentIndex + 1;
+		} else if (currentValue > input) upperIndex = currentIndex - 1;
+		else throw new RuntimeError("Input is not a number.", key);
+	}
+	return 0;
+}
+
+// src/expression/definitions/step.ts
+var Step = class Step {
+	constructor(type, input, stops, key) {
+		this.type = type;
+		this.input = input;
+		this.key = key;
+		this.labels = [];
+		this.outputs = [];
+		for (const [label, expression] of stops) {
+			this.labels.push(label);
+			this.outputs.push(expression);
+		}
+	}
+	static parse(args, context) {
+		if (args.length - 1 < 4) return context.error(`Expected at least 4 arguments, but found only ${args.length - 1}.`);
+		if ((args.length - 1) % 2 !== 0) return context.error("Expected an even number of arguments.");
+		const input = context.parse(args[1], 1, NumberType);
+		if (!input) return null;
+		const stops = [];
+		let outputType = null;
+		if (context.expectedType && context.expectedType.kind !== "value") outputType = context.expectedType;
+		for (let i = 1; i < args.length; i += 2) {
+			const label = i === 1 ? -Infinity : args[i];
+			const value = args[i + 1];
+			const labelKey = i;
+			const valueKey = i + 1;
+			if (typeof label !== "number") return context.error("Input/output pairs for \"step\" expressions must be defined using literal numeric values (not computed expressions) for the input values.", labelKey);
+			if (stops.length && stops[stops.length - 1][0] >= label) return context.error("Input/output pairs for \"step\" expressions must be arranged with input values in strictly ascending order.", labelKey);
+			const parsed = context.parse(value, valueKey, outputType);
+			if (!parsed) return null;
+			outputType = outputType || parsed.type;
+			stops.push([label, parsed]);
+		}
+		return new Step(outputType, input, stops, context.key);
+	}
+	evaluate(ctx) {
+		const labels = this.labels;
+		const outputs = this.outputs;
+		if (labels.length === 1) return outputs[0].evaluate(ctx);
+		const value = this.input.evaluate(ctx);
+		if (value <= labels[0]) return outputs[0].evaluate(ctx);
+		const stopCount = labels.length;
+		if (value >= labels[stopCount - 1]) return outputs[stopCount - 1].evaluate(ctx);
+		return outputs[findStopLessThanOrEqualTo(labels, value, this.key)].evaluate(ctx);
+	}
+	eachChild(fn) {
+		fn(this.input);
+		for (const expression of this.outputs) fn(expression);
+	}
+	outputDefined() {
+		return this.outputs.every((out) => out.outputDefined());
+	}
+};
+
+// node_modules/@mapbox/unitbezier/index.js
+function unitBezier(p1x, p1y, p2x, p2y) {
+	const cx = 3 * p1x;
+	const bx = 3 * (p2x - p1x) - cx;
+	const ax = 1 - cx - bx;
+	const cy = 3 * p1y;
+	const by = 3 * (p2y - p1y) - cy;
+	const ay = 1 - cy - by;
+	return function solve(x, epsilon = 1e-6) {
+		if (x <= 0) return 0;
+		if (x >= 1) return 1;
+		let t = x;
+		for (let i = 0; i < 8; i++) {
+			const x2 = ((ax * t + bx) * t + cx) * t - x;
+			if (Math.abs(x2) < epsilon) return ((ay * t + by) * t + cy) * t;
+			const d2 = (3 * ax * t + 2 * bx) * t + cx;
+			if (Math.abs(d2) < 1e-6) break;
+			t -= x2 / d2;
+		}
+		let t0 = 0;
+		let t1 = 1;
+		t = x;
+		for (let i = 0; i < 20; i++) {
+			const x2 = ((ax * t + bx) * t + cx) * t;
+			if (Math.abs(x2 - x) < epsilon) break;
+			if (x > x2) t0 = t;
+			else t1 = t;
+			t = (t0 + t1) * .5;
+		}
+		return ((ay * t + by) * t + cy) * t;
+	};
+}
+
+// src/expression/definitions/interpolate.ts
+var Interpolate = class Interpolate {
+	constructor(type, operator, interpolation, input, stops, key) {
+		this.type = type;
+		this.operator = operator;
+		this.interpolation = interpolation;
+		this.input = input;
+		this.key = key;
+		this.labels = [];
+		this.outputs = [];
+		for (const [label, expression] of stops) {
+			this.labels.push(label);
+			this.outputs.push(expression);
+		}
+	}
+	static interpolationFactor(interpolation, input, lower, upper) {
+		let t = 0;
+		if (interpolation.name === "exponential") t = exponentialInterpolation(input, interpolation.base, lower, upper);
+		else if (interpolation.name === "linear") t = exponentialInterpolation(input, 1, lower, upper);
+		else if (interpolation.name === "cubic-bezier") {
+			const c = interpolation.controlPoints;
+			t = unitBezier(c[0], c[1], c[2], c[3])(exponentialInterpolation(input, 1, lower, upper));
+		}
+		return t;
+	}
+	static parse(args, context) {
+		let [operator, interpolation, input, ...rest] = args;
+		if (!Array.isArray(interpolation) || interpolation.length === 0) return context.error("Expected an interpolation type expression.", 1);
+		if (interpolation[0] === "linear") interpolation = { name: "linear" };
+		else if (interpolation[0] === "exponential") {
+			const base = interpolation[1];
+			if (typeof base !== "number") return context.error("Exponential interpolation requires a numeric base.", 1, 1);
+			interpolation = {
+				name: "exponential",
+				base
+			};
+		} else if (interpolation[0] === "cubic-bezier") {
+			const controlPoints = interpolation.slice(1);
+			if (controlPoints.length !== 4 || controlPoints.some((t) => typeof t !== "number" || t < 0 || t > 1)) return context.error("Cubic bezier interpolation requires four numeric arguments with values between 0 and 1.", 1);
+			interpolation = {
+				name: "cubic-bezier",
+				controlPoints
+			};
+		} else return context.error(`Unknown interpolation type ${String(interpolation[0])}`, 1, 0);
+		if (args.length - 1 < 4) return context.error(`Expected at least 4 arguments, but found only ${args.length - 1}.`);
+		if ((args.length - 1) % 2 !== 0) return context.error("Expected an even number of arguments.");
+		input = context.parse(input, 2, NumberType);
+		if (!input) return null;
+		const stops = [];
+		let outputType = null;
+		if ((operator === "interpolate-hcl" || operator === "interpolate-lab") && context.expectedType != ColorArrayType) outputType = ColorType;
+		else if (context.expectedType && context.expectedType.kind !== "value") outputType = context.expectedType;
+		for (let i = 0; i < rest.length; i += 2) {
+			const label = rest[i];
+			const value = rest[i + 1];
+			const labelKey = i + 3;
+			const valueKey = i + 4;
+			if (typeof label !== "number") return context.error("Input/output pairs for \"interpolate\" expressions must be defined using literal numeric values (not computed expressions) for the input values.", labelKey);
+			if (stops.length && stops[stops.length - 1][0] >= label) return context.error("Input/output pairs for \"interpolate\" expressions must be arranged with input values in strictly ascending order.", labelKey);
+			const parsed = context.parse(value, valueKey, outputType);
+			if (!parsed) return null;
+			outputType = outputType || parsed.type;
+			stops.push([label, parsed]);
+		}
+		if (!verifyType(outputType, NumberType) && !verifyType(outputType, ProjectionDefinitionType) && !verifyType(outputType, ColorType) && !verifyType(outputType, PaddingType) && !verifyType(outputType, NumberArrayType) && !verifyType(outputType, ColorArrayType) && !verifyType(outputType, VariableAnchorOffsetCollectionType) && !verifyType(outputType, array(NumberType))) return context.error(`Type ${typeToString(outputType)} is not interpolatable.`);
+		return new Interpolate(outputType, operator, interpolation, input, stops, context.key);
 	}
 	evaluate(ctx) {
-		for (const [test, expression] of this.branches) if (test.evaluate(ctx)) return expression.evaluate(ctx);
-		return this.otherwise.evaluate(ctx);
-	}
-	eachChild(fn) {
-		for (const [test, expression] of this.branches) {
-			fn(test);
-			fn(expression);
+		const labels = this.labels;
+		const outputs = this.outputs;
+		if (labels.length === 1) return outputs[0].evaluate(ctx);
+		const value = this.input.evaluate(ctx);
+		if (value <= labels[0]) return outputs[0].evaluate(ctx);
+		const stopCount = labels.length;
+		if (value >= labels[stopCount - 1]) return outputs[stopCount - 1].evaluate(ctx);
+		const index = findStopLessThanOrEqualTo(labels, value, this.key);
+		const lower = labels[index];
+		const upper = labels[index + 1];
+		const t = Interpolate.interpolationFactor(this.interpolation, value, lower, upper);
+		const outputLower = outputs[index].evaluate(ctx);
+		const outputUpper = outputs[index + 1].evaluate(ctx);
+		switch (this.operator) {
+			case "interpolate": switch (this.type.kind) {
+				case "number": return interpolateNumber(outputLower, outputUpper, t);
+				case "color": return Color$1.interpolate(outputLower, outputUpper, t);
+				case "padding": return Padding.interpolate(outputLower, outputUpper, t);
+				case "colorArray": return ColorArray.interpolate(outputLower, outputUpper, t);
+				case "numberArray": return NumberArray.interpolate(outputLower, outputUpper, t);
+				case "variableAnchorOffsetCollection": return VariableAnchorOffsetCollection.interpolate(outputLower, outputUpper, t, this.key);
+				case "array": return interpolateArray(outputLower, outputUpper, t);
+				case "projectionDefinition": return ProjectionDefinition.interpolate(outputLower, outputUpper, t);
+			}
+			case "interpolate-hcl": switch (this.type.kind) {
+				case "color": return Color$1.interpolate(outputLower, outputUpper, t, "hcl");
+				case "colorArray": return ColorArray.interpolate(outputLower, outputUpper, t, "hcl");
+			}
+			case "interpolate-lab": switch (this.type.kind) {
+				case "color": return Color$1.interpolate(outputLower, outputUpper, t, "lab");
+				case "colorArray": return ColorArray.interpolate(outputLower, outputUpper, t, "lab");
+			}
 		}
-		fn(this.otherwise);
-	}
-	outputDefined() {
-		return this.branches.every(([_, out]) => out.outputDefined()) && this.otherwise.outputDefined();
-	}
-};
-
-// src/expression/definitions/slice.ts
-var Slice = class Slice {
-	constructor(type, input, beginIndex, key, endIndex) {
-		this.type = type;
-		this.input = input;
-		this.beginIndex = beginIndex;
-		this.key = key;
-		this.endIndex = endIndex;
-	}
-	static parse(args, context) {
-		if (args.length <= 2 || args.length >= 5) return context.error(`Expected 2 or 3 arguments, but found ${args.length - 1} instead.`);
-		const input = context.parse(args[1], 1, ValueType);
-		const beginIndex = context.parse(args[2], 2, NumberType);
-		if (!input || !beginIndex) return null;
-		if (!isValidType(input.type, [
-			array(ValueType),
-			StringType,
-			ValueType
-		])) return context.error(`Expected first argument to be of type array or string, but found ${typeToString(input.type)} instead`);
-		if (args.length === 4) {
-			const endIndex = context.parse(args[3], 3, NumberType);
-			if (!endIndex) return null;
-			return new Slice(input.type, input, beginIndex, context.key, endIndex);
-		} else return new Slice(input.type, input, beginIndex, context.key);
-	}
-	evaluate(ctx) {
-		const input = this.input.evaluate(ctx);
-		const beginIndex = this.beginIndex.evaluate(ctx);
-		let endIndex;
-		if (this.endIndex) endIndex = this.endIndex.evaluate(ctx);
-		if (isValidNativeType(input, ["string"])) return [...input].slice(beginIndex, endIndex).join("");
-		else if (isValidNativeType(input, ["array"])) return input.slice(beginIndex, endIndex);
-		else throw new RuntimeError(`Expected first argument to be of type array or string, but found ${typeToString(typeOf(input))} instead.`, this.key);
 	}
 	eachChild(fn) {
 		fn(this.input);
-		fn(this.beginIndex);
-		if (this.endIndex) fn(this.endIndex);
+		for (const expression of this.outputs) fn(expression);
 	}
 	outputDefined() {
-		return false;
+		return this.outputs.every((out) => out.outputDefined());
 	}
 };
+/**
+* Returns a ratio that can be used to interpolate between exponential function
+* stops.
+* How it works: Two consecutive stop values define a (scaled and shifted) exponential function `f(x) = a * base^x + b`, where `base` is the user-specified base,
+* and `a` and `b` are constants affording sufficient degrees of freedom to fit
+* the function to the given stops.
+*
+* Here's a bit of algebra that lets us compute `f(x)` directly from the stop
+* values without explicitly solving for `a` and `b`:
+*
+* First stop value: `f(x0) = y0 = a * base^x0 + b`
+* Second stop value: `f(x1) = y1 = a * base^x1 + b`
+* => `y1 - y0 = a(base^x1 - base^x0)`
+* => `a = (y1 - y0)/(base^x1 - base^x0)`
+*
+* Desired value: `f(x) = y = a * base^x + b`
+* => `f(x) = y0 + a * (base^x - base^x0)`
+*
+* From the above, we can replace the `a` in `a * (base^x - base^x0)` and do a
+* little algebra:
+* ```
+* a * (base^x - base^x0) = (y1 - y0)/(base^x1 - base^x0) * (base^x - base^x0)
+*                     = (y1 - y0) * (base^x - base^x0) / (base^x1 - base^x0)
+* ```
+*
+* If we let `(base^x - base^x0) / (base^x1 base^x0)`, then we have
+* `f(x) = y0 + (y1 - y0) * ratio`.  In other words, `ratio` may be treated as
+* an interpolation factor between the two stops' output values.
+*
+* (Note: a slightly different form for `ratio`,
+* `(base^(x-x0) - 1) / (base^(x1-x0) - 1) `, is equivalent, but requires fewer
+* expensive `Math.pow()` operations.)
+*
+* @private
+*/
+function exponentialInterpolation(input, base, lowerValue, upperValue) {
+	const difference = upperValue - lowerValue;
+	const progress = input - lowerValue;
+	if (difference === 0) return 0;
+	else if (base === 1) return progress / difference;
+	else return (Math.pow(base, progress) - 1) / (Math.pow(base, difference) - 1);
+}
+const interpolateFactory = {
+	color: Color$1.interpolate,
+	number: interpolateNumber,
+	padding: Padding.interpolate,
+	numberArray: NumberArray.interpolate,
+	colorArray: ColorArray.interpolate,
+	variableAnchorOffsetCollection: VariableAnchorOffsetCollection.interpolate,
+	array: interpolateArray
+};
 
 // src/expression/definitions/coalesce.ts
 var Coalesce = class Coalesce {
@@ -13076,6 +13123,87 @@ var NumberFormat = class NumberFormat {
 	}
 };
 
+// src/expression/definitions/format.ts
+var FormatExpression = class FormatExpression {
+	constructor(sections) {
+		this.type = FormattedType;
+		this.sections = sections;
+	}
+	static parse(args, context) {
+		if (args.length < 2) return context.error("Expected at least one argument.");
+		const firstArg = args[1];
+		if (!Array.isArray(firstArg) && typeof firstArg === "object") return context.error("First argument must be an image or text section.");
+		const sections = [];
+		let nextTokenMayBeObject = false;
+		for (let i = 1; i <= args.length - 1; ++i) {
+			const arg = args[i];
+			if (nextTokenMayBeObject && typeof arg === "object" && !Array.isArray(arg)) {
+				nextTokenMayBeObject = false;
+				let scale = null;
+				if (arg["font-scale"]) {
+					scale = context.parse(arg["font-scale"], 1, NumberType);
+					if (!scale) return null;
+				}
+				let font = null;
+				if (arg["text-font"]) {
+					font = context.parse(arg["text-font"], 1, array(StringType));
+					if (!font) return null;
+				}
+				let textColor = null;
+				if (arg["text-color"]) {
+					textColor = context.parse(arg["text-color"], 1, ColorType);
+					if (!textColor) return null;
+				}
+				let verticalAlign = null;
+				if (arg["vertical-align"]) {
+					if (typeof arg["vertical-align"] === "string" && !VERTICAL_ALIGN_OPTIONS.includes(arg["vertical-align"])) return context.error(`'vertical-align' must be one of: 'bottom', 'center', 'top' but found '${arg["vertical-align"]}' instead.`);
+					verticalAlign = context.parse(arg["vertical-align"], 1, StringType);
+					if (!verticalAlign) return null;
+				}
+				const lastExpression = sections[sections.length - 1];
+				lastExpression.scale = scale;
+				lastExpression.font = font;
+				lastExpression.textColor = textColor;
+				lastExpression.verticalAlign = verticalAlign;
+			} else {
+				const content = context.parse(args[i], 1, ValueType);
+				if (!content) return null;
+				const kind = content.type.kind;
+				if (kind !== "string" && kind !== "value" && kind !== "null" && kind !== "resolvedImage") return context.error("Formatted text type must be 'string', 'value', 'image' or 'null'.");
+				nextTokenMayBeObject = true;
+				sections.push({
+					content,
+					scale: null,
+					font: null,
+					textColor: null,
+					verticalAlign: null
+				});
+			}
+		}
+		return new FormatExpression(sections);
+	}
+	evaluate(ctx) {
+		const evaluateSection = (section) => {
+			const evaluatedContent = section.content.evaluate(ctx);
+			if (typeOf(evaluatedContent) === ResolvedImageType) return new FormattedSection("", evaluatedContent, null, null, null, section.verticalAlign ? section.verticalAlign.evaluate(ctx) : null);
+			return new FormattedSection(valueToString(evaluatedContent), null, section.scale ? section.scale.evaluate(ctx) : null, section.font ? section.font.evaluate(ctx).join(",") : null, section.textColor ? section.textColor.evaluate(ctx) : null, section.verticalAlign ? section.verticalAlign.evaluate(ctx) : null);
+		};
+		return new Formatted(this.sections.map(evaluateSection));
+	}
+	eachChild(fn) {
+		for (const section of this.sections) {
+			fn(section.content);
+			if (section.scale) fn(section.scale);
+			if (section.font) fn(section.font);
+			if (section.textColor) fn(section.textColor);
+			if (section.verticalAlign) fn(section.verticalAlign);
+		}
+	}
+	outputDefined() {
+		return false;
+	}
+};
+
 // src/expression/definitions/image.ts
 var ImageExpression = class ImageExpression {
 	constructor(input) {
@@ -13425,21 +13553,64 @@ var TinyQueue = class {
 		}
 		data[pos] = item;
 	}
-	_down(pos) {
-		const { data, compare } = this;
-		const halfLength = this.length >> 1;
-		const item = data[pos];
-		while (pos < halfLength) {
-			let bestChild = (pos << 1) + 1;
-			const right = bestChild + 1;
-			if (right < this.length && compare(data[right], data[bestChild]) < 0) bestChild = right;
-			if (compare(data[bestChild], item) >= 0) break;
-			data[pos] = data[bestChild];
-			pos = bestChild;
-		}
-		data[pos] = item;
+	_down(pos) {
+		const { data, compare } = this;
+		const halfLength = this.length >> 1;
+		const item = data[pos];
+		while (pos < halfLength) {
+			let bestChild = (pos << 1) + 1;
+			const right = bestChild + 1;
+			if (right < this.length && compare(data[right], data[bestChild]) < 0) bestChild = right;
+			if (compare(data[bestChild], item) >= 0) break;
+			data[pos] = data[bestChild];
+			pos = bestChild;
+		}
+		data[pos] = item;
+	}
+};
+
+// src/util/classify_rings.ts
+/**
+* Classifies an array of rings into polygons with outer rings and holes
+* @param rings - the rings to classify
+* @param maxRings - the maximum number of rings to include in a polygon, use 0 to include all rings
+* @returns an array of polygons with internal rings as holes
+*/
+function classifyRings$1(rings, maxRings) {
+	if (rings.length <= 1) return [rings];
+	const polygons = [];
+	let polygon;
+	let ccw;
+	for (const ring of rings) {
+		const area = calculateSignedArea(ring);
+		if (area === 0) continue;
+		ring.area = Math.abs(area);
+		if (ccw === void 0) ccw = area < 0;
+		if (ccw === area < 0) {
+			if (polygon) polygons.push(polygon);
+			polygon = [ring];
+		} else polygon.push(ring);
+	}
+	if (polygon) polygons.push(polygon);
+	return polygons;
+}
+/**
+* Returns the signed area for the polygon ring.  Positive areas are exterior rings and
+* have a clockwise winding.  Negative areas are interior rings and have a counter clockwise
+* ordering.
+*
+* @param ring - Exterior or interior ring
+* @returns Signed area
+*/
+function calculateSignedArea(ring) {
+	let sum = 0;
+	for (let i = 0, len = ring.length, j = len - 1, p1, p2; i < len; j = i++) {
+		p1 = ring[i];
+		p2 = ring[j];
+		sum += (p2.x - p1.x) * (p1.y + p2.y);
 	}
-};
+	return sum;
+}
 
 // src/util/cheap_ruler.ts
 const RE = 6378.137;
@@ -13999,162 +14170,6 @@ const expressions = {
 	"global-state": GlobalState
 };
 
-// src/expression/parsing_error.ts
-var ExpressionParsingError = class extends Error {
-	constructor(key, message) {
-		super(message);
-		this.message = message;
-		this.key = key;
-	}
-};
-
-// src/expression/scope.ts
-/**
-* Tracks `let` bindings during expression parsing.
-* @private
-*/
-var Scope = class Scope {
-	constructor(parent, bindings = []) {
-		this.parent = parent;
-		this.bindings = {};
-		for (const [name, expression] of bindings) this.bindings[name] = expression;
-	}
-	concat(bindings) {
-		return new Scope(this, bindings);
-	}
-	get(name) {
-		if (this.bindings[name]) return this.bindings[name];
-		if (this.parent) return this.parent.get(name);
-		throw new Error(`${name} not found in scope.`);
-	}
-	has(name) {
-		if (this.bindings[name]) return true;
-		return this.parent ? this.parent.has(name) : false;
-	}
-};
-
-// src/expression/parsing_context.ts
-/**
-* State associated parsing at a given point in an expression tree.
-* @private
-*/
-var ParsingContext = class ParsingContext {
-	constructor(registry, isConstantFunc, path = [], expectedType, scope = new Scope(), errors = []) {
-		this.registry = registry;
-		this.path = path;
-		this.key = path.map((part) => `[${part}]`).join("");
-		this.scope = scope;
-		this.errors = errors;
-		this.expectedType = expectedType;
-		this._isConstant = isConstantFunc;
-	}
-	/**
-	* @param expr the JSON expression to parse
-	* @param index the optional argument index if this expression is an argument of a parent expression that's being parsed
-	* @param options
-	* @param options.omitTypeAnnotations set true to omit inferred type annotations.  Caller beware: with this option set, the parsed expression's type will NOT satisfy `expectedType` if it would normally be wrapped in an inferred annotation.
-	* @private
-	*/
-	parse(expr, index, expectedType, bindings, options = {}) {
-		if (index != null) return this.concat(index, expectedType, bindings)._parse(expr, options);
-		return this._parse(expr, options);
-	}
-	_parse(expr, options) {
-		if (expr === null || typeof expr === "string" || typeof expr === "boolean" || typeof expr === "number") expr = ["literal", expr];
-		const key = this.key;
-		function annotate(parsed, type, typeAnnotation) {
-			if (typeAnnotation === "assert") return new Assertion(type, [parsed], key);
-			else if (typeAnnotation === "coerce") return new Coercion(type, [parsed], key);
-			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\", []].");
-			const op = expr[0];
-			if (typeof op !== "string") {
-				this.error(`Expression name must be a string, but found ${typeof op} instead. If you wanted a literal array, use ["literal", [...]].`, 0);
-				return null;
-			}
-			const Expr = this.registry[op];
-			if (Expr) {
-				let parsed = Expr.parse(expr, this);
-				if (!parsed) return null;
-				if (this.expectedType) {
-					const expected = this.expectedType;
-					const actual = parsed.type;
-					if ((expected.kind === "string" || expected.kind === "number" || expected.kind === "boolean" || expected.kind === "object" || expected.kind === "array") && actual.kind === "value") parsed = annotate(parsed, expected, options.typeAnnotation || "assert");
-					else if ("projectionDefinition" === expected.kind && [
-						"string",
-						"array",
-						"value"
-					].includes(actual.kind) || [
-						"color",
-						"formatted",
-						"resolvedImage"
-					].includes(expected.kind) && ["value", "string"].includes(actual.kind) || ["padding", "numberArray"].includes(expected.kind) && [
-						"value",
-						"number",
-						"array"
-					].includes(actual.kind) || "colorArray" === expected.kind && [
-						"value",
-						"string",
-						"array"
-					].includes(actual.kind) || "variableAnchorOffsetCollection" === expected.kind && ["value", "array"].includes(actual.kind)) parsed = annotate(parsed, expected, options.typeAnnotation || "coerce");
-					else if (this.checkSubtype(expected, actual)) return null;
-				}
-				if (!(parsed instanceof Literal) && parsed.type.kind !== "resolvedImage" && this._isConstant(parsed)) {
-					const ec = new EvaluationContext();
-					try {
-						parsed = new Literal(parsed.type, parsed.evaluate(ec));
-					} catch (e) {
-						this.error(e.message);
-						return null;
-					}
-				}
-				return parsed;
-			}
-			return this.error(`Unknown expression "${op}". If you wanted a literal array, use ["literal", [...]].`, 0);
-		} else if (typeof expr === "undefined") return this.error("'undefined' value invalid. Use null instead.");
-		else if (typeof expr === "object") return this.error("Bare objects invalid. Use [\"literal\", {...}] instead.");
-		else return this.error(`Expected an array, but found ${typeof expr} instead.`);
-	}
-	/**
-	* Returns a copy of this context suitable for parsing the subexpression at
-	* index `index`, optionally appending to 'let' binding map.
-	*
-	* Note that `errors` property, intended for collecting errors while
-	* parsing, is copied by reference rather than cloned.
-	* @private
-	*/
-	concat(index, expectedType, bindings) {
-		const path = typeof index === "number" ? this.path.concat(index) : this.path;
-		const scope = bindings ? this.scope.concat(bindings) : this.scope;
-		return new ParsingContext(this.registry, this._isConstant, path, expectedType || null, scope, this.errors);
-	}
-	/**
-	* Push a parsing (or type checking) error into the `this.errors`
-	* @param error The message
-	* @param keys Optionally specify the source of the error at a child
-	* of the current expression at `this.key`.
-	* @private
-	*/
-	error(error, ...keys) {
-		const key = `${this.key}${keys.map((k) => `[${k}]`).join("")}`;
-		this.errors.push(new ExpressionParsingError(key, error));
-	}
-	/**
-	* Returns null if `t` is a subtype of `expected`; otherwise returns an
-	* error message and also pushes it to `this.errors`.
-	* @param expected The expected type
-	* @param t The actual type
-	* @returns null if `t` is a subtype of `expected`; otherwise returns an error message
-	*/
-	checkSubtype(expected, t) {
-		const error = checkSubtype(expected, t);
-		if (error) this.error(error);
-		return error;
-	}
-};
-
 // src/expression/compound_expression.ts
 var CompoundExpression = class CompoundExpression {
 	constructor(name, type, evaluate, args, key) {
@@ -14730,6 +14745,20 @@ function isGlobalPropertyConstant(e, properties) {
 	return result;
 }
 
+// src/util/result.ts
+function success(value) {
+	return {
+		result: "success",
+		value
+	};
+}
+function error(value) {
+	return {
+		result: "error",
+		value
+	};
+}
+
 // src/util/properties.ts
 function supportsPropertyExpression(spec) {
 	return spec["property-type"] === "data-driven" || spec["property-type"] === "cross-faded-data-driven";
@@ -14966,20 +14995,6 @@ function interpolationFactor(input, base, lowerValue, upperValue) {
 	else return (Math.pow(base, progress) - 1) / (Math.pow(base, difference) - 1);
 }
 
-// src/util/result.ts
-function success(value) {
-	return {
-		result: "success",
-		value
-	};
-}
-function error(value) {
-	return {
-		result: "error",
-		value
-	};
-}
-
 // src/expression/index.ts
 var StyleExpression = class {
 	constructor(expression, rootKey, propertySpec, globalState) {
@@ -15863,6 +15878,174 @@ async function loadGlyphRange(template, fontStack, start, fetchFn) {
     }
 }
 
+/**
+ * A PNG file of RGBA pixels, for images that are drawn from a data URI, like the sheets of a
+ * sprite. Without compression: its deflate stream holds the pixels in stored blocks, which needs
+ * no dependency and runs in browsers too. The file is a little larger than the pixels.
+ */
+/** The CRC-32 table of PNG chunks, built on first use. */
+let crcTable;
+function crc32(bytes, start, end) {
+    if (!crcTable) {
+        crcTable = new Uint32Array(256);
+        for (let n = 0; n < 256; n++) {
+            let c = n;
+            for (let k = 0; k < 8; k++)
+                c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+            crcTable[n] = c >>> 0;
+        }
+    }
+    let crc = 0xffffffff;
+    for (let i = start; i < end; i++)
+        crc = crcTable[(crc ^ bytes[i]) & 0xff] ^ (crc >>> 8);
+    return (crc ^ 0xffffffff) >>> 0;
+}
+/** The checksum of a zlib stream. */
+function adler32(bytes) {
+    let a = 1;
+    let b = 0;
+    // sums of up to 5552 bytes cannot overflow before the modulo
+    for (let i = 0; i < bytes.length;) {
+        const end = Math.min(i + 5552, bytes.length);
+        for (; i < end; i++) {
+            a += bytes[i];
+            b += a;
+        }
+        a %= 65521;
+        b %= 65521;
+    }
+    return ((b << 16) | a) >>> 0;
+}
+/** The longest stored deflate block. */
+const MAX_BLOCK = 65535;
+/** A zlib stream of the bytes in stored deflate blocks. */
+function zlibStored(raw) {
+    const blocks = Math.max(1, Math.ceil(raw.length / MAX_BLOCK));
+    const out = new Uint8Array(2 + blocks * 5 + raw.length + 4);
+    const view = new DataView(out.buffer);
+    // deflate with a 32 KB window, no dictionary, the fastest level
+    out[0] = 0x78;
+    out[1] = 0x01;
+    let at = 2;
+    for (let block = 0; block < blocks; block++) {
+        const start = block * MAX_BLOCK;
+        const length = Math.min(MAX_BLOCK, raw.length - start);
+        out[at] = block === blocks - 1 ? 1 : 0;
+        view.setUint16(at + 1, length, true);
+        view.setUint16(at + 3, ~length & 0xffff, true);
+        out.set(raw.subarray(start, start + length), at + 5);
+        at += 5 + length;
+    }
+    view.setUint32(at, adler32(raw));
+    return out;
+}
+/** A chunk of a PNG file: its length, type, data and CRC. */
+function chunk(type, data) {
+    const out = new Uint8Array(12 + data.length);
+    const view = new DataView(out.buffer);
+    view.setUint32(0, data.length);
+    for (let i = 0; i < 4; i++)
+        out[4 + i] = type.charCodeAt(i);
+    out.set(data, 8);
+    view.setUint32(8 + data.length, crc32(out, 4, 8 + data.length));
+    return out;
+}
+/**
+ * A PNG file of an image of `width` × `height` pixels, given as RGBA, row by row, not
+ * premultiplied: as `ImageData` and MapLibre's `map.addImage` have them.
+ * @throws If `data` does not hold `width * height` pixels.
+ */
+function encodePNG(width, height, data) {
+    if (!Number.isInteger(width) || !Number.isInteger(height) || width <= 0 || height <= 0) {
+        throw new Error(`An image must have a positive whole width and height, not ${String(width)} × ${String(height)}`);
+    }
+    if (data.length !== width * height * 4) {
+        throw new Error(`An image of ${String(width)} × ${String(height)} pixels needs ${String(width * height * 4)} bytes, not ${String(data.length)}`);
+    }
+    const header = new Uint8Array(13);
+    const view = new DataView(header.buffer);
+    view.setUint32(0, width);
+    view.setUint32(4, height);
+    // 8 bits per channel, RGBA, no interlace
+    header[8] = 8;
+    header[9] = 6;
+    // each row starts with its filter: none
+    const row = width * 4;
+    const raw = new Uint8Array((row + 1) * height);
+    for (let y = 0; y < height; y++)
+        raw.set(data.subarray(y * row, (y + 1) * row), y * (row + 1) + 1);
+    const parts = [
+        new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]),
+        chunk('IHDR', header),
+        chunk('IDAT', zlibStored(raw)),
+        chunk('IEND', new Uint8Array(0)),
+    ];
+    const png = new Uint8Array(parts.reduce((sum, part) => sum + part.length, 0));
+    let at = 0;
+    for (const part of parts) {
+        png.set(part, at);
+        at += part.length;
+    }
+    return png;
+}
+
+/**
+ * The images in an atlas like the sprite's, each on a sheet of its own. An image that cannot be
+ * drawn, e.g. with too few pixels, is left out with a warning.
+ */
+function imageAtlas(images, warn) {
+    const atlas = new Map();
+    for (const image of images) {
+        const { id, width, height, data, pixelRatio = 1, sdf = false } = image;
+        if (atlas.has(id)) {
+            warn(`The image "${id}" is given twice in "images": the first one is drawn.`);
+            continue;
+        }
+        if (!(pixelRatio > 0)) {
+            warn(`The image "${id}" in "images" has no positive pixelRatio: it is left out.`);
+            continue;
+        }
+        let png;
+        try {
+            png = encodePNG(width, height, data);
+        }
+        catch (error) {
+            warn(`The image "${id}" in "images" is left out: ${error.message}.`);
+            continue;
+        }
+        const buffer = png.buffer.slice(png.byteOffset, png.byteOffset + png.byteLength);
+        atlas.set(id, {
+            width,
+            height,
+            x: 0,
+            y: 0,
+            pixelRatio,
+            sdf,
+            sheetDataUri: `data:image/png;base64,${arrayBufferToBase64(buffer)}`,
+            sheetWidth: width,
+            sheetHeight: height,
+        });
+    }
+    return atlas;
+}
+/**
+ * The sprite's atlas with the images added, like `map.addImage` in MapLibre GL JS, which fails for
+ * an id that the style has already: an image of the sprite keeps its place, with a warning.
+ */
+function withImages(sprite, images, warn) {
+    if (images.size === 0)
+        return sprite;
+    const atlas = new Map(sprite);
+    for (const [id, entry] of images) {
+        if (atlas.has(id)) {
+            warn(`The image "${id}" in "images" is in the sprite too: the sprite's is drawn.`);
+            continue;
+        }
+        atlas.set(id, entry);
+    }
+    return atlas;
+}
+
 // DEFLATE is a complex format; to read this code, you should probably check the RFC first:
 // https://tools.ietf.org/html/rfc1951
 // You may also wish to take a look at the guide I made about this program:
@@ -21256,6 +21439,9 @@ class SVGMapRenderer {
     #pmtiles;
     #fetch;
     #sprite;
+    /** The images of {@link SVGMapRendererOptions.images}, encoded on first use. */
+    #imageList;
+    #images;
     #sources;
     #glyphRanges = new Map();
     #onWarning;
@@ -21268,6 +21454,7 @@ class SVGMapRenderer {
     constructor(options) {
         this.#style = options.style;
         this.#onWarning = options.onWarning ?? ((message) => console.warn(message));
+        this.#imageList = options.images ?? [];
         let labels = 
         // eslint-disable-next-line @typescript-eslint/no-deprecated -- still supported, mapped to `labels`
         options.labels ?? (options.renderLabels === true ? 'glyphs-text' : 'none');
@@ -21395,7 +21582,8 @@ class SVGMapRenderer {
         const sprite = loadSprite(this.#style, this.#fetch).then(({ atlas, complete }) => {
             if (!complete && this.#sprite === sprite)
                 this.#sprite = undefined;
-            return atlas;
+            this.#images ??= imageAtlas(this.#imageList, (message) => this.#warn(message));
+            return withImages(atlas, this.#images, (message) => this.#warn(message));
         });
         this.#sprite = sprite;
         return sprite;