(function (f) {
if (typeof exports === 'object' && typeof module !== 'undefined') {
module.exports = f();
} else if (typeof define === 'function' && define.amd) {
define([], f);
} else {
var g;
if (typeof window !== 'undefined') {
g = window;
} else if (typeof global !== 'undefined') {
g = global;
} else if (typeof self !== 'undefined') {
g = self;
} else {
g = this;
}
g.ArcGISTiledMapServiceSource = f();
}
})(function () {
var define, module, exports;
return (function () {
function e(t, n, r) {
function s(o, u) {
if (!n[o]) {
if (!t[o]) {
var a = typeof require == 'function' && require;
if (!u && a) return a(o, !0);
if (i) return i(o, !0);
var f = new Error('Cannot find module \'' + o + '\'');
throw f.code = 'MODULE_NOT_FOUND', f;
}
var l = n[o] = {exports: {}};
t[o][0].call(l.exports, function (e) {
var n = t[o][1][e];
return s(n ? n : e);
}, l, l.exports, e, t, n, r);
}
return n[o].exports;
}
var i = typeof require == 'function' && require;
for (var o = 0; o < r.length; o++) s(r[o]);
return s;
}
return e;
})()({
1: [function (require, module, exports) {
'use strict';
module.exports = Point;
/**
* A standalone point geometry with useful accessor, comparison, and
* modification methods.
*
* @class Point
* @param {Number} x the x-coordinate. this could be longitude or screen
* pixels, or any other sort of unit.
* @param {Number} y the y-coordinate. this could be latitude or screen
* pixels, or any other sort of unit.
* @example
* var point = new Point(-77, 38);
*/
function Point(x, y) {
this.x = x;
this.y = y;
}
Point.prototype = {
/**
* Clone this point, returning a new point that can be modified
* without affecting the old one.
* @return {Point} the clone
*/
clone: function () {
return new Point(this.x, this.y);
},
/**
* Add this point's x & y coordinates to another point,
* yielding a new point.
* @param {Point} p the other point
* @return {Point} output point
*/
add: function (p) {
return this.clone()._add(p);
},
/**
* Subtract this point's x & y coordinates to from point,
* yielding a new point.
* @param {Point} p the other point
* @return {Point} output point
*/
sub: function (p) {
return this.clone()._sub(p);
},
/**
* Multiply this point's x & y coordinates by point,
* yielding a new point.
* @param {Point} p the other point
* @return {Point} output point
*/
multByPoint: function (p) {
return this.clone()._multByPoint(p);
},
/**
* Divide this point's x & y coordinates by point,
* yielding a new point.
* @param {Point} p the other point
* @return {Point} output point
*/
divByPoint: function (p) {
return this.clone()._divByPoint(p);
},
/**
* Multiply this point's x & y coordinates by a factor,
* yielding a new point.
* @param {Point} k factor
* @return {Point} output point
*/
mult: function (k) {
return this.clone()._mult(k);
},
/**
* Divide this point's x & y coordinates by a factor,
* yielding a new point.
* @param {Point} k factor
* @return {Point} output point
*/
div: function (k) {
return this.clone()._div(k);
},
/**
* Rotate this point around the 0, 0 origin by an angle a,
* given in radians
* @param {Number} a angle to rotate around, in radians
* @return {Point} output point
*/
rotate: function (a) {
return this.clone()._rotate(a);
},
/**
* Rotate this point around p point by an angle a,
* given in radians
* @param {Number} a angle to rotate around, in radians
* @param {Point} p Point to rotate around
* @return {Point} output point
*/
rotateAround: function (a, p) {
return this.clone()._rotateAround(a, p);
},
/**
* Multiply this point by a 4x1 transformation matrix
* @param {Array<Number>} m transformation matrix
* @return {Point} output point
*/
matMult: function (m) {
return this.clone()._matMult(m);
},
/**
* Calculate this point but as a unit vector from 0, 0, meaning
* that the distance from the resulting point to the 0, 0
* coordinate will be equal to 1 and the angle from the resulting
* point to the 0, 0 coordinate will be the same as before.
* @return {Point} unit vector point
*/
unit: function () {
return this.clone()._unit();
},
/**
* Compute a perpendicular point, where the new y coordinate
* is the old x coordinate and the new x coordinate is the old y
* coordinate multiplied by -1
* @return {Point} perpendicular point
*/
perp: function () {
return this.clone()._perp();
},
/**
* Return a version of this point with the x & y coordinates
* rounded to integers.
* @return {Point} rounded point
*/
round: function () {
return this.clone()._round();
},
/**
* Return the magitude of this point: this is the Euclidean
* distance from the 0, 0 coordinate to this point's x and y
* coordinates.
* @return {Number} magnitude
*/
mag: function () {
return Math.sqrt(this.x * this.x + this.y * this.y);
},
/**
* Judge whether this point is equal to another point, returning
* true or false.
* @param {Point} other the other point
* @return {boolean} whether the points are equal
*/
equals: function (other) {
return this.x === other.x &&
this.y === other.y;
},
/**
* Calculate the distance from this point to another point
* @param {Point} p the other point
* @return {Number} distance
*/
dist: function (p) {
return Math.sqrt(this.distSqr(p));
},
/**
* Calculate the distance from this point to another point,
* without the square root step. Useful if you're comparing
* relative distances.
* @param {Point} p the other point
* @return {Number} distance
*/
distSqr: function (p) {
var dx = p.x - this.x,
dy = p.y - this.y;
return dx * dx + dy * dy;
},
/**
* Get the angle from the 0, 0 coordinate to this point, in radians
* coordinates.
* @return {Number} angle
*/
angle: function () {
return Math.atan2(this.y, this.x);
},
/**
* Get the angle from this point to another point, in radians
* @param {Point} b the other point
* @return {Number} angle
*/
angleTo: function (b) {
return Math.atan2(this.y - b.y, this.x - b.x);
},
/**
* Get the angle between this point and another point, in radians
* @param {Point} b the other point
* @return {Number} angle
*/
angleWith: function (b) {
return this.angleWithSep(b.x, b.y);
},
/*
* Find the angle of the two vectors, solving the formula for
* the cross product a x b = |a||b|sin(θ) for θ.
* @param {Number} x the x-coordinate
* @param {Number} y the y-coordinate
* @return {Number} the angle in radians
*/
angleWithSep: function (x, y) {
return Math.atan2(
this.x * y - this.y * x,
this.x * x + this.y * y);
},
_matMult: function (m) {
var x = m[0] * this.x + m[1] * this.y,
y = m[2] * this.x + m[3] * this.y;
this.x = x;
this.y = y;
return this;
},
_add: function (p) {
this.x += p.x;
this.y += p.y;
return this;
},
_sub: function (p) {
this.x -= p.x;
this.y -= p.y;
return this;
},
_mult: function (k) {
this.x *= k;
this.y *= k;
return this;
},
_div: function (k) {
this.x /= k;
this.y /= k;
return this;
},
_multByPoint: function (p) {
this.x *= p.x;
this.y *= p.y;
return this;
},
_divByPoint: function (p) {
this.x /= p.x;
this.y /= p.y;
return this;
},
_unit: function () {
this._div(this.mag());
return this;
},
_perp: function () {
var y = this.y;
this.y = this.x;
this.x = -y;
return this;
},
_rotate: function (angle) {
var cos = Math.cos(angle),
sin = Math.sin(angle),
x = cos * this.x - sin * this.y,
y = sin * this.x + cos * this.y;
this.x = x;
this.y = y;
return this;
},
_rotateAround: function (angle, p) {
var cos = Math.cos(angle),
sin = Math.sin(angle),
x = p.x + cos * (this.x - p.x) - sin * (this.y - p.y),
y = p.y + sin * (this.x - p.x) + cos * (this.y - p.y);
this.x = x;
this.y = y;
return this;
},
_round: function () {
this.x = Math.round(this.x);
this.y = Math.round(this.y);
return this;
}
};
/**
* Construct a point from an array if necessary, otherwise if the input
* is already a Point, or an unknown type, return it unchanged
* @param {Array<Number>|Point|*} a any kind of input value
* @return {Point} constructed point, or passed-through value.
* @example
* // this
* var point = Point.convert([0, 1]);
* // is equivalent to
* var point = new Point(0, 1);
*/
Point.convert = function (a) {
if (a instanceof Point) {
return a;
}
if (Array.isArray(a)) {
return new Point(a[0], a[1]);
}
return a;
};
}, {}],
2: [function (require, module, exports) {
/*
* Copyright (C) 2008 Apple Inc. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Ported from Webkit
* http://svn.webkit.org/repository/webkit/trunk/Source/WebCore/platform/graphics/UnitBezier.h
*/
module.exports = UnitBezier;
function UnitBezier(p1x, p1y, p2x, p2y) {
// Calculate the polynomial coefficients, implicit first and last control points are (0,0) and (1,1).
this.cx = 3.0 * p1x;
this.bx = 3.0 * (p2x - p1x) - this.cx;
this.ax = 1.0 - this.cx - this.bx;
this.cy = 3.0 * p1y;
this.by = 3.0 * (p2y - p1y) - this.cy;
this.ay = 1.0 - this.cy - this.by;
this.p1x = p1x;
this.p1y = p2y;
this.p2x = p2x;
this.p2y = p2y;
}
UnitBezier.prototype.sampleCurveX = function (t) {
// `ax t^3 + bx t^2 + cx t' expanded using Horner's rule.
return ((this.ax * t + this.bx) * t + this.cx) * t;
};
UnitBezier.prototype.sampleCurveY = function (t) {
return ((this.ay * t + this.by) * t + this.cy) * t;
};
UnitBezier.prototype.sampleCurveDerivativeX = function (t) {
return (3.0 * this.ax * t + 2.0 * this.bx) * t + this.cx;
};
UnitBezier.prototype.solveCurveX = function (x, epsilon) {
if (typeof epsilon === 'undefined') epsilon = 1e-6;
var t0, t1, t2, x2, i;
// First try a few iterations of Newton's method -- normally very fast.
for (t2 = x, i = 0; i < 8; i++) {
x2 = this.sampleCurveX(t2) - x;
if (Math.abs(x2) < epsilon) return t2;
var d2 = this.sampleCurveDerivativeX(t2);
if (Math.abs(d2) < 1e-6) break;
t2 = t2 - x2 / d2;
}
// Fall back to the bisection method for reliability.
t0 = 0.0;
t1 = 1.0;
t2 = x;
if (t2 < t0) return t0;
if (t2 > t1) return t1;
while (t0 < t1) {
x2 = this.sampleCurveX(t2);
if (Math.abs(x2 - x) < epsilon) return t2;
if (x > x2) {
t0 = t2;
} else {
t1 = t2;
}
t2 = (t1 - t0) * 0.5 + t0;
}
// Failure.
return t2;
};
UnitBezier.prototype.solve = function (x, epsilon) {
return this.sampleCurveY(this.solveCurveX(x, epsilon));
};
}, {}],
3: [function (require, module, exports) {
'use strict';//
/**
* A coordinate is a column, row, zoom combination, often used
* as the data component of a tile.
*
* @param {number} column
* @param {number} row
* @param {number} zoom
* @private
*/
var Coordinate = function Coordinate(column, row, zoom) {
this.column = column;
this.row = row;
this.zoom = zoom;
};
/**
* Create a clone of this coordinate that can be mutated without
* changing the original coordinate
*
* @returns {Coordinate} clone
* @private
* var coord = new Coordinate(0, 0, 0);
* var c2 = coord.clone();
* // since coord is cloned, modifying a property of c2 does
* // not modify it.
* c2.zoom = 2;
*/
Coordinate.prototype.clone = function clone() {
return new Coordinate(this.column, this.row, this.zoom);
};
/**
* Zoom this coordinate to a given zoom level. This returns a new
* coordinate object, not mutating the old one.
*
* @param {number} zoom
* @returns {Coordinate} zoomed coordinate
* @private
* @example
* var coord = new Coordinate(0, 0, 0);
* var c2 = coord.zoomTo(1);
* c2 // equals new Coordinate(0, 0, 1);
*/
Coordinate.prototype.zoomTo = function zoomTo(zoom) {
return this.clone()._zoomTo(zoom);
};
/**
* Subtract the column and row values of this coordinate from those
* of another coordinate. The other coordinat will be zoomed to the
* same level as `this` before the subtraction occurs
*
* @param {Coordinate} c other coordinate
* @returns {Coordinate} result
* @private
*/
Coordinate.prototype.sub = function sub(c) {
return this.clone()._sub(c);
};
Coordinate.prototype._zoomTo = function _zoomTo(zoom) {
var scale = Math.pow(2, zoom - this.zoom);
this.column *= scale;
this.row *= scale;
this.zoom = zoom;
return this;
};
Coordinate.prototype._sub = function _sub(c) {
c = c.zoomTo(this.zoom);
this.column -= c.column;
this.row -= c.row;
return this;
};
module.exports = Coordinate;
}, {}],
4: [function (require, module, exports) {
'use strict';//
var wrap = require('../util/util').wrap;
/**
* A `LngLat` object represents a given longitude and latitude coordinate, measured in degrees.
*
* Mapbox GL uses longitude, latitude coordinate order (as opposed to latitude, longitude) to match GeoJSON.
*
* 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(-73.9749, 40.7736);
* @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/)
*/
var LngLat = function LngLat(lng, lat) {
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
*/
LngLat.prototype.wrap = function wrap$1() {
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]
*/
LngLat.prototype.toArray = function 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)"
*/
LngLat.prototype.toString = function toString() {
return ('LngLat(' + (this.lng) + ', ' + (this.lat) + ')');
};
/**
* Returns a `LngLatBounds` from the coordinates extended by a given `radius`.
*
* @param {number} radius 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]]
*/
LngLat.prototype.toBounds = function toBounds(radius) {
var earthCircumferenceInMetersAtEquator = 40075017;
var latAccuracy = 360 * radius / earthCircumferenceInMetersAtEquator,
lngAccuracy = latAccuracy / Math.cos((Math.PI / 180) * this.lat);
var LngLatBounds = require('./lng_lat_bounds');
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 to a `LngLat` object.
*
* If a `LngLat` object is passed in, the function returns it unchanged.
*
* @param {LngLatLike} input An array of two numbers 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}
*/
LngLat.convert = function convert(input) {
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(Number(input.lng), Number(input.lat));
}
throw new Error('`LngLatLike` argument must be specified as a LngLat instance, an object {lng: <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` properties.
*
* @typedef {LngLat | {lng: number, lat: number} | [number, number]} LngLatLike
* @example
* var v1 = new mapboxgl.LngLat(-122.420679, 37.772537);
* var v2 = [-122.420679, 37.772537];
*/
module.exports = LngLat;
}, {'../util/util': 11, './lng_lat_bounds': 5}],
5: [function (require, module, exports) {
'use strict';//
var LngLat = require('./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);
*/
var LngLatBounds = function LngLatBounds(sw, ne) {
if (!sw) {
return;
} 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
* @returns {LngLatBounds} `this`
*/
LngLatBounds.prototype.setNorthEast = function setNorthEast(ne) {
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
* @returns {LngLatBounds} `this`
*/
LngLatBounds.prototype.setSouthWest = function setSouthWest(sw) {
this._sw = sw instanceof LngLat ? new LngLat(sw.lng, sw.lat) : LngLat.convert(sw);
return this;
};
/**
* Extend the bounds to include a given LngLat or LngLatBounds.
*
* @param {LngLat|LngLatBounds} obj object to extend to
* @returns {LngLatBounds} `this`
*/
LngLatBounds.prototype.extend = function extend(obj) {
var sw = this._sw,
ne = this._ne;
var 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.every(Array.isArray)) {
return this.extend(LngLatBounds.convert(obj));
} else {
return this.extend(LngLat.convert(obj));
}
}
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}
*/
LngLatBounds.prototype.getCenter = function getCenter() {
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.
*/
LngLatBounds.prototype.getSouthWest = function getSouthWest() {
return this._sw;
};
/**
* Returns the northeast corner of the bounding box.
*
* @returns {LngLat} The northeast corner of the bounding box.
*/
LngLatBounds.prototype.getNorthEast = function getNorthEast() {
return this._ne;
};
/**
* Returns the northwest corner of the bounding box.
*
* @returns {LngLat} The northwest corner of the bounding box.
*/
LngLatBounds.prototype.getNorthWest = function getNorthWest() {
return new LngLat(this.getWest(), this.getNorth());
};
/**
* Returns the southeast corner of the bounding box.
*
* @returns {LngLat} The southeast corner of the bounding box.
*/
LngLatBounds.prototype.getSouthEast = function getSouthEast() {
return new LngLat(this.getEast(), this.getSouth());
};
/**
* Returns the west edge of the bounding box.
*
* @returns {number} The west edge of the bounding box.
*/
LngLatBounds.prototype.getWest = function getWest() {
return this._sw.lng;
};
/**
* Returns the south edge of the bounding box.
*
* @returns {number} The south edge of the bounding box.
*/
LngLatBounds.prototype.getSouth = function getSouth() {
return this._sw.lat;
};
/**
* Returns the east edge of the bounding box.
*
* @returns {number} The east edge of the bounding box.
*/
LngLatBounds.prototype.getEast = function getEast() {
return this._ne.lng;
};
/**
* Returns the north edge of the bounding box.
*
* @returns {number} The north edge of the bounding box.
*/
LngLatBounds.prototype.getNorth = function getNorth() {
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]]
*/
LngLatBounds.prototype.toArray = function 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))"
*/
LngLatBounds.prototype.toString = function toString() {
return ('LngLatBounds(' + (this._sw.toString()) + ', ' + (this._ne.toString()) + ')');
};
/**
* 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}}
*/
LngLatBounds.convert = function convert(input) {
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]];
*/
module.exports = LngLatBounds;
}, {'./lng_lat': 4}],
6: [function (require, module, exports) {
'use strict';//
var ref = require('../util/window');
var HTMLImageElement = ref.HTMLImageElement;
var HTMLCanvasElement = ref.HTMLCanvasElement;
var HTMLVideoElement = ref.HTMLVideoElement;
var ImageData = ref.ImageData;
var Texture = function Texture(context, image, format, premultiply) {
this.context = context;
var width = image.width;
var height = image.height;
this.size = [width, height];
this.format = format;
this.texture = context.gl.createTexture();
this.update(image, premultiply);
};
Texture.prototype.update = function update(image, premultiply) {
var width = image.width;
var height = image.height;
this.size = [width, height];
var ref = this;
var context = ref.context;
var gl = context.gl;
gl.bindTexture(gl.TEXTURE_2D, this.texture);
context.pixelStoreUnpack.set(1);
if (this.format === gl.RGBA && premultiply !== false) {
context.pixelStoreUnpackPremultiplyAlpha.set(true);
}
if (image instanceof HTMLImageElement || image instanceof HTMLCanvasElement || image instanceof HTMLVideoElement || image instanceof ImageData) {
gl.texImage2D(gl.TEXTURE_2D, 0, this.format, this.format, gl.UNSIGNED_BYTE, image);
} else {
gl.texImage2D(gl.TEXTURE_2D, 0, this.format, width, height, 0, this.format, gl.UNSIGNED_BYTE, image.data);
}
};
Texture.prototype.bind = function bind(filter, wrap, minFilter) {
var ref = this;
var context = ref.context;
var gl = context.gl;
gl.bindTexture(gl.TEXTURE_2D, this.texture);
if (filter !== this.filter) {
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, filter);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, minFilter || filter);
this.filter = filter;
}
if (wrap !== this.wrap) {
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, wrap);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, wrap);
this.wrap = wrap;
}
};
Texture.prototype.destroy = function destroy() {
var ref = this.context;
var gl = ref.gl;
gl.deleteTexture(this.texture);
this.texture = (null );
};
module.exports = Texture;
}, {'../util/window': 9}],
7: [function (require, module, exports) {
'use strict';//
var LngLatBounds = require('../geo/lng_lat_bounds');
var clamp = require('../util/util').clamp;
var TileBounds = function TileBounds(bounds, minzoom, maxzoom) {
this.bounds = LngLatBounds.convert(this.validateBounds(bounds));
this.minzoom = minzoom || 0;
this.maxzoom = maxzoom || 24;
};
TileBounds.prototype.validateBounds = function validateBounds(bounds) {
// make sure the bounds property contains valid longitude and latitudes
if (!Array.isArray(bounds) || bounds.length !== 4) {
return [-180, -90, 180, 90];
}
return [Math.max(-180, bounds[0]), Math.max(-90, bounds[1]), Math.min(180, bounds[2]), Math.min(90, bounds[3])];
};
TileBounds.prototype.contains = function contains(tileID) {
var level = {
minX: Math.floor(this.lngX(this.bounds.getWest(), tileID.z)),
minY: Math.floor(this.latY(this.bounds.getNorth(), tileID.z)),
maxX: Math.ceil(this.lngX(this.bounds.getEast(), tileID.z)),
maxY: Math.ceil(this.latY(this.bounds.getSouth(), tileID.z))
};
var hit = tileID.x >= level.minX && tileID.x < level.maxX && tileID.y >= level.minY && tileID.y < level.maxY;
return hit;
};
TileBounds.prototype.lngX = function lngX(lng, zoom) {
return (lng + 180) * (Math.pow(2, zoom) / 360);
};
TileBounds.prototype.latY = function latY(lat, zoom) {
var f = clamp(Math.sin(Math.PI / 180 * lat), -0.9999, 0.9999);
var scale = Math.pow(2, zoom) / (2 * Math.PI);
return Math.pow(2, zoom - 1) + 0.5 * Math.log((1 + f) / (1 - f)) * -scale;
};
module.exports = TileBounds;
}, {'../geo/lng_lat_bounds': 5, '../util/util': 11}],
8: [function (require, module, exports) {
'use strict';//
var window = require('./window');
/**
* The type of a resource.
* @private
* @readonly
* @enum {string}
*/
var ResourceType = {
Unknown: 'Unknown',
Style: 'Style',
Source: 'Source',
Tile: 'Tile',
Glyphs: 'Glyphs',
SpriteImage: 'SpriteImage',
SpriteJSON: 'SpriteJSON',
Image: 'Image'
};
exports.ResourceType = ResourceType;
if (typeof Object.freeze == 'function') {
Object.freeze(ResourceType);
}
/**
* A `RequestParameters` object to be returned from Map.options.transformRequest callbacks.
* @typedef {Object} RequestParameters
* @property {string} url The URL to be requested.
* @property {Object} headers The headers to be sent with the request.
* @property {string} credentials `'same-origin'|'include'` Use 'include' to send cookies with cross-origin requests.
*/
var AJAXError = (function (Error) {
function AJAXError(message, status) {
Error.call(this, message);
this.status = status;
}
if (Error) AJAXError.__proto__ = Error;
AJAXError.prototype = Object.create(Error && Error.prototype);
AJAXError.prototype.constructor = AJAXError;
return AJAXError;
}(Error));
function makeRequest(requestParameters) {
var xhr = new window.XMLHttpRequest();
xhr.open('GET', requestParameters.url, true);
for (var k in requestParameters.headers) {
xhr.setRequestHeader(k, requestParameters.headers[k]);
}
xhr.withCredentials = requestParameters.credentials === 'include';
return xhr;
}
exports.getJSON = function (requestParameters, callback) {
var xhr = makeRequest(requestParameters);
xhr.setRequestHeader('Accept', 'application/json');
xhr.onerror = function () {
callback(new Error(xhr.statusText));
};
xhr.onload = function () {
if (xhr.status >= 200 && xhr.status < 300 && xhr.response) {
var data;
try {
data = JSON.parse(xhr.response);
} catch (err) {
return callback(err);
}
callback(null, data);
} else {
callback(new AJAXError(xhr.statusText, xhr.status));
}
};
xhr.send();
return xhr;
};
exports.getArrayBuffer = function (requestParameters, callback) {
var xhr = makeRequest(requestParameters);
xhr.responseType = 'arraybuffer';
xhr.onerror = function () {
callback(new Error(xhr.statusText));
};
xhr.onload = function () {
var response = xhr.response;
if (response.byteLength === 0 && xhr.status === 200) {
return callback(new Error('http status 200 returned without content.'));
}
if (xhr.status >= 200 && xhr.status < 300 && xhr.response) {
callback(null, {
data: response,
cacheControl: xhr.getResponseHeader('Cache-Control'),
expires: xhr.getResponseHeader('Expires')
});
} else {
callback(new AJAXError(xhr.statusText, xhr.status));
}
};
xhr.send();
return xhr;
};
function sameOrigin(url) {
var a = window.document.createElement('a');
a.href = url;
return a.protocol === window.document.location.protocol && a.host === window.document.location.host;
}
var transparentPngUrl = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVQYV2NgAAIAAAUAAarVyFEAAAAASUVORK5CYII=';
exports.getImage = function (requestParameters, callback) {
// request the image with XHR to work around caching issues
// see https://github.com/mapbox/mapbox-gl-js/issues/1470
return exports.getArrayBuffer(requestParameters, function (err, imgData) {
if (err) {
callback(err);
} else if (imgData) {
var img = new window.Image();
var URL = window.URL || window.webkitURL;
img.onload = function () {
callback(null, img);
URL.revokeObjectURL(img.src);
};
var blob = new window.Blob([new Uint8Array(imgData.data)], {type: 'image/png'});
(img ).cacheControl = imgData.cacheControl;
(img ).expires = imgData.expires;
img.src = imgData.data.byteLength ? URL.createObjectURL(blob) : transparentPngUrl;
}
});
};
exports.getVideo = function (urls, callback) {
var video = window.document.createElement('video');
video.onloadstart = function () {
callback(null, video);
};
for (var i = 0; i < urls.length; i++) {
var s = window.document.createElement('source');
if (!sameOrigin(urls[i])) {
video.crossOrigin = 'Anonymous';
}
s.src = urls[i];
video.appendChild(s);
}
return video;
};
}, {'./window': 9}],
9: [function (require, module, exports) {
'use strict';//
/* eslint-env browser */
module.exports = (self );
}, {}],
10: [function (require, module, exports) {
'use strict';//
var util = require('./util');
function _addEventListener(type, listener, listenerList) {
listenerList[type] = listenerList[type] || [];
listenerList[type].push(listener);
}
function _removeEventListener(type, listener, listenerList) {
if (listenerList && listenerList[type]) {
var index = listenerList[type].indexOf(listener);
if (index !== -1) {
listenerList[type].splice(index, 1);
}
}
}
/**
* Methods mixed in to other classes for event capabilities.
*
* @mixin Evented
*/
var Evented = function Evented() {
};
Evented.prototype.on = function on(type, listener) {
this._listeners = this._listeners || {};
_addEventListener(type, listener, this._listeners);
return this;
};
/**
* Removes a previously registered event listener.
*
* @param {string} type The event type to remove listeners for.
* @param {Function} listener The listener function to remove.
* @returns {Object} `this`
*/
Evented.prototype.off = function off(type, listener) {
_removeEventListener(type, listener, this._listeners);
_removeEventListener(type, listener, this._oneTimeListeners);
return this;
};
/**
* Adds a listener that will be called only once to a specified event type.
*
* The listener will be called first time the event fires after the listener is registered.
*
* @param {string} type The event type to listen for.
* @param {Function} listener The function to be called when the event is fired the first time.
* @returns {Object} `this`
*/
Evented.prototype.once = function once(type, listener) {
this._oneTimeListeners = this._oneTimeListeners || {};
_addEventListener(type, listener, this._oneTimeListeners);
return this;
};
/**
* Fires an event of the specified type.
*
* @param {string} type The type of event to fire.
* @param {Object} [data] Data to be passed to any listeners.
* @returns {Object} `this`
*/
Evented.prototype.fire = function fire(type, data) {
var this$1 = this;
if (this.listens(type)) {
data = util.extend({}, data, {type: type, target: this});
// make sure adding or removing listeners inside other listeners won't cause an infinite loop
var listeners = this._listeners && this._listeners[type] ? this._listeners[type].slice() : [];
for (var i = 0, list = listeners; i < list.length; i += 1) {
var listener = list[i];
listener.call(this$1, data);
}
var oneTimeListeners = this._oneTimeListeners && this._oneTimeListeners[type] ? this._oneTimeListeners[type].slice() : [];
for (var i$1 = 0, list$1 = oneTimeListeners; i$1 < list$1.length; i$1 += 1) {
var listener$1 = list$1[i$1];
_removeEventListener(type, listener$1, this$1._oneTimeListeners);
listener$1.call(this$1, data);
}
if (this._eventedParent) {
this._eventedParent.fire(type, util.extend({}, data, typeof this._eventedParentData === 'function' ? this._eventedParentData() : this._eventedParentData));
}
// To ensure that no error events are dropped, print them to the
// console if they have no listeners.
} else if (util.endsWith(type, 'error')) {
console.error((data && data.error) || data || 'Empty error event');
}
return this;
};
/**
* Returns a true if this instance of Evented or any forwardeed instances of Evented have a listener for the specified type.
*
* @param {string} type The event type
* @returns {boolean} `true` if there is at least one registered listener for specified event type, `false` otherwise
*/
Evented.prototype.listens = function listens(type) {
return (
(this._listeners && this._listeners[type] && this._listeners[type].length > 0) ||
(this._oneTimeListeners && this._oneTimeListeners[type] && this._oneTimeListeners[type].length > 0) ||
(this._eventedParent && this._eventedParent.listens(type))
);
};
/**
* Bubble all events fired by this instance of Evented to this parent instance of Evented.
*
* @private
* @returns {Object} `this`
*/
Evented.prototype.setEventedParent = function setEventedParent(parent, data) {
this._eventedParent = parent;
this._eventedParentData = data;
return this;
};
module.exports = Evented;
}, {'./util': 11}],
11: [function (require, module, exports) {
'use strict';//
var UnitBezier = require('@mapbox/unitbezier');
var Coordinate = require('../geo/coordinate');
var Point = require('@mapbox/point-geometry');
/**
* @module util
* @private
*/
/**
* Given a value `t` that varies between 0 and 1, return
* an interpolation function that eases between 0 and 1 in a pleasing
* cubic in-out fashion.
*
* @private
*/
exports.easeCubicInOut = function (t) {
if (t <= 0) {
return 0;
}
if (t >= 1) {
return 1;
}
var t2 = t * t,
t3 = t2 * t;
return 4 * (t < 0.5 ? t3 : 3 * (t - t2) + t3 - 0.75);
};
/**
* Given given (x, y), (x1, y1) control points for a bezier curve,
* return a function that interpolates along that curve.
*
* @param p1x control point 1 x coordinate
* @param p1y control point 1 y coordinate
* @param p2x control point 2 x coordinate
* @param p2y control point 2 y coordinate
* @private
*/
exports.bezier = function (p1x, p1y, p2x, p2y) {
var bezier = new UnitBezier(p1x, p1y, p2x, p2y);
return function (t) {
return bezier.solve(t);
};
};
/**
* A default bezier-curve powered easing function with
* control points (0.25, 0.1) and (0.25, 1)
*
* @private
*/
exports.ease = exports.bezier(0.25, 0.1, 0.25, 1);
/**
* constrain n to the given range via min + max
*
* @param n value
* @param min the minimum value to be returned
* @param max the maximum value to be returned
* @returns the clamped value
* @private
*/
exports.clamp = function (n, min, max) {
return Math.min(max, Math.max(min, n));
};
/**
* constrain n to the given range, excluding the minimum, via modular arithmetic
*
* @param n value
* @param min the minimum value to be returned, exclusive
* @param max the maximum value to be returned, inclusive
* @returns constrained number
* @private
*/
exports.wrap = function (n, min, max) {
var d = max - min;
var w = ((n - min) % d + d) % d + min;
return (w === min) ? max : w;
};
/*
* Call an asynchronous function on an array of arguments,
* calling `callback` with the completed results of all calls.
*
* @param array input to each call of the async function.
* @param fn an async function with signature (data, callback)
* @param callback a callback run after all async work is done.
* called with an array, containing the results of each async call.
* @private
*/
exports.asyncAll = function (array,
fn,
callback) {
if (!array.length) {
return callback(null, []);
}
var remaining = array.length;
var results = new Array(array.length);
var error = null;
array.forEach(function (item, i) {
fn(item, function (err, result) {
if (err) {
error = err;
}
results[i] = ((result ) ); // https://github.com/facebook/flow/issues/2123
if (--remaining === 0) {
callback(error, results);
}
});
});
};
/*
* Polyfill for Object.values. Not fully spec compliant, but we don't
* need it to be.
*
* @private
*/
exports.values = function (obj) {
var result = [];
for (var k in obj) {
result.push(obj[k]);
}
return result;
};
/*
* Compute the difference between the keys in one object and the keys
* in another object.
*
* @returns keys difference
* @private
*/
exports.keysDifference = function (obj, other) {
var difference = [];
for (var i in obj) {
if (!(i in other)) {
difference.push(i);
}
}
return difference;
};
/**
* Given a destination object and optionally many source objects,
* copy all properties from the source objects into the destination.
* The last source object given overrides properties from previous
* source objects.
*
* @param dest destination object
* @param sources sources from which properties are pulled
* @private
*/
exports.extend = function (dest) {
var sources = [], len = arguments.length - 1;
while (len-- > 0) sources[len] = arguments[len + 1];
for (var i = 0, list = sources; i < list.length; i += 1) {
var src = list[i];
for (var k in src) {
dest[k] = src[k];
}
}
return dest;
};
/**
* Given an object and a number of properties as strings, return version
* of that object with only those properties.
*
* @param src the object
* @param properties an array of property names chosen
* to appear on the resulting object.
* @returns object with limited properties.
* @example
* var foo = { name: 'Charlie', age: 10 };
* var justName = pick(foo, ['name']);
* // justName = { name: 'Charlie' }
* @private
*/
exports.pick = function (src, properties) {
var result = {};
for (var i = 0; i < properties.length; i++) {
var k = properties[i];
if (k in src) {
result[k] = src[k];
}
}
return result;
};
var id = 1;
/**
* Return a unique numeric id, starting at 1 and incrementing with
* each call.
*
* @returns unique numeric id.
* @private
*/
exports.uniqueId = function () {
return id++;
};
/**
* Given an array of member function names as strings, replace all of them
* with bound versions that will always refer to `context` as `this`. This
* is useful for classes where otherwise event bindings would reassign
* `this` to the evented object or some other value: this lets you ensure
* the `this` value always.
*
* @param fns list of member function names
* @param context the context value
* @example
* function MyClass() {
* bindAll(['ontimer'], this);
* this.name = 'Tom';
* }
* MyClass.prototype.ontimer = function() {
* alert(this.name);
* };
* var myClass = new MyClass();
* setTimeout(myClass.ontimer, 100);
* @private
*/
exports.bindAll = function (fns, context) {
fns.forEach(function (fn) {
if (!context[fn]) {
return;
}
context[fn] = context[fn].bind(context);
});
};
/**
* Given a list of coordinates, get their center as a coordinate.
*
* @returns centerpoint
* @private
*/
exports.getCoordinatesCenter = function (coords) {
var minX = Infinity;
var minY = Infinity;
var maxX = -Infinity;
var maxY = -Infinity;
for (var i = 0; i < coords.length; i++) {
minX = Math.min(minX, coords[i].column);
minY = Math.min(minY, coords[i].row);
maxX = Math.max(maxX, coords[i].column);
maxY = Math.max(maxY, coords[i].row);
}
var dx = maxX - minX;
var dy = maxY - minY;
var dMax = Math.max(dx, dy);
var zoom = Math.max(0, Math.floor(-Math.log(dMax) / Math.LN2));
return new Coordinate((minX + maxX) / 2, (minY + maxY) / 2, 0)
.zoomTo(zoom);
};
/**
* Determine if a string ends with a particular substring
*
* @private
*/
exports.endsWith = function (string, suffix) {
return string.indexOf(suffix, string.length - suffix.length) !== -1;
};
/**
* Create an object by mapping all the values of an existing object while
* preserving their keys.
*
* @private
*/
exports.mapObject = function (input, iterator, context) {
var this$1 = this;
var output = {};
for (var key in input) {
output[key] = iterator.call(context || this$1, input[key], key, input);
}
return output;
};
/**
* Create an object by filtering out values of an existing object.
*
* @private
*/
exports.filterObject = function (input, iterator, context) {
var this$1 = this;
var output = {};
for (var key in input) {
if (iterator.call(context || this$1, input[key], key, input)) {
output[key] = input[key];
}
}
return output;
};
/**
* Deeply compares two object literals.
*
* @private
*/
exports.deepEqual = function (a, b) {
if (Array.isArray(a)) {
if (!Array.isArray(b) || a.length !== b.length) {
return false;
}
for (var i = 0; i < a.length; i++) {
if (!exports.deepEqual(a[i], b[i])) {
return false;
}
}
return true;
}
if (typeof a === 'object' && a !== null && b !== null) {
if (!(typeof b === 'object')) {
return false;
}
var keys = Object.keys(a);
if (keys.length !== Object.keys(b).length) {
return false;
}
for (var key in a) {
if (!exports.deepEqual(a[key], b[key])) {
return false;
}
}
return true;
}
return a === b;
};
/**
* Deeply clones two objects.
*
* @private
*/
exports.clone = function (input) {
if (Array.isArray(input)) {
return input.map(exports.clone);
} else if (typeof input === 'object' && input) {
return ((exports.mapObject(input, exports.clone) ) );
} else {
return input;
}
};
/**
* Check if two arrays have at least one common element.
*
* @private
*/
exports.arraysIntersect = function (a, b) {
for (var l = 0; l < a.length; l++) {
if (b.indexOf(a[l]) >= 0) {
return true;
}
}
return false;
};
/**
* Print a warning message to the console and ensure duplicate warning messages
* are not printed.
*
* @private
*/
var warnOnceHistory = {};
exports.warnOnce = function (message) {
if (!warnOnceHistory[message]) {
// console isn't defined in some WebWorkers, see #2558
if (typeof console !== 'undefined') {
console.warn(message);
}
warnOnceHistory[message] = true;
}
};
/**
* Indicates if the provided Points are in a counter clockwise (true) or clockwise (false) order
*
* @returns true for a counter clockwise set of points
*/
// http://bryceboe.com/2006/10/23/line-segment-intersection-algorithm/
exports.isCounterClockwise = function (a, b, c) {
return (c.y - a.y) * (b.x - a.x) > (b.y - a.y) * (c.x - a.x);
};
/**
* Returns the signed area for the polygon ring. Postive areas are exterior rings and
* have a clockwise winding. Negative areas are interior rings and have a counter clockwise
* ordering.
*
* @param ring Exterior or interior ring
*/
exports.calculateSignedArea = function (ring) {
var sum = 0;
for (var i = 0, len = ring.length, j = len - 1, p1 = (void 0), p2 = (void 0); i < len; j = i++) {
p1 = ring[i];
p2 = ring[j];
sum += (p2.x - p1.x) * (p1.y + p2.y);
}
return sum;
};
/**
* Detects closed polygons, first + last point are equal
*
* @param points array of points
* @return true if the points are a closed polygon
*/
exports.isClosedPolygon = function (points) {
// If it is 2 points that are the same then it is a point
// If it is 3 points with start and end the same then it is a line
if (points.length < 4) {
return false;
}
var p1 = points[0];
var p2 = points[points.length - 1];
if (Math.abs(p1.x - p2.x) > 0 ||
Math.abs(p1.y - p2.y) > 0) {
return false;
}
// polygon simplification can produce polygons with zero area and more than 3 points
return (Math.abs(exports.calculateSignedArea(points)) > 0.01);
};
/**
* Converts spherical coordinates to cartesian coordinates.
*
* @param spherical Spherical coordinates, in [radial, azimuthal, polar]
* @return cartesian coordinates in [x, y, z]
*/
exports.sphericalToCartesian = function (ref) {
var r = ref[0];
var azimuthal = ref[1];
var polar = ref[2];
// We abstract "north"/"up" (compass-wise) to be 0° when really this is 90° (π/2):
// correct for that here
azimuthal += 90;
// Convert azimuthal and polar angles to radians
azimuthal *= Math.PI / 180;
polar *= Math.PI / 180;
return {
x: r * Math.cos(azimuthal) * Math.sin(polar),
y: r * Math.sin(azimuthal) * Math.sin(polar),
z: r * Math.cos(polar)
};
};
/**
* Parses data from 'Cache-Control' headers.
*
* @param cacheControl Value of 'Cache-Control' header
* @return object containing parsed header info.
*/
exports.parseCacheControl = function (cacheControl) {
// Taken from [Wreck](https://github.com/hapijs/wreck)
var re = /(?:^|(?:\s*\,\s*))([^\x00-\x20\(\)<>@\,;\:\\"\/\[\]\?\=\{\}\x7F]+)(?:\=(?:([^\x00-\x20\(\)<>@\,;\:\\"\/\[\]\?\=\{\}\x7F]+)|(?:\"((?:[^"\\]|\\.)*)\")))?/g;
var header = {};
cacheControl.replace(re, function ($0, $1, $2, $3) {
var value = $2 || $3;
header[$1] = value ? value.toLowerCase() : true;
return '';
});
if (header['max-age']) {
var maxAge = parseInt(header['max-age'], 10);
if (isNaN(maxAge)) {
delete header['max-age'];
}
else {
header['max-age'] = maxAge;
}
}
return header;
};
}, {'../geo/coordinate': 3, '@mapbox/point-geometry': 1, '@mapbox/unitbezier': 2}],
12: [function (require, module, exports) {
//
var util = require('mapbox-gl/src/util/util');
var ajax = require('mapbox-gl/src/util/ajax');
var Evented = require('mapbox-gl/src/util/evented');
var loadArcGISMapServer = require('./load_arcgis_mapserver');
var TileBounds = require('mapbox-gl/src/source/tile_bounds');
var Texture = require('mapbox-gl/src/render/texture');
var helpers = require('./helpers');
var ArcGISTiledMapServiceSource = (function (Evented) {
function ArcGISTiledMapServiceSource(id, options, dispatcher, eventedParent) {
Evented.call(this);
this.id = id;
this.dispatcher = dispatcher;
this.setEventedParent(eventedParent);
this.type = 'arcgisraster';
this.minzoom = 0;
this.maxzoom = 22;
this.roundZoom = true;
this.tileSize = 512;
this._loaded = false;
this._options = util.extend({}, options);
util.extend(this, util.pick(options, ['url', 'scheme', 'tileSize']));
}
if (Evented) ArcGISTiledMapServiceSource.__proto__ = Evented;
ArcGISTiledMapServiceSource.prototype = Object.create(Evented && Evented.prototype);
ArcGISTiledMapServiceSource.prototype.constructor = ArcGISTiledMapServiceSource;
ArcGISTiledMapServiceSource.prototype.load = function load() {
this.fire('dataloading', {dataType: 'source'});
this.fire('data', {dataType: 'source', sourceDataType: 'metadata'});
this.fire('data', {dataType: 'source', sourceDataType: 'content'});
// loadArcGISMapServer(this._options, (err, metadata) => {
// if (err) {
// this.fire('error', err);
// } else if (metadata) {
// util.extend(this, metadata);
//
// if (metadata.bounds) {
// this.tileBounds = new TileBounds(metadata.bounds, this.minzoom, this.maxzoom);
// }
//
// // `content` is included here to prevent a race condition where `Style#_updateSources` is called
// // before the TileJSON arrives. this makes sure the tiles needed are loaded once TileJSON arrives
// // ref: https://github.com/mapbox/mapbox-gl-js/pull/4347#discussion_r104418088
// this.fire('data', {dataType: 'source', sourceDataType: 'metadata'});
// this.fire('data', {dataType: 'source', sourceDataType: 'content'});
// }
// });
};
ArcGISTiledMapServiceSource.prototype.template = function template(str, data) {
return str.replace(/\{ *([\w_]+) *\}/g, function (str, key) {
let value = data[key];
if (!value) {
if (key === 'L') {
value = ('00' + data.z.toString(16)).slice(-2);
} else if (key === 'R') {
value = ('00000000' + data.y.toString(16)).slice(-8);
} else if (key === 'C') {
value = ('00000000' + data.x.toString(16)).slice(-8);
}
if (value === undefined) {
throw new Error('No value provided for variable ' + str);
}
} else if (typeof value === 'function') {
value = value(data);
}
return value;
});
};
ArcGISTiledMapServiceSource.prototype.onAdd = function onAdd(map) {
// // set the urls
// const baseUrl = this.url.split('?')[0];
// this.tileUrl = `${baseUrl}/tile/{z}/{y}/{x}`;
//
// const arcgisonline = new RegExp(/tiles.arcgis(online)?\.com/g);
// if (arcgisonline.test(this.url)) {
// this.tileUrl = this.tileUrl.replace('://tiles', '://tiles{s}');
// this.subdomains = ['1', '2', '3', '4'];
// }
//
// if (this.token) {
// this.tileUrl += (`?token=${this.token}`);
// }
this.map = map;
this.load();
};
ArcGISTiledMapServiceSource.prototype.serialize = function serialize() {
return util.extend({}, this._options);
};
ArcGISTiledMapServiceSource.prototype.hasTile = function hasTile(tileID) {
return !this.tileBounds || this.tileBounds.contains(tileID.canonical);
};
ArcGISTiledMapServiceSource.prototype.loadTile = function loadTile(tile, callback) {
var this$1 = this;
//convert to ags coords
var tilePoint = {
z: tile.tileID.overscaledZ,
x: tile.tileID.canonical.x,
y: tile.tileID.canonical.y
};
var url = this.template(this.url, {x: tilePoint.x, y: tilePoint.y, z: tilePoint.z});
tile.request = ajax.getImage({url: url}, function (err, img) {
delete tile.request;
if (tile.aborted) {
tile.state = 'unloaded';
callback(null);
} else if (err) {
tile.state = 'errored';
callback(err);
} else if (img) {
if (this$1.map._refreshExpiredTiles) {
tile.setExpiryData(img);
}
delete (img
).cacheControl;
delete (img
).expires;
var context = this$1.map.painter.context;
var gl = context.gl;
tile.texture = this$1.map.painter.getTileTexture(img.width);
if (tile.texture) {
tile.texture.bind(gl.LINEAR, gl.CLAMP_TO_EDGE, gl.LINEAR_MIPMAP_NEAREST);
gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, gl.RGBA, gl.UNSIGNED_BYTE, img);
} else {
tile.texture = new Texture(context, img, gl.RGBA);
tile.texture.bind(gl.LINEAR, gl.CLAMP_TO_EDGE, gl.LINEAR_MIPMAP_NEAREST);
if (context.extTextureFilterAnisotropic) {
gl.texParameterf(gl.TEXTURE_2D, context.extTextureFilterAnisotropic.TEXTURE_MAX_ANISOTROPY_EXT, context.extTextureFilterAnisotropicMax);
}
}
gl.generateMipmap(gl.TEXTURE_2D);
tile.state = 'loaded';
callback(null);
}
});
};
ArcGISTiledMapServiceSource.prototype.abortTile = function abortTile(tile, callback) {
if (tile.request) {
tile.request.abort();
delete tile.request;
}
callback();
};
ArcGISTiledMapServiceSource.prototype.unloadTile = function unloadTile(tile, callback) {
if (tile.texture) {
this.map.painter.saveTileTexture(tile.texture);
}
callback();
};
ArcGISTiledMapServiceSource.prototype.hasTransition = function hasTransition() {
return false;
};
return ArcGISTiledMapServiceSource;
}(Evented));
module.exports = ArcGISTiledMapServiceSource;
}, {
'./helpers': 13,
'./load_arcgis_mapserver': 15,
'mapbox-gl/src/render/texture': 6,
'mapbox-gl/src/source/tile_bounds': 7,
'mapbox-gl/src/util/ajax': 8,
'mapbox-gl/src/util/evented': 10,
'mapbox-gl/src/util/util': 11
}],
13: [function (require, module, exports) {
//From https://github.com/Leaflet/Leaflet/blob/master/src/core/Util.js
var _templateRe = /\{ *([\w_]+) *\}/g;
var _template = function (str, data) {
return str.replace(_templateRe, function (str, key) {
var value = data[key];
if (value === undefined) {
throw new Error(('No value provided for variable ' + str));
} else if (typeof value === 'function') {
value = value(data);
}
return value;
});
};
//From https://github.com/Leaflet/Leaflet/blob/master/src/layer/tile/TileLayer.js
var _getSubdomain = function (tilePoint, subdomains) {
if (subdomains) {
var index = Math.abs(tilePoint.x + tilePoint.y) % subdomains.length;
return subdomains[index];
}
return null;
};
module.exports = {
_template: _template,
_getSubdomain: _getSubdomain
};
}, {}],
14: [function (require, module, exports) {
var ArcGISTiledMapServiceSource = require('./arcgis_tiled_map_service_source');
module.exports = ArcGISTiledMapServiceSource;
}, {'./arcgis_tiled_map_service_source': 12}],
15: [function (require, module, exports) {
'use strict';
module.exports = function (options, callback) {
callback(null, {});
};
}, {}]
}, {}, [14])(14);
});
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","node_modules/@mapbox/point-geometry/index.js","node_modules/@mapbox/unitbezier/index.js","E:/mapbox-gl-arcgis-tiled-map-service-master/node_modules/mapbox-gl/src/geo/coordinate.js","E:/mapbox-gl-arcgis-tiled-map-service-master/node_modules/mapbox-gl/src/geo/lng_lat.js","E:/mapbox-gl-arcgis-tiled-map-service-master/node_modules/mapbox-gl/src/geo/lng_lat_bounds.js","E:/mapbox-gl-arcgis-tiled-map-service-master/node_modules/mapbox-gl/src/render/texture.js","E:/mapbox-gl-arcgis-tiled-map-service-master/node_modules/mapbox-gl/src/source/tile_bounds.js","E:/mapbox-gl-arcgis-tiled-map-service-master/node_modules/mapbox-gl/src/util/ajax.js","E:/mapbox-gl-arcgis-tiled-map-service-master/node_modules/mapbox-gl/src/util/browser/window.js","E:/mapbox-gl-arcgis-tiled-map-service-master/node_modules/mapbox-gl/src/util/evented.js","E:/mapbox-gl-arcgis-tiled-map-service-master/node_modules/mapbox-gl/src/util/util.js","E:/mapbox-gl-arcgis-tiled-map-service-master/src/arcgis_tiled_map_service_source.js","E:/mapbox-gl-arcgis-tiled-map-service-master/src/helpers.js","E:/mapbox-gl-arcgis-tiled-map-service-master/src/index.js","E:/mapbox-gl-arcgis-tiled-map-service-master/src/load_arcgis_mapserver.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACAA;;;;;;;ACAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACAA;;;;ACAA","file":"generated.js","sourceRoot":"","sourcesContent":["(function(){function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s}return e})()","'use strict';\n\nmodule.exports = Point;\n\n/**\n * A standalone point geometry with useful accessor, comparison, and\n * modification methods.\n *\n * @class Point\n * @param {Number} x the x-coordinate. this could be longitude or screen\n * pixels, or any other sort of unit.\n * @param {Number} y the y-coordinate. this could be latitude or screen\n * pixels, or any other sort of unit.\n * @example\n * var point = new Point(-77, 38);\n */\nfunction Point(x, y) {\n    this.x = x;\n    this.y = y;\n}\n\nPoint.prototype = {\n\n    /**\n     * Clone this point, returning a new point that can be modified\n     * without affecting the old one.\n     * @return {Point} the clone\n     */\n    clone: function() { return new Point(this.x, this.y); },\n\n    /**\n     * Add this point's x & y coordinates to another point,\n     * yielding a new point.\n     * @param {Point} p the other point\n     * @return {Point} output point\n     */\n    add:     function(p) { return this.clone()._add(p); },\n\n    /**\n     * Subtract this point's x & y coordinates to from point,\n     * yielding a new point.\n     * @param {Point} p the other point\n     * @return {Point} output point\n     */\n    sub:     function(p) { return this.clone()._sub(p); },\n\n    /**\n     * Multiply this point's x & y coordinates by point,\n     * yielding a new point.\n     * @param {Point} p the other point\n     * @return {Point} output point\n     */\n    multByPoint:    function(p) { return this.clone()._multByPoint(p); },\n\n    /**\n     * Divide this point's x & y coordinates by point,\n     * yielding a new point.\n     * @param {Point} p the other point\n     * @return {Point} output point\n     */\n    divByPoint:     function(p) { return this.clone()._divByPoint(p); },\n\n    /**\n     * Multiply this point's x & y coordinates by a factor,\n     * yielding a new point.\n     * @param {Point} k factor\n     * @return {Point} output point\n     */\n    mult:    function(k) { return this.clone()._mult(k); },\n\n    /**\n     * Divide this point's x & y coordinates by a factor,\n     * yielding a new point.\n     * @param {Point} k factor\n     * @return {Point} output point\n     */\n    div:     function(k) { return this.clone()._div(k); },\n\n    /**\n     * Rotate this point around the 0, 0 origin by an angle a,\n     * given in radians\n     * @param {Number} a angle to rotate around, in radians\n     * @return {Point} output point\n     */\n    rotate:  function(a) { return this.clone()._rotate(a); },\n\n    /**\n     * Rotate this point around p point by an angle a,\n     * given in radians\n     * @param {Number} a angle to rotate around, in radians\n     * @param {Point} p Point to rotate around\n     * @return {Point} output point\n     */\n    rotateAround:  function(a,p) { return this.clone()._rotateAround(a,p); },\n\n    /**\n     * Multiply this point by a 4x1 transformation matrix\n     * @param {Array<Number>} m transformation matrix\n     * @return {Point} output point\n     */\n    matMult: function(m) { return this.clone()._matMult(m); },\n\n    /**\n     * Calculate this point but as a unit vector from 0, 0, meaning\n     * that the distance from the resulting point to the 0, 0\n     * coordinate will be equal to 1 and the angle from the resulting\n     * point to the 0, 0 coordinate will be the same as before.\n     * @return {Point} unit vector point\n     */\n    unit:    function() { return this.clone()._unit(); },\n\n    /**\n     * Compute a perpendicular point, where the new y coordinate\n     * is the old x coordinate and the new x coordinate is the old y\n     * coordinate multiplied by -1\n     * @return {Point} perpendicular point\n     */\n    perp:    function() { return this.clone()._perp(); },\n\n    /**\n     * Return a version of this point with the x & y coordinates\n     * rounded to integers.\n     * @return {Point} rounded point\n     */\n    round:   function() { return this.clone()._round(); },\n\n    /**\n     * Return the magitude of this point: this is the Euclidean\n     * distance from the 0, 0 coordinate to this point's x and y\n     * coordinates.\n     * @return {Number} magnitude\n     */\n    mag: function() {\n        return Math.sqrt(this.x * this.x + this.y * this.y);\n    },\n\n    /**\n     * Judge whether this point is equal to another point, returning\n     * true or false.\n     * @param {Point} other the other point\n     * @return {boolean} whether the points are equal\n     */\n    equals: function(other) {\n        return this.x === other.x &&\n               this.y === other.y;\n    },\n\n    /**\n     * Calculate the distance from this point to another point\n     * @param {Point} p the other point\n     * @return {Number} distance\n     */\n    dist: function(p) {\n        return Math.sqrt(this.distSqr(p));\n    },\n\n    /**\n     * Calculate the distance from this point to another point,\n     * without the square root step. Useful if you're comparing\n     * relative distances.\n     * @param {Point} p the other point\n     * @return {Number} distance\n     */\n    distSqr: function(p) {\n        var dx = p.x - this.x,\n            dy = p.y - this.y;\n        return dx * dx + dy * dy;\n    },\n\n    /**\n     * Get the angle from the 0, 0 coordinate to this point, in radians\n     * coordinates.\n     * @return {Number} angle\n     */\n    angle: function() {\n        return Math.atan2(this.y, this.x);\n    },\n\n    /**\n     * Get the angle from this point to another point, in radians\n     * @param {Point} b the other point\n     * @return {Number} angle\n     */\n    angleTo: function(b) {\n        return Math.atan2(this.y - b.y, this.x - b.x);\n    },\n\n    /**\n     * Get the angle between this point and another point, in radians\n     * @param {Point} b the other point\n     * @return {Number} angle\n     */\n    angleWith: function(b) {\n        return this.angleWithSep(b.x, b.y);\n    },\n\n    /*\n     * Find the angle of the two vectors, solving the formula for\n     * the cross product a x b = |a||b|sin(θ) for θ.\n     * @param {Number} x the x-coordinate\n     * @param {Number} y the y-coordinate\n     * @return {Number} the angle in radians\n     */\n    angleWithSep: function(x, y) {\n        return Math.atan2(\n            this.x * y - this.y * x,\n            this.x * x + this.y * y);\n    },\n\n    _matMult: function(m) {\n        var x = m[0] * this.x + m[1] * this.y,\n            y = m[2] * this.x + m[3] * this.y;\n        this.x = x;\n        this.y = y;\n        return this;\n    },\n\n    _add: function(p) {\n        this.x += p.x;\n        this.y += p.y;\n        return this;\n    },\n\n    _sub: function(p) {\n        this.x -= p.x;\n        this.y -= p.y;\n        return this;\n    },\n\n    _mult: function(k) {\n        this.x *= k;\n        this.y *= k;\n        return this;\n    },\n\n    _div: function(k) {\n        this.x /= k;\n        this.y /= k;\n        return this;\n    },\n\n    _multByPoint: function(p) {\n        this.x *= p.x;\n        this.y *= p.y;\n        return this;\n    },\n\n    _divByPoint: function(p) {\n        this.x /= p.x;\n        this.y /= p.y;\n        return this;\n    },\n\n    _unit: function() {\n        this._div(this.mag());\n        return this;\n    },\n\n    _perp: function() {\n        var y = this.y;\n        this.y = this.x;\n        this.x = -y;\n        return this;\n    },\n\n    _rotate: function(angle) {\n        var cos = Math.cos(angle),\n            sin = Math.sin(angle),\n            x = cos * this.x - sin * this.y,\n            y = sin * this.x + cos * this.y;\n        this.x = x;\n        this.y = y;\n        return this;\n    },\n\n    _rotateAround: function(angle, p) {\n        var cos = Math.cos(angle),\n            sin = Math.sin(angle),\n            x = p.x + cos * (this.x - p.x) - sin * (this.y - p.y),\n            y = p.y + sin * (this.x - p.x) + cos * (this.y - p.y);\n        this.x = x;\n        this.y = y;\n        return this;\n    },\n\n    _round: function() {\n        this.x = Math.round(this.x);\n        this.y = Math.round(this.y);\n        return this;\n    }\n};\n\n/**\n * Construct a point from an array if necessary, otherwise if the input\n * is already a Point, or an unknown type, return it unchanged\n * @param {Array<Number>|Point|*} a any kind of input value\n * @return {Point} constructed point, or passed-through value.\n * @example\n * // this\n * var point = Point.convert([0, 1]);\n * // is equivalent to\n * var point = new Point(0, 1);\n */\nPoint.convert = function (a) {\n    if (a instanceof Point) {\n        return a;\n    }\n    if (Array.isArray(a)) {\n        return new Point(a[0], a[1]);\n    }\n    return a;\n};\n","/*\n * Copyright (C) 2008 Apple Inc. All Rights Reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions\n * are met:\n * 1. Redistributions of source code must retain the above copyright\n *    notice, this list of conditions and the following disclaimer.\n * 2. Redistributions in binary form must reproduce the above copyright\n *    notice, this list of conditions and the following disclaimer in the\n *    documentation and/or other materials provided with the distribution.\n *\n * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY\n * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\n * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR\n * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,\n * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\n * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\n * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY\n * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n *\n * Ported from Webkit\n * http://svn.webkit.org/repository/webkit/trunk/Source/WebCore/platform/graphics/UnitBezier.h\n */\n\nmodule.exports = UnitBezier;\n\nfunction UnitBezier(p1x, p1y, p2x, p2y) {\n    // Calculate the polynomial coefficients, implicit first and last control points are (0,0) and (1,1).\n    this.cx = 3.0 * p1x;\n    this.bx = 3.0 * (p2x - p1x) - this.cx;\n    this.ax = 1.0 - this.cx - this.bx;\n\n    this.cy = 3.0 * p1y;\n    this.by = 3.0 * (p2y - p1y) - this.cy;\n    this.ay = 1.0 - this.cy - this.by;\n\n    this.p1x = p1x;\n    this.p1y = p2y;\n    this.p2x = p2x;\n    this.p2y = p2y;\n}\n\nUnitBezier.prototype.sampleCurveX = function(t) {\n    // `ax t^3 + bx t^2 + cx t' expanded using Horner's rule.\n    return ((this.ax * t + this.bx) * t + this.cx) * t;\n};\n\nUnitBezier.prototype.sampleCurveY = function(t) {\n    return ((this.ay * t + this.by) * t + this.cy) * t;\n};\n\nUnitBezier.prototype.sampleCurveDerivativeX = function(t) {\n    return (3.0 * this.ax * t + 2.0 * this.bx) * t + this.cx;\n};\n\nUnitBezier.prototype.solveCurveX = function(x, epsilon) {\n    if (typeof epsilon === 'undefined') epsilon = 1e-6;\n\n    var t0, t1, t2, x2, i;\n\n    // First try a few iterations of Newton's method -- normally very fast.\n    for (t2 = x, i = 0; i < 8; i++) {\n\n        x2 = this.sampleCurveX(t2) - x;\n        if (Math.abs(x2) < epsilon) return t2;\n\n        var d2 = this.sampleCurveDerivativeX(t2);\n        if (Math.abs(d2) < 1e-6) break;\n\n        t2 = t2 - x2 / d2;\n    }\n\n    // Fall back to the bisection method for reliability.\n    t0 = 0.0;\n    t1 = 1.0;\n    t2 = x;\n\n    if (t2 < t0) return t0;\n    if (t2 > t1) return t1;\n\n    while (t0 < t1) {\n\n        x2 = this.sampleCurveX(t2);\n        if (Math.abs(x2 - x) < epsilon) return t2;\n\n        if (x > x2) {\n            t0 = t2;\n        } else {\n            t1 = t2;\n        }\n\n        t2 = (t1 - t0) * 0.5 + t0;\n    }\n\n    // Failure.\n    return t2;\n};\n\nUnitBezier.prototype.solve = function(x, epsilon) {\n    return this.sampleCurveY(this.solveCurveX(x, epsilon));\n};\n","//      \n\n/**\n * A coordinate is a column, row, zoom combination, often used\n * as the data component of a tile.\n *\n * @param {number} column\n * @param {number} row\n * @param {number} zoom\n * @private\n */\nclass Coordinate {\n                   \n                \n                 \n    constructor(column        , row        , zoom        ) {\n        this.column = column;\n        this.row = row;\n        this.zoom = zoom;\n    }\n\n    /**\n     * Create a clone of this coordinate that can be mutated without\n     * changing the original coordinate\n     *\n     * @returns {Coordinate} clone\n     * @private\n     * var coord = new Coordinate(0, 0, 0);\n     * var c2 = coord.clone();\n     * // since coord is cloned, modifying a property of c2 does\n     * // not modify it.\n     * c2.zoom = 2;\n     */\n    clone() {\n        return new Coordinate(this.column, this.row, this.zoom);\n    }\n\n    /**\n     * Zoom this coordinate to a given zoom level. This returns a new\n     * coordinate object, not mutating the old one.\n     *\n     * @param {number} zoom\n     * @returns {Coordinate} zoomed coordinate\n     * @private\n     * @example\n     * var coord = new Coordinate(0, 0, 0);\n     * var c2 = coord.zoomTo(1);\n     * c2 // equals new Coordinate(0, 0, 1);\n     */\n    zoomTo(zoom        ) { return this.clone()._zoomTo(zoom); }\n\n    /**\n     * Subtract the column and row values of this coordinate from those\n     * of another coordinate. The other coordinat will be zoomed to the\n     * same level as `this` before the subtraction occurs\n     *\n     * @param {Coordinate} c other coordinate\n     * @returns {Coordinate} result\n     * @private\n     */\n    sub(c            ) { return this.clone()._sub(c); }\n\n    _zoomTo(zoom        ) {\n        const scale = Math.pow(2, zoom - this.zoom);\n        this.column *= scale;\n        this.row *= scale;\n        this.zoom = zoom;\n        return this;\n    }\n\n    _sub(c            ) {\n        c = c.zoomTo(this.zoom);\n        this.column -= c.column;\n        this.row -= c.row;\n        return this;\n    }\n}\n\nmodule.exports = Coordinate;\n","//      \n\nconst wrap = require('../util/util').wrap;\n\n/**\n * A `LngLat` object represents a given longitude and latitude coordinate, measured in degrees.\n *\n * Mapbox GL uses longitude, latitude coordinate order (as opposed to latitude, longitude) to match GeoJSON.\n *\n * Note that any Mapbox GL method that accepts a `LngLat` object as an argument or option\n * can also accept an `Array` of two numbers and will perform an implicit conversion.\n * This flexible type is documented as {@link LngLatLike}.\n *\n * @param {number} lng Longitude, measured in degrees.\n * @param {number} lat Latitude, measured in degrees.\n * @example\n * var ll = new mapboxgl.LngLat(-73.9749, 40.7736);\n * @see [Get coordinates of the mouse pointer](https://www.mapbox.com/mapbox-gl-js/example/mouse-position/)\n * @see [Display a popup](https://www.mapbox.com/mapbox-gl-js/example/popup/)\n * @see [Highlight features within a bounding box](https://www.mapbox.com/mapbox-gl-js/example/using-box-queryrenderedfeatures/)\n * @see [Create a timeline animation](https://www.mapbox.com/mapbox-gl-js/example/timeline-animation/)\n */\nclass LngLat {\n                \n                \n\n    constructor(lng        , lat        ) {\n        if (isNaN(lng) || isNaN(lat)) {\n            throw new Error(`Invalid LngLat object: (${lng}, ${lat})`);\n        }\n        this.lng = +lng;\n        this.lat = +lat;\n        if (this.lat > 90 || this.lat < -90) {\n            throw new Error('Invalid LngLat latitude value: must be between -90 and 90');\n        }\n    }\n\n    /**\n     * Returns a new `LngLat` object whose longitude is wrapped to the range (-180, 180).\n     *\n     * @returns {LngLat} The wrapped `LngLat` object.\n     * @example\n     * var ll = new mapboxgl.LngLat(286.0251, 40.7736);\n     * var wrapped = ll.wrap();\n     * wrapped.lng; // = -73.9749\n     */\n    wrap() {\n        return new LngLat(wrap(this.lng, -180, 180), this.lat);\n    }\n\n    /**\n     * Returns the coordinates represented as an array of two numbers.\n     *\n     * @returns {Array<number>} The coordinates represeted as an array of longitude and latitude.\n     * @example\n     * var ll = new mapboxgl.LngLat(-73.9749, 40.7736);\n     * ll.toArray(); // = [-73.9749, 40.7736]\n     */\n    toArray() {\n        return [this.lng, this.lat];\n    }\n\n    /**\n     * Returns the coordinates represent as a string.\n     *\n     * @returns {string} The coordinates represented as a string of the format `'LngLat(lng, lat)'`.\n     * @example\n     * var ll = new mapboxgl.LngLat(-73.9749, 40.7736);\n     * ll.toString(); // = \"LngLat(-73.9749, 40.7736)\"\n     */\n    toString() {\n        return `LngLat(${this.lng}, ${this.lat})`;\n    }\n\n    /**\n     * Returns a `LngLatBounds` from the coordinates extended by a given `radius`.\n     *\n     * @param {number} radius Distance in meters from the coordinates to extend the bounds.\n     * @returns {LngLatBounds} A new `LngLatBounds` object representing the coordinates extended by the `radius`.\n     * @example\n     * var ll = new mapboxgl.LngLat(-73.9749, 40.7736);\n     * ll.toBounds(100).toArray(); // = [[-73.97501862141328, 40.77351016847229], [-73.97478137858673, 40.77368983152771]]\n     */\n    toBounds(radius        ) {\n        const earthCircumferenceInMetersAtEquator = 40075017;\n        const latAccuracy = 360 * radius / earthCircumferenceInMetersAtEquator,\n            lngAccuracy = latAccuracy / Math.cos((Math.PI / 180) * this.lat);\n\n        const LngLatBounds = require('./lng_lat_bounds');\n        return new LngLatBounds(new LngLat(this.lng - lngAccuracy, this.lat - latAccuracy),\n            new LngLat(this.lng + lngAccuracy, this.lat + latAccuracy));\n    }\n\n    /**\n     * Converts an array of two numbers to a `LngLat` object.\n     *\n     * If a `LngLat` object is passed in, the function returns it unchanged.\n     *\n     * @param {LngLatLike} input An array of two numbers to convert, or a `LngLat` object to return.\n     * @returns {LngLat} A new `LngLat` object, if a conversion occurred, or the original `LngLat` object.\n     * @example\n     * var arr = [-73.9749, 40.7736];\n     * var ll = mapboxgl.LngLat.convert(arr);\n     * ll;   // = LngLat {lng: -73.9749, lat: 40.7736}\n     */\n    static convert(input            )         {\n        if (input instanceof LngLat) {\n            return input;\n        }\n        if (Array.isArray(input) && (input.length === 2 || input.length === 3)) {\n            return new LngLat(Number(input[0]), Number(input[1]));\n        }\n        if (!Array.isArray(input) && typeof input === 'object' && input !== null) {\n            return new LngLat(Number(input.lng), Number(input.lat));\n        }\n        throw new Error(\"`LngLatLike` argument must be specified as a LngLat instance, an object {lng: <lng>, lat: <lat>}, or an array of [<lng>, <lat>]\");\n    }\n}\n\n/**\n * A {@link LngLat} object, an array of two numbers representing longitude and latitude,\n * or an object with `lng` and `lat` properties.\n *\n * @typedef {LngLat | {lng: number, lat: number} | [number, number]} LngLatLike\n * @example\n * var v1 = new mapboxgl.LngLat(-122.420679, 37.772537);\n * var v2 = [-122.420679, 37.772537];\n */\n                                                                                \n\nmodule.exports = LngLat;\n","//      \n\nconst LngLat = require('./lng_lat');\n\n                                          \n\n/**\n * A `LngLatBounds` object represents a geographical bounding box,\n * defined by its southwest and northeast points in longitude and latitude.\n *\n * If no arguments are provided to the constructor, a `null` bounding box is created.\n *\n * Note that any Mapbox GL method that accepts a `LngLatBounds` object as an argument or option\n * can also accept an `Array` of two {@link LngLatLike} constructs and will perform an implicit conversion.\n * This flexible type is documented as {@link LngLatBoundsLike}.\n *\n * @param {LngLatLike} [sw] The southwest corner of the bounding box.\n * @param {LngLatLike} [ne] The northeast corner of the bounding box.\n * @example\n * var sw = new mapboxgl.LngLat(-73.9876, 40.7661);\n * var ne = new mapboxgl.LngLat(-73.9397, 40.8002);\n * var llb = new mapboxgl.LngLatBounds(sw, ne);\n */\nclass LngLatBounds {\n                \n                \n\n    // This constructor is too flexible to type. It should not be so flexible.\n    constructor(sw     , ne     ) {\n        if (!sw) {\n            return;\n        } else if (ne) {\n            this.setSouthWest(sw).setNorthEast(ne);\n        } else if (sw.length === 4) {\n            this.setSouthWest([sw[0], sw[1]]).setNorthEast([sw[2], sw[3]]);\n        } else {\n            this.setSouthWest(sw[0]).setNorthEast(sw[1]);\n        }\n    }\n\n    /**\n     * Set the northeast corner of the bounding box\n     *\n     * @param {LngLatLike} ne\n     * @returns {LngLatBounds} `this`\n     */\n    setNorthEast(ne            ) {\n        this._ne = ne instanceof LngLat ? new LngLat(ne.lng, ne.lat) : LngLat.convert(ne);\n        return this;\n    }\n\n    /**\n     * Set the southwest corner of the bounding box\n     *\n     * @param {LngLatLike} sw\n     * @returns {LngLatBounds} `this`\n     */\n    setSouthWest(sw            ) {\n        this._sw = sw instanceof LngLat ? new LngLat(sw.lng, sw.lat) : LngLat.convert(sw);\n        return this;\n    }\n\n    /**\n     * Extend the bounds to include a given LngLat or LngLatBounds.\n     *\n     * @param {LngLat|LngLatBounds} obj object to extend to\n     * @returns {LngLatBounds} `this`\n     */\n    extend(obj) {\n        const sw = this._sw,\n            ne = this._ne;\n        let sw2, ne2;\n\n        if (obj instanceof LngLat) {\n            sw2 = obj;\n            ne2 = obj;\n\n        } else if (obj instanceof LngLatBounds) {\n            sw2 = obj._sw;\n            ne2 = obj._ne;\n\n            if (!sw2 || !ne2) return this;\n\n        } else {\n            if (Array.isArray(obj)) {\n                if (obj.every(Array.isArray)) {\n                    return this.extend(LngLatBounds.convert(obj));\n                } else {\n                    return this.extend(LngLat.convert(obj));\n                }\n            }\n            return this;\n        }\n\n        if (!sw && !ne) {\n            this._sw = new LngLat(sw2.lng, sw2.lat);\n            this._ne = new LngLat(ne2.lng, ne2.lat);\n\n        } else {\n            sw.lng = Math.min(sw2.lng, sw.lng);\n            sw.lat = Math.min(sw2.lat, sw.lat);\n            ne.lng = Math.max(ne2.lng, ne.lng);\n            ne.lat = Math.max(ne2.lat, ne.lat);\n        }\n\n        return this;\n    }\n\n    /**\n     * Returns the geographical coordinate equidistant from the bounding box's corners.\n     *\n     * @returns {LngLat} The bounding box's center.\n     * @example\n     * var llb = new mapboxgl.LngLatBounds([-73.9876, 40.7661], [-73.9397, 40.8002]);\n     * llb.getCenter(); // = LngLat {lng: -73.96365, lat: 40.78315}\n     */\n    getCenter()         {\n        return new LngLat((this._sw.lng + this._ne.lng) / 2, (this._sw.lat + this._ne.lat) / 2);\n    }\n\n    /**\n     * Returns the southwest corner of the bounding box.\n     *\n     * @returns {LngLat} The southwest corner of the bounding box.\n     */\n    getSouthWest()         { return this._sw; }\n\n    /**\n    * Returns the northeast corner of the bounding box.\n    *\n    * @returns {LngLat} The northeast corner of the bounding box.\n     */\n    getNorthEast()         { return this._ne; }\n\n    /**\n    * Returns the northwest corner of the bounding box.\n    *\n    * @returns {LngLat} The northwest corner of the bounding box.\n     */\n    getNorthWest()         { return new LngLat(this.getWest(), this.getNorth()); }\n\n    /**\n    * Returns the southeast corner of the bounding box.\n    *\n    * @returns {LngLat} The southeast corner of the bounding box.\n     */\n    getSouthEast()         { return new LngLat(this.getEast(), this.getSouth()); }\n\n    /**\n    * Returns the west edge of the bounding box.\n    *\n    * @returns {number} The west edge of the bounding box.\n     */\n    getWest()         { return this._sw.lng; }\n\n    /**\n    * Returns the south edge of the bounding box.\n    *\n    * @returns {number} The south edge of the bounding box.\n     */\n    getSouth()         { return this._sw.lat; }\n\n    /**\n    * Returns the east edge of the bounding box.\n    *\n    * @returns {number} The east edge of the bounding box.\n     */\n    getEast()         { return this._ne.lng; }\n\n    /**\n    * Returns the north edge of the bounding box.\n    *\n    * @returns {number} The north edge of the bounding box.\n     */\n    getNorth()         { return this._ne.lat; }\n\n    /**\n     * Returns the bounding box represented as an array.\n     *\n     * @returns {Array<Array<number>>} The bounding box represented as an array, consisting of the\n     *   southwest and northeast coordinates of the bounding represented as arrays of numbers.\n     * @example\n     * var llb = new mapboxgl.LngLatBounds([-73.9876, 40.7661], [-73.9397, 40.8002]);\n     * llb.toArray(); // = [[-73.9876, 40.7661], [-73.9397, 40.8002]]\n     */\n    toArray() {\n        return [this._sw.toArray(), this._ne.toArray()];\n    }\n\n    /**\n     * Return the bounding box represented as a string.\n     *\n     * @returns {string} The bounding box represents as a string of the format\n     *   `'LngLatBounds(LngLat(lng, lat), LngLat(lng, lat))'`.\n     * @example\n     * var llb = new mapboxgl.LngLatBounds([-73.9876, 40.7661], [-73.9397, 40.8002]);\n     * llb.toString(); // = \"LngLatBounds(LngLat(-73.9876, 40.7661), LngLat(-73.9397, 40.8002))\"\n     */\n    toString() {\n        return `LngLatBounds(${this._sw.toString()}, ${this._ne.toString()})`;\n    }\n\n    /**\n     * Converts an array to a `LngLatBounds` object.\n     *\n     * If a `LngLatBounds` object is passed in, the function returns it unchanged.\n     *\n     * Internally, the function calls `LngLat#convert` to convert arrays to `LngLat` values.\n     *\n     * @param {LngLatBoundsLike} input An array of two coordinates to convert, or a `LngLatBounds` object to return.\n     * @returns {LngLatBounds} A new `LngLatBounds` object, if a conversion occurred, or the original `LngLatBounds` object.\n     * @example\n     * var arr = [[-73.9876, 40.7661], [-73.9397, 40.8002]];\n     * var llb = mapboxgl.LngLatBounds.convert(arr);\n     * llb;   // = LngLatBounds {_sw: LngLat {lng: -73.9876, lat: 40.7661}, _ne: LngLat {lng: -73.9397, lat: 40.8002}}\n     */\n    static convert(input                  )               {\n        if (!input || input instanceof LngLatBounds) return input;\n        return new LngLatBounds(input);\n    }\n}\n\n/**\n * A {@link LngLatBounds} object, an array of {@link LngLatLike} objects in [sw, ne] order,\n * or an array of numbers in [west, south, east, north] order.\n *\n * @typedef {LngLatBounds | [LngLatLike, LngLatLike] | [number, number, number, number]} LngLatBoundsLike\n * @example\n * var v1 = new mapboxgl.LngLatBounds(\n *   new mapboxgl.LngLat(-73.9876, 40.7661),\n *   new mapboxgl.LngLat(-73.9397, 40.8002)\n * );\n * var v2 = new mapboxgl.LngLatBounds([-73.9876, 40.7661], [-73.9397, 40.8002])\n * var v3 = [[-73.9876, 40.7661], [-73.9397, 40.8002]];\n */\n                                                                                                          \n\nmodule.exports = LngLatBounds;\n","//      \n\nconst {HTMLImageElement, HTMLCanvasElement, HTMLVideoElement, ImageData} = require('../util/window');\n\n                                         \n                                                         \n\n                           \n                                                  \n                                                    \n                           \n                                                    \n                                                                   \n                                                      \n                         \n                                                    \n                                                           \n                                                              \n\n                   \n                  \n                   \n              \n \n\n                          \n               \n                \n                      \n                       \n                      \n               \n                 \n\nclass Texture {\n                     \n                        \n                          \n                          \n                           \n                       \n\n    constructor(context         , image              , format               , premultiply          ) {\n        this.context = context;\n\n        const {width, height} = image;\n        this.size = [width, height];\n        this.format = format;\n\n        this.texture = context.gl.createTexture();\n        this.update(image, premultiply);\n    }\n\n    update(image              , premultiply          ) {\n        const {width, height} = image;\n        this.size = [width, height];\n\n        const {context} = this;\n        const {gl} = context;\n        gl.bindTexture(gl.TEXTURE_2D, this.texture);\n        context.pixelStoreUnpack.set(1);\n\n        if (this.format === gl.RGBA && premultiply !== false) {\n            context.pixelStoreUnpackPremultiplyAlpha.set(true);\n        }\n\n        if (image instanceof HTMLImageElement || image instanceof HTMLCanvasElement || image instanceof HTMLVideoElement || image instanceof ImageData) {\n            gl.texImage2D(gl.TEXTURE_2D, 0, this.format, this.format, gl.UNSIGNED_BYTE, image);\n        } else {\n            gl.texImage2D(gl.TEXTURE_2D, 0, this.format, width, height, 0, this.format, gl.UNSIGNED_BYTE, image.data);\n        }\n    }\n\n    bind(filter               , wrap             , minFilter                ) {\n        const {context} = this;\n        const {gl} = context;\n        gl.bindTexture(gl.TEXTURE_2D, this.texture);\n\n        if (filter !== this.filter) {\n            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, filter);\n            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, minFilter || filter);\n            this.filter = filter;\n        }\n\n        if (wrap !== this.wrap) {\n            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, wrap);\n            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, wrap);\n            this.wrap = wrap;\n        }\n    }\n\n    destroy() {\n        const {gl} = this.context;\n        gl.deleteTexture(this.texture);\n        this.texture = (null     );\n    }\n}\n\nmodule.exports = Texture;\n","//      \n\nconst LngLatBounds = require('../geo/lng_lat_bounds');\nconst clamp = require('../util/util').clamp;\n\n                                               \n\nclass TileBounds {\n                         \n                    \n                    \n\n    constructor(bounds                                  , minzoom         , maxzoom         ) {\n        this.bounds = LngLatBounds.convert(this.validateBounds(bounds));\n        this.minzoom = minzoom || 0;\n        this.maxzoom = maxzoom || 24;\n    }\n\n    validateBounds(bounds                                  ) {\n        // make sure the bounds property contains valid longitude and latitudes\n        if (!Array.isArray(bounds) || bounds.length !== 4) return [-180, -90, 180, 90];\n        return [Math.max(-180, bounds[0]), Math.max(-90, bounds[1]), Math.min(180, bounds[2]), Math.min(90, bounds[3])];\n    }\n\n    contains(tileID                 ) {\n        const level = {\n            minX: Math.floor(this.lngX(this.bounds.getWest(), tileID.z)),\n            minY: Math.floor(this.latY(this.bounds.getNorth(), tileID.z)),\n            maxX: Math.ceil(this.lngX(this.bounds.getEast(), tileID.z)),\n            maxY: Math.ceil(this.latY(this.bounds.getSouth(), tileID.z))\n        };\n        const hit = tileID.x >= level.minX && tileID.x < level.maxX && tileID.y >= level.minY && tileID.y < level.maxY;\n        return hit;\n    }\n\n    lngX(lng        , zoom        ) {\n        return (lng + 180) * (Math.pow(2, zoom) / 360);\n    }\n\n    latY(lat        , zoom        ) {\n        const f = clamp(Math.sin(Math.PI / 180 * lat), -0.9999, 0.9999);\n        const scale = Math.pow(2, zoom) / (2 * Math.PI);\n        return Math.pow(2, zoom - 1) + 0.5 * Math.log((1 + f) / (1 - f)) * -scale;\n    }\n}\n\nmodule.exports = TileBounds;\n","//      \n\nconst window = require('./window');\n\n                                                  \n\n/**\n * The type of a resource.\n * @private\n * @readonly\n * @enum {string}\n */\nconst ResourceType = {\n    Unknown: 'Unknown',\n    Style: 'Style',\n    Source: 'Source',\n    Tile: 'Tile',\n    Glyphs: 'Glyphs',\n    SpriteImage: 'SpriteImage',\n    SpriteJSON: 'SpriteJSON',\n    Image: 'Image'\n};\nexports.ResourceType = ResourceType;\n\nif (typeof Object.freeze == 'function') {\n    Object.freeze(ResourceType);\n}\n\n/**\n * A `RequestParameters` object to be returned from Map.options.transformRequest callbacks.\n * @typedef {Object} RequestParameters\n * @property {string} url The URL to be requested.\n * @property {Object} headers The headers to be sent with the request.\n * @property {string} credentials `'same-origin'|'include'` Use 'include' to send cookies with cross-origin requests.\n */\n                                 \n                \n                     \n                                           \n  \n\nclass AJAXError extends Error {\n                   \n    constructor(message        , status        ) {\n        super(message);\n        this.status = status;\n    }\n}\n\nfunction makeRequest(requestParameters                   )                 {\n    const xhr                 = new window.XMLHttpRequest();\n\n    xhr.open('GET', requestParameters.url, true);\n    for (const k in requestParameters.headers) {\n        xhr.setRequestHeader(k, requestParameters.headers[k]);\n    }\n    xhr.withCredentials = requestParameters.credentials === 'include';\n    return xhr;\n}\n\nexports.getJSON = function(requestParameters                   , callback                 ) {\n    const xhr = makeRequest(requestParameters);\n    xhr.setRequestHeader('Accept', 'application/json');\n    xhr.onerror = function() {\n        callback(new Error(xhr.statusText));\n    };\n    xhr.onload = function() {\n        if (xhr.status >= 200 && xhr.status < 300 && xhr.response) {\n            let data;\n            try {\n                data = JSON.parse(xhr.response);\n            } catch (err) {\n                return callback(err);\n            }\n            callback(null, data);\n        } else {\n            callback(new AJAXError(xhr.statusText, xhr.status));\n        }\n    };\n    xhr.send();\n    return xhr;\n};\n\nexports.getArrayBuffer = function(requestParameters                   , callback                                                                        ) {\n    const xhr = makeRequest(requestParameters);\n    xhr.responseType = 'arraybuffer';\n    xhr.onerror = function() {\n        callback(new Error(xhr.statusText));\n    };\n    xhr.onload = function() {\n        const response              = xhr.response;\n        if (response.byteLength === 0 && xhr.status === 200) {\n            return callback(new Error('http status 200 returned without content.'));\n        }\n        if (xhr.status >= 200 && xhr.status < 300 && xhr.response) {\n            callback(null, {\n                data: response,\n                cacheControl: xhr.getResponseHeader('Cache-Control'),\n                expires: xhr.getResponseHeader('Expires')\n            });\n        } else {\n            callback(new AJAXError(xhr.statusText, xhr.status));\n        }\n    };\n    xhr.send();\n    return xhr;\n};\n\nfunction sameOrigin(url) {\n    const a                    = window.document.createElement('a');\n    a.href = url;\n    return a.protocol === window.document.location.protocol && a.host === window.document.location.host;\n}\n\nconst transparentPngUrl = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVQYV2NgAAIAAAUAAarVyFEAAAAASUVORK5CYII=';\n\nexports.getImage = function(requestParameters                   , callback                            ) {\n    // request the image with XHR to work around caching issues\n    // see https://github.com/mapbox/mapbox-gl-js/issues/1470\n    return exports.getArrayBuffer(requestParameters, (err, imgData) => {\n        if (err) {\n            callback(err);\n        } else if (imgData) {\n            const img                   = new window.Image();\n            const URL = window.URL || window.webkitURL;\n            img.onload = () => {\n                callback(null, img);\n                URL.revokeObjectURL(img.src);\n            };\n            const blob       = new window.Blob([new Uint8Array(imgData.data)], { type: 'image/png' });\n            (img     ).cacheControl = imgData.cacheControl;\n            (img     ).expires = imgData.expires;\n            img.src = imgData.data.byteLength ? URL.createObjectURL(blob) : transparentPngUrl;\n        }\n    });\n};\n\nexports.getVideo = function(urls               , callback                            ) {\n    const video                   = window.document.createElement('video');\n    video.onloadstart = function() {\n        callback(null, video);\n    };\n    for (let i = 0; i < urls.length; i++) {\n        const s                    = window.document.createElement('source');\n        if (!sameOrigin(urls[i])) {\n            video.crossOrigin = 'Anonymous';\n        }\n        s.src = urls[i];\n        video.appendChild(s);\n    }\n    return video;\n};\n","//      \n\n/* eslint-env browser */\nmodule.exports = (self        );\n","//      \n\nconst util = require('./util');\n\n                                \n                                               \n\nfunction _addEventListener(type        , listener          , listenerList           ) {\n    listenerList[type] = listenerList[type] || [];\n    listenerList[type].push(listener);\n}\n\nfunction _removeEventListener(type        , listener          , listenerList           ) {\n    if (listenerList && listenerList[type]) {\n        const index = listenerList[type].indexOf(listener);\n        if (index !== -1) {\n            listenerList[type].splice(index, 1);\n        }\n    }\n}\n\n/**\n * Methods mixed in to other classes for event capabilities.\n *\n * @mixin Evented\n */\nclass Evented {\n                          \n                                 \n                             \n                                                 \n\n    /**\n     * Adds a listener to a specified event type.\n     *\n     * @param {string} type The event type to add a listen for.\n     * @param {Function} listener The function to be called when the event is fired.\n     *   The listener function is called with the data object passed to `fire`,\n     *   extended with `target` and `type` properties.\n     * @returns {Object} `this`\n     */\n    on(type   , listener          )       {\n        this._listeners = this._listeners || {};\n        _addEventListener(type, listener, this._listeners);\n\n        return this;\n    }\n\n    /**\n     * Removes a previously registered event listener.\n     *\n     * @param {string} type The event type to remove listeners for.\n     * @param {Function} listener The listener function to remove.\n     * @returns {Object} `this`\n     */\n    off(type   , listener          ) {\n        _removeEventListener(type, listener, this._listeners);\n        _removeEventListener(type, listener, this._oneTimeListeners);\n\n        return this;\n    }\n\n    /**\n     * Adds a listener that will be called only once to a specified event type.\n     *\n     * The listener will be called first time the event fires after the listener is registered.\n     *\n     * @param {string} type The event type to listen for.\n     * @param {Function} listener The function to be called when the event is fired the first time.\n     * @returns {Object} `this`\n     */\n    once(type        , listener          ) {\n        this._oneTimeListeners = this._oneTimeListeners || {};\n        _addEventListener(type, listener, this._oneTimeListeners);\n\n        return this;\n    }\n\n    /**\n     * Fires an event of the specified type.\n     *\n     * @param {string} type The type of event to fire.\n     * @param {Object} [data] Data to be passed to any listeners.\n     * @returns {Object} `this`\n     */\n    fire(type        , data         ) {\n        if (this.listens(type)) {\n            data = util.extend({}, data, {type: type, target: this});\n\n            // make sure adding or removing listeners inside other listeners won't cause an infinite loop\n            const listeners = this._listeners && this._listeners[type] ? this._listeners[type].slice() : [];\n            for (const listener of listeners) {\n                listener.call(this, data);\n            }\n\n            const oneTimeListeners = this._oneTimeListeners && this._oneTimeListeners[type] ? this._oneTimeListeners[type].slice() : [];\n            for (const listener of oneTimeListeners) {\n                _removeEventListener(type, listener, this._oneTimeListeners);\n                listener.call(this, data);\n            }\n\n            if (this._eventedParent) {\n                this._eventedParent.fire(type, util.extend({}, data, typeof this._eventedParentData === 'function' ? this._eventedParentData() : this._eventedParentData));\n            }\n\n        // To ensure that no error events are dropped, print them to the\n        // console if they have no listeners.\n        } else if (util.endsWith(type, 'error')) {\n            console.error((data && data.error) || data || 'Empty error event');\n        }\n\n        return this;\n    }\n\n    /**\n     * Returns a true if this instance of Evented or any forwardeed instances of Evented have a listener for the specified type.\n     *\n     * @param {string} type The event type\n     * @returns {boolean} `true` if there is at least one registered listener for specified event type, `false` otherwise\n     */\n    listens(type        ) {\n        return (\n            (this._listeners && this._listeners[type] && this._listeners[type].length > 0) ||\n            (this._oneTimeListeners && this._oneTimeListeners[type] && this._oneTimeListeners[type].length > 0) ||\n            (this._eventedParent && this._eventedParent.listens(type))\n        );\n    }\n\n    /**\n     * Bubble all events fired by this instance of Evented to this parent instance of Evented.\n     *\n     * @private\n     * @returns {Object} `this`\n     */\n    setEventedParent(parent          , data                        ) {\n        this._eventedParent = parent;\n        this._eventedParentData = data;\n\n        return this;\n    }\n}\n\nmodule.exports = Evented;\n","//      \n\nconst UnitBezier = require('@mapbox/unitbezier');\nconst Coordinate = require('../geo/coordinate');\nconst Point = require('@mapbox/point-geometry');\n\n                                                \n\n/**\n * @module util\n * @private\n */\n\n/**\n * Given a value `t` that varies between 0 and 1, return\n * an interpolation function that eases between 0 and 1 in a pleasing\n * cubic in-out fashion.\n *\n * @private\n */\nexports.easeCubicInOut = function(t        )         {\n    if (t <= 0) return 0;\n    if (t >= 1) return 1;\n    const t2 = t * t,\n        t3 = t2 * t;\n    return 4 * (t < 0.5 ? t3 : 3 * (t - t2) + t3 - 0.75);\n};\n\n/**\n * Given given (x, y), (x1, y1) control points for a bezier curve,\n * return a function that interpolates along that curve.\n *\n * @param p1x control point 1 x coordinate\n * @param p1y control point 1 y coordinate\n * @param p2x control point 2 x coordinate\n * @param p2y control point 2 y coordinate\n * @private\n */\nexports.bezier = function(p1x        , p1y        , p2x        , p2y        )                        {\n    const bezier = new UnitBezier(p1x, p1y, p2x, p2y);\n    return function(t        ) {\n        return bezier.solve(t);\n    };\n};\n\n/**\n * A default bezier-curve powered easing function with\n * control points (0.25, 0.1) and (0.25, 1)\n *\n * @private\n */\nexports.ease = exports.bezier(0.25, 0.1, 0.25, 1);\n\n/**\n * constrain n to the given range via min + max\n *\n * @param n value\n * @param min the minimum value to be returned\n * @param max the maximum value to be returned\n * @returns the clamped value\n * @private\n */\nexports.clamp = function (n        , min        , max        )         {\n    return Math.min(max, Math.max(min, n));\n};\n\n/**\n * constrain n to the given range, excluding the minimum, via modular arithmetic\n *\n * @param n value\n * @param min the minimum value to be returned, exclusive\n * @param max the maximum value to be returned, inclusive\n * @returns constrained number\n * @private\n */\nexports.wrap = function (n        , min        , max        )         {\n    const d = max - min;\n    const w = ((n - min) % d + d) % d + min;\n    return (w === min) ? max : w;\n};\n\n/*\n * Call an asynchronous function on an array of arguments,\n * calling `callback` with the completed results of all calls.\n *\n * @param array input to each call of the async function.\n * @param fn an async function with signature (data, callback)\n * @param callback a callback run after all async work is done.\n * called with an array, containing the results of each async call.\n * @private\n */\nexports.asyncAll = function               (\n    array             ,\n    fn                                                    ,\n    callback                         \n) {\n    if (!array.length) { return callback(null, []); }\n    let remaining = array.length;\n    const results = new Array(array.length);\n    let error = null;\n    array.forEach((item, i) => {\n        fn(item, (err, result) => {\n            if (err) error = err;\n            results[i] = ((result     )        ); // https://github.com/facebook/flow/issues/2123\n            if (--remaining === 0) callback(error, results);\n        });\n    });\n};\n\n/*\n * Polyfill for Object.values. Not fully spec compliant, but we don't\n * need it to be.\n *\n * @private\n */\nexports.values = function   (obj                    )           {\n    const result = [];\n    for (const k in obj) {\n        result.push(obj[k]);\n    }\n    return result;\n};\n\n/*\n * Compute the difference between the keys in one object and the keys\n * in another object.\n *\n * @returns keys difference\n * @private\n */\nexports.keysDifference = function      (obj                    , other                    )                {\n    const difference = [];\n    for (const i in obj) {\n        if (!(i in other)) {\n            difference.push(i);\n        }\n    }\n    return difference;\n};\n\n/**\n * Given a destination object and optionally many source objects,\n * copy all properties from the source objects into the destination.\n * The last source object given overrides properties from previous\n * source objects.\n *\n * @param dest destination object\n * @param sources sources from which properties are pulled\n * @private\n */\nexports.extend = function (dest        , ...sources                )         {\n    for (const src of sources) {\n        for (const k in src) {\n            dest[k] = src[k];\n        }\n    }\n    return dest;\n};\n\n/**\n * Given an object and a number of properties as strings, return version\n * of that object with only those properties.\n *\n * @param src the object\n * @param properties an array of property names chosen\n * to appear on the resulting object.\n * @returns object with limited properties.\n * @example\n * var foo = { name: 'Charlie', age: 10 };\n * var justName = pick(foo, ['name']);\n * // justName = { name: 'Charlie' }\n * @private\n */\nexports.pick = function (src        , properties               )         {\n    const result = {};\n    for (let i = 0; i < properties.length; i++) {\n        const k = properties[i];\n        if (k in src) {\n            result[k] = src[k];\n        }\n    }\n    return result;\n};\n\nlet id = 1;\n\n/**\n * Return a unique numeric id, starting at 1 and incrementing with\n * each call.\n *\n * @returns unique numeric id.\n * @private\n */\nexports.uniqueId = function ()         {\n    return id++;\n};\n\n/**\n * Given an array of member function names as strings, replace all of them\n * with bound versions that will always refer to `context` as `this`. This\n * is useful for classes where otherwise event bindings would reassign\n * `this` to the evented object or some other value: this lets you ensure\n * the `this` value always.\n *\n * @param fns list of member function names\n * @param context the context value\n * @example\n * function MyClass() {\n *   bindAll(['ontimer'], this);\n *   this.name = 'Tom';\n * }\n * MyClass.prototype.ontimer = function() {\n *   alert(this.name);\n * };\n * var myClass = new MyClass();\n * setTimeout(myClass.ontimer, 100);\n * @private\n */\nexports.bindAll = function(fns               , context        )       {\n    fns.forEach((fn) => {\n        if (!context[fn]) { return; }\n        context[fn] = context[fn].bind(context);\n    });\n};\n\n/**\n * Given a list of coordinates, get their center as a coordinate.\n *\n * @returns centerpoint\n * @private\n */\nexports.getCoordinatesCenter = function(coords                   )             {\n    let minX = Infinity;\n    let minY = Infinity;\n    let maxX = -Infinity;\n    let maxY = -Infinity;\n\n    for (let i = 0; i < coords.length; i++) {\n        minX = Math.min(minX, coords[i].column);\n        minY = Math.min(minY, coords[i].row);\n        maxX = Math.max(maxX, coords[i].column);\n        maxY = Math.max(maxY, coords[i].row);\n    }\n\n    const dx = maxX - minX;\n    const dy = maxY - minY;\n    const dMax = Math.max(dx, dy);\n    const zoom = Math.max(0, Math.floor(-Math.log(dMax) / Math.LN2));\n    return new Coordinate((minX + maxX) / 2, (minY + maxY) / 2, 0)\n        .zoomTo(zoom);\n};\n\n/**\n * Determine if a string ends with a particular substring\n *\n * @private\n */\nexports.endsWith = function(string        , suffix        )          {\n    return string.indexOf(suffix, string.length - suffix.length) !== -1;\n};\n\n/**\n * Create an object by mapping all the values of an existing object while\n * preserving their keys.\n *\n * @private\n */\nexports.mapObject = function(input        , iterator          , context         )         {\n    const output = {};\n    for (const key in input) {\n        output[key] = iterator.call(context || this, input[key], key, input);\n    }\n    return output;\n};\n\n/**\n * Create an object by filtering out values of an existing object.\n *\n * @private\n */\nexports.filterObject = function(input        , iterator          , context         )         {\n    const output = {};\n    for (const key in input) {\n        if (iterator.call(context || this, input[key], key, input)) {\n            output[key] = input[key];\n        }\n    }\n    return output;\n};\n\n/**\n * Deeply compares two object literals.\n *\n * @private\n */\nexports.deepEqual = function(a        , b        )          {\n    if (Array.isArray(a)) {\n        if (!Array.isArray(b) || a.length !== b.length) return false;\n        for (let i = 0; i < a.length; i++) {\n            if (!exports.deepEqual(a[i], b[i])) return false;\n        }\n        return true;\n    }\n    if (typeof a === 'object' && a !== null && b !== null) {\n        if (!(typeof b === 'object')) return false;\n        const keys = Object.keys(a);\n        if (keys.length !== Object.keys(b).length) return false;\n        for (const key in a) {\n            if (!exports.deepEqual(a[key], b[key])) return false;\n        }\n        return true;\n    }\n    return a === b;\n};\n\n/**\n * Deeply clones two objects.\n *\n * @private\n */\nexports.clone = function   (input   )    {\n    if (Array.isArray(input)) {\n        return input.map(exports.clone);\n    } else if (typeof input === 'object' && input) {\n        return ((exports.mapObject(input, exports.clone)     )   );\n    } else {\n        return input;\n    }\n};\n\n/**\n * Check if two arrays have at least one common element.\n *\n * @private\n */\nexports.arraysIntersect = function   (a          , b          )          {\n    for (let l = 0; l < a.length; l++) {\n        if (b.indexOf(a[l]) >= 0) return true;\n    }\n    return false;\n};\n\n/**\n * Print a warning message to the console and ensure duplicate warning messages\n * are not printed.\n *\n * @private\n */\nconst warnOnceHistory                           = {};\nexports.warnOnce = function(message        )       {\n    if (!warnOnceHistory[message]) {\n        // console isn't defined in some WebWorkers, see #2558\n        if (typeof console !== \"undefined\") console.warn(message);\n        warnOnceHistory[message] = true;\n    }\n};\n\n/**\n * Indicates if the provided Points are in a counter clockwise (true) or clockwise (false) order\n *\n * @returns true for a counter clockwise set of points\n */\n// http://bryceboe.com/2006/10/23/line-segment-intersection-algorithm/\nexports.isCounterClockwise = function(a       , b       , c       )          {\n    return (c.y - a.y) * (b.x - a.x) > (b.y - a.y) * (c.x - a.x);\n};\n\n/**\n * Returns the signed area for the polygon ring.  Postive areas are exterior rings and\n * have a clockwise winding.  Negative areas are interior rings and have a counter clockwise\n * ordering.\n *\n * @param ring Exterior or interior ring\n */\nexports.calculateSignedArea = function(ring              )         {\n    let sum = 0;\n    for (let i = 0, len = ring.length, j = len - 1, p1, p2; i < len; j = i++) {\n        p1 = ring[i];\n        p2 = ring[j];\n        sum += (p2.x - p1.x) * (p1.y + p2.y);\n    }\n    return sum;\n};\n\n/**\n * Detects closed polygons, first + last point are equal\n *\n * @param points array of points\n * @return true if the points are a closed polygon\n */\nexports.isClosedPolygon = function(points              )          {\n    // If it is 2 points that are the same then it is a point\n    // If it is 3 points with start and end the same then it is a line\n    if (points.length < 4)\n        return false;\n\n    const p1 = points[0];\n    const p2 = points[points.length - 1];\n\n    if (Math.abs(p1.x - p2.x) > 0 ||\n        Math.abs(p1.y - p2.y) > 0) {\n        return false;\n    }\n\n    // polygon simplification can produce polygons with zero area and more than 3 points\n    return (Math.abs(exports.calculateSignedArea(points)) > 0.01);\n};\n\n/**\n * Converts spherical coordinates to cartesian coordinates.\n *\n * @param spherical Spherical coordinates, in [radial, azimuthal, polar]\n * @return cartesian coordinates in [x, y, z]\n */\n\nexports.sphericalToCartesian = function([r, azimuthal, polar]                          )                                    {\n    // We abstract \"north\"/\"up\" (compass-wise) to be 0° when really this is 90° (π/2):\n    // correct for that here\n    azimuthal += 90;\n\n    // Convert azimuthal and polar angles to radians\n    azimuthal *= Math.PI / 180;\n    polar *= Math.PI / 180;\n\n    return {\n        x: r * Math.cos(azimuthal) * Math.sin(polar),\n        y: r * Math.sin(azimuthal) * Math.sin(polar),\n        z: r * Math.cos(polar)\n    };\n};\n\n/**\n * Parses data from 'Cache-Control' headers.\n *\n * @param cacheControl Value of 'Cache-Control' header\n * @return object containing parsed header info.\n */\n\nexports.parseCacheControl = function(cacheControl        )         {\n    // Taken from [Wreck](https://github.com/hapijs/wreck)\n    const re = /(?:^|(?:\\s*\\,\\s*))([^\\x00-\\x20\\(\\)<>@\\,;\\:\\\\\"\\/\\[\\]\\?\\=\\{\\}\\x7F]+)(?:\\=(?:([^\\x00-\\x20\\(\\)<>@\\,;\\:\\\\\"\\/\\[\\]\\?\\=\\{\\}\\x7F]+)|(?:\\\"((?:[^\"\\\\]|\\\\.)*)\\\")))?/g;\n\n    const header = {};\n    cacheControl.replace(re, ($0, $1, $2, $3) => {\n        const value = $2 || $3;\n        header[$1] = value ? value.toLowerCase() : true;\n        return '';\n    });\n\n    if (header['max-age']) {\n        const maxAge = parseInt(header['max-age'], 10);\n        if (isNaN(maxAge)) delete header['max-age'];\n        else header['max-age'] = maxAge;\n    }\n\n    return header;\n};\n","//      \n\nconst util = require('mapbox-gl/src/util/util');\nconst ajax = require('mapbox-gl/src/util/ajax');\nconst Evented = require('mapbox-gl/src/util/evented');\nconst loadArcGISMapServer = require('./load_arcgis_mapserver');\nconst TileBounds = require('mapbox-gl/src/source/tile_bounds');\nconst Texture = require('mapbox-gl/src/render/texture');\nconst helpers = require('./helpers');\n\n                                                        \n                                                                   \n           \n\n   \n    \n                       \n           \n\n          \n    \n                                \n           \n\n    \n    \n                            \n                                                           \n\nclass ArcGISTiledMapServiceSource extends Evented                   {\n\n                                  \n               \n                    \n                    \n                \n                   \n                     \n\n                                              \n                           \n                       \n                           \n             \n                         \n\n                     \n                                                                       \n\n    constructor(id        , options                                                          , dispatcher            , eventedParent         ) {\n        super();\n        this.id = id;\n        this.dispatcher = dispatcher;\n        this.setEventedParent(eventedParent);\n\n        this.type = 'arcgisraster';\n        this.minzoom = 0;\n        this.maxzoom = 22;\n        this.roundZoom = true;\n        this.tileSize = 512;\n        this._loaded = false;\n\n        this._options = util.extend({}, options);\n        util.extend(this, util.pick(options, ['url', 'scheme', 'tileSize']));\n    }\n\n    load() {\n        this.fire('dataloading', {dataType: 'source'});\n        this.fire('data', {dataType: 'source', sourceDataType: 'metadata'});\n        this.fire('data', {dataType: 'source', sourceDataType: 'content'});\n        // loadArcGISMapServer(this._options, (err, metadata) => {\n        //     if (err) {\n        //         this.fire('error', err);\n        //     } else if (metadata) {\n        //         util.extend(this, metadata);\n        //\n        //         if (metadata.bounds) {\n        //             this.tileBounds = new TileBounds(metadata.bounds, this.minzoom, this.maxzoom);\n        //         }\n        //\n        //     // `content` is included here to prevent a race condition where `Style#_updateSources` is called\n        //     // before the TileJSON arrives. this makes sure the tiles needed are loaded once TileJSON arrives\n        //     // ref: https://github.com/mapbox/mapbox-gl-js/pull/4347#discussion_r104418088\n        //     this.fire('data', {dataType: 'source', sourceDataType: 'metadata'});\n        //     this.fire('data', {dataType: 'source', sourceDataType: 'content'});\n        //     }\n        // });\n    }\n\n    template(str, data) {\n        return str.replace(/\\{ *([\\w_]+) *\\}/g, function (str, key) {\n            var value = data[key];\n            if (value === undefined) {\n                throw new Error('No value provided for variable ' + str);\n            } else if (typeof value === 'function') {\n                value = value(data);\n            }\n            return value;\n        });\n    }\n\n    onAdd(map     ) {\n        // // set the urls\n        // const baseUrl = this.url.split('?')[0];\n        // this.tileUrl = `${baseUrl}/tile/{z}/{y}/{x}`;\n        //\n        // const arcgisonline = new RegExp(/tiles.arcgis(online)?\\.com/g);\n        // if (arcgisonline.test(this.url)) {\n        //     this.tileUrl = this.tileUrl.replace('://tiles', '://tiles{s}');\n        //     this.subdomains = ['1', '2', '3', '4'];\n        // }\n        //\n        // if (this.token) {\n        //     this.tileUrl += (`?token=${this.token}`);\n        // }\n\n        this.map = map;\n        this.load();\n    }\n\n    serialize() {\n        return util.extend({}, this._options);\n    }\n\n    hasTile(tileID                  ) {\n        return !this.tileBounds || this.tileBounds.contains(tileID.canonical);\n    }\n\n    loadTile(tile      , callback                ) {\n        //convert to ags coords\n        const tilePoint = {z: tile.tileID.overscaledZ, x: tile.tileID.canonical.x, y: tile.tileID.canonical.y};\n\n        const url = this.template(this.url, {x: tilePoint.x, y: tilePoint.y, z: tilePoint.z});\n        tile.request = ajax.getImage({url}, (err, img) => {\n            delete tile.request;\n\n            if (tile.aborted) {\n                tile.state = 'unloaded';\n                callback(null);\n            } else if (err) {\n                tile.state = 'errored';\n                callback(err);\n            } else if (img) {\n                if (this.map._refreshExpiredTiles) tile.setExpiryData(img);\n                delete (img\n             \n                   \n            ).\n                cacheControl;\n                delete (img\n             \n                   \n            ).\n                expires;\n\n                const context = this.map.painter.context;\n                const gl = context.gl;\n                tile.texture = this.map.painter.getTileTexture(img.width);\n                if (tile.texture) {\n                    tile.texture.bind(gl.LINEAR, gl.CLAMP_TO_EDGE, gl.LINEAR_MIPMAP_NEAREST);\n                    gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, gl.RGBA, gl.UNSIGNED_BYTE, img);\n                } else {\n                    tile.texture = new Texture(context, img, gl.RGBA);\n                    tile.texture.bind(gl.LINEAR, gl.CLAMP_TO_EDGE, gl.LINEAR_MIPMAP_NEAREST);\n\n                    if (context.extTextureFilterAnisotropic) {\n                        gl.texParameterf(gl.TEXTURE_2D, context.extTextureFilterAnisotropic.TEXTURE_MAX_ANISOTROPY_EXT, context.extTextureFilterAnisotropicMax);\n                    }\n                }\n                gl.generateMipmap(gl.TEXTURE_2D);\n\n                tile.state = 'loaded';\n\n                callback(null);\n            }\n        });\n    }\n\n    abortTile(tile      , callback                ) {\n        if (tile.request) {\n            tile.request.abort();\n            delete tile.request;\n        }\n        callback();\n    }\n\n    unloadTile(tile      , callback                ) {\n        if (tile.texture) this.map.painter.saveTileTexture(tile.texture);\n        callback();\n    }\n\n    hasTransition() {\n        return false;\n    }\n}\n\nmodule.exports = ArcGISTiledMapServiceSource;","\n//From https://github.com/Leaflet/Leaflet/blob/master/src/core/Util.js\nconst _templateRe = /\\{ *([\\w_]+) *\\}/g;\nconst _template = function (str, data) {\n    return str.replace(_templateRe, (str, key) => {\n        let value = data[key];\n\n        if (value === undefined) {\n            throw new Error(`No value provided for variable ${str}`);\n\n        } else if (typeof value === 'function') {\n            value = value(data);\n        }\n        return value;\n    });\n};\n\n//From https://github.com/Leaflet/Leaflet/blob/master/src/layer/tile/TileLayer.js\nconst _getSubdomain = function (tilePoint, subdomains) {\n    if (subdomains) {\n        const index = Math.abs(tilePoint.x + tilePoint.y) % subdomains.length;\n        return subdomains[index];\n    }\n    return null;\n};\n\nmodule.exports = {\n    _template,\n    _getSubdomain\n};\n","const ArcGISTiledMapServiceSource = require('./arcgis_tiled_map_service_source');\nmodule.exports = ArcGISTiledMapServiceSource;","'use strict';\n\nmodule.exports = function (options, callback) {\n\n    callback(null, {});\n\n};\n"]}