@mapbox/mapbox-gl-style-spec 14.31.0 → 14.32.0

package/expression/definitions/index.ts

@@ -53,7 +53,8 @@ import type {Expression, ExpressionRegistry} from '../expression';
 
 type LegacyFilterValue = string | number | boolean;
 
-const expressions: ExpressionRegistry = {
+// Prototype-less so that a lookup of an arbitrary operator name needs no own-property guard.
+const expressions: ExpressionRegistry = Object.assign(Object.create(null) as ExpressionRegistry, {
     // special forms
     '==': Equals,
     '!=': NotEquals,
@@ -91,7 +92,7 @@ const expressions: ExpressionRegistry = {
     'within': Within,
     'distance': Distance,
     'config': Config
-};
+});
 
 function rgba(ctx: EvaluationContext, [r, g, b, a]: Expression[]) {
     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment

package/expression/expression_dependencies.ts

@@ -3,31 +3,28 @@ import Config from "./definitions/config";
 
 import type {Expression} from "./expression";
 
-function getConfigDependencies(e: Expression): Set<string> {
-    if (e instanceof Config) {
-        const singleConfig = new Set([e.key]);
-        return singleConfig;
-    }
+export type ExpressionDependencies = {
+    configDependencies: Set<string>;
+    isIndoorDependent: boolean;
+};
 
-    let result = new Set<string>();
-    e.eachChild(arg => {
-        result = new Set([...result, ...getConfigDependencies(arg)]);
-    });
-    return result;
-}
+// Shared by every expression without config dependencies, which is the vast majority; read-only.
+const NO_CONFIG_DEPENDENCIES: Set<string> = new Set();
 
-function isIndoorDependent(e: Expression): boolean {
-    if (e instanceof CompoundExpression && e.name === 'is-active-floor') {
-        return true;
+function collect(e: Expression, deps: ExpressionDependencies) {
+    if (e instanceof Config) {
+        if (deps.configDependencies === NO_CONFIG_DEPENDENCIES) deps.configDependencies = new Set();
+        deps.configDependencies.add(e.key);
+        return; // `Config.eachChild` is a no-op
     }
-
-    let result = false;
-    e.eachChild(arg => {
-        if (!result && isIndoorDependent(arg)) {
-            result = true;
-        }
-    });
-    return result;
+    if (e instanceof CompoundExpression && e.name === 'is-active-floor') deps.isIndoorDependent = true;
+    e.eachChild(arg => { collect(arg, deps); });
 }
 
-export {getConfigDependencies, isIndoorDependent};
+// One traversal for both dependency kinds, and no per-node allocation: this runs for every
+// expression of every property of every layer at style load, so the walk dominates what it finds.
+export function getExpressionDependencies(e: Expression): ExpressionDependencies {
+    const deps = {configDependencies: NO_CONFIG_DEPENDENCIES, isIndoorDependent: false};
+    collect(e, deps);
+    return deps;
+}

package/expression/index.ts

@@ -85,8 +85,9 @@ export class StyleExpression {
         this._evaluator = new EvaluationContext(scope, options, iconImageUseTheme);
         this._defaultValue = propertySpec ? getDefaultValue(propertySpec) : null;
         this._enumValues = propertySpec && propertySpec.type === 'enum' ? propertySpec.values : null;
-        this.configDependencies = expressionDependencies.getConfigDependencies(expression);
-        this.isIndoorDependent = expressionDependencies.isIndoorDependent(expression);
+        const dependencies = expressionDependencies.getExpressionDependencies(expression);
+        this.configDependencies = dependencies.configDependencies;
+        this.isIndoorDependent = dependencies.isIndoorDependent;
     }
 
     evaluateWithoutErrorHandling(
@@ -233,8 +234,9 @@ export class ZoomConstantExpression<Kind extends EvaluationKind> {
         this.isLightConstant = isLightConstant;
         this.isLineProgressConstant = isLineProgressConstant;
         this.isStateDependent = kind !== ('constant' as EvaluationKind) && !isConstant.isStateConstant(expression.expression);
-        this.configDependencies = expressionDependencies.getConfigDependencies(expression.expression);
-        this.isIndoorDependent = expressionDependencies.isIndoorDependent(expression.expression);
+        // Already walked by the wrapped `StyleExpression` over the same parsed expression
+        this.configDependencies = expression.configDependencies;
+        this.isIndoorDependent = expression.isIndoorDependent;
     }
 
     evaluateWithoutErrorHandling(
@@ -280,10 +282,11 @@ export class ZoomDependentExpression<Kind extends EvaluationKind> {
         this.zoomStops = zoomStops;
         this._styleExpression = expression;
         this.isStateDependent = kind !== ('camera' as EvaluationKind) && !isConstant.isStateConstant(expression.expression);
-        this.isIndoorDependent = expressionDependencies.isIndoorDependent(expression.expression);
+        // Already walked by the wrapped `StyleExpression` over the same parsed expression
+        this.isIndoorDependent = expression.isIndoorDependent;
         this.isLightConstant = isLightConstant;
         this.isLineProgressConstant = isLineProgressConstant;
-        this.configDependencies = expressionDependencies.getConfigDependencies(expression.expression);
+        this.configDependencies = expression.configDependencies;
         this.interpolationType = interpolationType;
     }
 
@@ -393,48 +396,42 @@ export interface CompositeExpression {
 export type StylePropertyExpression = ConstantExpression | SourceExpression | CameraExpression | CompositeExpression;
 
 export function createPropertyExpression(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    expression: any,
+    expression: unknown,
     propertySpec: StylePropertySpecification,
     scope?: string | null,
     options?: ConfigOptions | null,
     iconImageUseTheme?: string | null
 ): Result<StylePropertyExpression, Array<ParsingError>> {
-    expression = createExpression(expression, propertySpec, scope, options, iconImageUseTheme);
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    if (expression.result === 'error') {
-        return expression as Result<StylePropertyExpression, Array<ParsingError>>;
+    const styleExpression = createExpression(expression, propertySpec, scope, options, iconImageUseTheme);
+    if (styleExpression.result === 'error') {
+        return styleExpression;
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
-    const parsed = expression.value.expression;
+    const parsed = styleExpression.value.expression;
 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
     const isFeatureConstant = isConstant.isFeatureConstant(parsed);
     if (!isFeatureConstant && !supportsPropertyExpression(propertySpec)) {
         return error([new ParsingError('', 'data expressions not supported')]);
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-    const isZoomConstant = isConstant.isGlobalPropertyConstant(parsed, ['zoom', 'pitch', 'distance-from-center']);
+    const globalDependencies = isConstant.getGlobalDependencies(parsed);
+
+    const isZoomConstant = (globalDependencies & isConstant.GlobalDependency.Zoom) === 0;
     if (!isZoomConstant && !supportsZoomExpression(propertySpec)) {
         return error([new ParsingError('', 'zoom expressions not supported')]);
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-    const isLightConstant = isConstant.isGlobalPropertyConstant(parsed, ['measure-light']);
+    const isLightConstant = (globalDependencies & isConstant.GlobalDependency.Light) === 0;
     if (!isLightConstant && !supportsLightExpression(propertySpec)) {
         return error([new ParsingError('', 'measure-light expression not supported')]);
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-    const isLineProgressConstant = isConstant.isGlobalPropertyConstant(parsed, ['line-progress']);
+    const isLineProgressConstant = (globalDependencies & isConstant.GlobalDependency.LineProgress) === 0;
     if (!isLineProgressConstant && !supportsLineProgressExpression(propertySpec)) {
         return error([new ParsingError('', 'line-progress expression not supported')]);
     }
 
     const canRelaxZoomRestriction = propertySpec.expression && propertySpec.expression.relaxZoomRestriction;
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
     const zoomCurve = findZoomCurve(parsed);
     if (!zoomCurve && !isZoomConstant && !canRelaxZoomRestriction) {
         return error([new ParsingError('', '"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression, or in the properties of atmosphere.')]);
@@ -446,19 +443,15 @@ export function createPropertyExpression(
 
     if (!zoomCurve) {
         return success((isFeatureConstant && isLineProgressConstant) ?
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
-            (new ZoomConstantExpression('constant', expression.value, isLightConstant, isLineProgressConstant) as ConstantExpression) :
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
-            (new ZoomConstantExpression('source', expression.value, isLightConstant, isLineProgressConstant) as SourceExpression));
+            (new ZoomConstantExpression('constant', styleExpression.value, isLightConstant, isLineProgressConstant) as ConstantExpression) :
+            (new ZoomConstantExpression('source', styleExpression.value, isLightConstant, isLineProgressConstant) as SourceExpression));
     }
 
     const interpolationType = zoomCurve instanceof Interpolate ? zoomCurve.interpolation : undefined;
 
     return success((isFeatureConstant && isLineProgressConstant) ?
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
-        (new ZoomDependentExpression('camera', expression.value, zoomCurve.labels, interpolationType, isLightConstant, isLineProgressConstant) as CameraExpression) :
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
-        (new ZoomDependentExpression('composite', expression.value, zoomCurve.labels, interpolationType, isLightConstant, isLineProgressConstant) as CompositeExpression));
+        (new ZoomDependentExpression('camera', styleExpression.value, zoomCurve.labels, interpolationType, isLightConstant, isLineProgressConstant) as CameraExpression) :
+        (new ZoomDependentExpression('composite', styleExpression.value, zoomCurve.labels, interpolationType, isLightConstant, isLineProgressConstant) as CompositeExpression));
 }
 
 // serialization wrapper for old-style stop functions normalized to the

package/expression/is_constant.ts

@@ -69,4 +69,23 @@ function isGlobalPropertyConstant(e: Expression, properties: Array<string>): boo
     return isGlobalPropertyConstantSet(e, new Set(properties));
 }
 
-export {isFeatureConstant, isGlobalPropertyConstant, isGlobalPropertyConstantSet, isStateConstant};
+// Bitmask so that one walk answers all three: `createPropertyExpression` used to call
+// `isGlobalPropertyConstant` once per group, traversing every expression of every property in
+// full each time, since those calls only exit early on the rare dependent branch.
+export const GlobalDependency = {Zoom: 1, Light: 2, LineProgress: 4};
+
+const globalDependencyFlags: Record<string, number> = {
+    'zoom': GlobalDependency.Zoom,
+    'pitch': GlobalDependency.Zoom,
+    'distance-from-center': GlobalDependency.Zoom,
+    'measure-light': GlobalDependency.Light,
+    'line-progress': GlobalDependency.LineProgress
+};
+
+function getGlobalDependencies(e: Expression): number {
+    let flags = e instanceof CompoundExpression ? globalDependencyFlags[e.name] || 0 : 0;
+    e.eachChild(arg => { flags |= getGlobalDependencies(arg); });
+    return flags;
+}
+
+export {isFeatureConstant, isGlobalPropertyConstant, isGlobalPropertyConstantSet, isStateConstant, getGlobalDependencies};

package/expression/parsing_context.ts

@@ -1,5 +1,5 @@
 import Scope from './scope';
-import {checkSubtype} from './types';
+import {checkSubtype, NullType, StringType, BooleanType, NumberType} from './types';
 import ParsingError from './parsing_error';
 import Literal from './definitions/literal';
 import Assertion from './definitions/assertion';
@@ -15,6 +15,7 @@ import Var from './definitions/var';
 
 import type {Expression, ExpressionRegistry} from './expression';
 import type {Type} from './types';
+import type {Value} from './values';
 import type {ConfigOptions} from '../types/config_options';
 
 /**
@@ -77,9 +78,9 @@ class ParsingContext {
         index?: number,
         expectedType?: Type | null,
         bindings?: Array<[string, Expression]>,
-        options: {
+        options?: {
             typeAnnotation?: 'assert' | 'coerce' | 'omit';
-        } = {},
+        },
     ): Expression | null | void {
         if (index || expectedType) {
             const prevExpectedType = this.expectedType;
@@ -111,9 +112,9 @@ class ParsingContext {
         key: string,
         expectedType?: Type | null,
         bindings?: Array<[string, Expression]>,
-        options: {
+        options?: {
             typeAnnotation?: 'assert' | 'coerce' | 'omit';
-        } = {},
+        },
     ): Expression | null | void {
         const prevExpectedType = this.expectedType;
         const prevScope = this.scope;
@@ -129,67 +130,60 @@ class ParsingContext {
         return result;
     }
 
+    // Applies `expectedType` to a freshly parsed expression, wrapping it in an inferred assertion
+    // or coercion where that is what the expected type calls for. Returns null if the type is wrong.
+    _annotateToExpectedType(parsed: Expression, options?: {typeAnnotation?: 'assert' | 'coerce' | 'omit'}): Expression | null {
+        const expected = this.expectedType;
+        if (!expected) return parsed;
+        const actual = parsed.type;
+
+        // When we expect a number, string, boolean, or array but have a value, wrap it in an assertion.
+        // When we expect a color or formatted string, but have a string or value, wrap it in a coercion.
+        // Otherwise, we do static type-checking.
+        //
+        // These behaviors are overridable for:
+        //   * The "coalesce" operator, which needs to omit type annotations.
+        //   * String-valued properties (e.g. `text-field`), where coercion is more convenient than assertion.
+        //
+        if ((expected.kind === 'string' || expected.kind === 'number' || expected.kind === 'boolean' || expected.kind === 'object' || expected.kind === 'array') && actual.kind === 'value') {
+            return annotate(parsed, expected, options?.typeAnnotation || 'assert');
+        } else if ((expected.kind === 'color' || expected.kind === 'formatted' || expected.kind === 'resolvedImage') && (actual.kind === 'value' || actual.kind === 'string')) {
+            return annotate(parsed, expected, options?.typeAnnotation || 'coerce');
+        } else if (this.checkSubtype(expected, actual)) {
+            return null;
+        }
+
+        return parsed;
+    }
+
     _parse(
         expr: unknown,
-        options: {
+        options?: {
             typeAnnotation?: 'assert' | 'coerce' | 'omit';
         },
     ): Expression | null | void {
-        if (expr === null || typeof expr === 'string' || typeof expr === 'boolean' || typeof expr === 'number') {
-            expr = ['literal', expr];
-        }
+        // Scalars are nearly half of all parsed expressions and are always literal, so build the
+        // `Literal` here rather than round-tripping a `['literal', v]` array through the registry.
+        const scalarType = expr === null ? NullType :
+            typeof expr === 'string' ? StringType :
+            typeof expr === 'boolean' ? BooleanType :
+            typeof expr === 'number' ? NumberType : null;
 
-        if (Array.isArray(expr)) {
+        let result: Expression | null | void;
+
+        if (scalarType) {
+            result = new Literal(scalarType, expr as Value);
+        } else if (Array.isArray(expr)) {
             if (expr.length === 0) {
                 return this.error(`Expected an array with at least one element. If you wanted a literal array, use ["literal", []].`);
             }
 
-            const Expr = typeof expr[0] === 'string' && Object.hasOwn(this.registry, expr[0]) ? this.registry[expr[0]] : undefined;
-            if (Expr) {
-                let parsed = Expr.parse(expr, this);
-                if (!parsed) return null;
-
-                if (this.expectedType) {
-                    const expected = this.expectedType;
-                    const actual = parsed.type;
-
-                    // When we expect a number, string, boolean, or array but have a value, wrap it in an assertion.
-                    // When we expect a color or formatted string, but have a string or value, wrap it in a coercion.
-                    // Otherwise, we do static type-checking.
-                    //
-                    // These behaviors are overridable for:
-                    //   * The "coalesce" operator, which needs to omit type annotations.
-                    //   * String-valued properties (e.g. `text-field`), where coercion is more convenient than assertion.
-                    //
-                    if ((expected.kind === 'string' || expected.kind === 'number' || expected.kind === 'boolean' || expected.kind === 'object' || expected.kind === 'array') && actual.kind === 'value') {
-                        parsed = annotate(parsed, expected, options.typeAnnotation || 'assert');
-                    } else if ((expected.kind === 'color' || expected.kind === 'formatted' || expected.kind === 'resolvedImage') && (actual.kind === 'value' || actual.kind === 'string')) {
-                        parsed = annotate(parsed, expected, options.typeAnnotation || 'coerce');
-                    } else if (this.checkSubtype(expected, actual)) {
-                        return null;
-                    }
-                }
-
-                // If an expression's arguments are all literals, we can evaluate
-                // it immediately and replace it with a literal value in the
-                // parsed/compiled result. Expressions that expect an image should
-                // not be resolved here so we can later get the available images.
-                if (!(parsed instanceof Literal) && (parsed.type.kind !== 'resolvedImage') && isConstant(parsed)) {
-                    const ec = new EvaluationContext(this._scope, this.options, this.iconImageUseTheme);
-                    try {
-                        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                        parsed = new Literal(parsed.type, parsed.evaluate(ec));
-                    } catch (e) {
-                        this.error((e as Error).message);
-                        return null;
-                    }
-                }
-
-                return parsed;
-            }
-
+            const Expr = this.registry[expr[0] as string];
             // Try to parse as array
-            return Coercion.parse(['to-array', expr], this);
+            if (!Expr) return Coercion.parse(['to-array', expr], this);
+
+            result = Expr.parse(expr, this);
+            if (!result) return null;
         } else if (typeof expr === 'undefined') {
             return this.error(`'undefined' value invalid. Use null instead.`);
         } else if (typeof expr === 'object') {
@@ -197,6 +191,26 @@ class ParsingContext {
         } else {
             return this.error(`Expected an array, but found ${typeof expr} instead.`);
         }
+
+        let parsed = this._annotateToExpectedType(result, options);
+        if (!parsed) return null;
+
+        // If an expression's arguments are all literals, we can evaluate
+        // it immediately and replace it with a literal value in the
+        // parsed/compiled result. Expressions that expect an image should
+        // not be resolved here so we can later get the available images.
+        if (!(parsed instanceof Literal) && (parsed.type.kind !== 'resolvedImage') && isConstant(parsed)) {
+            const ec = new EvaluationContext(this._scope, this.options, this.iconImageUseTheme);
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                parsed = new Literal(parsed.type, parsed.evaluate(ec));
+            } catch (e) {
+                this.error((e as Error).message);
+                return null;
+            }
+        }
+
+        return parsed;
     }
 
     /**
@@ -235,10 +249,12 @@ class ParsingContext {
      * overload signatures without polluting the parent errors list.
      * @private
      */
+    // `path` is shared rather than copied: argument parsing pushes and pops it in balance, and
+    // `error` snapshots `key` into the message eagerly, so the fork never observes a stale path.
     _forkForSignature(): ParsingContext {
         return new ParsingContext(
             this.registry,
-            this.path.slice(),
+            this.path,
             null,
             this.scope,
             [],
@@ -273,7 +289,7 @@ class ParsingContext {
 
 export default ParsingContext;
 
-const CONSTANT_FOLD_EXCLUDED_GLOBALS = new Set([
+const CONSTANT_FOLD_EXCLUDED_GLOBALS: ReadonlySet<string> = new Set([
     'zoom', 'heatmap-density', 'worldview', 'line-progress', 'raster-value',
     'sky-radial-progress', 'accumulated', 'is-supported-script', 'pitch',
     'distance-from-center', 'measure-light', 'raster-particle-speed', 'is-active-floor',

package/expression/types.ts

@@ -87,44 +87,26 @@ export function toString(type: Type): string {
     }
 }
 
-const valueMemberTypes = [
-    NullType,
-    NumberType,
-    StringType,
-    BooleanType,
-    ColorType,
-    FormattedType,
-    ObjectType,
-    array(ValueType),
-    ResolvedImageType
-];
-
 /**
  * Returns null if `t` is a subtype of `expected`; otherwise returns an
  * error message.
  * @private
  */
-export function checkSubtype(expected: Type, t: Type): string | null | undefined {
-    if (t.kind === 'error') {
-        // Error is a subtype of every type
-        return null;
-    } else if (expected.kind === 'array') {
-        if (t.kind === 'array' &&
-            ((t.N === 0 && t.itemType.kind === 'value') || !checkSubtype(expected.itemType, t.itemType)) &&
-            (typeof expected.N !== 'number' || expected.N === t.N)) {
-            return null;
-        }
-    } else if (expected.kind === t.kind) {
-        return null;
-    } else if (expected.kind === 'value') {
-        for (const memberType of valueMemberTypes) {
-            if (!checkSubtype(memberType, t)) {
-                return null;
-            }
-        }
-    }
+export function checkSubtype(expected: Type, t: Type): string | null {
+    return isSubtype(expected, t) ? null : `Expected ${toString(expected)} but found ${toString(t)} instead.`;
+}
 
-    return `Expected ${toString(expected)} but found ${toString(t)} instead.`;
+// Boolean, so that checks made speculatively rather than to report an error - overload resolution
+// in `CompoundExpression.parse`, the recursion below - build no message that nobody will read.
+function isSubtype(expected: Type, t: Type): boolean {
+    if (t.kind === 'error') return true; // error is a subtype of every type
+    if (expected.kind === 'array') {
+        return t.kind === 'array' &&
+            ((t.N === 0 && t.itemType.kind === 'value') || isSubtype(expected.itemType, t.itemType)) &&
+            (typeof expected.N !== 'number' || expected.N === t.N);
+    }
+    // `value` is a supertype of every type except `collator`
+    return expected.kind === t.kind || (expected.kind === 'value' && t.kind !== 'collator');
 }
 
 export function isValidType(provided: Type, allowedTypes: Array<Type>): boolean {

package/feature_filter/index.ts

@@ -203,6 +203,7 @@ function collapseDynamicBooleanExpressions(expression: any): any {
  * @param {Array<any>} filter the filter expression mutated in-place.
  */
 function unionDynamicBranches(filter: unknown[]) {
+    if (!Array.isArray(filter)) return;
     let isBranchingDynamically = false;
     const branches: unknown[] = [];
     if (filter[0] === 'case') {
@@ -262,7 +263,7 @@ function isRootExpressionDynamic(expression: string): boolean {
         expression === 'distance-from-center';
 }
 
-const dynamicConditionExpressions = new Set([
+const dynamicConditionExpressions: ReadonlySet<string> = new Set([
     'in',
     '==',
     '!=',

package/format.ts

@@ -1,26 +1,21 @@
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-// @ts-nocheck
-
 import reference from './reference/latest';
 import stringifyPretty from 'json-stringify-pretty-compact';
 
-function sortKeysBy(obj, reference) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const result: Record<string, any> = {};
+type ObjectLike = Record<string, unknown>;
+
+function sortKeysBy<T extends ObjectLike>(obj: T, reference: ObjectLike): T {
+    const result: ObjectLike = {};
     for (const key in reference) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         if (obj[key] !== undefined) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
             result[key] = obj[key];
         }
     }
     for (const key in obj) {
         if (result[key] === undefined) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
             result[key] = obj[key];
         }
     }
-    return result;
+    return result as T;
 }
 
 /**
@@ -44,16 +39,14 @@ function sortKeysBy(obj, reference) {
  * fs.writeFileSync('./dest.json', format(style));
  * fs.writeFileSync('./dest.min.json', format(style, 0));
  */
-function format(style, space = 2) {
-    style = sortKeysBy(style, reference.$root);
+function format(style: unknown, space = 2): string {
+    const sorted = sortKeysBy(style as ObjectLike, reference.$root as ObjectLike) as {layers?: ObjectLike[]};
 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    if (style.layers) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
-        style.layers = style.layers.map((layer) => sortKeysBy(layer, reference.layer));
+    if (sorted.layers) {
+        sorted.layers = sorted.layers.map((layer) => sortKeysBy(layer, reference.layer as ObjectLike));
     }
 
-    return stringifyPretty(style, {indent: space});
+    return stringifyPretty(sorted, {indent: space});
 }
 
 export default format;