maplibre-gl 3.2.1 → 3.3.0

package/dist/maplibre-gl-dev.js

@@ -1,4 +1,4 @@
-/* MapLibre GL JS is licensed under the 3-Clause BSD License. Full text of license: https://github.com/maplibre/maplibre-gl-js/blob/v3.2.1/LICENSE.txt */
+/* MapLibre GL JS is licensed under the 3-Clause BSD License. Full text of license: https://github.com/maplibre/maplibre-gl-js/blob/v3.3.0/LICENSE.txt */
 (function (global, factory) {
 typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
 typeof define === 'function' && define.amd ? define(factory) :
@@ -1031,6 +1031,7 @@ function makeFetchRequest(requestParameters, callback) {
         body: requestParameters.body,
         credentials: requestParameters.credentials,
         headers: requestParameters.headers,
+        cache: requestParameters.cache,
         referrer: getReferrer(),
         signal: controller.signal
     });
@@ -2548,6 +2549,25 @@ var layout_symbol = {
 		},
 		"property-type": "data-constant"
 	},
+	"text-variable-anchor-offset": {
+		type: "variableAnchorOffsetCollection",
+		requires: [
+			"text-field",
+			{
+				"symbol-placement": [
+					"point"
+				]
+			}
+		],
+		expression: {
+			interpolated: true,
+			parameters: [
+				"zoom",
+				"feature"
+			]
+		},
+		"property-type": "data-driven"
+	},
 	"text-anchor": {
 		type: "enum",
 		values: {
@@ -4867,6 +4887,7 @@ const CollatorType = { kind: 'collator' };
 const FormattedType = { kind: 'formatted' };
 const PaddingType = { kind: 'padding' };
 const ResolvedImageType = { kind: 'resolvedImage' };
+const VariableAnchorOffsetCollectionType = { kind: 'variableAnchorOffsetCollection' };
 function array$1(itemType, N) {
     return {
         kind: 'array',
@@ -4895,7 +4916,8 @@ const valueMemberTypes = [
     ObjectType,
     array$1(ValueType),
     PaddingType,
-    ResolvedImageType
+    ResolvedImageType,
+    VariableAnchorOffsetCollectionType
 ];
 /**
  * Returns null if `t` is a subtype of `expected`; otherwise returns an
@@ -5591,6 +5613,44 @@ class Padding {
     }
 }
 
+/** Set of valid anchor positions, as a set for validation */
+const anchors = new Set(['center', 'left', 'right', 'top', 'bottom', 'top-left', 'top-right', 'bottom-left', 'bottom-right']);
+/**
+ * Utility class to assist managing values for text-variable-anchor-offset property. Create instances from
+ * bare arrays using the static method `VariableAnchorOffsetCollection.parse`.
+ * @private
+ */
+class VariableAnchorOffsetCollection {
+    constructor(values) {
+        this.values = values.slice();
+    }
+    static parse(input) {
+        if (input instanceof VariableAnchorOffsetCollection) {
+            return input;
+        }
+        if (!Array.isArray(input) ||
+            input.length < 1 ||
+            input.length % 2 !== 0) {
+            return undefined;
+        }
+        for (let i = 0; i < input.length; i += 2) {
+            // Elements in even positions should be anchor positions; Elements in odd positions should be offset values
+            const anchorValue = input[i];
+            const offsetValue = input[i + 1];
+            if (typeof anchorValue !== 'string' || !anchors.has(anchorValue)) {
+                return undefined;
+            }
+            if (!Array.isArray(offsetValue) || offsetValue.length !== 2 || typeof offsetValue[0] !== 'number' || typeof offsetValue[1] !== 'number') {
+                return undefined;
+            }
+        }
+        return new VariableAnchorOffsetCollection(input);
+    }
+    toString() {
+        return JSON.stringify(this.values);
+    }
+}
+
 class ResolvedImage {
     constructor(options) {
         this.name = options.name;
@@ -5619,31 +5679,16 @@ function validateRGBA(r, g, b, a) {
     return null;
 }
 function isValue(mixed) {
-    if (mixed === null) {
-        return true;
-    }
-    else if (typeof mixed === 'string') {
-        return true;
-    }
-    else if (typeof mixed === 'boolean') {
-        return true;
-    }
-    else if (typeof mixed === 'number') {
-        return true;
-    }
-    else if (mixed instanceof Color) {
-        return true;
-    }
-    else if (mixed instanceof Collator) {
-        return true;
-    }
-    else if (mixed instanceof Formatted) {
-        return true;
-    }
-    else if (mixed instanceof Padding) {
-        return true;
-    }
-    else if (mixed instanceof ResolvedImage) {
+    if (mixed === null ||
+        typeof mixed === 'string' ||
+        typeof mixed === 'boolean' ||
+        typeof mixed === 'number' ||
+        mixed instanceof Color ||
+        mixed instanceof Collator ||
+        mixed instanceof Formatted ||
+        mixed instanceof Padding ||
+        mixed instanceof VariableAnchorOffsetCollection ||
+        mixed instanceof ResolvedImage) {
         return true;
     }
     else if (Array.isArray(mixed)) {
@@ -5691,6 +5736,9 @@ function typeOf(value) {
     else if (value instanceof Padding) {
         return PaddingType;
     }
+    else if (value instanceof VariableAnchorOffsetCollection) {
+        return VariableAnchorOffsetCollectionType;
+    }
     else if (value instanceof ResolvedImage) {
         return ResolvedImageType;
     }
@@ -5724,7 +5772,7 @@ function toString(value) {
     else if (type === 'string' || type === 'number' || type === 'boolean') {
         return String(value);
     }
-    else if (value instanceof Color || value instanceof Formatted || value instanceof Padding || value instanceof ResolvedImage) {
+    else if (value instanceof Color || value instanceof Formatted || value instanceof Padding || value instanceof VariableAnchorOffsetCollection || value instanceof ResolvedImage) {
         return value.toString();
     }
     else {
@@ -5888,71 +5936,80 @@ class Coercion {
         return new Coercion(type, parsed);
     }
     evaluate(ctx) {
-        if (this.type.kind === 'boolean') {
-            return Boolean(this.args[0].evaluate(ctx));
-        }
-        else if (this.type.kind === 'color') {
-            let input;
-            let error;
-            for (const arg of this.args) {
-                input = arg.evaluate(ctx);
-                error = null;
-                if (input instanceof Color) {
-                    return input;
-                }
-                else if (typeof input === 'string') {
-                    const c = ctx.parseColor(input);
-                    if (c)
-                        return c;
-                }
-                else if (Array.isArray(input)) {
-                    if (input.length < 3 || input.length > 4) {
-                        error = `Invalid rbga value ${JSON.stringify(input)}: expected an array containing either three or four numeric values.`;
+        switch (this.type.kind) {
+            case 'boolean':
+                return Boolean(this.args[0].evaluate(ctx));
+            case 'color': {
+                let input;
+                let error;
+                for (const arg of this.args) {
+                    input = arg.evaluate(ctx);
+                    error = null;
+                    if (input instanceof Color) {
+                        return input;
                     }
-                    else {
-                        error = validateRGBA(input[0], input[1], input[2], input[3]);
+                    else if (typeof input === 'string') {
+                        const c = ctx.parseColor(input);
+                        if (c)
+                            return c;
                     }
-                    if (!error) {
-                        return new Color(input[0] / 255, input[1] / 255, input[2] / 255, input[3]);
+                    else if (Array.isArray(input)) {
+                        if (input.length < 3 || input.length > 4) {
+                            error = `Invalid rbga value ${JSON.stringify(input)}: expected an array containing either three or four numeric values.`;
+                        }
+                        else {
+                            error = validateRGBA(input[0], input[1], input[2], input[3]);
+                        }
+                        if (!error) {
+                            return new Color(input[0] / 255, input[1] / 255, input[2] / 255, input[3]);
+                        }
                     }
                 }
+                throw new RuntimeError(error || `Could not parse color from value '${typeof input === 'string' ? input : JSON.stringify(input)}'`);
             }
-            throw new RuntimeError(error || `Could not parse color from value '${typeof input === 'string' ? input : JSON.stringify(input)}'`);
-        }
-        else if (this.type.kind === 'padding') {
-            let input;
-            for (const arg of this.args) {
-                input = arg.evaluate(ctx);
-                const pad = Padding.parse(input);
-                if (pad) {
-                    return pad;
+            case 'padding': {
+                let input;
+                for (const arg of this.args) {
+                    input = arg.evaluate(ctx);
+                    const pad = Padding.parse(input);
+                    if (pad) {
+                        return pad;
+                    }
                 }
+                throw new RuntimeError(`Could not parse padding from value '${typeof input === 'string' ? input : JSON.stringify(input)}'`);
             }
-            throw new RuntimeError(`Could not parse padding from value '${typeof input === 'string' ? input : JSON.stringify(input)}'`);
-        }
-        else if (this.type.kind === 'number') {
-            let value = null;
-            for (const arg of this.args) {
-                value = arg.evaluate(ctx);
-                if (value === null)
-                    return 0;
-                const num = Number(value);
-                if (isNaN(num))
-                    continue;
-                return num;
+            case 'variableAnchorOffsetCollection': {
+                let input;
+                for (const arg of this.args) {
+                    input = arg.evaluate(ctx);
+                    const coll = VariableAnchorOffsetCollection.parse(input);
+                    if (coll) {
+                        return coll;
+                    }
+                }
+                throw new RuntimeError(`Could not parse variableAnchorOffsetCollection from value '${typeof input === 'string' ? input : JSON.stringify(input)}'`);
             }
-            throw new RuntimeError(`Could not convert ${JSON.stringify(value)} to number.`);
-        }
-        else if (this.type.kind === 'formatted') {
-            // There is no explicit 'to-formatted' but this coercion can be implicitly
-            // created by properties that expect the 'formatted' type.
-            return Formatted.fromString(toString(this.args[0].evaluate(ctx)));
-        }
-        else if (this.type.kind === 'resolvedImage') {
-            return ResolvedImage.fromString(toString(this.args[0].evaluate(ctx)));
-        }
-        else {
-            return toString(this.args[0].evaluate(ctx));
+            case 'number': {
+                let value = null;
+                for (const arg of this.args) {
+                    value = arg.evaluate(ctx);
+                    if (value === null)
+                        return 0;
+                    const num = Number(value);
+                    if (isNaN(num))
+                        continue;
+                    return num;
+                }
+                throw new RuntimeError(`Could not convert ${JSON.stringify(value)} to number.`);
+            }
+            case 'formatted':
+                // There is no explicit 'to-formatted' but this coercion can be implicitly
+                // created by properties that expect the 'formatted' type.
+                return Formatted.fromString(toString(this.args[0].evaluate(ctx)));
+            case 'resolvedImage':
+                return ResolvedImage.fromString(toString(this.args[0].evaluate(ctx)));
+            default:
+                return toString(this.args[0].evaluate(ctx));
         }
     }
     eachChild(fn) {
@@ -6074,6 +6131,9 @@ class ParsingContext {
                     else if (expected.kind === 'padding' && (actual.kind === 'value' || actual.kind === 'number' || actual.kind === 'array')) {
                         parsed = annotate(parsed, expected, options.typeAnnotation || 'coerce');
                     }
+                    else if (expected.kind === 'variableAnchorOffsetCollection' && (actual.kind === 'value' || actual.kind === 'array')) {
+                        parsed = annotate(parsed, expected, options.typeAnnotation || 'coerce');
+                    }
                     else if (this.checkSubtype(expected, actual)) {
                         return null;
                     }
@@ -6844,6 +6904,7 @@ const interpolateFactory = (interpolationType) => {
         case 'color': return color;
         case 'array': return array;
         case 'padding': return padding;
+        case 'variableAnchorOffsetCollection': return variableAnchorOffsetCollection;
     }
 };
 function number(from, to, t) {
@@ -6905,11 +6966,32 @@ function array(from, to, t) {
 function padding(from, to, t) {
     return new Padding(array(from.values, to.values, t));
 }
+function variableAnchorOffsetCollection(from, to, t) {
+    const fromValues = from.values;
+    const toValues = to.values;
+    if (fromValues.length !== toValues.length) {
+        throw new RuntimeError(`Cannot interpolate values of different length. from: ${from.toString()}, to: ${to.toString()}`);
+    }
+    const output = [];
+    for (let i = 0; i < fromValues.length; i += 2) {
+        // Anchor entries must match
+        if (fromValues[i] !== toValues[i]) {
+            throw new RuntimeError(`Cannot interpolate values containing mismatched anchors. from[${i}]: ${fromValues[i]}, to[${i}]: ${toValues[i]}`);
+        }
+        output.push(fromValues[i]);
+        // Interpolate the offset values for each anchor
+        const [fx, fy] = fromValues[i + 1];
+        const [tx, ty] = toValues[i + 1];
+        output.push([number(fx, tx, t), number(fy, ty, t)]);
+    }
+    return new VariableAnchorOffsetCollection(output);
+}
 const interpolate = {
     number,
     color,
     array,
     padding,
+    variableAnchorOffsetCollection
 };
 
 class Interpolate {
@@ -7008,6 +7090,7 @@ class Interpolate {
         if (!verifyType(outputType, NumberType) &&
             !verifyType(outputType, ColorType) &&
             !verifyType(outputType, PaddingType) &&
+            !verifyType(outputType, VariableAnchorOffsetCollectionType) &&
             !verifyType(outputType, array$1(NumberType))) {
             return context.error(`Type ${toString$1(outputType)} is not interpolatable.`);
         }
@@ -8867,6 +8950,9 @@ function normalizePropertyExpression(value, specification) {
         else if (specification.type === 'padding' && (typeof value === 'number' || Array.isArray(value))) {
             constant = Padding.parse(value);
         }
+        else if (specification.type === 'variableAnchorOffsetCollection' && Array.isArray(value)) {
+            constant = VariableAnchorOffsetCollection.parse(value);
+        }
         return {
             kind: 'constant',
             evaluate: () => constant
@@ -8920,7 +9006,8 @@ function getExpectedType(spec) {
         boolean: BooleanType,
         formatted: FormattedType,
         padding: PaddingType,
-        resolvedImage: ResolvedImageType
+        resolvedImage: ResolvedImageType,
+        variableAnchorOffsetCollection: VariableAnchorOffsetCollectionType
     };
     if (spec.type === 'array') {
         return array$1(types[spec.value] || ValueType, spec.length);
@@ -8940,6 +9027,9 @@ function getDefaultValue(spec) {
     else if (spec.type === 'padding') {
         return Padding.parse(spec.default) || null;
     }
+    else if (spec.type === 'variableAnchorOffsetCollection') {
+        return VariableAnchorOffsetCollection.parse(spec.default) || null;
+    }
     else if (spec.default === undefined) {
         return null;
     }
@@ -10609,6 +10699,38 @@ function validatePadding(options) {
     }
 }
 
+function validateVariableAnchorOffsetCollection(options) {
+    const key = options.key;
+    const value = options.value;
+    const type = getType(value);
+    const styleSpec = options.styleSpec;
+    if (type !== 'array' || value.length < 1 || value.length % 2 !== 0) {
+        return [new ValidationError(key, value, 'variableAnchorOffsetCollection requires a non-empty array of even length')];
+    }
+    let errors = [];
+    for (let i = 0; i < value.length; i += 2) {
+        // Elements in even positions should be values from text-anchor enum
+        errors = errors.concat(validateEnum({
+            key: `${key}[${i}]`,
+            value: value[i],
+            valueSpec: styleSpec['layout_symbol']['text-anchor']
+        }));
+        // Elements in odd positions should be points (2-element numeric arrays)
+        errors = errors.concat(validateArray({
+            key: `${key}[${i + 1}]`,
+            value: value[i + 1],
+            valueSpec: {
+                length: 2,
+                value: 'number'
+            },
+            validateSpec: options.validateSpec,
+            style: options.style,
+            styleSpec
+        }));
+    }
+    return errors;
+}
+
 function validateSprite(options) {
     let errors = [];
     const sprite = options.value;
@@ -10671,6 +10793,7 @@ const VALIDATORS = {
     'formatted': validateFormatted,
     'resolvedImage': validateImage,
     'padding': validatePadding,
+    'variableAnchorOffsetCollection': validateVariableAnchorOffsetCollection,
     'sprite': validateSprite,
 };
 // Main recursive validation function. Tracks:
@@ -11999,6 +12122,7 @@ const lazyLoadRTLTextPlugin = function () {
 };
 
 /**
+ * @internal
  * A parameter that can be evaluated to a value
  */
 class EvaluationParameters {
@@ -12040,6 +12164,7 @@ class EvaluationParameters {
 }
 
 /**
+ * @internal
  *  `PropertyValue` represents the value part of a property key-value unit. It's used to represent both
  *  paint and layout property values, and regardless of whether or not their property supports data-driven
  *  expressions.
@@ -12070,6 +12195,7 @@ class PropertyValue {
     }
 }
 /**
+ * @internal
  * Paint properties are _transitionable_: they can change in a fluid manner, interpolating or cross-fading between
  * old and new value. The duration of the transition, and the delay before it begins, is configurable.
  *
@@ -12092,6 +12218,7 @@ class TransitionablePropertyValue {
     }
 }
 /**
+ * @internal
  * `Transitionable` stores a map of all (property name, `TransitionablePropertyValue`) pairs for paint properties of a
  * given layer type. It can calculate the `TransitioningPropertyValue`s for all of them at once, producing a
  * `Transitioning` instance for the same set of properties.
@@ -12151,6 +12278,7 @@ class Transitionable {
     }
 }
 /**
+ * @internal
  * `TransitioningPropertyValue` implements the first of two intermediate steps in the evaluation chain of a paint
  * property value. In this step, transitions between old and new values are handled: as long as the transition is in
  * progress, `TransitioningPropertyValue` maintains a reference to the prior value, and interpolates between it and
@@ -12199,6 +12327,7 @@ class TransitioningPropertyValue {
     }
 }
 /**
+ * @internal
  * `Transitioning` stores a map of all (property name, `TransitioningPropertyValue`) pairs for paint properties of a
  * given layer type. It can calculate the possibly-evaluated values for all of them at once, producing a
  * `PossiblyEvaluated` instance for the same set of properties.
@@ -12239,6 +12368,9 @@ class Layout {
         this._properties = properties;
         this._values = Object.create(properties.defaultPropertyValues);
     }
+    hasValue(name) {
+        return this._values[name].value !== undefined;
+    }
     getValue(name) {
         return clone$9(this._values[name].value);
     }
@@ -12264,6 +12396,7 @@ class Layout {
     }
 }
 /**
+ * @internal
  * `PossiblyEvaluatedPropertyValue` is used for data-driven paint and layout property values. It holds a
  * `PossiblyEvaluatedValue` and the `GlobalProperties` that were used to generate it. You're not allowed to supply
  * a different set of `GlobalProperties` when performing the final evaluation because they would be ignored in the
@@ -12291,6 +12424,7 @@ class PossiblyEvaluatedPropertyValue {
     }
 }
 /**
+ * @internal
  * `PossiblyEvaluated` stores a map of all (property name, `R`) pairs for paint or layout properties of a
  * given layer type.
  */
@@ -12304,6 +12438,7 @@ class PossiblyEvaluated {
     }
 }
 /**
+ * @internal
  * An implementation of `Property` for properties that do not permit data-driven (source or composite) expressions.
  * This restriction allows us to declare statically that the result of possibly evaluating this kind of property
  * is in fact always the scalar type `T`, and can be used without further evaluating the value on a per-feature basis.
@@ -12329,6 +12464,7 @@ class DataConstantProperty {
     }
 }
 /**
+ * @internal
  * An implementation of `Property` for properties that permit data-driven (source or composite) expressions.
  * The result of possibly evaluating this kind of property is `PossiblyEvaluatedPropertyValue<T>`; obtaining
  * a scalar value `T` requires further evaluation on a per-feature basis.
@@ -12381,6 +12517,7 @@ class DataDrivenProperty {
     }
 }
 /**
+ * @internal
  * An implementation of `Property` for  data driven `line-pattern` which are transitioned by cross-fading
  * rather than interpolation.
  */
@@ -12426,6 +12563,7 @@ class CrossFadedDataDrivenProperty extends DataDrivenProperty {
     }
 }
 /**
+ * @internal
  * An implementation of `Property` for `*-pattern` and `line-dasharray`, which are transitioned by cross-fading
  * rather than interpolation.
  */
@@ -12454,6 +12592,7 @@ class CrossFadedProperty {
     }
 }
 /**
+ * @internal
  * An implementation of `Property` for `heatmap-color` and `line-gradient`. Interpolation is a no-op, and
  * evaluation returns a boolean value in order to indicate its presence, but the real
  * evaluation happens in StyleLayer classes.
@@ -12468,6 +12607,7 @@ class ColorRampProperty {
     interpolate() { return false; }
 }
 /**
+ * @internal
  * `Properties` holds objects containing default values for the layout or paint property set of a given
  * layer type. These objects are immutable, and they are used as the prototypes for the `_values` members of
  * `Transitionable`, `Transitioning`, `Layout`, and `PossiblyEvaluated`. This allows these classes to avoid
@@ -12695,6 +12835,7 @@ class StyleLayer extends Evented {
 
 // Note: all "sizes" are measured in bytes
 /**
+ * @internal
  * A view type size
  */
 const viewTypes = {
@@ -12706,7 +12847,7 @@ const viewTypes = {
     'Uint32': Uint32Array,
     'Float32': Float32Array
 };
-/** */
+/** @internal */
 class Struct {
     /**
      * @param structArray - The StructArray the struct is stored in
@@ -12723,6 +12864,7 @@ class Struct {
 const DEFAULT_CAPACITY = 128;
 const RESIZE_MULTIPLIER = 5;
 /**
+ * @internal
  * `StructArray` provides an abstraction over `ArrayBuffer` and `TypedArray`
  * making it behave like an array of typed structs.
  *
@@ -12857,6 +12999,7 @@ function align$1(offset, size) {
 
 // This file is generated. Edit build/generate-struct-arrays.ts, then run `npm run codegen`.
 /**
+ * @internal
  * Implementation of the StructArray layout:
  * [0]: Int16[2]
  *
@@ -12881,6 +13024,7 @@ class StructArrayLayout2i4 extends StructArray {
 StructArrayLayout2i4.prototype.bytesPerElement = 4;
 register('StructArrayLayout2i4', StructArrayLayout2i4);
 /**
+ * @internal
  * Implementation of the StructArray layout:
  * [0]: Int16[3]
  *
@@ -12906,6 +13050,7 @@ class StructArrayLayout3i6 extends StructArray {
 StructArrayLayout3i6.prototype.bytesPerElement = 6;
 register('StructArrayLayout3i6', StructArrayLayout3i6);
 /**
+ * @internal
  * Implementation of the StructArray layout:
  * [0]: Int16[4]
  *
@@ -12932,6 +13077,7 @@ class StructArrayLayout4i8 extends StructArray {
 StructArrayLayout4i8.prototype.bytesPerElement = 8;
 register('StructArrayLayout4i8', StructArrayLayout4i8);
 /**
+ * @internal
  * Implementation of the StructArray layout:
  * [0]: Int16[2]
  * [4]: Int16[4]
@@ -12961,6 +13107,7 @@ class StructArrayLayout2i4i12 extends StructArray {
 StructArrayLayout2i4i12.prototype.bytesPerElement = 12;
 register('StructArrayLayout2i4i12', StructArrayLayout2i4i12);
 /**
+ * @internal
  * Implementation of the StructArray layout:
  * [0]: Int16[2]
  * [4]: Uint8[4]
@@ -12991,6 +13138,7 @@ class StructArrayLayout2i4ub8 extends StructArray {
 StructArrayLayout2i4ub8.prototype.bytesPerElement = 8;
 register('StructArrayLayout2i4ub8', StructArrayLayout2i4ub8);
 /**
+ * @internal
  * Implementation of the StructArray layout:
  * [0]: Float32[2]
  *
@@ -13015,6 +13163,7 @@ class StructArrayLayout2f8 extends StructArray {
 StructArrayLayout2f8.prototype.bytesPerElement = 8;
 register('StructArrayLayout2f8', StructArrayLayout2f8);
 /**
+ * @internal
  * Implementation of the StructArray layout:
  * [0]: Uint16[10]
  *
@@ -13047,6 +13196,7 @@ class StructArrayLayout10ui20 extends StructArray {
 StructArrayLayout10ui20.prototype.bytesPerElement = 20;
 register('StructArrayLayout10ui20', StructArrayLayout10ui20);
 /**
+ * @internal
  * Implementation of the StructArray layout:
  * [0]: Int16[4]
  * [8]: Uint16[4]
@@ -13084,6 +13234,7 @@ class StructArrayLayout4i4ui4i24 extends StructArray {
 StructArrayLayout4i4ui4i24.prototype.bytesPerElement = 24;
 register('StructArrayLayout4i4ui4i24', StructArrayLayout4i4ui4i24);
 /**
+ * @internal
  * Implementation of the StructArray layout:
  * [0]: Float32[3]
  *
@@ -13109,6 +13260,7 @@ class StructArrayLayout3f12 extends StructArray {
 StructArrayLayout3f12.prototype.bytesPerElement = 12;
 register('StructArrayLayout3f12', StructArrayLayout3f12);
 /**
+ * @internal
  * Implementation of the StructArray layout:
  * [0]: Uint32[1]
  *
@@ -13132,6 +13284,7 @@ class StructArrayLayout1ul4 extends StructArray {
 StructArrayLayout1ul4.prototype.bytesPerElement = 4;
 register('StructArrayLayout1ul4', StructArrayLayout1ul4);
 /**
+ * @internal
  * Implementation of the StructArray layout:
  * [0]: Int16[6]
  * [12]: Uint32[1]
@@ -13168,6 +13321,7 @@ class StructArrayLayout6i1ul2ui20 extends StructArray {
 StructArrayLayout6i1ul2ui20.prototype.bytesPerElement = 20;
 register('StructArrayLayout6i1ul2ui20', StructArrayLayout6i1ul2ui20);
 /**
+ * @internal
  * Implementation of the StructArray layout:
  * [0]: Int16[2]
  * [4]: Int16[2]
@@ -13198,6 +13352,7 @@ class StructArrayLayout2i2i2i12 extends StructArray {
 StructArrayLayout2i2i2i12.prototype.bytesPerElement = 12;
 register('StructArrayLayout2i2i2i12', StructArrayLayout2i2i2i12);
 /**
+ * @internal
  * Implementation of the StructArray layout:
  * [0]: Float32[2]
  * [8]: Float32[1]
@@ -13229,6 +13384,7 @@ class StructArrayLayout2f1f2i16 extends StructArray {
 StructArrayLayout2f1f2i16.prototype.bytesPerElement = 16;
 register('StructArrayLayout2f1f2i16', StructArrayLayout2f1f2i16);
 /**
+ * @internal
  * Implementation of the StructArray layout:
  * [0]: Uint8[2]
  * [4]: Float32[2]
@@ -13257,6 +13413,7 @@ class StructArrayLayout2ub2f12 extends StructArray {
 StructArrayLayout2ub2f12.prototype.bytesPerElement = 12;
 register('StructArrayLayout2ub2f12', StructArrayLayout2ub2f12);
 /**
+ * @internal
  * Implementation of the StructArray layout:
  * [0]: Uint16[3]
  *
@@ -13282,6 +13439,7 @@ class StructArrayLayout3ui6 extends StructArray {
 StructArrayLayout3ui6.prototype.bytesPerElement = 6;
 register('StructArrayLayout3ui6', StructArrayLayout3ui6);
 /**
+ * @internal
  * Implementation of the StructArray layout:
  * [0]: Int16[2]
  * [4]: Uint16[2]
@@ -13333,14 +13491,16 @@ class StructArrayLayout2i2ui3ul3ui2f3ub1ul1i48 extends StructArray {
 StructArrayLayout2i2ui3ul3ui2f3ub1ul1i48.prototype.bytesPerElement = 48;
 register('StructArrayLayout2i2ui3ul3ui2f3ub1ul1i48', StructArrayLayout2i2ui3ul3ui2f3ub1ul1i48);
 /**
+ * @internal
  * Implementation of the StructArray layout:
  * [0]: Int16[8]
  * [16]: Uint16[15]
  * [48]: Uint32[1]
- * [52]: Float32[4]
+ * [52]: Float32[2]
+ * [60]: Uint16[2]
  *
  */
-class StructArrayLayout8i15ui1ul4f68 extends StructArray {
+class StructArrayLayout8i15ui1ul2f2ui64 extends StructArray {
     _refreshViews() {
         this.uint8 = new Uint8Array(this.arrayBuffer);
         this.int16 = new Int16Array(this.arrayBuffer);
@@ -13354,8 +13514,8 @@ class StructArrayLayout8i15ui1ul4f68 extends StructArray {
         return this.emplace(i, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27);
     }
     emplace(i, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) {
-        const o2 = i * 34;
-        const o4 = i * 17;
+        const o2 = i * 32;
+        const o4 = i * 16;
         this.int16[o2 + 0] = v0;
         this.int16[o2 + 1] = v1;
         this.int16[o2 + 2] = v2;
@@ -13382,14 +13542,15 @@ class StructArrayLayout8i15ui1ul4f68 extends StructArray {
         this.uint32[o4 + 12] = v23;
         this.float32[o4 + 13] = v24;
         this.float32[o4 + 14] = v25;
-        this.float32[o4 + 15] = v26;
-        this.float32[o4 + 16] = v27;
+        this.uint16[o2 + 30] = v26;
+        this.uint16[o2 + 31] = v27;
         return i;
     }
 }
-StructArrayLayout8i15ui1ul4f68.prototype.bytesPerElement = 68;
-register('StructArrayLayout8i15ui1ul4f68', StructArrayLayout8i15ui1ul4f68);
+StructArrayLayout8i15ui1ul2f2ui64.prototype.bytesPerElement = 64;
+register('StructArrayLayout8i15ui1ul2f2ui64', StructArrayLayout8i15ui1ul2f2ui64);
 /**
+ * @internal
  * Implementation of the StructArray layout:
  * [0]: Float32[1]
  *
@@ -13413,6 +13574,36 @@ class StructArrayLayout1f4 extends StructArray {
 StructArrayLayout1f4.prototype.bytesPerElement = 4;
 register('StructArrayLayout1f4', StructArrayLayout1f4);
 /**
+ * @internal
+ * Implementation of the StructArray layout:
+ * [0]: Uint16[1]
+ * [4]: Float32[2]
+ *
+ */
+class StructArrayLayout1ui2f12 extends StructArray {
+    _refreshViews() {
+        this.uint8 = new Uint8Array(this.arrayBuffer);
+        this.uint16 = new Uint16Array(this.arrayBuffer);
+        this.float32 = new Float32Array(this.arrayBuffer);
+    }
+    emplaceBack(v0, v1, v2) {
+        const i = this.length;
+        this.resize(i + 1);
+        return this.emplace(i, v0, v1, v2);
+    }
+    emplace(i, v0, v1, v2) {
+        const o2 = i * 6;
+        const o4 = i * 3;
+        this.uint16[o2 + 0] = v0;
+        this.float32[o4 + 1] = v1;
+        this.float32[o4 + 2] = v2;
+        return i;
+    }
+}
+StructArrayLayout1ui2f12.prototype.bytesPerElement = 12;
+register('StructArrayLayout1ui2f12', StructArrayLayout1ui2f12);
+/**
+ * @internal
  * Implementation of the StructArray layout:
  * [0]: Uint32[1]
  * [4]: Uint16[2]
@@ -13441,6 +13632,7 @@ class StructArrayLayout1ul2ui8 extends StructArray {
 StructArrayLayout1ul2ui8.prototype.bytesPerElement = 8;
 register('StructArrayLayout1ul2ui8', StructArrayLayout1ul2ui8);
 /**
+ * @internal
  * Implementation of the StructArray layout:
  * [0]: Uint16[2]
  *
@@ -13465,6 +13657,7 @@ class StructArrayLayout2ui4 extends StructArray {
 StructArrayLayout2ui4.prototype.bytesPerElement = 4;
 register('StructArrayLayout2ui4', StructArrayLayout2ui4);
 /**
+ * @internal
  * Implementation of the StructArray layout:
  * [0]: Uint16[1]
  *
@@ -13488,6 +13681,7 @@ class StructArrayLayout1ui2 extends StructArray {
 StructArrayLayout1ui2.prototype.bytesPerElement = 2;
 register('StructArrayLayout1ui2', StructArrayLayout1ui2);
 /**
+ * @internal
  * Implementation of the StructArray layout:
  * [0]: Float32[4]
  *
@@ -13513,7 +13707,7 @@ class StructArrayLayout4f16 extends StructArray {
 }
 StructArrayLayout4f16.prototype.bytesPerElement = 16;
 register('StructArrayLayout4f16', StructArrayLayout4f16);
-/** */
+/** @internal */
 class CollisionBoxStruct extends Struct {
     get anchorPointX() { return this._structArray.int16[this._pos2 + 0]; }
     get anchorPointY() { return this._structArray.int16[this._pos2 + 1]; }
@@ -13527,7 +13721,7 @@ class CollisionBoxStruct extends Struct {
     get anchorPoint() { return new Point$2(this.anchorPointX, this.anchorPointY); }
 }
 CollisionBoxStruct.prototype.size = 20;
-/** */
+/** @internal */
 class CollisionBoxArray extends StructArrayLayout6i1ul2ui20 {
     /**
      * Return the CollisionBoxStruct at the given location in the array.
@@ -13538,7 +13732,7 @@ class CollisionBoxArray extends StructArrayLayout6i1ul2ui20 {
     }
 }
 register('CollisionBoxArray', CollisionBoxArray);
-/** */
+/** @internal */
 class PlacedSymbolStruct extends Struct {
     get anchorX() { return this._structArray.int16[this._pos2 + 0]; }
     get anchorY() { return this._structArray.int16[this._pos2 + 1]; }
@@ -13562,7 +13756,7 @@ class PlacedSymbolStruct extends Struct {
     get associatedIconIndex() { return this._structArray.int16[this._pos2 + 22]; }
 }
 PlacedSymbolStruct.prototype.size = 48;
-/** */
+/** @internal */
 class PlacedSymbolArray extends StructArrayLayout2i2ui3ul3ui2f3ub1ul1i48 {
     /**
      * Return the PlacedSymbolStruct at the given location in the array.
@@ -13573,7 +13767,7 @@ class PlacedSymbolArray extends StructArrayLayout2i2ui3ul3ui2f3ub1ul1i48 {
     }
 }
 register('PlacedSymbolArray', PlacedSymbolArray);
-/** */
+/** @internal */
 class SymbolInstanceStruct extends Struct {
     get anchorX() { return this._structArray.int16[this._pos2 + 0]; }
     get anchorY() { return this._structArray.int16[this._pos2 + 1]; }
@@ -13601,13 +13795,13 @@ class SymbolInstanceStruct extends Struct {
     get crossTileID() { return this._structArray.uint32[this._pos4 + 12]; }
     set crossTileID(x) { this._structArray.uint32[this._pos4 + 12] = x; }
     get textBoxScale() { return this._structArray.float32[this._pos4 + 13]; }
-    get textOffset0() { return this._structArray.float32[this._pos4 + 14]; }
-    get textOffset1() { return this._structArray.float32[this._pos4 + 15]; }
-    get collisionCircleDiameter() { return this._structArray.float32[this._pos4 + 16]; }
+    get collisionCircleDiameter() { return this._structArray.float32[this._pos4 + 14]; }
+    get textAnchorOffsetStartIndex() { return this._structArray.uint16[this._pos2 + 30]; }
+    get textAnchorOffsetEndIndex() { return this._structArray.uint16[this._pos2 + 31]; }
 }
-SymbolInstanceStruct.prototype.size = 68;
-/** */
-class SymbolInstanceArray extends StructArrayLayout8i15ui1ul4f68 {
+SymbolInstanceStruct.prototype.size = 64;
+/** @internal */
+class SymbolInstanceArray extends StructArrayLayout8i15ui1ul2f2ui64 {
     /**
      * Return the SymbolInstanceStruct at the given location in the array.
      * @param index The index of the element.
@@ -13617,26 +13811,44 @@ class SymbolInstanceArray extends StructArrayLayout8i15ui1ul4f68 {
     }
 }
 register('SymbolInstanceArray', SymbolInstanceArray);
-/** */
+/** @internal */
 class GlyphOffsetArray extends StructArrayLayout1f4 {
     getoffsetX(index) { return this.float32[index * 1 + 0]; }
 }
 register('GlyphOffsetArray', GlyphOffsetArray);
-/** */
+/** @internal */
 class SymbolLineVertexArray extends StructArrayLayout3i6 {
     getx(index) { return this.int16[index * 3 + 0]; }
     gety(index) { return this.int16[index * 3 + 1]; }
     gettileUnitDistanceFromAnchor(index) { return this.int16[index * 3 + 2]; }
 }
 register('SymbolLineVertexArray', SymbolLineVertexArray);
-/** */
+/** @internal */
+class TextAnchorOffsetStruct extends Struct {
+    get textAnchor() { return this._structArray.uint16[this._pos2 + 0]; }
+    get textOffset0() { return this._structArray.float32[this._pos4 + 1]; }
+    get textOffset1() { return this._structArray.float32[this._pos4 + 2]; }
+}
+TextAnchorOffsetStruct.prototype.size = 12;
+/** @internal */
+class TextAnchorOffsetArray extends StructArrayLayout1ui2f12 {
+    /**
+     * Return the TextAnchorOffsetStruct at the given location in the array.
+     * @param index The index of the element.
+     */
+    get(index) {
+        return new TextAnchorOffsetStruct(this, index);
+    }
+}
+register('TextAnchorOffsetArray', TextAnchorOffsetArray);
+/** @internal */
 class FeatureIndexStruct extends Struct {
     get featureIndex() { return this._structArray.uint32[this._pos4 + 0]; }
     get sourceLayerIndex() { return this._structArray.uint16[this._pos2 + 2]; }
     get bucketIndex() { return this._structArray.uint16[this._pos2 + 3]; }
 }
 FeatureIndexStruct.prototype.size = 8;
-/** */
+/** @internal */
 class FeatureIndexArray extends StructArrayLayout1ul2ui8 {
     /**
      * Return the FeatureIndexStruct at the given location in the array.
@@ -13694,6 +13906,7 @@ const layout$6 = createLayout([
 const { members: members$4, size: size$4, alignment: alignment$4 } = layout$6;
 
 /**
+ * @internal
  * Used for calculations on vector segments
  */
 class SegmentVector {
@@ -14022,6 +14235,7 @@ function swap$2(arr, i, j) {
 register('FeaturePositionMap', FeaturePositionMap);
 
 /**
+ * @internal
  * A base uniform abstract class
  */
 class Uniform {
@@ -14348,6 +14562,7 @@ class CrossFadedCompositeBinder {
     }
 }
 /**
+ * @internal
  * ProgramConfiguration contains the logic for binding style layer properties and tile
  * layer feature data into GL program uniforms and vertex attributes.
  *
@@ -14703,6 +14918,7 @@ function addCircleVertex(layoutVertexArray, x, y, extrudeX, extrudeY) {
     layoutVertexArray.emplaceBack((x * 2) + ((extrudeX + 1) / 2), (y * 2) + ((extrudeY + 1) / 2));
 }
 /**
+ * @internal
  * Circles are represented by two triangles.
  *
  * Each corner has a pos that is the center of the circle and an extrusion
@@ -22872,6 +23088,7 @@ function copyImage(srcImg, dstImg, srcPt, dstPt, size, channels) {
     return dstImg;
 }
 /**
+ * @internal
  * An image with alpha color value
  */
 class AlphaImage {
@@ -24789,6 +25006,7 @@ const LINE_DISTANCE_SCALE = 1 / 2;
 // The maximum line distance, in tile units, that fits in the buffer.
 const MAX_LINE_DISTANCE = Math.pow(2, LINE_DISTANCE_BUFFER_BITS - 1) / LINE_DISTANCE_SCALE;
 /**
+ * @internal
  * Line bucket class
  */
 class LineBucket {
@@ -25388,8 +25606,9 @@ const symbolInstance = createLayout([
     { type: 'Uint16', name: 'useRuntimeCollisionCircles' },
     { type: 'Uint32', name: 'crossTileID' },
     { type: 'Float32', name: 'textBoxScale' },
-    { type: 'Float32', components: 2, name: 'textOffset' },
     { type: 'Float32', name: 'collisionCircleDiameter' },
+    { type: 'Uint16', name: 'textAnchorOffsetStartIndex' },
+    { type: 'Uint16', name: 'textAnchorOffsetEndIndex' }
 ]);
 const glyphOffset = createLayout([
     { type: 'Float32', name: 'offsetX' }
@@ -25399,6 +25618,10 @@ const lineVertex = createLayout([
     { type: 'Int16', name: 'y' },
     { type: 'Int16', name: 'tileUnitDistanceFromAnchor' }
 ]);
+const textAnchorOffset = createLayout([
+    { type: 'Uint16', name: 'textAnchor' },
+    { type: 'Float32', components: 2, name: 'textOffset' }
+]);
 
 function transformTextInternal(text, layer, feature) {
     const transform = layer.layout.get('text-transform').evaluate(feature, {});
@@ -26492,6 +26715,7 @@ class ImagePosition {
     }
 }
 /**
+ * @internal
  * A class holding all the images
  */
 class ImageAtlas {
@@ -27317,6 +27541,7 @@ class CollisionBuffers {
 }
 register('CollisionBuffers', CollisionBuffers);
 /**
+ * @internal
  * Unlike other buckets, which simply implement #addFeature with type-specific
  * logic for (essentially) triangulating feature geometries, SymbolBucket
  * requires specialized behavior:
@@ -27389,6 +27614,7 @@ class SymbolBucket {
         this.glyphOffsetArray = new GlyphOffsetArray();
         this.lineVertexArray = new SymbolLineVertexArray();
         this.symbolInstances = new SymbolInstanceArray();
+        this.textAnchorOffsets = new TextAnchorOffsetArray();
     }
     calculateGlyphDependencies(text, stack, textAlongLine, allowVerticalPlacement, doesAllowVerticalWritingMode) {
         for (let i = 0; i < text.length; i++) {
@@ -27866,6 +28092,7 @@ const getLayout = () => layout = layout || new Properties({
     "text-justify": new DataDrivenProperty(v8Spec["layout_symbol"]["text-justify"]),
     "text-radial-offset": new DataDrivenProperty(v8Spec["layout_symbol"]["text-radial-offset"]),
     "text-variable-anchor": new DataConstantProperty(v8Spec["layout_symbol"]["text-variable-anchor"]),
+    "text-variable-anchor-offset": new DataDrivenProperty(v8Spec["layout_symbol"]["text-variable-anchor-offset"]),
     "text-anchor": new DataDrivenProperty(v8Spec["layout_symbol"]["text-anchor"]),
     "text-max-angle": new DataConstantProperty(v8Spec["layout_symbol"]["text-max-angle"]),
     "text-writing-mode": new DataConstantProperty(v8Spec["layout_symbol"]["text-writing-mode"]),
@@ -28788,6 +29015,7 @@ class CanonicalTileID {
     }
 }
 /**
+ * @internal
  * An unwrapped tile identifier
  */
 class UnwrappedTileID {
@@ -29090,6 +29318,7 @@ class GeoJSONFeature {
 }
 
 /**
+ * @internal
  * An in memory index class to allow fast interaction with features
  */
 class FeatureIndex {
@@ -29995,6 +30224,18 @@ function getCentroidCell(polygon) {
     return new Cell(x / area, y / area, 0, polygon);
 }
 
+exports.TextAnchorEnum = void 0;
+(function (TextAnchorEnum) {
+    TextAnchorEnum[TextAnchorEnum["center"] = 1] = "center";
+    TextAnchorEnum[TextAnchorEnum["left"] = 2] = "left";
+    TextAnchorEnum[TextAnchorEnum["right"] = 3] = "right";
+    TextAnchorEnum[TextAnchorEnum["top"] = 4] = "top";
+    TextAnchorEnum[TextAnchorEnum["bottom"] = 5] = "bottom";
+    TextAnchorEnum[TextAnchorEnum["top-left"] = 6] = "top-left";
+    TextAnchorEnum[TextAnchorEnum["top-right"] = 7] = "top-right";
+    TextAnchorEnum[TextAnchorEnum["bottom-left"] = 8] = "bottom-left";
+    TextAnchorEnum[TextAnchorEnum["bottom-right"] = 9] = "bottom-right";
+})(exports.TextAnchorEnum || (exports.TextAnchorEnum = {}));
 // The radial offset is to the edge of the text box
 // In the horizontal direction, the edge of the text box is where glyphs start
 // But in the vertical direction, the glyphs appear to "start" at the baseline
@@ -30076,14 +30317,60 @@ function evaluateVariableOffset(anchor, offset) {
     }
     return (offset[1] !== INVALID_TEXT_OFFSET) ? fromTextOffset(anchor, offset[0], offset[1]) : fromRadialOffset(anchor, offset[0]);
 }
+// Helper to support both text-variable-anchor and text-variable-anchor-offset. Offset values converted from EMs to PXs
+function getTextVariableAnchorOffset(layer, feature, canonical) {
+    var _a;
+    const layout = layer.layout;
+    // If style specifies text-variable-anchor-offset, just return it
+    const variableAnchorOffset = (_a = layout.get('text-variable-anchor-offset')) === null || _a === void 0 ? void 0 : _a.evaluate(feature, {}, canonical);
+    if (variableAnchorOffset) {
+        const sourceValues = variableAnchorOffset.values;
+        const destValues = [];
+        // Convert offsets from EM to PX, and apply baseline shift
+        for (let i = 0; i < sourceValues.length; i += 2) {
+            const anchor = destValues[i] = sourceValues[i];
+            const offset = sourceValues[i + 1].map(t => t * ONE_EM);
+            if (anchor.startsWith('top')) {
+                offset[1] -= baselineOffset;
+            }
+            else if (anchor.startsWith('bottom')) {
+                offset[1] += baselineOffset;
+            }
+            destValues[i + 1] = offset;
+        }
+        return new VariableAnchorOffsetCollection(destValues);
+    }
+    // If style specifies text-variable-anchor, convert to the new format
+    const variableAnchor = layout.get('text-variable-anchor');
+    if (variableAnchor) {
+        let textOffset;
+        const unevaluatedLayout = layer._unevaluatedLayout;
+        // The style spec says don't use `text-offset` and `text-radial-offset` together
+        // but doesn't actually specify what happens if you use both. We go with the radial offset.
+        if (unevaluatedLayout.getValue('text-radial-offset') !== undefined) {
+            textOffset = [layout.get('text-radial-offset').evaluate(feature, {}, canonical) * ONE_EM, INVALID_TEXT_OFFSET];
+        }
+        else {
+            textOffset = layout.get('text-offset').evaluate(feature, {}, canonical).map(t => t * ONE_EM);
+        }
+        const anchorOffsets = [];
+        for (const anchor of variableAnchor) {
+            anchorOffsets.push(anchor, evaluateVariableOffset(anchor, textOffset));
+        }
+        return new VariableAnchorOffsetCollection(anchorOffsets);
+    }
+    return null;
+}
+
 function performSymbolLayout(args) {
     args.bucket.createArrays();
     const tileSize = 512 * args.bucket.overscaling;
     args.bucket.tilePixelRatio = EXTENT / tileSize;
     args.bucket.compareText = {};
     args.bucket.iconsNeedLinear = false;
-    const layout = args.bucket.layers[0].layout;
-    const unevaluatedLayoutValues = args.bucket.layers[0]._unevaluatedLayout._values;
+    const layer = args.bucket.layers[0];
+    const layout = layer.layout;
+    const unevaluatedLayoutValues = layer._unevaluatedLayout._values;
     const sizes = {
         // Filled in below, if *SizeData.kind is 'composite'
         // compositeIconSizes: undefined,
@@ -30126,8 +30413,8 @@ function performSymbolLayout(args) {
             const spacing = layout.get('text-letter-spacing').evaluate(feature, {}, args.canonical) * ONE_EM;
             const spacingIfAllowed = allowsLetterSpacing(unformattedText) ? spacing : 0;
             const textAnchor = layout.get('text-anchor').evaluate(feature, {}, args.canonical);
-            const variableTextAnchor = layout.get('text-variable-anchor');
-            if (!variableTextAnchor) {
+            const variableAnchorOffset = getTextVariableAnchorOffset(layer, feature, args.canonical);
+            if (!variableAnchorOffset) {
                 const radialOffset = layout.get('text-radial-offset').evaluate(feature, {}, args.canonical);
                 // Layers with variable anchors use the `text-radial-offset` property and the [x, y] offset vector
                 // is calculated at placement time instead of layout time
@@ -30156,13 +30443,18 @@ function performSymbolLayout(args) {
                 }
             };
             // If this layer uses text-variable-anchor, generate shapings for all justification possibilities.
-            if (!textAlongLine && variableTextAnchor) {
-                const justifications = textJustify === 'auto' ?
-                    variableTextAnchor.map(a => getAnchorJustification(a)) :
-                    [textJustify];
+            if (!textAlongLine && variableAnchorOffset) {
+                const justifications = new Set();
+                if (textJustify === 'auto') {
+                    for (let i = 0; i < variableAnchorOffset.values.length; i += 2) {
+                        justifications.add(getAnchorJustification(variableAnchorOffset.values[i]));
+                    }
+                }
+                else {
+                    justifications.add(textJustify);
+                }
                 let singleLine = false;
-                for (let i = 0; i < justifications.length; i++) {
-                    const justification = justifications[i];
+                for (const justification of justifications) {
                     if (shapedTextOrientations.horizontal[justification])
                         continue;
                     if (singleLine) {
@@ -30327,6 +30619,18 @@ function addFeature(bucket, feature, shapedTextOrientations, shapedIcon, imageMa
         }
     }
 }
+function addTextVariableAnchorOffsets(textAnchorOffsets, variableAnchorOffset) {
+    const startIndex = textAnchorOffsets.length;
+    const values = variableAnchorOffset === null || variableAnchorOffset === void 0 ? void 0 : variableAnchorOffset.values;
+    if ((values === null || values === void 0 ? void 0 : values.length) > 0) {
+        for (let i = 0; i < values.length; i += 2) {
+            const anchor = exports.TextAnchorEnum[values[i]];
+            const offset = values[i + 1];
+            textAnchorOffsets.emplaceBack(anchor, offset[0], offset[1]);
+        }
+    }
+    return [startIndex, textAnchorOffsets.length];
+}
 function addTextVertices(bucket, anchor, shapedText, imageMap, layer, textAlongLine, feature, textOffset, lineArray, writingMode, placementTypes, placedTextSymbolIndices, placedIconIndex, sizes, canonical) {
     const glyphQuads = getGlyphQuads(anchor, shapedText, textOffset, layer, textAlongLine, feature, imageMap, bucket.allowVerticalPlacement);
     const sizeData = bucket.textSizeData;
@@ -30378,15 +30682,6 @@ function addSymbol(bucket, anchor, line, shapedTextOrientations, shapedIcon, ima
     let verticalPlacedIconSymbolIndex = -1;
     const placedTextSymbolIndices = {};
     let key = murmur3$1('');
-    let textOffset0 = 0;
-    let textOffset1 = 0;
-    if (layer._unevaluatedLayout.getValue('text-radial-offset') === undefined) {
-        [textOffset0, textOffset1] = layer.layout.get('text-offset').evaluate(feature, {}, canonical).map(t => t * ONE_EM);
-    }
-    else {
-        textOffset0 = layer.layout.get('text-radial-offset').evaluate(feature, {}, canonical) * ONE_EM;
-        textOffset1 = INVALID_TEXT_OFFSET;
-    }
     if (bucket.allowVerticalPlacement && shapedTextOrientations.vertical) {
         const textRotation = layer.layout.get('text-rotate').evaluate(feature, {}, canonical);
         const verticalTextRotation = textRotation + 90.0;
@@ -30487,7 +30782,9 @@ function addSymbol(bucket, anchor, line, shapedTextOrientations, shapedIcon, ima
     if (feature.sortKey !== undefined) {
         bucket.addToSortKeyRanges(bucket.symbolInstances.length, feature.sortKey);
     }
-    bucket.symbolInstances.emplaceBack(anchor.x, anchor.y, placedTextSymbolIndices.right >= 0 ? placedTextSymbolIndices.right : -1, placedTextSymbolIndices.center >= 0 ? placedTextSymbolIndices.center : -1, placedTextSymbolIndices.left >= 0 ? placedTextSymbolIndices.left : -1, placedTextSymbolIndices.vertical || -1, placedIconSymbolIndex, verticalPlacedIconSymbolIndex, key, textBoxStartIndex, textBoxEndIndex, verticalTextBoxStartIndex, verticalTextBoxEndIndex, iconBoxStartIndex, iconBoxEndIndex, verticalIconBoxStartIndex, verticalIconBoxEndIndex, featureIndex, numHorizontalGlyphVertices, numVerticalGlyphVertices, numIconVertices, numVerticalIconVertices, useRuntimeCollisionCircles, 0, textBoxScale, textOffset0, textOffset1, collisionCircleDiameter);
+    const variableAnchorOffset = getTextVariableAnchorOffset(layer, feature, canonical);
+    const [textAnchorOffsetStartIndex, textAnchorOffsetEndIndex] = addTextVariableAnchorOffsets(bucket.textAnchorOffsets, variableAnchorOffset);
+    bucket.symbolInstances.emplaceBack(anchor.x, anchor.y, placedTextSymbolIndices.right >= 0 ? placedTextSymbolIndices.right : -1, placedTextSymbolIndices.center >= 0 ? placedTextSymbolIndices.center : -1, placedTextSymbolIndices.left >= 0 ? placedTextSymbolIndices.left : -1, placedTextSymbolIndices.vertical || -1, placedIconSymbolIndex, verticalPlacedIconSymbolIndex, key, textBoxStartIndex, textBoxEndIndex, verticalTextBoxStartIndex, verticalTextBoxEndIndex, iconBoxStartIndex, iconBoxEndIndex, verticalIconBoxStartIndex, verticalIconBoxEndIndex, featureIndex, numHorizontalGlyphVertices, numVerticalGlyphVertices, numIconVertices, numVerticalIconVertices, useRuntimeCollisionCircles, 0, textBoxScale, collisionCircleDiameter, textAnchorOffsetStartIndex, textAnchorOffsetEndIndex);
 }
 function anchorIsTooClose(bucket, text, repeatDistance, anchor) {
     const compareText = bucket.compareText;
@@ -30893,9 +31190,8 @@ const PerformanceUtils = {
     }
 };
 /**
+ * @internal
  * Safe wrapper for the performance resource timing API in web workers with graceful degradation
- *
- * @hidden
  */
 class RequestPerformance {
     constructor(request) {
@@ -31010,7 +31306,6 @@ exports.emptyStyle = emptyStyle;
 exports.equals = equals$6;
 exports.evaluateSizeForFeature = evaluateSizeForFeature;
 exports.evaluateSizeForZoom = evaluateSizeForZoom;
-exports.evaluateVariableOffset = evaluateVariableOffset;
 exports.evented = evented;
 exports.extend = extend;
 exports.filterObject = filterObject;
@@ -31404,6 +31699,7 @@ class VectorTileWorkerSource {
         this.layerIndex = layerIndex;
         this.availableImages = availableImages;
         this.loadVectorData = loadVectorData || loadVectorTile;
+        this.fetching = {};
         this.loading = {};
         this.loaded = {};
     }
@@ -31442,6 +31738,7 @@ class VectorTileWorkerSource {
             }
             workerTile.vectorTile = response.vectorTile;
             workerTile.parse(response.vectorTile, this.layerIndex, this.availableImages, this.actor, (err, result) => {
+                delete this.fetching[uid];
                 if (err || !result)
                     return callback(err);
                 // Transferring a copy of rawTileData because the worker needs to retain its copy.
@@ -31449,6 +31746,8 @@ class VectorTileWorkerSource {
             });
             this.loaded = this.loaded || {};
             this.loaded[uid] = workerTile;
+            // keep the original fetching state so that reload tile can pick it up if the original parse is cancelled by reloads' parse
+            this.fetching[uid] = { rawTileData, cacheControl, resourceTiming };
         });
     }
     /**
@@ -31461,7 +31760,21 @@ class VectorTileWorkerSource {
             const workerTile = loaded[uid];
             workerTile.showCollisionBoxes = params.showCollisionBoxes;
             if (workerTile.status === 'parsing') {
-                workerTile.parse(workerTile.vectorTile, this.layerIndex, this.availableImages, this.actor, callback);
+                workerTile.parse(workerTile.vectorTile, this.layerIndex, this.availableImages, this.actor, (err, result) => {
+                    if (err || !result)
+                        return callback(err, result);
+                    // if we have cancelled the original parse, make sure to pass the rawTileData from the original fetch
+                    let parseResult;
+                    if (this.fetching[uid]) {
+                        const { rawTileData, cacheControl, resourceTiming } = this.fetching[uid];
+                        delete this.fetching[uid];
+                        parseResult = performance.extend({ rawTileData: rawTileData.slice(0) }, result, cacheControl, resourceTiming);
+                    }
+                    else {
+                        parseResult = result;
+                    }
+                    callback(null, parseResult);
+                });
             }
             else if (workerTile.status === 'done') {
                 // if there was no vector tile data on the initial load, don't try and re-parse tile
@@ -33716,7 +34029,7 @@ define(['./shared'], (function (performance) { 'use strict';
 
 var name = "maplibre-gl";
 var description = "BSD licensed community fork of mapbox-gl, a WebGL interactive maps library";
-var version$2 = "3.2.1";
+var version$2 = "3.3.0";
 var main = "dist/maplibre-gl.js";
 var style = "dist/maplibre-gl.css";
 var license = "BSD-3-Clause";
@@ -33735,7 +34048,7 @@ var dependencies = {
 	"@mapbox/unitbezier": "^0.0.1",
 	"@mapbox/vector-tile": "^1.3.1",
 	"@mapbox/whoots-js": "^3.1.0",
-	"@maplibre/maplibre-gl-style-spec": "^19.2.2",
+	"@maplibre/maplibre-gl-style-spec": "^19.3.0",
 	"@types/geojson": "^7946.0.10",
 	"@types/mapbox__point-geometry": "^0.1.2",
 	"@types/mapbox__vector-tile": "^1.3.0",
@@ -33769,7 +34082,7 @@ var devDependencies = {
 	"@types/d3": "^7.4.0",
 	"@types/diff": "^5.0.3",
 	"@types/earcut": "^2.1.1",
-	"@types/eslint": "^8.44.0",
+	"@types/eslint": "^8.44.2",
 	"@types/gl": "^6.0.2",
 	"@types/glob": "^8.1.0",
 	"@types/jest": "^29.5.3",
@@ -33777,40 +34090,40 @@ var devDependencies = {
 	"@types/minimist": "^1.2.2",
 	"@types/murmurhash-js": "^1.0.4",
 	"@types/nise": "^1.4.1",
-	"@types/node": "^20.4.4",
+	"@types/node": "^20.4.8",
 	"@types/offscreencanvas": "^2019.7.0",
 	"@types/pixelmatch": "^5.2.4",
 	"@types/pngjs": "^6.0.1",
-	"@types/react": "^18.2.15",
+	"@types/react": "^18.2.18",
 	"@types/react-dom": "^18.2.7",
 	"@types/request": "^2.48.8",
 	"@types/shuffle-seed": "^1.1.0",
 	"@types/window-or-global": "^1.0.4",
-	"@typescript-eslint/eslint-plugin": "^5.61.0",
-	"@typescript-eslint/parser": "^5.62.0",
+	"@typescript-eslint/eslint-plugin": "^6.2.1",
+	"@typescript-eslint/parser": "^6.2.1",
 	address: "^1.2.2",
 	benchmark: "^2.1.4",
 	canvas: "^2.11.2",
 	cssnano: "^6.0.1",
 	d3: "^7.8.5",
 	"d3-queue": "^3.0.7",
-	"devtools-protocol": "^0.0.1170846",
+	"devtools-protocol": "^0.0.1179426",
 	diff: "^5.1.0",
 	"dts-bundle-generator": "^8.0.1",
-	eslint: "^8.45.0",
+	eslint: "^8.46.0",
 	"eslint-config-mourner": "^3.0.0",
 	"eslint-plugin-html": "^7.1.0",
-	"eslint-plugin-import": "^2.27.5",
+	"eslint-plugin-import": "^2.28.0",
 	"eslint-plugin-jest": "^27.2.3",
+	"eslint-plugin-react": "^7.33.1",
 	"eslint-plugin-tsdoc": "0.2.17",
-	"eslint-plugin-react": "^7.33.0",
-	expect: "^29.5.0",
+	expect: "^29.6.2",
 	gl: "^6.0.2",
 	glob: "^10.3.3",
 	"is-builtin-module": "^3.2.1",
-	jest: "^29.6.1",
+	jest: "^29.6.2",
 	"jest-canvas-mock": "^2.5.2",
-	"jest-environment-jsdom": "^29.6.1",
+	"jest-environment-jsdom": "^29.6.2",
 	jsdom: "^22.1.0",
 	"json-stringify-pretty-compact": "^4.0.0",
 	minimist: "^1.2.8",
@@ -33822,14 +34135,14 @@ var devDependencies = {
 	"pdf-merger-js": "^4.3.0",
 	pixelmatch: "^5.3.0",
 	pngjs: "^7.0.0",
-	postcss: "^8.4.26",
+	postcss: "^8.4.27",
 	"postcss-cli": "^10.1.0",
 	"postcss-inline-svg": "^6.0.0",
 	"pretty-bytes": "^6.1.1",
-	puppeteer: "^20.9.0",
+	puppeteer: "^21.0.1",
 	react: "^18.2.0",
 	"react-dom": "^18.2.0",
-	rollup: "^3.26.3",
+	rollup: "^3.27.2",
 	"rollup-plugin-sourcemaps": "^0.6.3",
 	rw: "^1.3.3",
 	semver: "^7.5.4",
@@ -33840,10 +34153,10 @@ var devDependencies = {
 	"stylelint-config-standard": "^34.0.0",
 	"ts-jest": "^29.1.1",
 	"ts-node": "^10.9.1",
-	tslib: "^2.6.0",
+	tslib: "^2.6.1",
 	typedoc: "^0.24.8",
-	"typedoc-plugin-markdown": "^3.15.3",
-	"typedoc-plugin-missing-exports": "^2.0.0",
+	"typedoc-plugin-markdown": "^3.15.4",
+	"typedoc-plugin-missing-exports": "^2.0.1",
 	typescript: "^5.1.6"
 };
 var overrides = {
@@ -34210,7 +34523,7 @@ var ImageRequest;
         if (err) {
             callback(err);
         }
-        else if (data instanceof HTMLImageElement || data instanceof ImageBitmap) {
+        else if (data instanceof HTMLImageElement || performance.isImageBitmap(data)) {
             // User using addProtocol can directly return HTMLImageElement/ImageBitmap type
             // If HtmlImageElement is used to get image then response type will be HTMLImageElement
             callback(null, data);
@@ -34423,6 +34736,7 @@ function doOnceCompleted(callbackFunc, jsonsMap, imagesMap, err, expectedResultC
 }
 
 /**
+ * @internal
  * A `Texture` GL related object
  */
 class Texture {
@@ -35165,6 +35479,7 @@ class Light extends performance.Evented {
 }
 
 /**
+ * @internal
  * A LineAtlas lets us reuse rendered dashed lines
  * by writing many of them to a texture and then fetching their positions
  * using {@link LineAtlas#getDash}.
@@ -36219,9 +36534,7 @@ class RasterDEMTileSource extends RasterTileSource {
  * @see [Create and style clusters](https://maplibre.org/maplibre-gl-js/docs/examples/cluster/)
  */
 class GeoJSONSource extends performance.Evented {
-    /**
-     * @hidden
-     */
+    /** @internal */
     constructor(id, options, dispatcher, eventedParent) {
         super();
         this.load = () => {
@@ -36546,9 +36859,7 @@ var rasterBoundsAttributes = performance.createLayout([
  * ```
  */
 class ImageSource extends performance.Evented {
-    /**
-     * @hidden
-     */
+    /** @internal */
     constructor(id, options, dispatcher, eventedParent) {
         super();
         this.load = (newCoordinates, successCallback) => {
@@ -36722,7 +37033,7 @@ class ImageSource extends performance.Evented {
  * Given a list of coordinates, get their center as a coordinate.
  *
  * @returns centerpoint
- * @hidden
+ * @internal
  */
 function getCoordinatesCenterTileID(coords) {
     let minX = Infinity;
@@ -36943,9 +37254,7 @@ class VideoSource extends ImageSource {
  * ```
  */
 class CanvasSource extends ImageSource {
-    /**
-     * @hidden
-     */
+    /** @internal */
     constructor(id, options, dispatcher, eventedParent) {
         super(id, options, dispatcher, eventedParent);
         this.load = () => {
@@ -37297,6 +37606,7 @@ function deserialize(input, style) {
 
 const CLOCK_SKEW_RETRY_TIMEOUT = 30000;
 /**
+ * @internal
  * A tile object is the combination of a Coordinate, which defines
  * its place, as well as a unique ID and data tracking for its content
  */
@@ -37627,10 +37937,10 @@ class Tile {
 }
 
 /**
+ * @internal
  * A [least-recently-used cache](http://en.wikipedia.org/wiki/Cache_algorithms)
  * with hash lookup made possible by keeping a list of keys in parallel to
  * an array of dictionary of values
- *
  */
 class TileCache {
     /**
@@ -37808,6 +38118,7 @@ class TileCache {
 }
 
 /**
+ * @internal
  * SourceFeatureState manages the state and pending changes
  * to features in a source, separated by source layer.
  * stateChanges and deletedStates batch all changes to the tile (updates and removes, respectively)
@@ -37949,6 +38260,7 @@ class SourceFeatureState {
 }
 
 /**
+ * @internal
  * `SourceCache` is responsible for
  *
  *  - creating an instance of `Source`
@@ -38941,6 +39253,7 @@ function overlapAllowed(overlapA, overlapB) {
     return allowed;
 }
 /**
+ * @internal
  * GridIndex is a data structure for testing the intersection of
  * circles and rectangles in a 2d plane.
  * It is optimized for rapid insertion and querying.
@@ -39706,6 +40019,7 @@ function xyTransformMat4(out, a, m) {
 // stability, but it's expensive.
 const viewportPadding = 100;
 /**
+ * @internal
  * A collision index used to prevent symbols from overlapping. It keep tracks of
  * where previous symbols have been placed and is used to check if a new
  * symbol overlaps with any previously added symbols.
@@ -40060,8 +40374,7 @@ function calculateVariableLayoutShift(anchor, width, height, textOffset, textBox
     const { horizontalAlign, verticalAlign } = performance.getAnchorAlignment(anchor);
     const shiftX = -(horizontalAlign - 0.5) * width;
     const shiftY = -(verticalAlign - 0.5) * height;
-    const offset = performance.evaluateVariableOffset(anchor, textOffset);
-    return new performance.Point(shiftX + offset[0] * textBoxScale, shiftY + offset[1] * textBoxScale);
+    return new performance.Point(shiftX + textOffset[0] * textBoxScale, shiftY + textOffset[1] * textBoxScale);
 }
 function shiftVariableCollisionBox(collisionBox, shiftX, shiftY, rotateWithMap, pitchWithMap, angle) {
     const { x1, x2, y1, y2, anchorPointX, anchorPointY } = collisionBox;
@@ -40148,8 +40461,9 @@ class Placement {
             });
         }
     }
-    attemptAnchorPlacement(anchor, textBox, width, height, textBoxScale, rotateWithMap, pitchWithMap, textPixelRatio, posMatrix, collisionGroup, textOverlapMode, symbolInstance, bucket, orientation, iconBox, getElevation) {
-        const textOffset = [symbolInstance.textOffset0, symbolInstance.textOffset1];
+    attemptAnchorPlacement(textAnchorOffset, textBox, width, height, textBoxScale, rotateWithMap, pitchWithMap, textPixelRatio, posMatrix, collisionGroup, textOverlapMode, symbolInstance, bucket, orientation, iconBox, getElevation) {
+        const anchor = performance.TextAnchorEnum[textAnchorOffset.textAnchor];
+        const textOffset = [textAnchorOffset.textOffset0, textAnchorOffset.textOffset1];
         const shift = calculateVariableLayoutShift(anchor, width, height, textOffset, textBoxScale);
         const placedGlyphBoxes = this.collisionIndex.placeCollisionBox(shiftVariableCollisionBox(textBox, shift.x, shift.y, rotateWithMap, pitchWithMap, this.transform.angle), textOverlapMode, textPixelRatio, posMatrix, collisionGroup.predicate, getElevation);
         if (iconBox) {
@@ -40219,6 +40533,7 @@ class Placement {
         const tileID = this.retainedQueryData[bucket.bucketInstanceId].tileID;
         const getElevation = this.terrain ? (x, y) => this.terrain.getElevation(tileID, x, y) : null;
         const placeSymbol = (symbolInstance, collisionArrays) => {
+            var _a, _b;
             if (seenCrossTileIDs[symbolInstance.crossTileID])
                 return;
             if (holdingForFade) {
@@ -40280,7 +40595,10 @@ class Placement {
                         placed = placeHorizontalFn();
                     }
                 };
-                if (!layout.get('text-variable-anchor')) {
+                const textAnchorOffsetStart = symbolInstance.textAnchorOffsetStartIndex;
+                const textAnchorOffsetEnd = symbolInstance.textAnchorOffsetEndIndex;
+                // If start+end indices match, text-variable-anchor is not in play.
+                if (textAnchorOffsetEnd === textAnchorOffsetStart) {
                     const placeBox = (collisionTextBox, orientation) => {
                         const placedFeature = this.collisionIndex.placeCollisionBox(collisionTextBox, textOverlapMode, textPixelRatio, posMatrix, collisionGroup.predicate, getElevation);
                         if (placedFeature && placedFeature.box && placedFeature.box.length) {
@@ -40303,36 +40621,41 @@ class Placement {
                     updatePreviousOrientationIfNotPlaced(placed && placed.box && placed.box.length);
                 }
                 else {
-                    let anchors = layout.get('text-variable-anchor');
-                    // If this symbol was in the last placement, shift the previously used
-                    // anchor to the front of the anchor list, only if the previous anchor
-                    // is still in the anchor list
-                    if (this.prevPlacement && this.prevPlacement.variableOffsets[symbolInstance.crossTileID]) {
-                        const prevOffsets = this.prevPlacement.variableOffsets[symbolInstance.crossTileID];
-                        if (anchors.indexOf(prevOffsets.anchor) > 0) {
-                            anchors = anchors.filter(anchor => anchor !== prevOffsets.anchor);
-                            anchors.unshift(prevOffsets.anchor);
-                        }
-                    }
+                    // If this symbol was in the last placement, prefer placement using same anchor, if it's still available
+                    let prevAnchor = performance.TextAnchorEnum[(_b = (_a = this.prevPlacement) === null || _a === void 0 ? void 0 : _a.variableOffsets[symbolInstance.crossTileID]) === null || _b === void 0 ? void 0 : _b.anchor];
                     const placeBoxForVariableAnchors = (collisionTextBox, collisionIconBox, orientation) => {
                         const width = collisionTextBox.x2 - collisionTextBox.x1;
                         const height = collisionTextBox.y2 - collisionTextBox.y1;
                         const textBoxScale = symbolInstance.textBoxScale;
                         const variableIconBox = hasIconTextFit && (iconOverlapMode === 'never') ? collisionIconBox : null;
                         let placedBox = { box: [], offscreen: false };
-                        const placementAttempts = (textOverlapMode !== 'never') ? anchors.length * 2 : anchors.length;
-                        for (let i = 0; i < placementAttempts; ++i) {
-                            const anchor = anchors[i % anchors.length];
-                            const overlapMode = (i >= anchors.length) ? textOverlapMode : 'never';
-                            const result = this.attemptAnchorPlacement(anchor, collisionTextBox, width, height, textBoxScale, rotateWithMap, pitchWithMap, textPixelRatio, posMatrix, collisionGroup, overlapMode, symbolInstance, bucket, orientation, variableIconBox, getElevation);
-                            if (result) {
-                                placedBox = result.placedGlyphBoxes;
-                                if (placedBox && placedBox.box && placedBox.box.length) {
-                                    placeText = true;
-                                    shift = result.shift;
-                                    break;
+                        let placementPasses = (textOverlapMode === 'never') ? 1 : 2;
+                        let overlapMode = 'never';
+                        if (prevAnchor) {
+                            placementPasses++;
+                        }
+                        for (let pass = 0; pass < placementPasses; pass++) {
+                            for (let i = textAnchorOffsetStart; i < textAnchorOffsetEnd; i++) {
+                                const textAnchorOffset = bucket.textAnchorOffsets.get(i);
+                                if (prevAnchor && textAnchorOffset.textAnchor !== prevAnchor) {
+                                    continue;
+                                }
+                                const result = this.attemptAnchorPlacement(textAnchorOffset, collisionTextBox, width, height, textBoxScale, rotateWithMap, pitchWithMap, textPixelRatio, posMatrix, collisionGroup, overlapMode, symbolInstance, bucket, orientation, variableIconBox, getElevation);
+                                if (result) {
+                                    placedBox = result.placedGlyphBoxes;
+                                    if (placedBox && placedBox.box && placedBox.box.length) {
+                                        placeText = true;
+                                        shift = result.shift;
+                                        return placedBox;
+                                    }
                                 }
                             }
+                            if (prevAnchor) {
+                                prevAnchor = null;
+                            }
+                            else {
+                                overlapMode = textOverlapMode;
+                            }
                         }
                         return placedBox;
                     };
@@ -40603,11 +40926,12 @@ class Placement {
             bucket.iconCollisionBox.collisionVertexArray.clear();
         if (bucket.hasTextCollisionBoxData())
             bucket.textCollisionBox.collisionVertexArray.clear();
-        const layout = bucket.layers[0].layout;
+        const layer = bucket.layers[0];
+        const layout = layer.layout;
         const duplicateOpacityState = new JointOpacityState(null, 0, false, false, true);
         const textAllowOverlap = layout.get('text-allow-overlap');
         const iconAllowOverlap = layout.get('icon-allow-overlap');
-        const variablePlacement = layout.get('text-variable-anchor');
+        const hasVariablePlacement = layer._unevaluatedLayout.hasValue('text-variable-anchor') || layer._unevaluatedLayout.hasValue('text-variable-anchor-offset');
         const rotateWithMap = layout.get('text-rotation-alignment') === 'map';
         const pitchWithMap = layout.get('text-pitch-alignment') === 'map';
         const hasIconTextFit = layout.get('icon-text-fit') !== 'none';
@@ -40701,7 +41025,7 @@ class Placement {
                     let shift = new performance.Point(0, 0);
                     if (collisionArrays.textBox || collisionArrays.verticalTextBox) {
                         let used = true;
-                        if (variablePlacement) {
+                        if (hasVariablePlacement) {
                             const variableOffset = this.variableOffsets[crossTileID];
                             if (variableOffset) {
                                 // This will show either the currently placed position or the last
@@ -41497,6 +41821,7 @@ class Style extends performance.Evented {
         }
     }
     /**
+     * @internal
      * Apply queued style updates in a batch and recalculate zoom-dependent paint properties.
      */
     update(parameters) {
@@ -42598,7 +42923,7 @@ var symbolIconFrag = 'uniform sampler2D u_texture;varying vec2 v_tex;varying flo
 var symbolIconVert = 'const float PI=3.141592653589793;attribute vec4 a_pos_offset;attribute vec4 a_data;attribute vec4 a_pixeloffset;attribute vec3 a_projected_pos;attribute float a_fade_opacity;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform highp float u_camera_to_center_distance;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform float u_fade_change;uniform mat4 u_matrix;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform vec2 u_texsize;varying vec2 v_tex;varying float v_fade_opacity;\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\nvec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=a_data.xy;vec2 a_size=a_data.zw;float a_size_min=floor(a_size[0]*0.5);vec2 a_pxoffset=a_pixeloffset.xy;vec2 a_minFontScale=a_pixeloffset.zw/256.0;float ele=get_elevation(a_pos);highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec4 projectedPoint=u_matrix*vec4(a_pos,ele,1);highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?\ncamera_to_anchor_distance/u_camera_to_center_distance :\nu_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);size*=perspective_ratio;float fontScale=u_is_text ? size/24.0 : size;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=u_matrix*vec4(a_pos+vec2(1,0),ele,1);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy,ele,1.0);float z=float(u_pitch_with_map)*projected_pos.z/projected_pos.w;gl_Position=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*max(a_minFontScale,fontScale)+a_pxoffset/16.0),z,1.0);v_tex=a_tex/u_texsize;vec2 fade_opacity=unpack_opacity(a_fade_opacity);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;float visibility=calculate_visibility(projectedPoint);v_fade_opacity=max(0.0,min(visibility,fade_opacity[0]+fade_change));}';
 
 // This file is generated. Edit build/generate-shaders.ts, then run `npm run codegen`.
-var symbolSDFFrag = '#define SDF_PX 8.0\nuniform bool u_is_halo;uniform sampler2D u_texture;uniform highp float u_gamma_scale;uniform lowp float u_device_pixel_ratio;uniform bool u_is_text;varying vec2 v_data0;varying vec3 v_data1;\n#pragma mapbox: define highp vec4 fill_color\n#pragma mapbox: define highp vec4 halo_color\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float halo_width\n#pragma mapbox: define lowp float halo_blur\nvoid main() {\n#pragma mapbox: initialize highp vec4 fill_color\n#pragma mapbox: initialize highp vec4 halo_color\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize lowp float halo_width\n#pragma mapbox: initialize lowp float halo_blur\nfloat EDGE_GAMMA=0.105/u_device_pixel_ratio;vec2 tex=v_data0.xy;float gamma_scale=v_data1.x;float size=v_data1.y;float fade_opacity=v_data1[2];float fontScale=u_is_text ? size/24.0 : size;lowp vec4 color=fill_color;highp float gamma=EDGE_GAMMA/(fontScale*u_gamma_scale);lowp float buff=(256.0-64.0)/256.0;if (u_is_halo) {color=halo_color;gamma=(halo_blur*1.19/SDF_PX+EDGE_GAMMA)/(fontScale*u_gamma_scale);buff=(6.0-halo_width/fontScale)/SDF_PX;}lowp float dist=texture2D(u_texture,tex).a;highp float gamma_scaled=gamma*gamma_scale;highp float alpha=smoothstep(buff-gamma_scaled,buff+gamma_scaled,dist);gl_FragColor=color*(alpha*opacity*fade_opacity);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}';
+var symbolSDFFrag = '#define SDF_PX 8.0\nuniform bool u_is_halo;uniform sampler2D u_texture;uniform highp float u_gamma_scale;uniform lowp float u_device_pixel_ratio;uniform bool u_is_text;varying vec2 v_data0;varying vec3 v_data1;\n#pragma mapbox: define highp vec4 fill_color\n#pragma mapbox: define highp vec4 halo_color\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float halo_width\n#pragma mapbox: define lowp float halo_blur\nvoid main() {\n#pragma mapbox: initialize highp vec4 fill_color\n#pragma mapbox: initialize highp vec4 halo_color\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize lowp float halo_width\n#pragma mapbox: initialize lowp float halo_blur\nfloat EDGE_GAMMA=0.105/u_device_pixel_ratio;vec2 tex=v_data0.xy;float gamma_scale=v_data1.x;float size=v_data1.y;float fade_opacity=v_data1[2];float fontScale=u_is_text ? size/24.0 : size;lowp vec4 color=fill_color;highp float gamma=EDGE_GAMMA/(fontScale*u_gamma_scale);lowp float inner_edge=(256.0-64.0)/256.0;if (u_is_halo) {color=halo_color;gamma=(halo_blur*1.19/SDF_PX+EDGE_GAMMA)/(fontScale*u_gamma_scale);inner_edge=inner_edge+gamma*gamma_scale;}lowp float dist=texture2D(u_texture,tex).a;highp float gamma_scaled=gamma*gamma_scale;highp float alpha=smoothstep(inner_edge-gamma_scaled,inner_edge+gamma_scaled,dist);if (u_is_halo) {lowp float halo_edge=(6.0-halo_width/fontScale)/SDF_PX;alpha=min(smoothstep(halo_edge-gamma_scaled,halo_edge+gamma_scaled,dist),1.0-alpha);}gl_FragColor=color*(alpha*opacity*fade_opacity);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}';
 
 // This file is generated. Edit build/generate-shaders.ts, then run `npm run codegen`.
 var symbolSDFVert = 'const float PI=3.141592653589793;attribute vec4 a_pos_offset;attribute vec4 a_data;attribute vec4 a_pixeloffset;attribute vec3 a_projected_pos;attribute float a_fade_opacity;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform mat4 u_matrix;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform highp float u_camera_to_center_distance;uniform float u_fade_change;uniform vec2 u_texsize;varying vec2 v_data0;varying vec3 v_data1;\n#pragma mapbox: define highp vec4 fill_color\n#pragma mapbox: define highp vec4 halo_color\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float halo_width\n#pragma mapbox: define lowp float halo_blur\nvoid main() {\n#pragma mapbox: initialize highp vec4 fill_color\n#pragma mapbox: initialize highp vec4 halo_color\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize lowp float halo_width\n#pragma mapbox: initialize lowp float halo_blur\nvec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=a_data.xy;vec2 a_size=a_data.zw;float a_size_min=floor(a_size[0]*0.5);vec2 a_pxoffset=a_pixeloffset.xy;float ele=get_elevation(a_pos);highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec4 projectedPoint=u_matrix*vec4(a_pos,ele,1);highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?\ncamera_to_anchor_distance/u_camera_to_center_distance :\nu_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);size*=perspective_ratio;float fontScale=u_is_text ? size/24.0 : size;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=u_matrix*vec4(a_pos+vec2(1,0),ele,1);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy,ele,1.0);float z=float(u_pitch_with_map)*projected_pos.z/projected_pos.w;gl_Position=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*fontScale+a_pxoffset),z,1.0);float gamma_scale=gl_Position.w;vec2 fade_opacity=unpack_opacity(a_fade_opacity);float visibility=calculate_visibility(projectedPoint);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;float interpolated_fade_opacity=max(0.0,min(visibility,fade_opacity[0]+fade_change));v_data0=a_tex/u_texsize;v_data1=vec3(gamma_scale,size,interpolated_fade_opacity);}';
@@ -42755,6 +43080,7 @@ uniform ${precision} ${type} u_${name};
 }
 
 /**
+ * @internal
  * A vertex array object used to pass data to the webgl code
  */
 class VertexArrayObject {
@@ -42915,6 +43241,7 @@ function getTokenizedAttributesAndUniforms(array) {
     return result;
 }
 /**
+ * @internal
  * A webgl program to execute in the GPU space
  */
 class Program {
@@ -43648,6 +43975,7 @@ const programUniforms = {
 };
 
 /**
+ * @internal
  * an index buffer class
  */
 class IndexBuffer {
@@ -43701,6 +44029,7 @@ const AttributeType = {
     Float32: 'FLOAT'
 };
 /**
+ * @internal
  * The `VertexBuffer` class turns a `StructArray` into a WebGL buffer. Each member of the StructArray's
  * Struct type is converted to a WebGL attribute.
  */
@@ -44279,6 +44608,7 @@ class DepthStencilAttachment extends FramebufferAttachment {
 }
 
 /**
+ * @internal
  * A framebuffer holder object
  */
 class Framebuffer {
@@ -44329,6 +44659,7 @@ ColorMode.unblended = new ColorMode(ColorMode.Replace, performance.Color.transpa
 ColorMode.alphaBlended = new ColorMode([ONE, ONE_MINUS_SRC_ALPHA], performance.Color.transparent, [true, true, true, true]);
 
 /**
+ * @internal
  * A webgl wrapper class to allow injection, mocking and abstaction
  */
 class Context {
@@ -44697,10 +45028,10 @@ function drawSymbols(painter, sourceCache, layer, coords, variableOffsets) {
     // Disable the stencil test so that labels aren't clipped to tile boundaries.
     const stencilMode = StencilMode.disabled;
     const colorMode = painter.colorModeForRenderPass();
-    const variablePlacement = layer.layout.get('text-variable-anchor');
+    const hasVariablePlacement = layer._unevaluatedLayout.hasValue('text-variable-anchor') || layer._unevaluatedLayout.hasValue('text-variable-anchor-offset');
     //Compute variable-offsets before painting since icons and text data positioning
     //depend on each other in this case.
-    if (variablePlacement) {
+    if (hasVariablePlacement) {
         updateVariableAnchors(coords, painter, layer, sourceCache, layer.layout.get('text-rotation-alignment'), layer.layout.get('text-pitch-alignment'), variableOffsets);
     }
     if (layer.paint.get('icon-opacity').constantOr(1) !== 0) {
@@ -44718,8 +45049,7 @@ function calculateVariableRenderShift(anchor, width, height, textOffset, textBox
     const { horizontalAlign, verticalAlign } = performance.getAnchorAlignment(anchor);
     const shiftX = -(horizontalAlign - 0.5) * width;
     const shiftY = -(verticalAlign - 0.5) * height;
-    const variableOffset = performance.evaluateVariableOffset(anchor, textOffset);
-    return new performance.Point((shiftX / textBoxScale + variableOffset[0]) * renderTextSize, (shiftY / textBoxScale + variableOffset[1]) * renderTextSize);
+    return new performance.Point((shiftX / textBoxScale + textOffset[0]) * renderTextSize, (shiftY / textBoxScale + textOffset[1]) * renderTextSize);
 }
 function updateVariableAnchors(coords, painter, layer, sourceCache, rotationAlignment, pitchAlignment, variableOffsets) {
     const tr = painter.transform;
@@ -44835,7 +45165,7 @@ function drawLayerSymbols(painter, sourceCache, layer, coords, isText, translate
     const hasSortKey = !layer.layout.get('symbol-sort-key').isConstant();
     let sortFeaturesByKey = false;
     const depthMode = painter.depthModeForSublayer(0, DepthMode.ReadOnly);
-    const variablePlacement = layer.layout.get('text-variable-anchor');
+    const hasVariablePlacement = layer._unevaluatedLayout.hasValue('text-variable-anchor') || layer._unevaluatedLayout.hasValue('text-variable-anchor-offset');
     const tileRenderState = [];
     for (const coord of coords) {
         const tile = sourceCache.getTile(coord);
@@ -44880,7 +45210,7 @@ function drawLayerSymbols(painter, sourceCache, layer, coords, isText, translate
         const s = pixelsToTileUnits(tile, 1, painter.transform.zoom);
         const labelPlaneMatrix = getLabelPlaneMatrix(coord.posMatrix, pitchWithMap, rotateWithMap, painter.transform, s);
         const glCoordMatrix = getGlCoordMatrix(coord.posMatrix, pitchWithMap, rotateWithMap, painter.transform, s);
-        const hasVariableAnchors = variablePlacement && bucket.hasTextData();
+        const hasVariableAnchors = hasVariablePlacement && bucket.hasTextData();
         const updateTextFitIcon = layer.layout.get('icon-text-fit') !== 'none' &&
             hasVariableAnchors &&
             bucket.hasIconData();
@@ -44889,7 +45219,7 @@ function drawLayerSymbols(painter, sourceCache, layer, coords, isText, translate
             const rotateToLine = layer.layout.get('text-rotation-alignment') === 'map';
             updateLineLabels(bucket, coord.posMatrix, painter, isText, labelPlaneMatrix, glCoordMatrix, pitchWithMap, keepUpright, rotateToLine, getElevation);
         }
-        const matrix = painter.translatePosMatrix(coord.posMatrix, tile, translate, translateAnchor), uLabelPlaneMatrix = (alongLine || (isText && variablePlacement) || updateTextFitIcon) ? identityMat4 : labelPlaneMatrix, uglCoordMatrix = painter.translatePosMatrix(glCoordMatrix, tile, translate, translateAnchor, true);
+        const matrix = painter.translatePosMatrix(coord.posMatrix, tile, translate, translateAnchor), uLabelPlaneMatrix = (alongLine || (isText && hasVariablePlacement) || updateTextFitIcon) ? identityMat4 : labelPlaneMatrix, uglCoordMatrix = painter.translatePosMatrix(glCoordMatrix, tile, translate, translateAnchor, true);
         const hasHalo = isSDF && layer.paint.get(isText ? 'text-halo-width' : 'icon-halo-width').constantOr(1) !== 0;
         let uniformValues;
         if (isSDF) {
@@ -45801,6 +46131,7 @@ function drawTerrain(painter, terrain, tiles) {
 }
 
 /**
+ * @internal
  * Initialize a new painter object.
  */
 class Painter {
@@ -46440,6 +46771,7 @@ class EdgeInsets {
 }
 
 /**
+ * @internal
  * A single transform, generally used for a single tile to be
  * scaled, rotated, and zoomed.
  */
@@ -47680,6 +48012,7 @@ class BlockableMapEventHandler {
 }
 
 /**
+ * @internal
  * Shared utilities for the Handler classes to access the correct camera state.
  * If Camera.transformCameraUpdate is specified, the "desired state" of camera may differ from the state used for rendering.
  * The handlers need the "desired state" to track accumulated changes.
@@ -47715,9 +48048,7 @@ class TransformProvider {
  * @group Handlers
  */
 class BoxZoomHandler {
-    /**
-     * @hidden
-     */
+    /** @internal */
     constructor(map, options) {
         this._map = map;
         this._tr = new TransformProvider(map);
@@ -48314,9 +48645,7 @@ class TouchPanHandler {
  * @group Handlers
  */
 class TwoFingersTouchHandler {
-    /**
-     * @hidden
-     */
+    /** @internal */
     constructor() {
         this.reset();
     }
@@ -48590,9 +48919,7 @@ const defaultOptions$5 = {
  * @group Handlers
  */
 class KeyboardHandler {
-    /**
-    * @hidden
-    */
+    /** @internal */
     constructor(map) {
         this._tr = new TransformProvider(map);
         const stepOptions = defaultOptions$5;
@@ -48770,9 +49097,7 @@ const maxScalePerFrame = 2;
  * @group Handlers
  */
 class ScrollZoomHandler {
-    /**
-     * @hidden
-     */
+    /** @internal */
     constructor(map, triggerRenderFrame) {
         this._onTimeout = (initialEvent) => {
             this._type = 'wheel';
@@ -49036,9 +49361,7 @@ class ScrollZoomHandler {
  * @group Handlers
  */
 class DoubleClickZoomHandler {
-    /**
-     * @hidden
-    */
+    /** @internal */
     constructor(clickZoom, TapZoom) {
         this._clickZoom = clickZoom;
         this._tapZoom = TapZoom;
@@ -49090,9 +49413,7 @@ class DoubleClickZoomHandler {
  * It is used by other handlers
  */
 class ClickZoomHandler {
-    /**
-     * @hidden
-    */
+    /** @internal */
     constructor(map) {
         this._tr = new TransformProvider(map);
         this.reset();
@@ -49219,9 +49540,7 @@ class TapDragZoomHandler {
  * @group Handlers
  */
 class DragPanHandler {
-    /**
-     * @hidden
-    */
+    /** @internal */
     constructor(el, mousePan, touchPan) {
         this._el = el;
         this._mousePan = mousePan;
@@ -49286,9 +49605,7 @@ class DragPanHandler {
  * @group Handlers
  */
 class DragRotateHandler {
-    /**
-     * @hidden
-    */
+    /** @internal */
     constructor(options, mouseRotate, mousePitch) {
         this._pitchWithRotate = options.pitchWithRotate;
         this._mouseRotate = mouseRotate;
@@ -49347,9 +49664,7 @@ class DragRotateHandler {
  * @group Handlers
  */
 class TwoFingersTouchZoomRotateHandler {
-    /**
-     * @hidden
-    */
+    /** @internal */
     constructor(el, touchZoom, touchRotate, tapDragZoom) {
         this._el = el;
         this._touchZoom = touchZoom;
@@ -50183,6 +50498,7 @@ class Camera extends performance.Evented {
         return this._cameraForBoxAndBearing(bounds.getNorthWest(), bounds.getSouthEast(), bearing, options);
     }
     /**
+     * @internal
      * Calculate the center of these two points in the viewport and use
      * the highest zoom level up to and including `Map#getMaxZoom()` that fits
      * the points in the viewport at the specified bearing.
@@ -50192,7 +50508,6 @@ class Camera extends performance.Evented {
      * @param options - the camera options
      * @returns If map is able to fit to provided bounds, returns `center`, `zoom`, and `bearing`.
      *      If map is unable to fit, method will warn and return undefined.
-     * @hidden
      * @example
      * ```ts
      * let p0 = [-79, 43];
@@ -50549,11 +50864,11 @@ class Camera extends performance.Evented {
         this.transform.recalculateZoom(this.terrain);
     }
     /**
+     * @internal
      * Called when the camera is about to be manipulated.
      * If `transformCameraUpdate` is specified, a copy of the current transform is created to track the accumulated changes.
      * This underlying transform represents the "desired state" proposed by input handlers / animations / UI controls.
      * It may differ from the state used for rendering (`this.transform`).
-     * @hidden
      * @returns Transform to apply changes to
      */
     _getTransformForUpdate() {
@@ -50565,8 +50880,8 @@ class Camera extends performance.Evented {
         return this._requestedCameraState;
     }
     /**
+     * @internal
      * Called after the camera is done being manipulated.
-     * @hidden
      * @param tr - the requested camera end state
      * Call `transformCameraUpdate` if present, and then apply the "approved" changes.
      */
@@ -51169,6 +51484,7 @@ var pos3dAttributes = performance.createLayout([
 ]);
 
 /**
+ * @internal
  * This class is a helper for the Terrain-class, it:
  *   - loads raster-dem tiles
  *   - manages all renderToTexture tiles.
@@ -51327,6 +51643,7 @@ class TerrainSourceCache extends performance.Evented {
 }
 
 /**
+ * @internal
  * This is the main class which handles most of the 3D Terrain logic. It has the following topics:
  *    1) loads raster-dem tiles via the internal sourceCache this.sourceCache
  *    2) creates a depth-framebuffer, which is used to calculate the visibility of coordinates
@@ -51653,7 +51970,8 @@ class Terrain {
 }
 
 /**
- * RenderPool a resource pool for textures and framebuffers
+ * @internal
+ * `RenderPool` is a resource pool for textures and framebuffers
  */
 class RenderPool {
     constructor(_context, _size, _tileSize) {
@@ -51717,7 +52035,9 @@ class RenderPool {
     }
 }
 
-// lookup table which layers should rendered to texture
+/**
+ * lookup table which layers should rendered to texture
+ */
 const LAYERS = {
     background: true,
     fill: true,
@@ -51726,7 +52046,8 @@ const LAYERS = {
     hillshade: true
 };
 /**
- * RenderToTexture
+ * @internal
+ * A helper class to help define what should be rendered to texture and how
  */
 class RenderToTexture {
     constructor(painter, terrain) {
@@ -52091,9 +52412,9 @@ let Map$1 = class Map extends Camera {
         });
     }
     /**
+     * @internal
      * Returns a unique number for this map instance which is used for the MapLoadEvent
      * to make sure we only fire one event per instantiated map object.
-     * @hidden
      * @returns the uniq map ID
      */
     _getMapId() {
@@ -52241,9 +52562,9 @@ let Map$1 = class Map extends Camera {
         return this;
     }
     /**
+     * @internal
      * Return the map's pixel ratio eventually scaled down to respect maxCanvasSize.
      * Internally you should use this and not getPixelRatio().
-     * @hidden
      */
     _getClampedPixelRatio(width, height) {
         const { 0: maxCanvasWidth, 1: maxCanvasHeight } = this._maxCanvasSize;
@@ -54068,9 +54389,9 @@ let Map$1 = class Map extends Camera {
         return !this._styleDirty && !this._sourcesDirty && !!this.style && this.style.loaded();
     }
     /**
+     * @internal
      * Update this map's style and sources, and re-render the map.
      *
-     * @hidden
      * @param updateStyle - mark the map's style for reprocessing as
      * well as its sources
      * @returns `this`
@@ -54084,9 +54405,10 @@ let Map$1 = class Map extends Camera {
         return this;
     }
     /**
+     * @internal
      * Request that the given callback be executed during the next render
      * frame.  Schedule a render frame if one is not already scheduled.
-     * @hidden
+     *
      * @returns An id that can be used to cancel the callback
      */
     _requestRenderFrame(callback) {
@@ -54097,6 +54419,7 @@ let Map$1 = class Map extends Camera {
         this._renderTaskQueue.remove(id);
     }
     /**
+     * @internal
      * Call when a (re-)render of the map is required:
      * - The style has changed (`setPaintProperty()`, etc.)
      * - Source data has changed (e.g. tiles have finished loading)
@@ -54104,7 +54427,6 @@ let Map$1 = class Map extends Camera {
      * - A transition is in progress
      *
      * @param paintStartTimeStamp - The time when the animation frame began executing.
-     * @hidden
      *
      * @returns `this`
      */