styled-map-package-api 5.0.0-pre.0

package/dist/utils/fetch.cjs

@@ -0,0 +1,97 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fetch_exports = {};
+__export(fetch_exports, {
+  FetchQueue: () => FetchQueue
+});
+module.exports = __toCommonJS(fetch_exports);
+var import_ky = __toESM(require("ky"), 1);
+var import_p_limit = __toESM(require("p-limit"), 1);
+var import_streams = require('./streams.cjs');
+class FetchQueue {
+  /** @type {import('p-limit').LimitFunction} */
+  #limit;
+  /** @param {number} concurrency */
+  constructor(concurrency) {
+    this.#limit = (0, import_p_limit.default)(concurrency);
+  }
+  get activeCount() {
+    return this.#limit.activeCount;
+  }
+  /**
+   * Fetch a URL, limiting the number of concurrent downloads. Resolves with a
+   * `DownloadResponse`, which is a parsed from the Fetch `Response` objects,
+   * with `body` as a web ReadableStream, and the MIME type and content length
+   * of the response.
+   *
+   * NB: The response body stream must be consumed to the end, otherwise the
+   * queue will never be emptied.
+   *
+   * @param {string} url
+   * @param {{ onprogress?: import('./streams.js').ProgressCallback }} opts
+   * @returns {Promise<DownloadResponse>}
+   */
+  fetch(url, { onprogress } = {}) {
+    return new Promise((resolveResponse, rejectResponse) => {
+      this.#limit(fetchStream, {
+        url,
+        onresponse: resolveResponse,
+        onerror: rejectResponse,
+        onprogress
+      });
+    });
+  }
+}
+async function fetchStream({ url, onresponse, onerror, onprogress }) {
+  try {
+    const response = await (0, import_ky.default)(url, { retry: 3 });
+    if (!response.body) {
+      throw new Error("No body in response");
+    }
+    const contentType = response.headers.get("content-type");
+    const mimeType = typeof contentType === "string" ? contentType.split(";")[0] : null;
+    const contentLengthHeader = response.headers.get("content-length");
+    const contentLength = contentLengthHeader === null ? null : parseInt(contentLengthHeader, 10);
+    const passthrough = new TransformStream();
+    const pipePromise = response.body.pipeTo(passthrough.writable);
+    let body = passthrough.readable;
+    if (onprogress) {
+      const progress = new import_streams.ProgressStream({ onprogress });
+      body = body.pipeThrough(progress);
+    }
+    onresponse({ body, mimeType, contentLength });
+    await pipePromise;
+  } catch (err) {
+    onerror(err instanceof Error ? err : new Error("Unknown error"));
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FetchQueue
+});

package/dist/utils/fetch.d.cts

@@ -0,0 +1,50 @@
+import { ProgressCallback } from './streams.cjs';
+import 'stream/web';
+
+/**
+ * @typedef {object} DownloadResponse
+ * @property {ReadableStream<Uint8Array>} body Web ReadableStream of the response body
+ * @property {string | null} mimeType Content mime-type (from http content-type header)
+ * @property {number | null} contentLength Content length in bytes (from http content-length header)
+ */
+/**
+ * A wrapper for fetch that limits the number of concurrent downloads.
+ */
+declare class FetchQueue {
+    /** @param {number} concurrency */
+    constructor(concurrency: number);
+    get activeCount(): number;
+    /**
+     * Fetch a URL, limiting the number of concurrent downloads. Resolves with a
+     * `DownloadResponse`, which is a parsed from the Fetch `Response` objects,
+     * with `body` as a web ReadableStream, and the MIME type and content length
+     * of the response.
+     *
+     * NB: The response body stream must be consumed to the end, otherwise the
+     * queue will never be emptied.
+     *
+     * @param {string} url
+     * @param {{ onprogress?: import('./streams.js').ProgressCallback }} opts
+     * @returns {Promise<DownloadResponse>}
+     */
+    fetch(url: string, { onprogress }?: {
+        onprogress?: ProgressCallback;
+    }): Promise<DownloadResponse>;
+    #private;
+}
+type DownloadResponse = {
+    /**
+     * Web ReadableStream of the response body
+     */
+    body: ReadableStream<Uint8Array>;
+    /**
+     * Content mime-type (from http content-type header)
+     */
+    mimeType: string | null;
+    /**
+     * Content length in bytes (from http content-length header)
+     */
+    contentLength: number | null;
+};
+
+export { type DownloadResponse, FetchQueue };

package/dist/utils/fetch.d.ts

@@ -0,0 +1,50 @@
+import { ProgressCallback } from './streams.js';
+import 'stream/web';
+
+/**
+ * @typedef {object} DownloadResponse
+ * @property {ReadableStream<Uint8Array>} body Web ReadableStream of the response body
+ * @property {string | null} mimeType Content mime-type (from http content-type header)
+ * @property {number | null} contentLength Content length in bytes (from http content-length header)
+ */
+/**
+ * A wrapper for fetch that limits the number of concurrent downloads.
+ */
+declare class FetchQueue {
+    /** @param {number} concurrency */
+    constructor(concurrency: number);
+    get activeCount(): number;
+    /**
+     * Fetch a URL, limiting the number of concurrent downloads. Resolves with a
+     * `DownloadResponse`, which is a parsed from the Fetch `Response` objects,
+     * with `body` as a web ReadableStream, and the MIME type and content length
+     * of the response.
+     *
+     * NB: The response body stream must be consumed to the end, otherwise the
+     * queue will never be emptied.
+     *
+     * @param {string} url
+     * @param {{ onprogress?: import('./streams.js').ProgressCallback }} opts
+     * @returns {Promise<DownloadResponse>}
+     */
+    fetch(url: string, { onprogress }?: {
+        onprogress?: ProgressCallback;
+    }): Promise<DownloadResponse>;
+    #private;
+}
+type DownloadResponse = {
+    /**
+     * Web ReadableStream of the response body
+     */
+    body: ReadableStream<Uint8Array>;
+    /**
+     * Content mime-type (from http content-type header)
+     */
+    mimeType: string | null;
+    /**
+     * Content length in bytes (from http content-length header)
+     */
+    contentLength: number | null;
+};
+
+export { type DownloadResponse, FetchQueue };

package/dist/utils/fetch.js

@@ -0,0 +1,63 @@
+import ky from "ky";
+import pLimit from "p-limit";
+import { ProgressStream } from "./streams.js";
+class FetchQueue {
+  /** @type {import('p-limit').LimitFunction} */
+  #limit;
+  /** @param {number} concurrency */
+  constructor(concurrency) {
+    this.#limit = pLimit(concurrency);
+  }
+  get activeCount() {
+    return this.#limit.activeCount;
+  }
+  /**
+   * Fetch a URL, limiting the number of concurrent downloads. Resolves with a
+   * `DownloadResponse`, which is a parsed from the Fetch `Response` objects,
+   * with `body` as a web ReadableStream, and the MIME type and content length
+   * of the response.
+   *
+   * NB: The response body stream must be consumed to the end, otherwise the
+   * queue will never be emptied.
+   *
+   * @param {string} url
+   * @param {{ onprogress?: import('./streams.js').ProgressCallback }} opts
+   * @returns {Promise<DownloadResponse>}
+   */
+  fetch(url, { onprogress } = {}) {
+    return new Promise((resolveResponse, rejectResponse) => {
+      this.#limit(fetchStream, {
+        url,
+        onresponse: resolveResponse,
+        onerror: rejectResponse,
+        onprogress
+      });
+    });
+  }
+}
+async function fetchStream({ url, onresponse, onerror, onprogress }) {
+  try {
+    const response = await ky(url, { retry: 3 });
+    if (!response.body) {
+      throw new Error("No body in response");
+    }
+    const contentType = response.headers.get("content-type");
+    const mimeType = typeof contentType === "string" ? contentType.split(";")[0] : null;
+    const contentLengthHeader = response.headers.get("content-length");
+    const contentLength = contentLengthHeader === null ? null : parseInt(contentLengthHeader, 10);
+    const passthrough = new TransformStream();
+    const pipePromise = response.body.pipeTo(passthrough.writable);
+    let body = passthrough.readable;
+    if (onprogress) {
+      const progress = new ProgressStream({ onprogress });
+      body = body.pipeThrough(progress);
+    }
+    onresponse({ body, mimeType, contentLength });
+    await pipePromise;
+  } catch (err) {
+    onerror(err instanceof Error ? err : new Error("Unknown error"));
+  }
+}
+export {
+  FetchQueue
+};

package/dist/utils/file-formats.cjs

@@ -0,0 +1,96 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var file_formats_exports = {};
+__export(file_formats_exports, {
+  getFormatFromMimeType: () => getFormatFromMimeType,
+  getTileFormatFromBuffer: () => getTileFormatFromBuffer,
+  getTileFormatFromStream: () => getTileFormatFromStream
+});
+module.exports = __toCommonJS(file_formats_exports);
+var import_misc = require('./misc.cjs');
+const MAGIC_BYTES = (
+  /** @type {const} */
+  {
+    png: [137, 80, 78, 71, 13, 10, 26, 10],
+    jpg: [255, 216, 255],
+    // eslint-disable-next-line no-sparse-arrays
+    webp: [82, 73, 70, 70, , , , , 87, 69, 66, 80],
+    // Include the compression-type byte, which is always 0x08 (DEFLATE) for gzip
+    gz: [31, 139, 8]
+  }
+);
+const MIME_TYPES = (
+  /** @type {const} */
+  {
+    "image/png": "png",
+    "image/jpeg": "jpg",
+    "image/webp": "webp"
+  }
+);
+const magicByteMap = /* @__PURE__ */ new Map();
+for (const [ext, bytes] of Object.entries(MAGIC_BYTES)) {
+  magicByteMap.set(
+    bytes[0],
+    // @ts-ignore
+    ext
+  );
+}
+function getTileFormatFromBuffer(buf) {
+  const ext = magicByteMap.get(buf[0]);
+  if (!ext) {
+    throw new Error("Unknown file type");
+  }
+  const sig = MAGIC_BYTES[ext];
+  for (let i = 1; i < sig.length; i++) {
+    if (typeof sig[i] !== "undefined" && sig[i] !== buf[i]) {
+      throw new Error("Unknown file type");
+    }
+  }
+  if (ext === "gz") {
+    return "mvt";
+  }
+  return ext;
+}
+async function getTileFormatFromStream(tileData) {
+  const [stream1, stream2] = tileData.tee();
+  const reader = stream1.getReader();
+  let buffer = new Uint8Array(0);
+  while (buffer.length < 12) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    const newBuffer = new Uint8Array(buffer.length + value.length);
+    newBuffer.set(buffer);
+    newBuffer.set(value, buffer.length);
+    buffer = newBuffer;
+  }
+  reader.cancel();
+  const format = getTileFormatFromBuffer(buffer);
+  return [format, stream2];
+}
+function getFormatFromMimeType(mimeType) {
+  if (mimeType.startsWith("application/")) return "mvt";
+  if ((0, import_misc.hasOwn)(MIME_TYPES, mimeType)) return MIME_TYPES[mimeType];
+  throw new Error("Unsupported MIME type " + mimeType);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getFormatFromMimeType,
+  getTileFormatFromBuffer,
+  getTileFormatFromStream
+});

package/dist/utils/file-formats.d.cts

@@ -0,0 +1,33 @@
+import { c as TileFormat } from '../types-CJq90eOB.cjs';
+import '@maplibre/maplibre-gl-style-spec';
+import 'geojson';
+import 'type-fest';
+import 'events';
+
+/**
+ * For a given buffer, determine the tile format based on the magic bytes.
+ * Will throw for unknown file types.
+ * Smaller and faster version of magic-bytes.js due to the limited use case.
+ *
+ * @param {Buffer | Uint8Array} buf
+ * @returns {import("../writer.js").TileFormat}
+ */
+declare function getTileFormatFromBuffer(buf: Buffer | Uint8Array): TileFormat;
+/**
+ * Determine the tile format from a readable stream from the magic bytes at the
+ * start of the file. Used if data is served without a content-type header.
+ * Returns the format and a new readable stream that includes all original data.
+ *
+ * @param {ReadableStream<Uint8Array>} tileData Web ReadableStream
+ * @returns {Promise<[import("../writer.js").TileFormat, ReadableStream<Uint8Array>]>}
+ */
+declare function getTileFormatFromStream(tileData: ReadableStream<Uint8Array>): Promise<[TileFormat, ReadableStream<Uint8Array>]>;
+/**
+ * Get the tile format from a MIME type. Throws for unsupported types.
+ *
+ * @param {string} mimeType
+ * @returns {import("../writer.js").TileFormat}
+ */
+declare function getFormatFromMimeType(mimeType: string): TileFormat;
+
+export { getFormatFromMimeType, getTileFormatFromBuffer, getTileFormatFromStream };

package/dist/utils/file-formats.d.ts

@@ -0,0 +1,33 @@
+import { c as TileFormat } from '../types-CJq90eOB.js';
+import '@maplibre/maplibre-gl-style-spec';
+import 'geojson';
+import 'type-fest';
+import 'events';
+
+/**
+ * For a given buffer, determine the tile format based on the magic bytes.
+ * Will throw for unknown file types.
+ * Smaller and faster version of magic-bytes.js due to the limited use case.
+ *
+ * @param {Buffer | Uint8Array} buf
+ * @returns {import("../writer.js").TileFormat}
+ */
+declare function getTileFormatFromBuffer(buf: Buffer | Uint8Array): TileFormat;
+/**
+ * Determine the tile format from a readable stream from the magic bytes at the
+ * start of the file. Used if data is served without a content-type header.
+ * Returns the format and a new readable stream that includes all original data.
+ *
+ * @param {ReadableStream<Uint8Array>} tileData Web ReadableStream
+ * @returns {Promise<[import("../writer.js").TileFormat, ReadableStream<Uint8Array>]>}
+ */
+declare function getTileFormatFromStream(tileData: ReadableStream<Uint8Array>): Promise<[TileFormat, ReadableStream<Uint8Array>]>;
+/**
+ * Get the tile format from a MIME type. Throws for unsupported types.
+ *
+ * @param {string} mimeType
+ * @returns {import("../writer.js").TileFormat}
+ */
+declare function getFormatFromMimeType(mimeType: string): TileFormat;
+
+export { getFormatFromMimeType, getTileFormatFromBuffer, getTileFormatFromStream };

package/dist/utils/file-formats.js

@@ -0,0 +1,70 @@
+import { hasOwn } from "./misc.js";
+const MAGIC_BYTES = (
+  /** @type {const} */
+  {
+    png: [137, 80, 78, 71, 13, 10, 26, 10],
+    jpg: [255, 216, 255],
+    // eslint-disable-next-line no-sparse-arrays
+    webp: [82, 73, 70, 70, , , , , 87, 69, 66, 80],
+    // Include the compression-type byte, which is always 0x08 (DEFLATE) for gzip
+    gz: [31, 139, 8]
+  }
+);
+const MIME_TYPES = (
+  /** @type {const} */
+  {
+    "image/png": "png",
+    "image/jpeg": "jpg",
+    "image/webp": "webp"
+  }
+);
+const magicByteMap = /* @__PURE__ */ new Map();
+for (const [ext, bytes] of Object.entries(MAGIC_BYTES)) {
+  magicByteMap.set(
+    bytes[0],
+    // @ts-ignore
+    ext
+  );
+}
+function getTileFormatFromBuffer(buf) {
+  const ext = magicByteMap.get(buf[0]);
+  if (!ext) {
+    throw new Error("Unknown file type");
+  }
+  const sig = MAGIC_BYTES[ext];
+  for (let i = 1; i < sig.length; i++) {
+    if (typeof sig[i] !== "undefined" && sig[i] !== buf[i]) {
+      throw new Error("Unknown file type");
+    }
+  }
+  if (ext === "gz") {
+    return "mvt";
+  }
+  return ext;
+}
+async function getTileFormatFromStream(tileData) {
+  const [stream1, stream2] = tileData.tee();
+  const reader = stream1.getReader();
+  let buffer = new Uint8Array(0);
+  while (buffer.length < 12) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    const newBuffer = new Uint8Array(buffer.length + value.length);
+    newBuffer.set(buffer);
+    newBuffer.set(value, buffer.length);
+    buffer = newBuffer;
+  }
+  reader.cancel();
+  const format = getTileFormatFromBuffer(buffer);
+  return [format, stream2];
+}
+function getFormatFromMimeType(mimeType) {
+  if (mimeType.startsWith("application/")) return "mvt";
+  if (hasOwn(MIME_TYPES, mimeType)) return MIME_TYPES[mimeType];
+  throw new Error("Unsupported MIME type " + mimeType);
+}
+export {
+  getFormatFromMimeType,
+  getTileFormatFromBuffer,
+  getTileFormatFromStream
+};

package/dist/utils/geo.cjs

@@ -0,0 +1,84 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var geo_exports = {};
+__export(geo_exports, {
+  MAX_BOUNDS: () => MAX_BOUNDS,
+  getQuadkey: () => getQuadkey,
+  getTileUrl: () => getTileUrl,
+  tileToBBox: () => tileToBBox,
+  unionBBox: () => unionBBox
+});
+module.exports = __toCommonJS(geo_exports);
+const r2d = 180 / Math.PI;
+const MAX_BOUNDS = (
+  /** @type {BBox} */
+  [
+    -180,
+    -85.051129,
+    180,
+    85.051129
+  ]
+);
+function tileToBBox({ x, y, z }) {
+  const e = tile2lon({ x: x + 1, z });
+  const w = tile2lon({ x, z });
+  const s = tile2lat({ y: y + 1, z });
+  const n = tile2lat({ y, z });
+  return [w, s, e, n];
+}
+function getQuadkey({ x, y, z }) {
+  let quadkey = "";
+  let mask;
+  for (let i = z; i > 0; i--) {
+    mask = 1 << i - 1;
+    quadkey += (x & mask ? 1 : 0) + (y & mask ? 2 : 0);
+  }
+  return quadkey;
+}
+function getTileUrl(urls, { x, y, z, scheme = "xyz" }) {
+  const bboxEspg3857 = tileToBBox({ x, y: Math.pow(2, z) - y - 1, z });
+  const quadkey = getQuadkey({ x, y, z });
+  return urls[(x + y) % urls.length].replace("{prefix}", (x % 16).toString(16) + (y % 16).toString(16)).replace(/{z}/g, String(z)).replace(/{x}/g, String(x)).replace(/{y}/g, String(scheme === "tms" ? Math.pow(2, z) - y - 1 : y)).replace("{quadkey}", quadkey).replace("{bbox-epsg-3857}", bboxEspg3857.join(","));
+}
+function unionBBox(bboxes) {
+  let [w, s, e, n] = bboxes[0];
+  for (let i = 1; i < bboxes.length; i++) {
+    const [w1, s1, e1, n1] = bboxes[i];
+    w = Math.min(w, w1);
+    s = Math.min(s, s1);
+    e = Math.max(e, e1);
+    n = Math.max(n, n1);
+  }
+  return [w, s, e, n];
+}
+function tile2lon({ x, z }) {
+  return x / Math.pow(2, z) * 360 - 180;
+}
+function tile2lat({ y, z }) {
+  const n = Math.PI - 2 * Math.PI * y / Math.pow(2, z);
+  return r2d * Math.atan(0.5 * (Math.exp(n) - Math.exp(-n)));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MAX_BOUNDS,
+  getQuadkey,
+  getTileUrl,
+  tileToBBox,
+  unionBBox
+});

package/dist/utils/geo.d.cts

@@ -0,0 +1,46 @@
+/**
+ * @typedef {[number, number, number, number]} BBox
+ */
+/**
+ * Return the bounding box for the given tile.
+ *
+ * @param {{ x: number, y: number, z: number }} tile
+ * @returns {BBox} Bounding Box [w, s, e, n]
+ */
+declare function tileToBBox({ x, y, z }: {
+    x: number;
+    y: number;
+    z: number;
+}): BBox;
+/**
+ * @param {{ x: number, y: number, z: number }} tile
+ */
+declare function getQuadkey({ x, y, z }: {
+    x: number;
+    y: number;
+    z: number;
+}): string;
+/**
+ * From an array of tile URL templates, get the URL for the given tile.
+ *
+ * @param {string[]} urls
+ * @param {{ x: number, y: number, z: number, scheme?: 'xyz' | 'tms' }} opts
+ */
+declare function getTileUrl(urls: string[], { x, y, z, scheme }: {
+    x: number;
+    y: number;
+    z: number;
+    scheme?: "xyz" | "tms";
+}): string;
+/**
+ * Returns a bbox that is the smallest bounding box that contains all the input bboxes.
+ *
+ * @param {[BBox, ...BBox[]]} bboxes
+ * @returns {BBox} Bounding Box [w, s, e, n]
+ */
+declare function unionBBox(bboxes: [BBox, ...BBox[]]): BBox;
+/** Spherical Mercator max bounds, rounded to 6 decimal places */
+declare const MAX_BOUNDS: BBox;
+type BBox = [number, number, number, number];
+
+export { type BBox, MAX_BOUNDS, getQuadkey, getTileUrl, tileToBBox, unionBBox };

package/dist/utils/geo.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @typedef {[number, number, number, number]} BBox
+ */
+/**
+ * Return the bounding box for the given tile.
+ *
+ * @param {{ x: number, y: number, z: number }} tile
+ * @returns {BBox} Bounding Box [w, s, e, n]
+ */
+declare function tileToBBox({ x, y, z }: {
+    x: number;
+    y: number;
+    z: number;
+}): BBox;
+/**
+ * @param {{ x: number, y: number, z: number }} tile
+ */
+declare function getQuadkey({ x, y, z }: {
+    x: number;
+    y: number;
+    z: number;
+}): string;
+/**
+ * From an array of tile URL templates, get the URL for the given tile.
+ *
+ * @param {string[]} urls
+ * @param {{ x: number, y: number, z: number, scheme?: 'xyz' | 'tms' }} opts
+ */
+declare function getTileUrl(urls: string[], { x, y, z, scheme }: {
+    x: number;
+    y: number;
+    z: number;
+    scheme?: "xyz" | "tms";
+}): string;
+/**
+ * Returns a bbox that is the smallest bounding box that contains all the input bboxes.
+ *
+ * @param {[BBox, ...BBox[]]} bboxes
+ * @returns {BBox} Bounding Box [w, s, e, n]
+ */
+declare function unionBBox(bboxes: [BBox, ...BBox[]]): BBox;
+/** Spherical Mercator max bounds, rounded to 6 decimal places */
+declare const MAX_BOUNDS: BBox;
+type BBox = [number, number, number, number];
+
+export { type BBox, MAX_BOUNDS, getQuadkey, getTileUrl, tileToBBox, unionBBox };