index.js

var originShift = (2 * Math.PI * 6378137) / 2.0;
var d2r = Math.PI / 180;

export function initialResolution(tileSize) {
  tileSize = tileSize || 256;
  return (2 * Math.PI * 6378137) / tileSize;
}

/**
 * Hash tile for unique id key
 *
 * @param {Tile} tile [x, y, z]
 * @returns {number} hash
 * @example
 * var id = globalMercator.hash([312, 480, 4])
 * //=5728
 */
export function hash(tile) {
  var x = tile[0];
  var y = tile[1];
  var z = tile[2];
  return (1 << z) * ((1 << z) + x) + y;
}

/**
 * Get the tile for a point at a specified zoom level
 * https://github.com/mapbox/tilebelt
 *
 * @param {[number, number]} lnglat [Longitude, Latitude]
 * @param {number} zoom Zoom level
 * @param {boolean} [validate=true] validates LatLng coordinates
 * @returns {Google} Google (XYZ) Tile
 * @example
 * var tile = globalMercator.pointToTile([1, 1], 12)
 * //= [ 2059, 2036, 12 ]
 */
export function pointToTile(lnglat, zoom, validate) {
  var tile = pointToTileFraction(lnglat, zoom, validate);
  tile[0] = Math.floor(tile[0]);
  tile[1] = Math.floor(tile[1]);
  return tile;
}

/**
 * Get the precise fractional tile location for a point at a zoom level
 * https://github.com/mapbox/tilebelt
 *
 * @name pointToTileFraction
 * @param {[number, number]} lnglat [Longitude, Latitude]
 * @param {number} zoom Zoom level
 * @param {boolean} [validate=true] validates LatLng coordinates
 * @returns {Google} Google (XYZ) Tile
 * @example
 * var tile = globalMercator.pointToTileFraction([1, 1], 12)
 * //= [ 2059.3777777777777, 2036.6216445333432, 12 ]
 */
export function pointToTileFraction(lnglat, zoom, validate) {
  // lnglat = validateLngLat(lnglat, validate)
  var z = zoom;
  var lon = longitude(lnglat[0]);
  var lat = latitude(lnglat[1]);
  var sin = Math.sin(lat * d2r);
  var z2 = Math.pow(2, z);
  var x = z2 * (lon / 360 + 0.5);
  var y = z2 * (0.5 - (0.25 * Math.log((1 + sin) / (1 - sin))) / Math.PI);
  return validateTile([x, y, z], validate);
}

/**
 * Converts BBox to Center
 *
 * @param {BBox} bbox - [west, south, east, north] coordinates
 * @param {number} [decimal=6] - coordinate decimals
 * @return {LngLat} center
 * @example
 * var center = globalMercator.bboxToCenter([90, -45, 85, -50])
 * //= [ 87.5, -47.5 ]
 */
export function bboxToCenter(bbox, decimal = 6) {
  var west = bbox[0];
  var south = bbox[1];
  var east = bbox[2];
  var north = bbox[3];
  var lng = (west - east) / 2 + east;
  var lat = (south - north) / 2 + north;
  if (decimal !== undefined && decimal !== null) {
    lng = Number(lng.toFixed(decimal));
    lat = Number(lat.toFixed(decimal));
  }
  return [lng, lat];
}

/**
 * Converts LngLat coordinates to Meters coordinates.
 *
 * @param {[number, number]} lnglat [Longitude, Latitude]
 * @param {boolean} [validate=true] validates LatLng coordinates
 * @param {Object} accuracy - { enable: true, decimal: 6 }
 * @returns {Meters} Meters coordinates
 * @example
 * var meters = globalMercator.lngLatToMeters([126, 37])
 * //=[ 14026255.8, 4439106.7 ]
 */
export function lngLatToMeters(
  lnglat,
  validate,
  accuracy = { enable: true, decimal: 1 }
) {
  lnglat = validateLngLat(lnglat, validate);
  var lng = lnglat[0];
  var lat = lnglat[1];
  var x = (lng * originShift) / 180.0;
  var y =
    Math.log(Math.tan(((90 + lat) * Math.PI) / 360.0)) / (Math.PI / 180.0);
  y = (y * originShift) / 180.0;
  if (accuracy.enable) {
    x = Number(x.toFixed(accuracy.decimal));
    y = Number(y.toFixed(accuracy.decimal));
  }
  return [x, y];
}

/**
 * Converts Meters coordinates to LngLat coordinates.
 *
 * @param {Meters} meters Meters in Mercator [x, y]
 * @param {number} [decimal=6] - coordinate decimals
 * @returns {LngLat} LngLat coordinates
 * @example
 * var lnglat = globalMercator.metersToLngLat([14026255, 4439106])
 * //=[ 126, 37 ]
 */
export function metersToLngLat(meters, decimal = 6) {
  var x = meters[0];
  var y = meters[1];
  var lng = (x / originShift) * 180.0;
  var lat = (y / originShift) * 180.0;
  lat =
    (180 / Math.PI) *
    (2 * Math.atan(Math.exp((lat * Math.PI) / 180.0)) - Math.PI / 2.0);
  if (decimal !== undefined && decimal !== null) {
    lng = Number(lng.toFixed(decimal));
    lat = Number(lat.toFixed(decimal));
  }
  return [lng, lat];
}

/**
 * Converts Meters coordinates to Pixels coordinates.
 *
 * @param {Meters} meters Meters in Mercator [x, y]
 * @param {number} zoom Zoom level
 * @param {number} [tileSize=256] Tile size
 * @returns {Pixels} Pixels coordinates
 * @example
 * var pixels = globalMercator.metersToPixels([14026255, 4439106], 13)
 * //=[ 1782579.1, 1280877.3, 13 ]
 */
export function metersToPixels(meters, zoom, tileSize) {
  var x = meters[0];
  var y = meters[1];
  var res = resolution(zoom, tileSize);
  var px = (x + originShift) / res;
  var py = (y + originShift) / res;
  return [px, py, zoom];
}

/**
 * Converts LngLat coordinates to TMS Tile.
 *
 * @param {[number, number]} lnglat [Longitude, Latitude]
 * @param {number} zoom Zoom level
 * @param {boolean} [validate=true] validates LatLng coordinates
 * @returns {Tile} TMS Tile
 * @example
 * var tile = globalMercator.lngLatToTile([126, 37], 13)
 * //=[ 6963, 5003, 13 ]
 */
export function lngLatToTile(lnglat, zoom, validate) {
  lnglat = validateLngLat(lnglat, validate);
  var meters = lngLatToMeters(lnglat);
  var pixels = metersToPixels(meters, zoom);
  return pixelsToTile(pixels);
}

/**
 * Converts LngLat coordinates to Google (XYZ) Tile.
 *
 * @param {[number, number]} lnglat [Longitude, Latitude]
 * @param {number} zoom Zoom level
 * @param {boolean} [validate=true] validates LatLng coordinates
 * @returns {Google} Google (XYZ) Tile
 * @example
 * var google = globalMercator.lngLatToGoogle([126, 37], 13)
 * //=[ 6963, 3188, 13 ]
 */
export function lngLatToGoogle(lnglat, zoom, validate) {
  lnglat = validateLngLat(lnglat, validate);

  if (zoom === 0) {
    return [0, 0, 0];
  }
  var tile = lngLatToTile(lnglat, zoom);
  return tileToGoogle(tile);
}

/**
 * Converts Meters coordinates to TMS Tile.
 *
 * @param {Meters} meters Meters in Mercator [x, y]
 * @param {number} zoom Zoom level
 * @returns {Tile} TMS Tile
 * @example
 * var tile = globalMercator.metersToTile([14026255, 4439106], 13)
 * //=[ 6963, 5003, 13 ]
 */
export function metersToTile(meters, zoom) {
  if (zoom === 0) {
    return [0, 0, 0];
  }
  var pixels = metersToPixels(meters, zoom);
  return pixelsToTile(pixels);
}

/**
 * Converts Pixels coordinates to Meters coordinates.
 *
 * @param {Pixels} pixels Pixels [x, y, zoom]
 * @param {number} [tileSize=256] Tile size
 * @param {number} [decimal=1] - coordinate decimals
 * @returns {Meters} Meters coordinates
 * @example
 * var meters = globalMercator.pixelsToMeters([1782579, 1280877, 13])
 * //=[ 14026252.0, 4439099.5 ]
 */
export function pixelsToMeters(pixels, tileSize, decimal = 1) {
  var px = pixels[0];
  var py = pixels[1];
  var zoom = pixels[2];
  var res = resolution(zoom, tileSize);
  var mx = px * res - originShift;
  var my = originShift - py * res;
  if (decimal !== undefined && decimal !== null) {
    mx = Number(mx.toFixed(decimal));
    my = Number(my.toFixed(decimal));
  }
  return [mx, my];
}

/**
 * Converts Pixels coordinates to TMS Tile.
 *
 * @param {Pixels} pixels Pixels [x, y, zoom]
 * @param {number} [tileSize=256] Tile size
 * @param {boolean} [validate=true] validates Pixels coordinates
 * @returns {Tile} TMS Tile
 * @example
 * var tile = globalMercator.pixelsToTile([1782579, 1280877, 13])
 * //=[ 6963, 5003, 13 ]
 */
export function pixelsToTile(pixels, tileSize, validate) {
  tileSize = tileSize || 256;
  var px = pixels[0];
  var py = pixels[1];
  var zoom = pixels[2];
  if (zoom === 0) return [0, 0, 0];

  validateZoom(zoom, validate);
  var tx = Math.ceil(px / tileSize) - 1;
  var ty = Math.ceil(py / tileSize) - 1;
  if (tx < 0) tx = 0;
  if (ty < 0) ty = 0;
  return [tx, ty, zoom];
}

/**
 * Converts TMS Tile to bbox in Meters coordinates.
 *
 * @param {Tile} tile Tile [x, y, zoom]
 * @param {number} x TMS Tile X
 * @param {number} y TMS Tile Y
 * @param {number} zoom Zoom level
 * @param {number} [tileSize=256] Tile size
 * @param {boolean} [validate=true] validates Tile
 * @returns {BBox} bbox extent in [minX, minY, maxX, maxY] order
 * @example
 * var bbox = globalMercator.tileToBBoxMeters([6963, 5003, 13])
 * //=[ 14025277.4, 4437016.6, 14030169.4, 4441908.5 ]
 */
export function tileToBBoxMeters(tile, tileSize, validate) {
  validateTile(tile, validate);

  tileSize = tileSize || 256;
  var tx = tile[0];
  var ty = tile[1];
  var zoom = tile[2];
  var min = pixelsToMeters([tx * tileSize, ty * tileSize, zoom]);
  var max = pixelsToMeters([(tx + 1) * tileSize, (ty + 1) * tileSize, zoom]);
  return [min[0], min[1], max[0], max[1]];
}

/**
 * Converts TMS Tile to bbox in LngLat coordinates.
 *
 * @param {Tile} tile Tile [x, y, zoom]
 * @param {number} x TMS Tile X
 * @param {number} y TMS Tile Y
 * @param {number} zoom Zoom level
 * @param {boolean} [validate=true] validates Tile
 * @returns {BBox} bbox extent in [minX, minY, maxX, maxY] order
 * @example
 * var bbox = globalMercator.tileToBBox([6963, 5003, 13])
 * //=[ 125.991, 36.985, 126.035, 37.020 ]
 */
export function tileToBBox(tile, validate) {
  validateTile(tile, validate);

  var tx = tile[0];
  var ty = tile[1];
  var zoom = tile[2];
  if (zoom === 0) {
    return [-180, -85.051129, 180, 85.051129];
  }
  var bbox = tileToBBoxMeters([tx, ty, zoom]);
  var mx1 = bbox[0];
  var my1 = bbox[1];
  var mx2 = bbox[2];
  var my2 = bbox[3];
  var min = metersToLngLat([mx1, my1, zoom]);
  var max = metersToLngLat([mx2, my2, zoom]);
  return [min[0], min[1], max[0], max[1]];
}

/**
 * Converts Google (XYZ) Tile to bbox in Meters coordinates.
 *
 * @param {Google} google Google [x, y, zoom]
 * @returns {BBox} bbox extent in [minX, minY, maxX, maxY] order
 * @example
 * var bbox = globalMercator.googleToBBoxMeters([6963, 3188, 13])
 * //=[ 14025277.4, 4437016.6, 14030169.4, 4441908.5 ]
 */
export function googleToBBoxMeters(google) {
  var Tile = googleToTile(google);
  return tileToBBoxMeters(Tile);
}

/**
 * Converts Google (XYZ) Tile to bbox in LngLat coordinates.
 *
 * @param {Google} google Google [x, y, zoom]
 * @returns {BBox} bbox extent in [minX, minY, maxX, maxY] order
 * @example
 * var bbox = globalMercator.googleToBBox([6963, 3188, 13])
 * //=[ 125.991, 36.985, 126.035, 37.020 ]
 */
export function googleToBBox(google) {
  var Tile = googleToTile(google);
  return tileToBBox(Tile);
}

/**
 * Converts TMS Tile to Google (XYZ) Tile.
 *
 * @param {Tile} tile Tile [x, y, zoom]
 * @param {boolean} [validate=true] validates Tile
 * @returns {Google} Google (XYZ) Tile
 * @example
 * var google = globalMercator.tileToGoogle([6963, 5003, 13])
 * //=[ 6963, 3188, 13 ]
 */
export function tileToGoogle(tile, validate) {
  validateTile(tile, validate);

  var tx = tile[0];
  var ty = tile[1];
  var zoom = tile[2];
  if (zoom === 0) {
    return [0, 0, 0];
  }
  var x = tx;
  var y = Math.pow(2, zoom) - 1 - ty;
  return [x, y, zoom];
}

/**
 * Converts Google (XYZ) Tile to TMS Tile.
 *
 * @param {Google} google Google [x, y, zoom]
 * @returns {Tile} TMS Tile
 * @example
 * var tile = globalMercator.googleToTile([6963, 3188, 13])
 * //=[ 6963, 5003, 13 ]
 */
export function googleToTile(google) {
  var x = google[0];
  var y = google[1];
  var zoom = google[2];
  var tx = x;
  var ty = Math.pow(2, zoom) - y - 1;
  return [tx, ty, zoom];
}

/**
 * Converts Google (XYZ) Tile to Quadkey.
 *
 * @param {Google} google Google [x, y, zoom]
 * @returns {string} Microsoft's Quadkey schema
 * @example
 * var quadkey = globalMercator.googleToQuadkey([6963, 3188, 13])
 * //='1321102330211'
 */
export function googleToQuadkey(google) {
  var Tile = googleToTile(google);
  return tileToQuadkey(Tile);
}

/**
 * Converts TMS Tile to QuadKey.
 *
 * @param {Tile} tile Tile [x, y, zoom]
 * @param {boolean} [validate=true] validates Tile
 * @returns {string} Microsoft's Quadkey schema
 * @example
 * var quadkey = globalMercator.tileToQuadkey([6963, 5003, 13])
 * //='1321102330211'
 */
export function tileToQuadkey(tile, validate) {
  validateTile(tile, validate);

  var tx = tile[0];
  var ty = tile[1];
  var zoom = tile[2];
  // Zoom 0 does not exist for Quadkey
  if (zoom === 0) {
    return "";
  }
  var quadkey = "";
  ty = Math.pow(2, zoom) - 1 - ty;
  range(zoom, 0, -1).map(function (i) {
    var digit = 0;
    var mask = 1 << (i - 1);
    if ((tx & mask) !== 0) {
      digit += 1;
    }
    if ((ty & mask) !== 0) {
      digit += 2;
    }
    quadkey = quadkey.concat(digit);
  });
  return quadkey;
}

/**
 * Converts Quadkey to TMS Tile.
 *
 * @param {string} quadkey Microsoft's Quadkey schema
 * @returns {Tile} TMS Tile
 * @example
 * var tile = globalMercator.quadkeyToTile('1321102330211')
 * //=[ 6963, 5003, 13 ]
 */
export function quadkeyToTile(quadkey) {
  var Google = quadkeyToGoogle(quadkey);
  return googleToTile(Google);
}

/**
 * Converts Quadkey to Google (XYZ) Tile.
 *
 * @param {string} quadkey Microsoft's Quadkey schema
 * @returns {Google} Google (XYZ) Tile
 * @example
 * var google = globalMercator.quadkeyToGoogle('1321102330211')
 * //=[ 6963, 3188, 13 ]
 */
export function quadkeyToGoogle(quadkey) {
  var x = 0;
  var y = 0;
  var zoom = quadkey.length;
  range(zoom, 0, -1).map(function (i) {
    var mask = 1 << (i - 1);
    switch (parseInt(quadkey[zoom - i], 0)) {
      case 0:
        break;
      case 1:
        x += mask;
        break;
      case 2:
        y += mask;
        break;
      case 3:
        x += mask;
        y += mask;
        break;
      default:
        throw new Error("Invalid Quadkey digit sequence");
    }
  });
  return [x, y, zoom];
}

/**
 * Converts BBox from LngLat coordinates to Meters coordinates
 *
 * @param {BBox} bbox extent in [minX, minY, maxX, maxY] order
 * @returns {BBox} bbox extent in [minX, minY, maxX, maxY] order
 * @example
 * var meters = globalMercator.bboxToMeters([ 125, 35, 127, 37 ])
 * //=[ 13914936.3, 4163881.1, 14137575.3, 4439106.7 ]
 */
export function bboxToMeters(bbox) {
  var min = lngLatToMeters([bbox[0], bbox[1]]);
  var max = lngLatToMeters([bbox[2], bbox[3]]);
  return [min[0], min[1], max[0], max[1]];
}

/**
 * Validates TMS Tile.
 *
 * @param {Tile} tile Tile [x, y, zoom]
 * @param {boolean} [validate=true] validates Tile
 * @throws {Error} Will throw an error if TMS Tile is not valid.
 * @returns {Tile} TMS Tile
 * @example
 * globalMercator.validateTile([60, 80, 12])
 * //=[60, 80, 12]
 * globalMercator.validateTile([60, -43, 5])
 * //= Error: Tile <y> must not be less than 0
 * globalMercator.validateTile([25, 60, 3])
 * //= Error: Illegal parameters for tile
 */
export function validateTile(tile, validate) {
  var tx = tile[0];
  var ty = tile[1];
  var zoom = tile[2];
  if (validate === false) return tile;
  if (zoom === undefined || zoom === null)
    throw new Error("<zoom> is required");
  if (tx === undefined || tx === null) throw new Error("<x> is required");
  if (ty === undefined || ty === null) throw new Error("<y> is required");

  // Adjust values of tiles to fit within tile scheme
  zoom = validateZoom(zoom);
  tile = wrapTile(tile);

  // // Check to see if tile is valid based on the zoom level
  // // Currently impossible to hit since WrapTile handles this error
  // // will keep this test commented out in case it doesnt handle it
  // var maxCount = Math.pow(2, zoom)
  // if (tile[0] >= maxCount || tile[1] >= maxCount) throw new Error('Illegal parameters for tile')
  return tile;
}

/**
 * Wrap Tile -- Handles tiles which crosses the 180th meridian or 90th parallel
 *
 * @param {[number, number, number]} tile Tile
 * @param {number} zoom Zoom Level
 * @returns {[number, number, number]} Wrapped Tile
 * @example
 * globalMercator.wrapTile([0, 3, 2])
 * //= [0, 3, 2] -- Valid Tile X
 * globalMercator.wrapTile([4, 2, 2])
 * //= [0, 2, 2] -- Tile 4 does not exist, wrap around to TileX=0
 */
export function wrapTile(tile) {
  var tx = tile[0];
  var ty = tile[1];
  var zoom = tile[2];

  // Maximum tile allowed
  // zoom 0 => 1
  // zoom 1 => 2
  // zoom 2 => 4
  // zoom 3 => 8
  var maxTile = Math.pow(2, zoom);

  // Handle Tile X
  tx = tx % maxTile;
  if (tx < 0) tx = tx + maxTile;

  return [tx, ty, zoom];
}

/**
 * Validates Zoom level
 *
 * @param {number} zoom Zoom level
 * @param {boolean} [validate=true] validates Zoom level
 * @throws {Error} Will throw an error if zoom is not valid.
 * @returns {number} zoom Zoom level
 * @example
 * globalMercator.validateZoom(12)
 * //=12
 * globalMercator.validateZoom(-4)
 * //= Error: <zoom> cannot be less than 0
 * globalMercator.validateZoom(32)
 * //= Error: <zoom> cannot be greater than 30
 */
export function validateZoom(zoom) {
  if (zoom === false) return zoom;
  if (zoom === undefined || zoom === null) {
    throw new Error("<zoom> is required");
  }
  if (zoom < 0) {
    throw new Error("<zoom> cannot be less than 0");
  }
  if (zoom > 32) {
    throw new Error("<zoom> cannot be greater than 32");
  }
  return zoom;
}

/**
 * Validates LngLat coordinates
 *
 * @param {[number, number]} lnglat [Longitude, Latitude]
 * @param {boolean} [validate=true] validates LatLng coordinates
 * @throws {Error} Will throw an error if LngLat is not valid.
 * @returns {LngLat} LngLat coordinates
 * @example
 * globalMercator.validateLngLat([-115, 44])
 * //= [ -115, 44 ]
 * globalMercator.validateLngLat([-225, 44])
 * //= Error: LngLat [lng] must be within -180 to 180 degrees
 */
export function validateLngLat(lnglat, validate) {
  if (validate === false) return lnglat;

  var lng = longitude(lnglat[0]);
  var lat = latitude(lnglat[1]);

  // Global Mercator does not support latitudes within 85 to 90 degrees
  if (lat > 85) lat = 85;
  if (lat < -85) lat = -85;
  return [lng, lat];
}

/**
 * Retrieve resolution based on zoom level
 *
 * @private
 * @param {number} zoom zoom level
 * @param {number} [tileSize=256] Tile size
 * @returns {number} resolution
 * @example
 * var res = globalMercator.resolution(13)
 * //=19.109257071294063
 */
export function resolution(zoom, tileSize) {
  return initialResolution(tileSize) / Math.pow(2, zoom);
}

/**
 * Generate an integer Array containing an arithmetic progression.
 *
 * @private
 * @param {number} [start=0] Start
 * @param {number} stop Stop
 * @param {number} [step=1] Step
 * @returns {number[]} range
 * @example
 * globalMercator.range(3)
 * //=[ 0, 1, 2 ]
 * globalMercator.range(3, 6)
 * //=[ 3, 4, 5 ]
 * globalMercator.range(6, 3, -1)
 * //=[ 6, 5, 4 ]
 */
export function range(start, stop, step) {
  if (stop == null) {
    stop = start || 0;
    start = 0;
  }
  if (!step) {
    step = stop < start ? -1 : 1;
  }
  var length = Math.max(Math.ceil((stop - start) / step), 0);
  var range = Array(length);
  for (var idx = 0; idx < length; idx++, start += step) {
    range[idx] = start;
  }
  return range;
}

/**
 * Maximum extent of BBox
 *
 * @param {BBox|BBox[]} array BBox [west, south, east, north]
 * @returns {BBox} Maximum BBox
 * @example
 * var bbox = globalMercator.maxBBox([[-20, -30, 20, 30], [-110, -30, 120, 80]])
 * //=[-110, -30, 120, 80]
 */
export function maxBBox(array) {
  if (!array) throw new Error("array is required");

  // Single BBox
  if (array && array[0] && array.length === 4 && array[0][0] === undefined) {
    return array;
  }

  // Multiple BBox
  if (array && array[0] && array[0][0] !== undefined) {
    var west = array[0][0];
    var south = array[0][1];
    var east = array[0][2];
    var north = array[0][3];

    array.map(function (bbox) {
      if (bbox[0] < west) {
        west = bbox[0];
      }
      if (bbox[1] < south) {
        south = bbox[1];
      }
      if (bbox[2] > east) {
        east = bbox[2];
      }
      if (bbox[3] > north) {
        north = bbox[3];
      }
    });
    return [west, south, east, north];
  }
}

/**
 * Valid TMS Tile
 *
 * @param {Tile} tile Tile [x, y, zoom]
 * @returns {boolean} valid tile true/false
 * @example
 * globalMercator.validTile([60, 80, 12])
 * //= true
 * globalMercator.validTile([60, -43, 5])
 * //= false
 * globalMercator.validTile([25, 60, 3])
 * //= false
 */
export function validTile(tile) {
  try {
    validateTile(tile);
    return true;
  } catch (e) {
    return false;
  }
}

/**
 * Modifies a Latitude to fit within +/-90 degrees.
 *
 * @param {number} lat latitude to modify
 * @returns {number} modified latitude
 * @example
 * globalMercator.latitude(100)
 * //= -80
 */
export function latitude(lat) {
  if (lat === undefined || lat === null) throw new Error("lat is required");

  // Latitudes cannot extends beyond +/-90 degrees
  if (lat > 90 || lat < -90) {
    lat = lat % 180;
    if (lat > 90) lat = -180 + lat;
    if (lat < -90) lat = 180 + lat;
    if (lat === 0) lat = 0;
  }
  return lat;
}

/**
 * Modifies a Longitude to fit within +/-180 degrees.
 *
 * @param {number} lng longitude to modify
 * @returns {number} modified longitude
 * @example
 * globalMercator.longitude(190)
 * //= -170
 */
export function longitude(lng) {
  if (lng === undefined || lng === null) throw new Error("lng is required");

  // lngitudes cannot extends beyond +/-90 degrees
  if (lng > 180 || lng < -180) {
    lng = lng % 360;
    if (lng > 180) lng = -360 + lng;
    if (lng < -180) lng = 360 + lng;
    if (lng === 0) lng = 0;
  }
  return lng;
}

/**
 * Get the smallest tile to cover a bbox
 *
 * @param {Array<number>} bbox BBox
 * @returns {Array<number>} tile Tile
 * @example
 * var tile = bboxToTile([-178, 84, -177, 85])
 * //=tile
 */
export function bboxToTile(bboxCoords) {
  var min = pointToTile([bboxCoords[0], bboxCoords[1]], 32);
  var max = pointToTile([bboxCoords[2], bboxCoords[3]], 32);
  var bbox = [min[0], min[1], max[0], max[1]];

  var z = getBboxZoom(bbox);
  if (z === 0) return [0, 0, 0];
  var x = bbox[0] >>> (32 - z);
  var y = bbox[1] >>> (32 - z);
  return [x, y, z];
}

function getBboxZoom(bbox) {
  var MAX_ZOOM = 28;
  for (var z = 0; z < MAX_ZOOM; z++) {
    var mask = 1 << (32 - (z + 1));
    if (
      (bbox[0] & mask) !== (bbox[2] & mask) ||
      (bbox[1] & mask) !== (bbox[3] & mask)
    ) {
      return z;
    }
  }

  return MAX_ZOOM;
}