mapbox-gl 1.13.2

package/src/data/raster_bounds_attributes.js

@@ -0,0 +1,7 @@
+// @flow
+import {createLayout} from '../util/struct_array';
+
+export default createLayout([
+    {name: 'a_pos', type: 'Int16', components: 2},
+    {name: 'a_texture_pos', type: 'Int16', components: 2}
+]);

package/src/data/segment.js

@@ -0,0 +1,76 @@
+// @flow
+
+import {warnOnce} from '../util/util';
+
+import {register} from '../util/web_worker_transfer';
+
+import type VertexArrayObject from '../render/vertex_array_object';
+import type {StructArray} from '../util/struct_array';
+
+export type Segment = {
+    sortKey: number | void,
+    vertexOffset: number,
+    primitiveOffset: number,
+    vertexLength: number,
+    primitiveLength: number,
+    vaos: {[_: string]: VertexArrayObject}
+}
+
+class SegmentVector {
+    static MAX_VERTEX_ARRAY_LENGTH: number;
+    segments: Array<Segment>;
+
+    constructor(segments?: Array<Segment> = []) {
+        this.segments = segments;
+    }
+
+    prepareSegment(numVertices: number, layoutVertexArray: StructArray, indexArray: StructArray, sortKey?: number): Segment {
+        let segment: Segment = this.segments[this.segments.length - 1];
+        if (numVertices > SegmentVector.MAX_VERTEX_ARRAY_LENGTH) warnOnce(`Max vertices per segment is ${SegmentVector.MAX_VERTEX_ARRAY_LENGTH}: bucket requested ${numVertices}`);
+        if (!segment || segment.vertexLength + numVertices > SegmentVector.MAX_VERTEX_ARRAY_LENGTH || segment.sortKey !== sortKey) {
+            segment = ({
+                vertexOffset: layoutVertexArray.length,
+                primitiveOffset: indexArray.length,
+                vertexLength: 0,
+                primitiveLength: 0
+            }: any);
+            if (sortKey !== undefined) segment.sortKey = sortKey;
+            this.segments.push(segment);
+        }
+        return segment;
+    }
+
+    get() {
+        return this.segments;
+    }
+
+    destroy() {
+        for (const segment of this.segments) {
+            for (const k in segment.vaos) {
+                segment.vaos[k].destroy();
+            }
+        }
+    }
+
+    static simpleSegment(vertexOffset: number, primitiveOffset: number, vertexLength: number, primitiveLength: number): SegmentVector {
+        return new SegmentVector([{
+            vertexOffset,
+            primitiveOffset,
+            vertexLength,
+            primitiveLength,
+            vaos: {},
+            sortKey: 0
+        }]);
+    }
+}
+
+/*
+ * The maximum size of a vertex array. This limit is imposed by WebGL's 16 bit
+ * addressing of vertex buffers.
+ * @private
+ * @readonly
+ */
+SegmentVector.MAX_VERTEX_ARRAY_LENGTH = Math.pow(2, 16) - 1;
+
+register('SegmentVector', SegmentVector);
+export default SegmentVector;

package/src/geo/edge_insets.js

@@ -0,0 +1,102 @@
+// @flow
+import {number} from "../style-spec/util/interpolate";
+import Point  from "@mapbox/point-geometry";
+import {clamp} from "../util/util";
+
+/**
+ * An `EdgeInset` object represents screen space padding applied to the edges of the viewport.
+ * This shifts the apprent center or the vanishing point of the map. This is useful for adding floating UI elements
+ * on top of the map and having the vanishing point shift as UI elements resize.
+ *
+ * @param {number} [top=0]
+ * @param {number} [bottom=0]
+ * @param {number} [left=0]
+ * @param {number} [right=0]
+ */
+class EdgeInsets {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+
+    constructor(top: number = 0, bottom: number = 0, left: number = 0, right: number = 0) {
+        if (isNaN(top) || top < 0 ||
+            isNaN(bottom) || bottom < 0 ||
+            isNaN(left) || left < 0 ||
+            isNaN(right) || right < 0
+        ) {
+            throw new Error('Invalid value for edge-insets, top, bottom, left and right must all be numbers');
+        }
+
+        this.top = top;
+        this.bottom = bottom;
+        this.left = left;
+        this.right = right;
+    }
+
+    /**
+     * Interpolates the inset in-place.
+     * This maintains the current inset value for any inset not present in `target`.
+     *
+     * @param {PaddingOptions} target
+     * @param {number} t
+     * @returns {EdgeInsets}
+     * @memberof EdgeInsets
+     */
+    interpolate(start: PaddingOptions | EdgeInsets, target: PaddingOptions, t: number): EdgeInsets {
+        if (target.top != null && start.top != null) this.top = number(start.top, target.top, t);
+        if (target.bottom != null && start.bottom != null) this.bottom = number(start.bottom, target.bottom, t);
+        if (target.left != null && start.left != null) this.left = number(start.left, target.left, t);
+        if (target.right != null && start.right != null) this.right = number(start.right, target.right, t);
+
+        return this;
+    }
+
+    /**
+     * Utility method that computes the new apprent center or vanishing point after applying insets.
+     * This is in pixels and with the top left being (0.0) and +y being downwards.
+     *
+     * @param {number} width
+     * @param {number} height
+     * @returns {Point}
+     * @memberof EdgeInsets
+     */
+    getCenter(width: number, height: number): Point {
+        // Clamp insets so they never overflow width/height and always calculate a valid center
+        const x = clamp((this.left + width - this.right) / 2, 0, width);
+        const y = clamp((this.top + height - this.bottom) / 2, 0, height);
+
+        return new Point(x, y);
+    }
+
+    equals(other: PaddingOptions): boolean {
+        return this.top === other.top &&
+            this.bottom === other.bottom &&
+            this.left === other.left &&
+            this.right === other.right;
+    }
+
+    clone(): EdgeInsets {
+        return new EdgeInsets(this.top, this.bottom, this.left, this.right);
+    }
+
+    /**
+     * Returns the current sdtate as json, useful when you want to have a
+     * read-only representation of the inset.
+     *
+     * @returns {PaddingOptions}
+     * @memberof EdgeInsets
+     */
+    toJSON(): PaddingOptions {
+        return {
+            top: this.top,
+            bottom: this.bottom,
+            left: this.left,
+            right: this.right
+        };
+    }
+}
+
+export type PaddingOptions = {top: ?number, bottom: ?number, right: ?number, left: ?number};
+
+export default EdgeInsets;

package/src/geo/lng_lat.js

@@ -0,0 +1,168 @@
+// @flow
+
+import {wrap} from '../util/util';
+import LngLatBounds from './lng_lat_bounds';
+
+/*
+* Approximate radius of the earth in meters.
+* Uses the WGS-84 approximation. The radius at the equator is ~6378137 and at the poles is ~6356752. https://en.wikipedia.org/wiki/World_Geodetic_System#WGS84
+* 6371008.8 is one published "average radius" see https://en.wikipedia.org/wiki/Earth_radius#Mean_radius, or ftp://athena.fsv.cvut.cz/ZFG/grs80-Moritz.pdf p.4
+*/
+export const earthRadius = 6371008.8;
+
+/**
+ * A `LngLat` object represents a given longitude and latitude coordinate, measured in degrees.
+ * These coordinates are based on the [WGS84 (EPSG:4326) standard](https://en.wikipedia.org/wiki/World_Geodetic_System#WGS84).
+ *
+ * Mapbox GL uses longitude, latitude coordinate order (as opposed to latitude, longitude) to match the
+ * [GeoJSON specification](https://tools.ietf.org/html/rfc7946).
+ *
+ * Note that any Mapbox GL method that accepts a `LngLat` object as an argument or option
+ * can also accept an `Array` of two numbers and will perform an implicit conversion.
+ * This flexible type is documented as {@link LngLatLike}.
+ *
+ * @param {number} lng Longitude, measured in degrees.
+ * @param {number} lat Latitude, measured in degrees.
+ * @example
+ * var ll = new mapboxgl.LngLat(-123.9749, 40.7736);
+ * ll.lng; // = -123.9749
+ * @see [Get coordinates of the mouse pointer](https://www.mapbox.com/mapbox-gl-js/example/mouse-position/)
+ * @see [Display a popup](https://www.mapbox.com/mapbox-gl-js/example/popup/)
+ * @see [Highlight features within a bounding box](https://www.mapbox.com/mapbox-gl-js/example/using-box-queryrenderedfeatures/)
+ * @see [Create a timeline animation](https://www.mapbox.com/mapbox-gl-js/example/timeline-animation/)
+ */
+class LngLat {
+    lng: number;
+    lat: number;
+
+    constructor(lng: number, lat: number) {
+        if (isNaN(lng) || isNaN(lat)) {
+            throw new Error(`Invalid LngLat object: (${lng}, ${lat})`);
+        }
+        this.lng = +lng;
+        this.lat = +lat;
+        if (this.lat > 90 || this.lat < -90) {
+            throw new Error('Invalid LngLat latitude value: must be between -90 and 90');
+        }
+    }
+
+    /**
+     * Returns a new `LngLat` object whose longitude is wrapped to the range (-180, 180).
+     *
+     * @returns {LngLat} The wrapped `LngLat` object.
+     * @example
+     * var ll = new mapboxgl.LngLat(286.0251, 40.7736);
+     * var wrapped = ll.wrap();
+     * wrapped.lng; // = -73.9749
+     */
+    wrap() {
+        return new LngLat(wrap(this.lng, -180, 180), this.lat);
+    }
+
+    /**
+     * Returns the coordinates represented as an array of two numbers.
+     *
+     * @returns {Array<number>} The coordinates represeted as an array of longitude and latitude.
+     * @example
+     * var ll = new mapboxgl.LngLat(-73.9749, 40.7736);
+     * ll.toArray(); // = [-73.9749, 40.7736]
+     */
+    toArray() {
+        return [this.lng, this.lat];
+    }
+
+    /**
+     * Returns the coordinates represent as a string.
+     *
+     * @returns {string} The coordinates represented as a string of the format `'LngLat(lng, lat)'`.
+     * @example
+     * var ll = new mapboxgl.LngLat(-73.9749, 40.7736);
+     * ll.toString(); // = "LngLat(-73.9749, 40.7736)"
+     */
+    toString() {
+        return `LngLat(${this.lng}, ${this.lat})`;
+    }
+
+    /**
+     * Returns the approximate distance between a pair of coordinates in meters
+     * Uses the Haversine Formula (from R.W. Sinnott, "Virtues of the Haversine", Sky and Telescope, vol. 68, no. 2, 1984, p. 159)
+     *
+     * @param {LngLat} lngLat coordinates to compute the distance to
+     * @returns {number} Distance in meters between the two coordinates.
+     * @example
+     * var new_york = new mapboxgl.LngLat(-74.0060, 40.7128);
+     * var los_angeles = new mapboxgl.LngLat(-118.2437, 34.0522);
+     * new_york.distanceTo(los_angeles); // = 3935751.690893987, "true distance" using a non-spherical approximation is ~3966km
+     */
+    distanceTo(lngLat: LngLat) {
+        const rad = Math.PI / 180;
+        const lat1 = this.lat * rad;
+        const lat2 = lngLat.lat * rad;
+        const a = Math.sin(lat1) * Math.sin(lat2) + Math.cos(lat1) * Math.cos(lat2) * Math.cos((lngLat.lng - this.lng) * rad);
+
+        const maxMeters = earthRadius * Math.acos(Math.min(a, 1));
+        return maxMeters;
+    }
+
+    /**
+     * Returns a `LngLatBounds` from the coordinates extended by a given `radius`. The returned `LngLatBounds` completely contains the `radius`.
+     *
+     * @param {number} [radius=0] Distance in meters from the coordinates to extend the bounds.
+     * @returns {LngLatBounds} A new `LngLatBounds` object representing the coordinates extended by the `radius`.
+     * @example
+     * var ll = new mapboxgl.LngLat(-73.9749, 40.7736);
+     * ll.toBounds(100).toArray(); // = [[-73.97501862141328, 40.77351016847229], [-73.97478137858673, 40.77368983152771]]
+     */
+    toBounds(radius?: number = 0) {
+        const earthCircumferenceInMetersAtEquator = 40075017;
+        const latAccuracy = 360 * radius / earthCircumferenceInMetersAtEquator,
+            lngAccuracy = latAccuracy / Math.cos((Math.PI / 180) * this.lat);
+
+        return new LngLatBounds(new LngLat(this.lng - lngAccuracy, this.lat - latAccuracy),
+            new LngLat(this.lng + lngAccuracy, this.lat + latAccuracy));
+    }
+
+    /**
+     * Converts an array of two numbers or an object with `lng` and `lat` or `lon` and `lat` properties
+     * to a `LngLat` object.
+     *
+     * If a `LngLat` object is passed in, the function returns it unchanged.
+     *
+     * @param {LngLatLike} input An array of two numbers or object to convert, or a `LngLat` object to return.
+     * @returns {LngLat} A new `LngLat` object, if a conversion occurred, or the original `LngLat` object.
+     * @example
+     * var arr = [-73.9749, 40.7736];
+     * var ll = mapboxgl.LngLat.convert(arr);
+     * ll;   // = LngLat {lng: -73.9749, lat: 40.7736}
+     */
+    static convert(input: LngLatLike): LngLat {
+        if (input instanceof LngLat) {
+            return input;
+        }
+        if (Array.isArray(input) && (input.length === 2 || input.length === 3)) {
+            return new LngLat(Number(input[0]), Number(input[1]));
+        }
+        if (!Array.isArray(input) && typeof input === 'object' && input !== null) {
+            return new LngLat(
+                // flow can't refine this to have one of lng or lat, so we have to cast to any
+                Number('lng' in input ? (input: any).lng : (input: any).lon),
+                Number(input.lat)
+            );
+        }
+        throw new Error("`LngLatLike` argument must be specified as a LngLat instance, an object {lng: <lng>, lat: <lat>}, an object {lon: <lng>, lat: <lat>}, or an array of [<lng>, <lat>]");
+    }
+}
+
+/**
+ * A {@link LngLat} object, an array of two numbers representing longitude and latitude,
+ * or an object with `lng` and `lat` or `lon` and `lat` properties.
+ *
+ * @typedef {LngLat | {lng: number, lat: number} | {lon: number, lat: number} | [number, number]} LngLatLike
+ * @example
+ * var v1 = new mapboxgl.LngLat(-122.420679, 37.772537);
+ * var v2 = [-122.420679, 37.772537];
+ * var v3 = {lon: -122.420679, lat: 37.772537};
+ */
+export type LngLatLike = LngLat | {lng: number, lat: number} | {lon: number, lat: number} | [number, number];
+
+export default LngLat;

package/src/geo/lng_lat_bounds.js

@@ -0,0 +1,276 @@
+// @flow
+
+import LngLat from './lng_lat';
+
+import type {LngLatLike} from './lng_lat';
+
+/**
+ * A `LngLatBounds` object represents a geographical bounding box,
+ * defined by its southwest and northeast points in longitude and latitude.
+ *
+ * If no arguments are provided to the constructor, a `null` bounding box is created.
+ *
+ * Note that any Mapbox GL method that accepts a `LngLatBounds` object as an argument or option
+ * can also accept an `Array` of two {@link LngLatLike} constructs and will perform an implicit conversion.
+ * This flexible type is documented as {@link LngLatBoundsLike}.
+ *
+ * @param {LngLatLike} [sw] The southwest corner of the bounding box.
+ * @param {LngLatLike} [ne] The northeast corner of the bounding box.
+ * @example
+ * var sw = new mapboxgl.LngLat(-73.9876, 40.7661);
+ * var ne = new mapboxgl.LngLat(-73.9397, 40.8002);
+ * var llb = new mapboxgl.LngLatBounds(sw, ne);
+ */
+class LngLatBounds {
+    _ne: LngLat;
+    _sw: LngLat;
+
+    // This constructor is too flexible to type. It should not be so flexible.
+    constructor(sw: any, ne: any) {
+        if (!sw) {
+            // noop
+        } else if (ne) {
+            this.setSouthWest(sw).setNorthEast(ne);
+        } else if (sw.length === 4) {
+            this.setSouthWest([sw[0], sw[1]]).setNorthEast([sw[2], sw[3]]);
+        } else {
+            this.setSouthWest(sw[0]).setNorthEast(sw[1]);
+        }
+    }
+
+    /**
+     * Set the northeast corner of the bounding box
+     *
+     * @param {LngLatLike} ne a {@link LngLatLike} object describing the northeast corner of the bounding box.
+     * @returns {LngLatBounds} `this`
+     */
+    setNorthEast(ne: LngLatLike) {
+        this._ne = ne instanceof LngLat ? new LngLat(ne.lng, ne.lat) : LngLat.convert(ne);
+        return this;
+    }
+
+    /**
+     * Set the southwest corner of the bounding box
+     *
+     * @param {LngLatLike} sw a {@link LngLatLike} object describing the southwest corner of the bounding box.
+     * @returns {LngLatBounds} `this`
+     */
+    setSouthWest(sw: LngLatLike) {
+        this._sw = sw instanceof LngLat ? new LngLat(sw.lng, sw.lat) : LngLat.convert(sw);
+        return this;
+    }
+
+    /**
+     * Extend the bounds to include a given LngLatLike or LngLatBoundsLike.
+     *
+     * @param {LngLatLike|LngLatBoundsLike} obj object to extend to
+     * @returns {LngLatBounds} `this`
+     */
+    extend(obj: LngLatLike | LngLatBoundsLike) {
+        const sw = this._sw,
+            ne = this._ne;
+        let sw2, ne2;
+
+        if (obj instanceof LngLat) {
+            sw2 = obj;
+            ne2 = obj;
+
+        } else if (obj instanceof LngLatBounds) {
+            sw2 = obj._sw;
+            ne2 = obj._ne;
+
+            if (!sw2 || !ne2) return this;
+
+        } else {
+            if (Array.isArray(obj)) {
+                if (obj.length === 4 || obj.every(Array.isArray)) {
+                    const lngLatBoundsObj = ((obj: any): LngLatBoundsLike);
+                    return this.extend(LngLatBounds.convert(lngLatBoundsObj));
+                } else {
+                    const lngLatObj = ((obj: any): LngLatLike);
+                    return this.extend(LngLat.convert(lngLatObj));
+                }
+            }
+            return this;
+        }
+
+        if (!sw && !ne) {
+            this._sw = new LngLat(sw2.lng, sw2.lat);
+            this._ne = new LngLat(ne2.lng, ne2.lat);
+
+        } else {
+            sw.lng = Math.min(sw2.lng, sw.lng);
+            sw.lat = Math.min(sw2.lat, sw.lat);
+            ne.lng = Math.max(ne2.lng, ne.lng);
+            ne.lat = Math.max(ne2.lat, ne.lat);
+        }
+
+        return this;
+    }
+
+    /**
+     * Returns the geographical coordinate equidistant from the bounding box's corners.
+     *
+     * @returns {LngLat} The bounding box's center.
+     * @example
+     * var llb = new mapboxgl.LngLatBounds([-73.9876, 40.7661], [-73.9397, 40.8002]);
+     * llb.getCenter(); // = LngLat {lng: -73.96365, lat: 40.78315}
+     */
+    getCenter(): LngLat {
+        return new LngLat((this._sw.lng + this._ne.lng) / 2, (this._sw.lat + this._ne.lat) / 2);
+    }
+
+    /**
+     * Returns the southwest corner of the bounding box.
+     *
+     * @returns {LngLat} The southwest corner of the bounding box.
+     */
+    getSouthWest(): LngLat { return this._sw; }
+
+    /**
+    * Returns the northeast corner of the bounding box.
+    *
+    * @returns {LngLat} The northeast corner of the bounding box.
+     */
+    getNorthEast(): LngLat { return this._ne; }
+
+    /**
+    * Returns the northwest corner of the bounding box.
+    *
+    * @returns {LngLat} The northwest corner of the bounding box.
+     */
+    getNorthWest(): LngLat { return new LngLat(this.getWest(), this.getNorth()); }
+
+    /**
+    * Returns the southeast corner of the bounding box.
+    *
+    * @returns {LngLat} The southeast corner of the bounding box.
+     */
+    getSouthEast(): LngLat { return new LngLat(this.getEast(), this.getSouth()); }
+
+    /**
+    * Returns the west edge of the bounding box.
+    *
+    * @returns {number} The west edge of the bounding box.
+     */
+    getWest(): number { return this._sw.lng; }
+
+    /**
+    * Returns the south edge of the bounding box.
+    *
+    * @returns {number} The south edge of the bounding box.
+     */
+    getSouth(): number { return this._sw.lat; }
+
+    /**
+    * Returns the east edge of the bounding box.
+    *
+    * @returns {number} The east edge of the bounding box.
+     */
+    getEast(): number { return this._ne.lng; }
+
+    /**
+    * Returns the north edge of the bounding box.
+    *
+    * @returns {number} The north edge of the bounding box.
+     */
+    getNorth(): number { return this._ne.lat; }
+
+    /**
+     * Returns the bounding box represented as an array.
+     *
+     * @returns {Array<Array<number>>} The bounding box represented as an array, consisting of the
+     *   southwest and northeast coordinates of the bounding represented as arrays of numbers.
+     * @example
+     * var llb = new mapboxgl.LngLatBounds([-73.9876, 40.7661], [-73.9397, 40.8002]);
+     * llb.toArray(); // = [[-73.9876, 40.7661], [-73.9397, 40.8002]]
+     */
+    toArray() {
+        return [this._sw.toArray(), this._ne.toArray()];
+    }
+
+    /**
+     * Return the bounding box represented as a string.
+     *
+     * @returns {string} The bounding box represents as a string of the format
+     *   `'LngLatBounds(LngLat(lng, lat), LngLat(lng, lat))'`.
+     * @example
+     * var llb = new mapboxgl.LngLatBounds([-73.9876, 40.7661], [-73.9397, 40.8002]);
+     * llb.toString(); // = "LngLatBounds(LngLat(-73.9876, 40.7661), LngLat(-73.9397, 40.8002))"
+     */
+    toString() {
+        return `LngLatBounds(${this._sw.toString()}, ${this._ne.toString()})`;
+    }
+
+    /**
+     * Check if the bounding box is an empty/`null`-type box.
+     *
+     * @returns {boolean} True if bounds have been defined, otherwise false.
+     */
+    isEmpty() {
+        return !(this._sw && this._ne);
+    }
+
+    /**
+    * Check if the point is within the bounding box.
+    *
+    * @param {LngLatLike} lnglat geographic point to check against.
+    * @returns {boolean} True if the point is within the bounding box.
+    * @example
+    * var llb = new mapboxgl.LngLatBounds(
+    *   new mapboxgl.LngLat(-73.9876, 40.7661),
+    *   new mapboxgl.LngLat(-73.9397, 40.8002)
+    * );
+    *
+    * var ll = new mapboxgl.LngLat(-73.9567, 40.7789);
+    *
+    * console.log(llb.contains(ll)); // = true
+    */
+    contains(lnglat: LngLatLike) {
+        const {lng, lat} = LngLat.convert(lnglat);
+
+        const containsLatitude = this._sw.lat <= lat && lat <= this._ne.lat;
+        let containsLongitude = this._sw.lng <= lng && lng <= this._ne.lng;
+        if (this._sw.lng > this._ne.lng) { // wrapped coordinates
+            containsLongitude = this._sw.lng >= lng && lng >= this._ne.lng;
+        }
+
+        return containsLatitude && containsLongitude;
+    }
+
+    /**
+     * Converts an array to a `LngLatBounds` object.
+     *
+     * If a `LngLatBounds` object is passed in, the function returns it unchanged.
+     *
+     * Internally, the function calls `LngLat#convert` to convert arrays to `LngLat` values.
+     *
+     * @param {LngLatBoundsLike} input An array of two coordinates to convert, or a `LngLatBounds` object to return.
+     * @returns {LngLatBounds} A new `LngLatBounds` object, if a conversion occurred, or the original `LngLatBounds` object.
+     * @example
+     * var arr = [[-73.9876, 40.7661], [-73.9397, 40.8002]];
+     * var llb = mapboxgl.LngLatBounds.convert(arr);
+     * llb;   // = LngLatBounds {_sw: LngLat {lng: -73.9876, lat: 40.7661}, _ne: LngLat {lng: -73.9397, lat: 40.8002}}
+     */
+    static convert(input: LngLatBoundsLike): LngLatBounds {
+        if (!input || input instanceof LngLatBounds) return input;
+        return new LngLatBounds(input);
+    }
+}
+
+/**
+ * A {@link LngLatBounds} object, an array of {@link LngLatLike} objects in [sw, ne] order,
+ * or an array of numbers in [west, south, east, north] order.
+ *
+ * @typedef {LngLatBounds | [LngLatLike, LngLatLike] | [number, number, number, number]} LngLatBoundsLike
+ * @example
+ * var v1 = new mapboxgl.LngLatBounds(
+ *   new mapboxgl.LngLat(-73.9876, 40.7661),
+ *   new mapboxgl.LngLat(-73.9397, 40.8002)
+ * );
+ * var v2 = new mapboxgl.LngLatBounds([-73.9876, 40.7661], [-73.9397, 40.8002])
+ * var v3 = [[-73.9876, 40.7661], [-73.9397, 40.8002]];
+ */
+export type LngLatBoundsLike = LngLatBounds | [LngLatLike, LngLatLike] | [number, number, number, number];
+
+export default LngLatBounds;