@mapbox/mapbox-gl-style-spec 14.31.0 → 14.32.0-rc.1

package/function/index.ts

@@ -1,6 +1,3 @@
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-// @ts-nocheck
-
 import * as colorSpaces from '../util/color_spaces';
 import Color from '../util/color';
 import {getType, isNumber} from '../util/get_type';
@@ -11,60 +8,76 @@ import ResolvedImage from '../expression/types/resolved_image';
 import {supportsInterpolation} from '../util/properties';
 import {findStopLessThanOrEqualTo} from '../expression/stops';
 
-import type {FunctionSpecification} from '../types';
-
-export function isFunction(value) {
+import type {InterpolationType} from '../expression/definitions/interpolate';
+import type {StylePropertySpecification} from '../style-spec';
+import type {
+    FunctionSpecification,
+    PropertyFunctionStop,
+    SourceFunctionSpecification,
+    ZoomAndPropertyFunctionStop
+} from '../types';
+
+type StopKey = ZoomAndPropertyFunctionStop<unknown>[0]['value'];
+type CompositeStopInput = ZoomAndPropertyFunctionStop<unknown>[0];
+type Stop = [StopKey | CompositeStopInput, unknown];
+type CategoricalStop = Extract<SourceFunctionSpecification<unknown>, {type: 'categorical'}>['stops'][number];
+type NumericStop = PropertyFunctionStop<unknown>;
+type FunctionParameters = Pick<FunctionSpecification<unknown>, 'base' | 'property' | 'type' | 'default'> & {
+    stops?: Stop[];
+    colorSpace?: string;
+};
+type FeatureLike = {properties?: Record<string, unknown>};
+type HashedStops = Record<string, unknown>;
+type EvaluationArguments = [globals: {zoom: number} | number, feature?: FeatureLike | null];
+type Evaluator = {evaluate: (...args: EvaluationArguments) => unknown};
+type EvaluationFunction = (
+    parameters: FunctionParameters,
+    propertySpec: StylePropertySpecification,
+    input: unknown,
+    hashedStops?: HashedStops,
+    categoricalKeyType?: string,
+) => unknown;
+type InterpolationFunction = (from: unknown, to: unknown, t: number) => unknown;
+type ColorSpace = Record<'forward' | 'reverse', typeof identityFunction> & {interpolate: InterpolationFunction};
+
+export function isFunction(value: unknown): boolean {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 
-function identityFunction(x) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+function identityFunction(x: unknown): unknown {
     return x;
 }
 
-export function createFunction(parameters, propertySpec) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+export function createFunction(input: unknown, propertySpec: StylePropertySpecification) {
+    let parameters = input as FunctionParameters;
     const isColor = propertySpec.type === 'color';
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    const zoomAndFeatureDependent = (parameters.stops as FunctionSpecification<unknown>['stops'] | undefined) && typeof parameters.stops[0][0] === 'object';
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    const zoomAndFeatureDependent = parameters.stops && typeof parameters.stops[0]![0] === 'object';
     const featureDependent = zoomAndFeatureDependent || parameters.property !== undefined;
     const zoomDependent = zoomAndFeatureDependent || !featureDependent;
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument
     const type = parameters.type || (supportsInterpolation(propertySpec) ? 'exponential' : 'interval');
 
     if (isColor) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         parameters = {...parameters};
 
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         if (parameters.stops) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
             parameters.stops = parameters.stops.map((stop) => {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument
-                return [stop[0], Color.parse(stop[1])];
+                return [stop[0], Color.parse(stop[1] as string | Color | null)];
             });
         }
 
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         if (parameters.default) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument
-            parameters.default = Color.parse(parameters.default);
+            parameters.default = Color.parse(parameters.default as string | Color);
         } else {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument
             parameters.default = Color.parse(propertySpec.default);
         }
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    if (parameters.colorSpace && parameters.colorSpace !== 'rgb' && !colorSpaces[parameters.colorSpace]) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    if (parameters.colorSpace && parameters.colorSpace !== 'rgb' && !colorSpaces[parameters.colorSpace as keyof typeof colorSpaces]) {
         throw new Error(`Unknown color space: ${parameters.colorSpace}`);
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    let innerFun: ((parameters: any, propertySpec: any, input: any, hashedStops?: any, categoricalKeyType?: any) => any) | undefined;
-    let hashedStops: Record<string | number, unknown> | undefined;
+    let innerFun: EvaluationFunction;
+    let hashedStops: HashedStops | undefined;
     let categoricalKeyType: string | undefined;
     if (type === 'exponential') {
         innerFun = evaluateExponentialFunction;
@@ -74,17 +87,13 @@ export function createFunction(parameters, propertySpec) {
         innerFun = evaluateCategoricalFunction;
 
         // For categorical functions, generate an Object as a hashmap of the stops for fast searching
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        hashedStops = Object.create(null);
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        for (const stop of parameters.stops) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-            hashedStops[stop[0]] = stop[1];
+        hashedStops = Object.create(null) as HashedStops;
+        for (const stop of parameters.stops as CategoricalStop[]) {
+            hashedStops[stop[0] as string | number] = stop[1];
         }
 
         // Infer key type based on first stop key-- used to encforce strict type checking later
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        categoricalKeyType = typeof parameters.stops[0][0];
+        categoricalKeyType = typeof (parameters.stops as CategoricalStop[])[0]![0];
 
     } else if (type === 'identity') {
         innerFun = evaluateIdentityFunction;
@@ -93,206 +102,149 @@ export function createFunction(parameters, propertySpec) {
     }
 
     if (zoomAndFeatureDependent) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const featureFunctions: Record<string, any> = {};
-        const zoomStops = [];
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        for (let s = 0; s < parameters.stops.length; s++) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
-            const stop = parameters.stops[s];
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+        const featureFunctions: Record<string, FunctionParameters & {zoom: number; stops: Stop[]}> = {};
+        const zoomStops: number[] = [];
+        for (let s = 0; s < parameters.stops!.length; s++) {
+            const stop = parameters.stops![s] as [CompositeStopInput, unknown];
             const zoom = stop[0].zoom;
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
             if (featureFunctions[zoom] === undefined) {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
                 featureFunctions[zoom] = {
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                     zoom,
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
                     type: parameters.type,
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
                     property: parameters.property,
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
                     default: parameters.default,
                     stops: []
                 };
                 zoomStops.push(zoom);
             }
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
             featureFunctions[zoom].stops.push([stop[0].value, stop[1]]);
         }
 
-        const featureFunctionStops = [];
+        const featureFunctionStops: Array<[number, Evaluator]> = [];
         for (const z of zoomStops) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-            featureFunctionStops.push([featureFunctions[z].zoom, createFunction(featureFunctions[z], propertySpec)]);
+            featureFunctionStops.push([featureFunctions[z]!.zoom, createFunction(featureFunctions[z]!, propertySpec) as Evaluator]);
         }
 
-        const interpolationType = {name: 'linear'};
+        const interpolationType: InterpolationType = {name: 'linear'};
         return {
             kind: 'composite',
             interpolationType,
 
             interpolationFactor: Interpolate.interpolationFactor.bind(undefined, interpolationType),
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
             zoomStops: featureFunctionStops.map(s => s[0]),
-            evaluate({zoom}, properties) {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call
-                return evaluateExponentialFunction({
+            evaluate({zoom}: {zoom: number}, properties: FeatureLike | null | undefined) {
+                return (evaluateExponentialFunction({
                     stops: featureFunctionStops,
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
                     base: parameters.base
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-                }, propertySpec, zoom).evaluate(zoom, properties);
+                }, propertySpec, zoom) as Evaluator).evaluate(zoom, properties);
             }
         };
     } else if (zoomDependent) {
-        const interpolationType = type === 'exponential' ?
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+        const interpolationType: InterpolationType | null = type === 'exponential' ?
             {name: 'exponential', base: parameters.base !== undefined ? parameters.base : 1} : null;
         return {
             kind: 'camera',
             interpolationType,
 
-            interpolationFactor: Interpolate.interpolationFactor.bind(undefined, interpolationType),
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-            zoomStops: parameters.stops.map(s => s[0]),
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-            evaluate: ({zoom}) => innerFun(parameters, propertySpec, zoom, hashedStops, categoricalKeyType)
+            interpolationFactor: Interpolate.interpolationFactor.bind(undefined, interpolationType as InterpolationType),
+            zoomStops: parameters.stops!.map(s => s[0]),
+            evaluate: ({zoom}: {zoom: number}) => innerFun(parameters, propertySpec, zoom, hashedStops, categoricalKeyType)
         };
     } else {
         return {
             kind: 'source',
-            evaluate(_, feature) {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
-                const value = feature && feature.properties ? feature.properties[parameters.property] : undefined;
+            evaluate(_: unknown, feature: FeatureLike | null | undefined) {
+                const value = feature && feature.properties ? feature.properties[parameters.property!] : undefined;
                 if (value === undefined) {
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access
                     return coalesce(parameters.default, propertySpec.default);
                 }
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                 return innerFun(parameters, propertySpec, value, hashedStops, categoricalKeyType);
             }
         };
     }
 }
 
-function coalesce(a, b, c) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+function coalesce(a: unknown, b: unknown, c?: unknown): unknown {
     if (a !== undefined) return a;
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     if (b !== undefined) return b;
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     if (c !== undefined) return c;
 }
 
-function evaluateCategoricalFunction(parameters, propertySpec, input, hashedStops, keyType) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
-    const evaluated = typeof input === keyType ? hashedStops[input] : undefined; // Enforce strict typing on input
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access
+function evaluateCategoricalFunction(
+    parameters: FunctionParameters,
+    propertySpec: StylePropertySpecification,
+    input: unknown,
+    hashedStops?: HashedStops,
+    keyType?: string,
+): unknown {
+    const evaluated = typeof input === keyType ? hashedStops![input as string | number] : undefined; // Enforce strict typing on input
     return coalesce(evaluated, parameters.default, propertySpec.default);
 }
 
-function evaluateIntervalFunction(parameters, propertySpec, input) {
+function evaluateIntervalFunction(parameters: FunctionParameters, propertySpec: StylePropertySpecification, input: unknown): unknown {
     // Edge cases
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access
     if (!isNumber(input)) return coalesce(parameters.default, propertySpec.default);
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
-    const n = parameters.stops.length;
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access
-    if (n === 1) return parameters.stops[0][1];
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access
-    if (input <= parameters.stops[0][0]) return parameters.stops[0][1];
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access
-    if (input >= parameters.stops[n - 1][0]) return parameters.stops[n - 1][1];
-
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-    const index = findStopLessThanOrEqualTo(parameters.stops.map((stop) => stop[0]), input);
-
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access
-    return parameters.stops[index][1];
+    const stops = parameters.stops as NumericStop[];
+    const n = stops.length;
+    if (n === 1) return stops[0]![1];
+    if (input <= stops[0]![0]) return stops[0]![1];
+    if (input >= stops[n - 1]![0]) return stops[n - 1]![1];
+
+    const index = findStopLessThanOrEqualTo(stops.map((stop) => stop[0]), input);
+
+    return stops[index]![1];
 }
 
-function evaluateExponentialFunction(parameters, propertySpec, input) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+function evaluateExponentialFunction(parameters: FunctionParameters, propertySpec: StylePropertySpecification, input: unknown): unknown {
     const base = parameters.base !== undefined ? parameters.base : 1;
 
     // Edge cases
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access
     if (!isNumber(input)) return coalesce(parameters.default, propertySpec.default);
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
-    const n = parameters.stops.length;
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access
-    if (n === 1) return parameters.stops[0][1];
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access
-    if (input <= parameters.stops[0][0]) return parameters.stops[0][1];
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access
-    if (input >= parameters.stops[n - 1][0]) return parameters.stops[n - 1][1];
-
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-    const index = findStopLessThanOrEqualTo(parameters.stops.map((stop) => stop[0]), input);
-    const t = interpolationFactor(
-        input, base,
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        parameters.stops[index][0],
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        parameters.stops[index + 1][0]);
-
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
-    const outputLower = parameters.stops[index][1];
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
-    const outputUpper = parameters.stops[index + 1][1];
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
-    let interp = interpolate[propertySpec.type] || identityFunction;
-
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    const stops = parameters.stops as NumericStop[];
+    const n = stops.length;
+    if (n === 1) return stops[0]![1];
+    if (input <= stops[0]![0]) return stops[0]![1];
+    if (input >= stops[n - 1]![0]) return stops[n - 1]![1];
+
+    const index = findStopLessThanOrEqualTo(stops.map((stop) => stop[0]), input);
+    const t = interpolationFactor(input, base, stops[index]![0], stops[index + 1]![0]);
+
+    const outputLower = stops[index]![1];
+    const outputUpper = stops[index + 1]![1];
+    let interp = (interpolate[propertySpec.type as keyof typeof interpolate] as InterpolationFunction | undefined) || identityFunction;
+
     if (parameters.colorSpace && parameters.colorSpace !== 'rgb') {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
-        const colorspace = colorSpaces[parameters.colorSpace];
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        const colorspace = colorSpaces[parameters.colorSpace as keyof typeof colorSpaces] as ColorSpace;
         interp = (a, b) => colorspace.reverse(colorspace.interpolate(colorspace.forward(a), colorspace.forward(b), t));
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    if (typeof outputLower.evaluate === 'function') {
+    if (typeof (outputLower as Partial<Evaluator>).evaluate === 'function') {
         return {
-            evaluate(...args) {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-                const evaluatedLower = outputLower.evaluate.apply(undefined, args);
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-                const evaluatedUpper = outputUpper.evaluate.apply(undefined, args);
+            evaluate(...args: EvaluationArguments) {
+                const evaluatedLower = (outputLower as Evaluator).evaluate.apply(undefined, args);
+                const evaluatedUpper = (outputUpper as Evaluator).evaluate.apply(undefined, args);
                 // Special case for fill-outline-color, which has no spec default.
                 if (evaluatedLower === undefined || evaluatedUpper === undefined) {
                     return undefined;
                 }
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call
                 return interp(evaluatedLower, evaluatedUpper, t);
             }
         };
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call
     return interp(outputLower, outputUpper, t);
 }
 
-function evaluateIdentityFunction(parameters, propertySpec, input) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+function evaluateIdentityFunction(parameters: FunctionParameters, propertySpec: StylePropertySpecification, input: unknown): unknown {
     if (propertySpec.type === 'color') {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-        input = Color.parse(input);
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        input = Color.parse(input as string | Color | null);
     } else if (propertySpec.type === 'formatted') {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-        input = Formatted.fromString(input.toString());
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        input = Formatted.fromString((input as {toString: () => string}).toString());
     } else if (propertySpec.type === 'resolvedImage') {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-        input = ResolvedImage.build(input.toString());
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    } else if (getType(input) !== propertySpec.type && (propertySpec.type !== 'enum' || !propertySpec.values[input])) {
+        input = ResolvedImage.build((input as {toString: () => string}).toString());
+    } else if (getType(input) !== propertySpec.type && (propertySpec.type !== 'enum' || !propertySpec.values![input as keyof typeof propertySpec.values])) {
         input = undefined;
     }
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access
     return coalesce(input, parameters.default, propertySpec.default);
 }
 
@@ -334,7 +286,7 @@ function evaluateIdentityFunction(parameters, propertySpec, input) {
  *
  * @private
  */
-function interpolationFactor(input, base, lowerValue, upperValue) {
+function interpolationFactor(input: number, base: number, lowerValue: number, upperValue: number): number {
     const difference = upperValue - lowerValue;
     const progress = input - lowerValue;
 
@@ -343,7 +295,6 @@ function interpolationFactor(input, base, lowerValue, upperValue) {
     } else if (base === 1) {
         return progress / difference;
     } else {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         return (Math.pow(base, progress) - 1) / (Math.pow(base, difference) - 1);
     }
 }