@mapbox/mapbox-gl-style-spec 14.24.1 → 14.25.0

package/expression/compound_expression.ts

@@ -1,6 +1,6 @@
 import {toString} from './types';
 import ParsingContext from './parsing_context';
-import assert from 'assert';
+import assert from '../util/assert';
 
 import type EvaluationContext from './evaluation_context';
 import type {Expression, ExpressionRegistry, SerializedExpression} from './expression';

package/expression/definitions/assertion.ts

@@ -1,4 +1,4 @@
-import assert from 'assert';
+import assert from '../../util/assert';
 import {
     ObjectType,
     ValueType,

package/expression/definitions/at_interpolated.ts

@@ -1,5 +1,6 @@
 import {array, ValueType, NumberType} from '../types';
 import RuntimeError from '../runtime_error';
+import {lerp} from '../../util/lerp';
 
 import type {Expression, SerializedExpression} from '../expression';
 import type ParsingContext from '../parsing_context';
@@ -60,7 +61,7 @@ class AtInterpolated implements Expression {
 
         // Linear interpolation
         const fraction = index - lowerIndex;
-        return lowerValue * (1 - fraction) + upperValue * fraction;
+        return lerp(lowerValue, upperValue, fraction);
     }
 
     eachChild(fn: (_: Expression) => void) {

package/expression/definitions/case.ts

@@ -1,4 +1,4 @@
-import assert from 'assert';
+import assert from '../../util/assert';
 import {BooleanType} from '../types';
 
 import type {Expression, SerializedExpression} from '../expression';

package/expression/definitions/coalesce.ts

@@ -1,4 +1,4 @@
-import assert from 'assert';
+import assert from '../../util/assert';
 import {checkSubtype, ValueType} from '../types';
 import ResolvedImage from '../types/resolved_image';
 

package/expression/definitions/coercion.ts

@@ -1,4 +1,4 @@
-import assert from 'assert';
+import assert from '../../util/assert';
 import {BooleanType, ColorType, NumberType, StringType, ValueType, array, NullType} from '../types';
 import {Color, isValue, toString as valueToString, typeOf, validateRGBA} from '../values';
 import RuntimeError from '../runtime_error';

package/expression/definitions/distance.ts

@@ -1,6 +1,7 @@
 import {isValue} from '../values';
 import {NumberType} from '../types';
 import {classifyRings, updateBBox, boxWithinBox, pointWithinPolygon, segmentIntersectSegment} from '../../util/geometry_util';
+import {lngFromMercatorX, latFromMercatorY} from '../../util/mercator';
 import CheapRuler from "cheap-ruler";
 import TinyQueue from "tinyqueue";
 import EXTENT from '../../data/extent';
@@ -126,15 +127,6 @@ function bboxToBBoxDistance(bbox1: BBox, bbox2: BBox, ruler: CheapRuler) {
     return ruler.distance([0.0, 0.0], [dx, dy]);
 }
 
-function lngFromMercatorX(x: number): number {
-    return x * 360 - 180;
-}
-
-function latFromMercatorY(y: number): number {
-    const y2 = 180 - y * 360;
-    return 360 / Math.PI * Math.atan(Math.exp(y2 * Math.PI / 180)) - 90;
-}
-
 export function getLngLatPoint(coord: Point, canonical: CanonicalTileID, extent: number = EXTENT): [number, number] {
     const tilesAtZoom = Math.pow(2, canonical.z);
     const x = (coord.x / extent + canonical.x) / tilesAtZoom;

package/expression/definitions/interpolate.ts

@@ -1,4 +1,4 @@
-import UnitBezier from '@mapbox/unitbezier';
+import unitBezier from '@mapbox/unitbezier';
 import * as interpolate from '../../util/interpolate';
 import {toString, NumberType, ColorType} from '../types';
 import {findStopLessThanOrEqualTo} from '../stops';
@@ -57,8 +57,8 @@ class Interpolate implements Expression {
             t = exponentialInterpolation(input, 1, lower, upper);
         } else if (interpolation.name === 'cubic-bezier') {
             const c = interpolation.controlPoints;
-            const ub = new UnitBezier(c[0], c[1], c[2], c[3]);
-            t = ub.solve(exponentialInterpolation(input, 1, lower, upper));
+            const ub = unitBezier(c[0], c[1], c[2], c[3]);
+            t = ub(exponentialInterpolation(input, 1, lower, upper));
         }
         return t;
     }

package/expression/definitions/literal.ts

@@ -1,4 +1,4 @@
-import assert from 'assert';
+import assert from '../../util/assert';
 import {isValue, typeOf, Color} from '../values';
 import Formatted from '../types/formatted';
 

package/expression/definitions/match.ts

@@ -1,4 +1,4 @@
-import assert from 'assert';
+import assert from '../../util/assert';
 import {typeOf} from '../values';
 import {typeEquals, ValueType} from '../types';
 

package/expression/definitions/number_format.ts

@@ -14,12 +14,14 @@ export default class NumberFormat implements Expression {
     minFractionDigits: Expression | null; // Default 0
     maxFractionDigits: Expression | null; // Default 3
 
-    constructor(number: Expression,
-                locale: Expression | null,
-                currency: Expression | null,
-                unit: Expression | null,
-                minFractionDigits: Expression | null,
-                maxFractionDigits: Expression | null) {
+    constructor(
+        number: Expression,
+        locale: Expression | null,
+        currency: Expression | null,
+        unit: Expression | null,
+        minFractionDigits: Expression | null,
+        maxFractionDigits: Expression | null
+    ) {
         this.type = StringType;
         this.number = number;
         this.locale = locale;

package/expression/definitions/within.ts

@@ -1,6 +1,7 @@
 import {isValue} from '../values';
 import {BooleanType} from '../types';
 import {updateBBox, boxWithinBox, pointWithinPolygon, segmentIntersectSegment} from '../../util/geometry_util';
+import {mercatorXfromLng, mercatorYfromLat} from '../../util/mercator';
 
 import type Point from '@mapbox/point-geometry';
 import type {Type} from '../types';
@@ -14,14 +15,6 @@ type GeoJSONPolygons = GeoJSON.Polygon | GeoJSON.MultiPolygon;
 
 const EXTENT = 8192;
 
-function mercatorXfromLng(lng: number) {
-    return (180 + lng) / 360;
-}
-
-function mercatorYfromLat(lat: number) {
-    return (180 - (180 / Math.PI * Math.log(Math.tan(Math.PI / 4 + lat * Math.PI / 360)))) / 360;
-}
-
 function getTileCoordinates(p: GeoJSON.Position, canonical: CanonicalTileID) {
     const x = mercatorXfromLng(p[0]);
     const y = mercatorYfromLat(p[1]);

package/expression/evaluation_context.ts

@@ -23,16 +23,11 @@ class EvaluationContext {
     options: ConfigOptions | null | undefined;
     iconImageUseTheme: string | null | undefined;
 
-    _parseColorCache: {
-        [_: string]: Color | null | undefined;
-    };
-
     constructor(scope?: string | null, options?: ConfigOptions | null, iconImageUseTheme?: string) {
         this.globals = null;
         this.feature = null;
         this.featureState = null;
         this.formattedSection = null;
-        this._parseColorCache = {};
         this.availableImages = null;
         this.canonical = null;
         this.featureTileCoord = null;
@@ -90,11 +85,7 @@ class EvaluationContext {
     }
 
     parseColor(input: string): Color | undefined {
-        let cached = this._parseColorCache[input];
-        if (!cached) {
-            cached = this._parseColorCache[input] = Color.parse(input);
-        }
-        return cached;
+        return Color.parse(input);
     }
 
     getConfig(id: string): ConfigOptionValue | null | undefined {

package/expression/index.ts

@@ -1,4 +1,4 @@
-import assert from 'assert';
+import assert from '../util/assert';
 import ParsingError from './parsing_error';
 import ParsingContext from './parsing_context';
 import EvaluationContext from './evaluation_context';

package/expression/values.ts

@@ -1,4 +1,4 @@
-import assert from 'assert';
+import assert from '../util/assert';
 import Color from '../util/color';
 import Collator from './types/collator';
 import Formatted from './types/formatted';
@@ -131,11 +131,10 @@ export function typeOf(value: Value): Type {
 }
 
 export function toString(value: Value): string {
-    const type = typeof value;
     if (value === null) {
         return '';
-    } else if (type === 'string' || type === 'number' || type === 'boolean') {
-        return String(value as string | number | boolean);
+    } else if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
     } else if (value instanceof Formatted || value instanceof ResolvedImage || value instanceof Color) {
         return value.toString();
     } else {

package/feature_filter/index.ts

@@ -2,7 +2,7 @@ import latest from '../reference/latest';
 import {deepUnbundle} from '../util/unbundle_jsonlint';
 import {createExpression} from '../expression/index';
 import {isFeatureConstant} from '../expression/is_constant';
-import assert from 'assert';
+import assert from '../util/assert';
 
 import type Point from '@mapbox/point-geometry';
 import type {CanonicalTileID} from '../types/tile_id';

package/function/convert.ts

@@ -1,4 +1,4 @@
-import assert from 'assert';
+import assert from '../util/assert';
 
 import type {StylePropertySpecification} from '../style-spec';
 import type {

package/group_by_layout.ts

@@ -81,13 +81,19 @@ export default function groupByLayout(
                 k = layer.id;
             } else {
                 k =  getKey(layer);
-                // The usage of "line-progress" inside "line-width" makes the property act like a layout property.
-                // We need to split it from the group to avoid conflicts in the bucket creation.
+                // The usage of "line-progress" inside "line-width" or "line-emissive-strength"
+                // makes the property act like a layout property: the bucket needs to evaluate it
+                // per-vertex against the first layer's paint, so layers that disagree on whether
+                // line-progress is used can't share a bucket.
                 if (layer.type === 'line' && layer["paint"]) {
                     const lineWidth = layer["paint"]['line-width'];
                     if (containsKey(lineWidth, 'line-progress')) {
                         k += `/${stringify(layer["paint"]['line-width'])}`;
                     }
+                    const lineEmissiveStrength = layer["paint"]['line-emissive-strength'];
+                    if (containsKey(lineEmissiveStrength, 'line-progress')) {
+                        k += `/${stringify(layer["paint"]['line-emissive-strength'])}`;
+                    }
                 }
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mapbox/mapbox-gl-style-spec",
-  "version": "14.24.1",
+  "version": "14.25.0",
   "description": "a specification for mapbox gl styles",
   "author": "Mapbox",
   "license": "SEE LICENSE IN LICENSE.txt",
@@ -32,7 +32,7 @@
     "pretest": "npm run build",
     "test": "node ./test.js",
     "build": "npm run build-spec && npm run build-dts",
-    "build-dts": "dts-bundle-generator --no-banner --export-referenced-types=false -o ./dist/index.d.ts ./style-spec.ts",
+    "build-dts": "dts-bundle-generator --no-banner --export-referenced-types=false --project ../../tsconfig.browser.json -o ./dist/index.d.ts ./style-spec.ts",
     "build-spec": "rollup -c && rollup -c --environment esm",
     "prepublishOnly": "npm run build",
     "postpublish": "rm dist/index.cjs dist/index.d.ts"
@@ -45,13 +45,11 @@
   },
   "dependencies": {
     "@mapbox/point-geometry": "^1.1.0",
-    "@mapbox/unitbezier": "^0.0.1",
+    "@mapbox/unitbezier": "^1.0.0",
     "cheap-ruler": "^4.0.0",
-    "csscolorparser": "~1.0.2",
+    "csscolorparser": "~1.0.3",
     "json-stringify-pretty-compact": "^4.0.0",
-    "minimist": "^1.2.6",
     "quickselect": "^3.0.0",
-    "rw": "^1.3.3",
     "tinyqueue": "^3.0.0"
   }
 }

package/read_style.ts

@@ -2,10 +2,10 @@ import ParsingError from './error/parsing_error';
 
 import type {StyleSpecification} from './types';
 
-export default function readStyle(style: string | Buffer | StyleSpecification): StyleSpecification {
+export default function readStyle(style: string | Uint8Array | StyleSpecification): StyleSpecification {
     if (style instanceof String || typeof style === 'string' || ArrayBuffer.isView(style)) {
         try {
-            const str = style.toString();
+            const str = ArrayBuffer.isView(style) ? new TextDecoder().decode(style) : style.toString();
             JSON.parse(str); // first try full parsing to catch malformed JSON
             return parse(str) as StyleSpecification; // then our custom parser
         } catch (e) {
@@ -111,7 +111,7 @@ function parseTokens(s: string, tokens: number[]) {
             while (tokens[i] !== RBRACE) {
                 const key: string = JSON.parse(s.slice(tokens[i + 1], tokens[i + 2])) as string;
                 i += 3;
-                obj[key] = parseValue();
+                Object.defineProperty(obj, key, {value: parseValue(), enumerable: true, configurable: true, writable: true});
             }
             i += 3;
             return obj;
@@ -122,7 +122,7 @@ function parseTokens(s: string, tokens: number[]) {
             i += 3;
             return arr;
         }
-        /* eslint-disable no-new-wrappers */
+
         if (type === STRING) return setLine(new String(JSON.parse(s.slice(start, end))), line);
         if (type === NUMBER) return setLine(new Number(+s.slice(start, end)), line);
         if (type === TRUE)   return setLine(new Boolean(true), line);

package/reference/v8.json

@@ -8874,7 +8874,8 @@
         "interpolated": true,
         "parameters": [
           "zoom",
-          "measure-light"
+          "measure-light",
+          "line-progress"
         ]
       },
       "property-type": "data-driven"
@@ -11634,10 +11635,21 @@
         }
       }
     },
-    "model-ignore-line-cutout": {
-      "type": "boolean",
-      "doc": "When set to true, the layer is not going to be affected by the line cutout effect.",
-      "default": false,
+    "model-line-cutout-mode": {
+      "type": "enum",
+      "doc": "Selects the way the line cutout effect is applied to the model.",
+      "default": "enabled",
+      "values": {
+        "enabled": {
+          "doc": "The model receives the cutout without any special handling."
+        },
+        "disabled": {
+          "doc": "The cutout effect is disabled for the model."
+        },
+        "enabled-above-cutout": {
+          "doc": "Only enabled if the model is above the cutout plane, such as for models above cut tunnels."
+        }
+      },
       "transition": false,
       "expression": {
         "interpolated": false
@@ -11647,8 +11659,9 @@
       "private": true,
       "sdk-support": {
         "basic functionality": {
-          "android": "11.21.0",
-          "ios": "11.21.0"
+          "js": "3.26.0",
+          "android": "11.26.0",
+          "ios": "11.26.0"
         }
       }
     }

package/rollup.config.js

@@ -1,6 +1,6 @@
 import resolve from '@rollup/plugin-node-resolve';
 import commonjs from '@rollup/plugin-commonjs';
-import unassert from 'rollup-plugin-unassert';
+import strip from '@rollup/plugin-strip';
 import json from '@rollup/plugin-json';
 import esbuild from 'rollup-plugin-esbuild';
 import {fileURLToPath} from 'url';
@@ -19,10 +19,13 @@ const config = [{
         sourcemap: true
     },
     plugins: [
-        esbuild({tsconfig: `${__dirname}/../../tsconfig.json`}),
+        esbuild({tsconfig: `${__dirname}/../../tsconfig.browser.json`}),
         json(),
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-        unassert({include: ['*.js', '**/*.js', '*.ts', '**/*.ts']}),
+        strip({
+            sourceMap: true,
+            functions: ['assert', 'assert.*'],
+            include: ['**/*.ts']
+        }),
         resolve({
             browser: true,
             preferBuiltins: false

package/test.js

@@ -15,7 +15,7 @@ process.on('unhandledRejection', (/** @type {Error} */ error) => {
 });
 
 const require = createRequire(import.meta.url);
-const stylePath = require.resolve('mapbox-gl-styles/styles/basic-v9.json');
+const stylePath = require.resolve('@mapbox/mapbox-gl-styles/styles/basic-v9.json');
 
 try {
     // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access

package/types/config_options.ts

@@ -1,13 +1,13 @@
 import type {Expression} from '../expression/expression';
 
 export type ConfigOptionValue = {
-  default: Expression;
-  value?: Expression;
-  values?: Array<unknown>;
-  minValue?: number;
-  maxValue?: number;
-  stepValue?: number;
-  type?: 'string' | 'number' | 'boolean' | 'color';
+    default: Expression;
+    value?: Expression;
+    values?: Array<unknown>;
+    minValue?: number;
+    maxValue?: number;
+    stepValue?: number;
+    type?: 'string' | 'number' | 'boolean' | 'color';
 };
 
 export type ConfigOptions = Map<string, ConfigOptionValue>;

package/types/lut.ts

@@ -1,7 +1,7 @@
 export type LUT = {
-  image: {
-    width: number;
-    height: number;
-    data: Uint8Array;
-  };
+    image: {
+        width: number;
+        height: number;
+        data: Uint8Array;
+    };
 };

package/types/tile_id.ts

@@ -1,5 +1,5 @@
 export type CanonicalTileID = {
-  z: number;
-  x: number;
-  y: number;
+    z: number;
+    x: number;
+    y: number;
 };

package/types.ts

@@ -1422,7 +1422,7 @@ export type ModelLayerSpecification = {
         /**
          * @experimental This property is experimental and subject to change in future versions.
          */
-        "model-ignore-line-cutout"?: boolean | ExpressionSpecification
+        "model-line-cutout-mode"?: "enabled" | "disabled" | "enabled-above-cutout" | ExpressionSpecification
     },
     /**
      * @experimental This property is experimental and subject to change in future versions.
@@ -1593,6 +1593,8 @@ export type LayoutSpecification = UnionToIntersection<NonNullable<LayerSpecifica
 
 export type PaintSpecification = UnionToIntersection<NonNullable<LayerSpecification['paint']>>;
 
+export type LayerBaseSpecification = Pick<LayerSpecification, "slot" | "minzoom" | "maxzoom" | "filter" | "appearances">;
+
 // Aliases for easier migration from @types/mapbox-gl
 
 export type Layer = Pick<

package/union-to-intersection.ts

@@ -1,4 +1,4 @@
 export type UnionToIntersection<U> =
     (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ?
-    {[K in keyof I]: I[K]} :
-    never;
+        {[K in keyof I]: I[K]} :
+        never;

package/util/assert.ts

@@ -0,0 +1,3 @@
+export default function assert(condition: unknown, message?: string): asserts condition {
+    if (!condition) throw new Error(message !== undefined ? message : 'Assertion failed');
+}

package/util/color.ts

@@ -1,8 +1,12 @@
 import {parseCSSColor} from 'csscolorparser';
-import {number as lerp} from './lerp';
+import {lerp} from './lerp';
 
 import type {LUT} from '../types/lut';
 
+// Color strings are parsed repeatedly during style load and evaluation; since Color
+// is immutable, parsed instances can be safely shared and cached by input string.
+const colorCache: Map<string, Color> = new Map();
+
 /**
  * An RGBA color value. Create instances from color strings using the static
  * method `Color.parse`. The constructor accepts RGB channel values in the range
@@ -15,10 +19,10 @@ import type {LUT} from '../types/lut';
  * @private
  */
 class Color {
-    r: number;
-    g: number;
-    b: number;
-    a: number;
+    readonly r: number;
+    readonly g: number;
+    readonly b: number;
+    readonly a: number;
 
     constructor(r: number, g: number, b: number, a: number = 1) {
         this.r = r;
@@ -50,17 +54,24 @@ class Color {
             return undefined;
         }
 
+        const cached = colorCache.get(input);
+        if (cached) {
+            return cached;
+        }
+
         const rgba = parseCSSColor(input);
         if (!rgba) {
             return undefined;
         }
 
-        return new Color(
+        const color = new Color(
             rgba[0] / 255,
             rgba[1] / 255,
             rgba[2] / 255,
             rgba[3]
         );
+        colorCache.set(input, color);
+        return color;
     }
 
     /**
@@ -152,28 +163,32 @@ export abstract class RenderColor {
             const i6 = (r1 + g1 * N2 + b0 * N) * 4;
             const i7 = (r1 + g1 * N2 + b1 * N) * 4;
 
+            // r/g/b are clamped to [0, N-1] above, so every index below is within bounds.
+            // The `as number` casts only suppress the `number | undefined` that
+            // `noUncheckedIndexedAccess` infers for typed-array reads; they are erased at
+            // runtime, so unlike a helper closure they add no per-construction allocation.
             // Trilinear interpolation.
             this.r = lerp(
                 lerp(
-                    lerp(data[i0], data[i1], bw),
-                    lerp(data[i2], data[i3], bw), gw),
+                    lerp(data[i0] as number, data[i1] as number, bw),
+                    lerp(data[i2] as number, data[i3] as number, bw), gw),
                 lerp(
-                    lerp(data[i4], data[i5], bw),
-                    lerp(data[i6], data[i7], bw), gw), rw) / 255 * (this.premultiplied ? a : 1);
+                    lerp(data[i4] as number, data[i5] as number, bw),
+                    lerp(data[i6] as number, data[i7] as number, bw), gw), rw) / 255 * (this.premultiplied ? a : 1);
             this.g = lerp(
                 lerp(
-                    lerp(data[i0 + 1], data[i1 + 1], bw),
-                    lerp(data[i2 + 1], data[i3 + 1], bw), gw),
+                    lerp(data[i0 + 1] as number, data[i1 + 1] as number, bw),
+                    lerp(data[i2 + 1] as number, data[i3 + 1] as number, bw), gw),
                 lerp(
-                    lerp(data[i4 + 1], data[i5 + 1], bw),
-                    lerp(data[i6 + 1], data[i7 + 1], bw), gw), rw) / 255 * (this.premultiplied ? a : 1);
+                    lerp(data[i4 + 1] as number, data[i5 + 1] as number, bw),
+                    lerp(data[i6 + 1] as number, data[i7 + 1] as number, bw), gw), rw) / 255 * (this.premultiplied ? a : 1);
             this.b = lerp(
                 lerp(
-                    lerp(data[i0 + 2], data[i1 + 2], bw),
-                    lerp(data[i2 + 2], data[i3 + 2], bw), gw),
+                    lerp(data[i0 + 2] as number, data[i1 + 2] as number, bw),
+                    lerp(data[i2 + 2] as number, data[i3 + 2] as number, bw), gw),
                 lerp(
-                    lerp(data[i4 + 2], data[i5 + 2], bw),
-                    lerp(data[i6 + 2], data[i7 + 2], bw), gw), rw) / 255 * (this.premultiplied ? a : 1);
+                    lerp(data[i4 + 2] as number, data[i5 + 2] as number, bw),
+                    lerp(data[i6 + 2] as number, data[i7 + 2] as number, bw), gw), rw) / 255 * (this.premultiplied ? a : 1);
             this.a = a;
         }
     }

package/util/deep_equal.ts

@@ -13,10 +13,12 @@ function deepEqual(a?: unknown, b?: unknown): boolean {
     }
     if (typeof a === 'object' && a !== null && b !== null) {
         if (!(typeof b === 'object')) return false;
-        const keys = Object.keys(a);
-        if (keys.length !== Object.keys(b).length) return false;
-        for (const key in a) {
-            if (!deepEqual(a[key], b[key])) return false;
+        const aRec = a as Record<string, unknown>;
+        const bRec = b as Record<string, unknown>;
+        const keys = Object.keys(aRec);
+        if (keys.length !== Object.keys(bRec).length) return false;
+        for (const key in aRec) {
+            if (!deepEqual(aRec[key], bRec[key])) return false;
         }
         return true;
     }

package/util/geometry_util.ts

@@ -11,7 +11,7 @@ export type BBox = [number, number, number, number];
  * have a clockwise winding.  Negative areas are interior rings and have a counter clockwise
  * ordering.
  */
-function calculateSignedArea(ring: Ring): number {
+export function calculateSignedArea(ring: Ring): number {
     let sum = 0;
     for (let i = 0, len = ring.length, j = len - 1, p1: Point, p2: Point; i < len; j = i++) {
         p1 = ring[i];

package/util/lerp.ts

@@ -1,3 +1,5 @@
-export function number(a: number, b: number, t: number): number {
+export function lerp(a: number, b: number, t: number): number {
     return (a * (1 - t)) + (b * t);
 }
+
+export {lerp as number};

package/util/mercator.ts

@@ -0,0 +1,16 @@
+export function mercatorXfromLng(lng: number): number {
+    return (180 + lng) / 360;
+}
+
+export function mercatorYfromLat(lat: number): number {
+    return (180 - (180 / Math.PI * Math.log(Math.tan(Math.PI / 4 + lat * Math.PI / 360)))) / 360;
+}
+
+export function lngFromMercatorX(x: number): number {
+    return x * 360 - 180;
+}
+
+export function latFromMercatorY(y: number): number {
+    const y2 = 180 - y * 360;
+    return 360 / Math.PI * Math.atan(Math.exp(y2 * Math.PI / 180)) - 90;
+}