@loaders.gl/pmtiles 4.0.0-beta.1

package/dist/dist.min.js

@@ -0,0 +1,4436 @@
+(() => {
+  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 __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __esm = (fn, res) => function __init() {
+    return fn && (res = (0, fn[Object.keys(fn)[0]])(fn = 0)), res;
+  };
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __reExport = (target, module, desc) => {
+    if (module && typeof module === "object" || typeof module === "function") {
+      for (let key of __getOwnPropNames(module))
+        if (!__hasOwnProp.call(target, key) && key !== "default")
+          __defProp(target, key, { get: () => module[key], enumerable: !(desc = __getOwnPropDesc(module, key)) || desc.enumerable });
+    }
+    return target;
+  };
+  var __toModule = (module) => {
+    return __reExport(__markAsModule(__defProp(module != null ? __create(__getProtoOf(module)) : {}, "default", module && module.__esModule && "default" in module ? { get: () => module.default, enumerable: true } : { value: module, enumerable: true })), module);
+  };
+
+  // ../loader-utils/src/lib/env-utils/assert.ts
+  function assert(condition, message) {
+    if (!condition) {
+      throw new Error(message || "loader assertion failed.");
+    }
+  }
+  var init_assert = __esm({
+    "../loader-utils/src/lib/env-utils/assert.ts"() {
+    }
+  });
+
+  // ../loader-utils/src/lib/env-utils/globals.ts
+  var globals, self_, window_, global_, document_, isBrowser, matches, nodeVersion;
+  var init_globals = __esm({
+    "../loader-utils/src/lib/env-utils/globals.ts"() {
+      globals = {
+        self: typeof self !== "undefined" && self,
+        window: typeof window !== "undefined" && window,
+        global: typeof global !== "undefined" && global,
+        document: typeof document !== "undefined" && document
+      };
+      self_ = globals.self || globals.window || globals.global || {};
+      window_ = globals.window || globals.self || globals.global || {};
+      global_ = globals.global || globals.self || globals.window || {};
+      document_ = globals.document || {};
+      isBrowser = Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser);
+      matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
+      nodeVersion = matches && parseFloat(matches[1]) || 0;
+    }
+  });
+
+  // ../../node_modules/@babel/runtime/helpers/esm/typeof.js
+  var init_typeof = __esm({
+    "../../node_modules/@babel/runtime/helpers/esm/typeof.js"() {
+    }
+  });
+
+  // ../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js
+  var init_toPrimitive = __esm({
+    "../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js"() {
+      init_typeof();
+    }
+  });
+
+  // ../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
+  var init_toPropertyKey = __esm({
+    "../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js"() {
+      init_typeof();
+      init_toPrimitive();
+    }
+  });
+
+  // ../../node_modules/@babel/runtime/helpers/esm/defineProperty.js
+  var init_defineProperty = __esm({
+    "../../node_modules/@babel/runtime/helpers/esm/defineProperty.js"() {
+      init_toPropertyKey();
+    }
+  });
+
+  // ../loader-utils/src/lib/path-utils/file-aliases.ts
+  function resolvePath(filename) {
+    for (const alias in fileAliases) {
+      if (filename.startsWith(alias)) {
+        const replacement = fileAliases[alias];
+        filename = filename.replace(alias, replacement);
+      }
+    }
+    if (!filename.startsWith("http://") && !filename.startsWith("https://")) {
+      filename = `${pathPrefix}${filename}`;
+    }
+    return filename;
+  }
+  var pathPrefix, fileAliases;
+  var init_file_aliases = __esm({
+    "../loader-utils/src/lib/path-utils/file-aliases.ts"() {
+      pathPrefix = "";
+      fileAliases = {};
+    }
+  });
+
+  // ../loader-utils/src/lib/sources/data-source.ts
+  function getFetchFunction(options) {
+    const fetchFunction = options?.fetch;
+    if (fetchFunction && typeof fetchFunction === "function") {
+      return (url, fetchOptions2) => fetchFunction(url, fetchOptions2);
+    }
+    const fetchOptions = options?.fetch;
+    if (fetchOptions && typeof fetchOptions !== "function") {
+      return (url) => fetch(url, fetchOptions);
+    }
+    return (url) => fetch(url);
+  }
+  var DataSource;
+  var init_data_source = __esm({
+    "../loader-utils/src/lib/sources/data-source.ts"() {
+      DataSource = class {
+        constructor(props) {
+          this._needsRefresh = true;
+          this.props = { ...props };
+          this.loadOptions = { ...props.loadOptions };
+          this.fetch = getFetchFunction(this.loadOptions);
+        }
+        setProps(props) {
+          this.props = Object.assign(this.props, props);
+          this.setNeedsRefresh();
+        }
+        setNeedsRefresh() {
+          this._needsRefresh = true;
+        }
+        getNeedsRefresh(clear = true) {
+          const needsRefresh = this._needsRefresh;
+          if (clear) {
+            this._needsRefresh = false;
+          }
+          return needsRefresh;
+        }
+      };
+    }
+  });
+
+  // ../loader-utils/src/index.ts
+  var init_src = __esm({
+    "../loader-utils/src/index.ts"() {
+      init_assert();
+      init_globals();
+      init_file_aliases();
+      init_data_source();
+    }
+  });
+
+  // ../images/src/lib/utils/version.ts
+  var VERSION;
+  var init_version = __esm({
+    "../images/src/lib/utils/version.ts"() {
+      VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+    }
+  });
+
+  // ../images/src/lib/category-api/image-type.ts
+  function isImageTypeSupported(type) {
+    switch (type) {
+      case "auto":
+        return IMAGE_BITMAP_SUPPORTED || IMAGE_SUPPORTED || DATA_SUPPORTED;
+      case "imagebitmap":
+        return IMAGE_BITMAP_SUPPORTED;
+      case "image":
+        return IMAGE_SUPPORTED;
+      case "data":
+        return DATA_SUPPORTED;
+      default:
+        throw new Error(`@loaders.gl/images: image ${type} not supported in this environment`);
+    }
+  }
+  function getDefaultImageType() {
+    if (IMAGE_BITMAP_SUPPORTED) {
+      return "imagebitmap";
+    }
+    if (IMAGE_SUPPORTED) {
+      return "image";
+    }
+    if (DATA_SUPPORTED) {
+      return "data";
+    }
+    throw new Error("Install '@loaders.gl/polyfills' to parse images under Node.js");
+  }
+  var _parseImageNode, IMAGE_SUPPORTED, IMAGE_BITMAP_SUPPORTED, NODE_IMAGE_SUPPORTED, DATA_SUPPORTED;
+  var init_image_type = __esm({
+    "../images/src/lib/category-api/image-type.ts"() {
+      init_src();
+      ({ _parseImageNode } = globalThis);
+      IMAGE_SUPPORTED = typeof Image !== "undefined";
+      IMAGE_BITMAP_SUPPORTED = typeof ImageBitmap !== "undefined";
+      NODE_IMAGE_SUPPORTED = Boolean(_parseImageNode);
+      DATA_SUPPORTED = isBrowser ? true : NODE_IMAGE_SUPPORTED;
+    }
+  });
+
+  // ../images/src/lib/category-api/parsed-image-api.ts
+  function getImageType(image) {
+    const format = getImageTypeOrNull(image);
+    if (!format) {
+      throw new Error("Not an image");
+    }
+    return format;
+  }
+  function getImageData(image) {
+    switch (getImageType(image)) {
+      case "data":
+        return image;
+      case "image":
+      case "imagebitmap":
+        const canvas = document.createElement("canvas");
+        const context = canvas.getContext("2d");
+        if (!context) {
+          throw new Error("getImageData");
+        }
+        canvas.width = image.width;
+        canvas.height = image.height;
+        context.drawImage(image, 0, 0);
+        return context.getImageData(0, 0, image.width, image.height);
+      default:
+        throw new Error("getImageData");
+    }
+  }
+  function getImageTypeOrNull(image) {
+    if (typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap) {
+      return "imagebitmap";
+    }
+    if (typeof Image !== "undefined" && image instanceof Image) {
+      return "image";
+    }
+    if (image && typeof image === "object" && image.data && image.width && image.height) {
+      return "data";
+    }
+    return null;
+  }
+  var init_parsed_image_api = __esm({
+    "../images/src/lib/category-api/parsed-image-api.ts"() {
+    }
+  });
+
+  // ../images/src/lib/parsers/svg-utils.ts
+  function isSVG(url) {
+    return url && (SVG_DATA_URL_PATTERN.test(url) || SVG_URL_PATTERN.test(url));
+  }
+  function getBlobOrSVGDataUrl(arrayBuffer, url) {
+    if (isSVG(url)) {
+      const textDecoder = new TextDecoder();
+      let xmlText = textDecoder.decode(arrayBuffer);
+      try {
+        if (typeof unescape === "function" && typeof encodeURIComponent === "function") {
+          xmlText = unescape(encodeURIComponent(xmlText));
+        }
+      } catch (error) {
+        throw new Error(error.message);
+      }
+      const src = `data:image/svg+xml;base64,${btoa(xmlText)}`;
+      return src;
+    }
+    return getBlob(arrayBuffer, url);
+  }
+  function getBlob(arrayBuffer, url) {
+    if (isSVG(url)) {
+      throw new Error("SVG cannot be parsed directly to imagebitmap");
+    }
+    return new Blob([new Uint8Array(arrayBuffer)]);
+  }
+  var SVG_DATA_URL_PATTERN, SVG_URL_PATTERN;
+  var init_svg_utils = __esm({
+    "../images/src/lib/parsers/svg-utils.ts"() {
+      SVG_DATA_URL_PATTERN = /^data:image\/svg\+xml/;
+      SVG_URL_PATTERN = /\.svg((\?|#).*)?$/;
+    }
+  });
+
+  // ../images/src/lib/parsers/parse-to-image.ts
+  async function parseToImage(arrayBuffer, options, url) {
+    const blobOrDataUrl = getBlobOrSVGDataUrl(arrayBuffer, url);
+    const URL = self.URL || self.webkitURL;
+    const objectUrl = typeof blobOrDataUrl !== "string" && URL.createObjectURL(blobOrDataUrl);
+    try {
+      return await loadToImage(objectUrl || blobOrDataUrl, options);
+    } finally {
+      if (objectUrl) {
+        URL.revokeObjectURL(objectUrl);
+      }
+    }
+  }
+  async function loadToImage(url, options) {
+    const image = new Image();
+    image.src = url;
+    if (options.image && options.image.decode && image.decode) {
+      await image.decode();
+      return image;
+    }
+    return await new Promise((resolve, reject) => {
+      try {
+        image.onload = () => resolve(image);
+        image.onerror = (err2) => reject(new Error(`Could not load image ${url}: ${err2}`));
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  var init_parse_to_image = __esm({
+    "../images/src/lib/parsers/parse-to-image.ts"() {
+      init_svg_utils();
+    }
+  });
+
+  // ../images/src/lib/parsers/parse-to-image-bitmap.ts
+  async function parseToImageBitmap(arrayBuffer, options, url) {
+    let blob;
+    if (isSVG(url)) {
+      const image = await parseToImage(arrayBuffer, options, url);
+      blob = image;
+    } else {
+      blob = getBlob(arrayBuffer, url);
+    }
+    const imagebitmapOptions = options && options.imagebitmap;
+    return await safeCreateImageBitmap(blob, imagebitmapOptions);
+  }
+  async function safeCreateImageBitmap(blob, imagebitmapOptions = null) {
+    if (isEmptyObject(imagebitmapOptions) || !imagebitmapOptionsSupported) {
+      imagebitmapOptions = null;
+    }
+    if (imagebitmapOptions) {
+      try {
+        return await createImageBitmap(blob, imagebitmapOptions);
+      } catch (error) {
+        console.warn(error);
+        imagebitmapOptionsSupported = false;
+      }
+    }
+    return await createImageBitmap(blob);
+  }
+  function isEmptyObject(object) {
+    for (const key in object || EMPTY_OBJECT) {
+      return false;
+    }
+    return true;
+  }
+  var EMPTY_OBJECT, imagebitmapOptionsSupported;
+  var init_parse_to_image_bitmap = __esm({
+    "../images/src/lib/parsers/parse-to-image-bitmap.ts"() {
+      init_svg_utils();
+      init_parse_to_image();
+      EMPTY_OBJECT = {};
+      imagebitmapOptionsSupported = true;
+    }
+  });
+
+  // ../images/src/lib/category-api/parse-isobmff-binary.ts
+  function getISOBMFFMediaType(buffer) {
+    if (!checkString(buffer, "ftyp", 4)) {
+      return null;
+    }
+    if ((buffer[8] & 96) === 0) {
+      return null;
+    }
+    return decodeMajorBrand(buffer);
+  }
+  function decodeMajorBrand(buffer) {
+    const brandMajor = getUTF8String(buffer, 8, 12).replace("\0", " ").trim();
+    switch (brandMajor) {
+      case "avif":
+      case "avis":
+        return { extension: "avif", mimeType: "image/avif" };
+      default:
+        return null;
+    }
+  }
+  function getUTF8String(array, start, end) {
+    return String.fromCharCode(...array.slice(start, end));
+  }
+  function stringToBytes(string) {
+    return [...string].map((character) => character.charCodeAt(0));
+  }
+  function checkString(buffer, header, offset = 0) {
+    const headerBytes = stringToBytes(header);
+    for (let i3 = 0; i3 < headerBytes.length; ++i3) {
+      if (headerBytes[i3] !== buffer[i3 + offset]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  var init_parse_isobmff_binary = __esm({
+    "../images/src/lib/category-api/parse-isobmff-binary.ts"() {
+    }
+  });
+
+  // ../images/src/lib/category-api/binary-image-api.ts
+  function getBinaryImageMetadata(binaryData) {
+    const dataView = toDataView(binaryData);
+    return getPngMetadata(dataView) || getJpegMetadata(dataView) || getGifMetadata(dataView) || getBmpMetadata(dataView) || getISOBMFFMetadata(dataView);
+  }
+  function getISOBMFFMetadata(binaryData) {
+    const buffer = new Uint8Array(binaryData instanceof DataView ? binaryData.buffer : binaryData);
+    const mediaType = getISOBMFFMediaType(buffer);
+    if (!mediaType) {
+      return null;
+    }
+    return {
+      mimeType: mediaType.mimeType,
+      width: 0,
+      height: 0
+    };
+  }
+  function getPngMetadata(binaryData) {
+    const dataView = toDataView(binaryData);
+    const isPng = dataView.byteLength >= 24 && dataView.getUint32(0, BIG_ENDIAN) === 2303741511;
+    if (!isPng) {
+      return null;
+    }
+    return {
+      mimeType: "image/png",
+      width: dataView.getUint32(16, BIG_ENDIAN),
+      height: dataView.getUint32(20, BIG_ENDIAN)
+    };
+  }
+  function getGifMetadata(binaryData) {
+    const dataView = toDataView(binaryData);
+    const isGif = dataView.byteLength >= 10 && dataView.getUint32(0, BIG_ENDIAN) === 1195984440;
+    if (!isGif) {
+      return null;
+    }
+    return {
+      mimeType: "image/gif",
+      width: dataView.getUint16(6, LITTLE_ENDIAN),
+      height: dataView.getUint16(8, LITTLE_ENDIAN)
+    };
+  }
+  function getBmpMetadata(binaryData) {
+    const dataView = toDataView(binaryData);
+    const isBmp = dataView.byteLength >= 14 && dataView.getUint16(0, BIG_ENDIAN) === 16973 && dataView.getUint32(2, LITTLE_ENDIAN) === dataView.byteLength;
+    if (!isBmp) {
+      return null;
+    }
+    return {
+      mimeType: "image/bmp",
+      width: dataView.getUint32(18, LITTLE_ENDIAN),
+      height: dataView.getUint32(22, LITTLE_ENDIAN)
+    };
+  }
+  function getJpegMetadata(binaryData) {
+    const dataView = toDataView(binaryData);
+    const isJpeg = dataView.byteLength >= 3 && dataView.getUint16(0, BIG_ENDIAN) === 65496 && dataView.getUint8(2) === 255;
+    if (!isJpeg) {
+      return null;
+    }
+    const { tableMarkers, sofMarkers } = getJpegMarkers();
+    let i3 = 2;
+    while (i3 + 9 < dataView.byteLength) {
+      const marker = dataView.getUint16(i3, BIG_ENDIAN);
+      if (sofMarkers.has(marker)) {
+        return {
+          mimeType: "image/jpeg",
+          height: dataView.getUint16(i3 + 5, BIG_ENDIAN),
+          width: dataView.getUint16(i3 + 7, BIG_ENDIAN)
+        };
+      }
+      if (!tableMarkers.has(marker)) {
+        return null;
+      }
+      i3 += 2;
+      i3 += dataView.getUint16(i3, BIG_ENDIAN);
+    }
+    return null;
+  }
+  function getJpegMarkers() {
+    const tableMarkers = new Set([65499, 65476, 65484, 65501, 65534]);
+    for (let i3 = 65504; i3 < 65520; ++i3) {
+      tableMarkers.add(i3);
+    }
+    const sofMarkers = new Set([
+      65472,
+      65473,
+      65474,
+      65475,
+      65477,
+      65478,
+      65479,
+      65481,
+      65482,
+      65483,
+      65485,
+      65486,
+      65487,
+      65502
+    ]);
+    return { tableMarkers, sofMarkers };
+  }
+  function toDataView(data) {
+    if (data instanceof DataView) {
+      return data;
+    }
+    if (ArrayBuffer.isView(data)) {
+      return new DataView(data.buffer);
+    }
+    if (data instanceof ArrayBuffer) {
+      return new DataView(data);
+    }
+    throw new Error("toDataView");
+  }
+  var BIG_ENDIAN, LITTLE_ENDIAN;
+  var init_binary_image_api = __esm({
+    "../images/src/lib/category-api/binary-image-api.ts"() {
+      init_parse_isobmff_binary();
+      BIG_ENDIAN = false;
+      LITTLE_ENDIAN = true;
+    }
+  });
+
+  // ../images/src/lib/parsers/parse-to-node-image.ts
+  async function parseToNodeImage(arrayBuffer, options) {
+    const { mimeType } = getBinaryImageMetadata(arrayBuffer) || {};
+    const _parseImageNode2 = globalThis._parseImageNode;
+    assert(_parseImageNode2);
+    return await _parseImageNode2(arrayBuffer, mimeType);
+  }
+  var init_parse_to_node_image = __esm({
+    "../images/src/lib/parsers/parse-to-node-image.ts"() {
+      init_src();
+      init_binary_image_api();
+    }
+  });
+
+  // ../images/src/lib/parsers/parse-image.ts
+  async function parseImage(arrayBuffer, options, context) {
+    options = options || {};
+    const imageOptions = options.image || {};
+    const imageType = imageOptions.type || "auto";
+    const { url } = context || {};
+    const loadType = getLoadableImageType(imageType);
+    let image;
+    switch (loadType) {
+      case "imagebitmap":
+        image = await parseToImageBitmap(arrayBuffer, options, url);
+        break;
+      case "image":
+        image = await parseToImage(arrayBuffer, options, url);
+        break;
+      case "data":
+        image = await parseToNodeImage(arrayBuffer, options);
+        break;
+      default:
+        assert(false);
+    }
+    if (imageType === "data") {
+      image = getImageData(image);
+    }
+    return image;
+  }
+  function getLoadableImageType(type) {
+    switch (type) {
+      case "auto":
+      case "data":
+        return getDefaultImageType();
+      default:
+        isImageTypeSupported(type);
+        return type;
+    }
+  }
+  var init_parse_image = __esm({
+    "../images/src/lib/parsers/parse-image.ts"() {
+      init_src();
+      init_image_type();
+      init_parsed_image_api();
+      init_parse_to_image();
+      init_parse_to_image_bitmap();
+      init_parse_to_node_image();
+    }
+  });
+
+  // ../images/src/image-loader.ts
+  var EXTENSIONS, MIME_TYPES, DEFAULT_IMAGE_LOADER_OPTIONS, ImageLoader;
+  var init_image_loader = __esm({
+    "../images/src/image-loader.ts"() {
+      init_version();
+      init_parse_image();
+      init_binary_image_api();
+      EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp", "bmp", "ico", "svg", "avif"];
+      MIME_TYPES = [
+        "image/png",
+        "image/jpeg",
+        "image/gif",
+        "image/webp",
+        "image/avif",
+        "image/bmp",
+        "image/vnd.microsoft.icon",
+        "image/svg+xml"
+      ];
+      DEFAULT_IMAGE_LOADER_OPTIONS = {
+        image: {
+          type: "auto",
+          decode: true
+        }
+      };
+      ImageLoader = {
+        id: "image",
+        module: "images",
+        name: "Images",
+        version: VERSION,
+        mimeTypes: MIME_TYPES,
+        extensions: EXTENSIONS,
+        parse: parseImage,
+        tests: [(arrayBuffer) => Boolean(getBinaryImageMetadata(new DataView(arrayBuffer)))],
+        options: DEFAULT_IMAGE_LOADER_OPTIONS
+      };
+    }
+  });
+
+  // ../images/src/index.ts
+  var init_src2 = __esm({
+    "../images/src/index.ts"() {
+      init_image_loader();
+    }
+  });
+
+  // ../../node_modules/@math.gl/polygon/dist/esm/polygon-utils.js
+  function getPolygonSignedArea(points, options = {}) {
+    const {
+      start = 0,
+      end = points.length
+    } = options;
+    const dim = options.size || 2;
+    let area2 = 0;
+    for (let i3 = start, j = end - dim; i3 < end; i3 += dim) {
+      area2 += (points[i3] - points[j]) * (points[i3 + 1] + points[j + 1]);
+      j = i3;
+    }
+    return area2 / 2;
+  }
+  var init_polygon_utils = __esm({
+    "../../node_modules/@math.gl/polygon/dist/esm/polygon-utils.js"() {
+    }
+  });
+
+  // ../../node_modules/@math.gl/polygon/dist/esm/polygon.js
+  var init_polygon = __esm({
+    "../../node_modules/@math.gl/polygon/dist/esm/polygon.js"() {
+      init_defineProperty();
+      init_polygon_utils();
+    }
+  });
+
+  // ../../node_modules/@math.gl/polygon/dist/esm/earcut.js
+  function earcut(positions, holeIndices, dim = 2, areas) {
+    const hasHoles = holeIndices && holeIndices.length;
+    const outerLen = hasHoles ? holeIndices[0] * dim : positions.length;
+    let outerNode = linkedList(positions, 0, outerLen, dim, true, areas && areas[0]);
+    const triangles = [];
+    if (!outerNode || outerNode.next === outerNode.prev)
+      return triangles;
+    let invSize;
+    let maxX;
+    let maxY;
+    let minX;
+    let minY;
+    let x3;
+    let y2;
+    if (hasHoles)
+      outerNode = eliminateHoles(positions, holeIndices, outerNode, dim, areas);
+    if (positions.length > 80 * dim) {
+      minX = maxX = positions[0];
+      minY = maxY = positions[1];
+      for (let i3 = dim; i3 < outerLen; i3 += dim) {
+        x3 = positions[i3];
+        y2 = positions[i3 + 1];
+        if (x3 < minX)
+          minX = x3;
+        if (y2 < minY)
+          minY = y2;
+        if (x3 > maxX)
+          maxX = x3;
+        if (y2 > maxY)
+          maxY = y2;
+      }
+      invSize = Math.max(maxX - minX, maxY - minY);
+      invSize = invSize !== 0 ? 1 / invSize : 0;
+    }
+    earcutLinked(outerNode, triangles, dim, minX, minY, invSize);
+    return triangles;
+  }
+  function linkedList(data, start, end, dim, clockwise, area2) {
+    let i3;
+    let last;
+    if (area2 === void 0) {
+      area2 = getPolygonSignedArea(data, {
+        start,
+        end,
+        size: dim
+      });
+    }
+    if (clockwise === area2 < 0) {
+      for (i3 = start; i3 < end; i3 += dim)
+        last = insertNode(i3, data[i3], data[i3 + 1], last);
+    } else {
+      for (i3 = end - dim; i3 >= start; i3 -= dim)
+        last = insertNode(i3, data[i3], data[i3 + 1], last);
+    }
+    if (last && equals(last, last.next)) {
+      removeNode(last);
+      last = last.next;
+    }
+    return last;
+  }
+  function filterPoints(start, end) {
+    if (!start)
+      return start;
+    if (!end)
+      end = start;
+    let p = start;
+    let again;
+    do {
+      again = false;
+      if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
+        removeNode(p);
+        p = end = p.prev;
+        if (p === p.next)
+          break;
+        again = true;
+      } else {
+        p = p.next;
+      }
+    } while (again || p !== end);
+    return end;
+  }
+  function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
+    if (!ear)
+      return;
+    if (!pass && invSize)
+      indexCurve(ear, minX, minY, invSize);
+    let stop = ear;
+    let prev;
+    let next;
+    while (ear.prev !== ear.next) {
+      prev = ear.prev;
+      next = ear.next;
+      if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
+        triangles.push(prev.i / dim);
+        triangles.push(ear.i / dim);
+        triangles.push(next.i / dim);
+        removeNode(ear);
+        ear = next.next;
+        stop = next.next;
+        continue;
+      }
+      ear = next;
+      if (ear === stop) {
+        if (!pass) {
+          earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1);
+        } else if (pass === 1) {
+          ear = cureLocalIntersections(filterPoints(ear), triangles, dim);
+          earcutLinked(ear, triangles, dim, minX, minY, invSize, 2);
+        } else if (pass === 2) {
+          splitEarcut(ear, triangles, dim, minX, minY, invSize);
+        }
+        break;
+      }
+    }
+  }
+  function isEar(ear) {
+    const a = ear.prev;
+    const b = ear;
+    const c = ear.next;
+    if (area(a, b, c) >= 0)
+      return false;
+    let p = ear.next.next;
+    while (p !== ear.prev) {
+      if (pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+        return false;
+      p = p.next;
+    }
+    return true;
+  }
+  function isEarHashed(ear, minX, minY, invSize) {
+    const a = ear.prev;
+    const b = ear;
+    const c = ear.next;
+    if (area(a, b, c) >= 0)
+      return false;
+    const minTX = a.x < b.x ? a.x < c.x ? a.x : c.x : b.x < c.x ? b.x : c.x;
+    const minTY = a.y < b.y ? a.y < c.y ? a.y : c.y : b.y < c.y ? b.y : c.y;
+    const maxTX = a.x > b.x ? a.x > c.x ? a.x : c.x : b.x > c.x ? b.x : c.x;
+    const maxTY = a.y > b.y ? a.y > c.y ? a.y : c.y : b.y > c.y ? b.y : c.y;
+    const minZ = zOrder(minTX, minTY, minX, minY, invSize);
+    const maxZ = zOrder(maxTX, maxTY, minX, minY, invSize);
+    let p = ear.prevZ;
+    let n = ear.nextZ;
+    while (p && p.z >= minZ && n && n.z <= maxZ) {
+      if (p !== ear.prev && p !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+        return false;
+      p = p.prevZ;
+      if (n !== ear.prev && n !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y) && area(n.prev, n, n.next) >= 0)
+        return false;
+      n = n.nextZ;
+    }
+    while (p && p.z >= minZ) {
+      if (p !== ear.prev && p !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+        return false;
+      p = p.prevZ;
+    }
+    while (n && n.z <= maxZ) {
+      if (n !== ear.prev && n !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y) && area(n.prev, n, n.next) >= 0)
+        return false;
+      n = n.nextZ;
+    }
+    return true;
+  }
+  function cureLocalIntersections(start, triangles, dim) {
+    let p = start;
+    do {
+      const a = p.prev;
+      const b = p.next.next;
+      if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
+        triangles.push(a.i / dim);
+        triangles.push(p.i / dim);
+        triangles.push(b.i / dim);
+        removeNode(p);
+        removeNode(p.next);
+        p = start = b;
+      }
+      p = p.next;
+    } while (p !== start);
+    return filterPoints(p);
+  }
+  function splitEarcut(start, triangles, dim, minX, minY, invSize) {
+    let a = start;
+    do {
+      let b = a.next.next;
+      while (b !== a.prev) {
+        if (a.i !== b.i && isValidDiagonal(a, b)) {
+          let c = splitPolygon(a, b);
+          a = filterPoints(a, a.next);
+          c = filterPoints(c, c.next);
+          earcutLinked(a, triangles, dim, minX, minY, invSize);
+          earcutLinked(c, triangles, dim, minX, minY, invSize);
+          return;
+        }
+        b = b.next;
+      }
+      a = a.next;
+    } while (a !== start);
+  }
+  function eliminateHoles(data, holeIndices, outerNode, dim, areas) {
+    const queue = [];
+    let i3;
+    let len;
+    let start;
+    let end;
+    let list;
+    for (i3 = 0, len = holeIndices.length; i3 < len; i3++) {
+      start = holeIndices[i3] * dim;
+      end = i3 < len - 1 ? holeIndices[i3 + 1] * dim : data.length;
+      list = linkedList(data, start, end, dim, false, areas && areas[i3 + 1]);
+      if (list === list.next)
+        list.steiner = true;
+      queue.push(getLeftmost(list));
+    }
+    queue.sort(compareX);
+    for (i3 = 0; i3 < queue.length; i3++) {
+      eliminateHole(queue[i3], outerNode);
+      outerNode = filterPoints(outerNode, outerNode.next);
+    }
+    return outerNode;
+  }
+  function compareX(a, b) {
+    return a.x - b.x;
+  }
+  function eliminateHole(hole, outerNode) {
+    outerNode = findHoleBridge(hole, outerNode);
+    if (outerNode) {
+      const b = splitPolygon(outerNode, hole);
+      filterPoints(outerNode, outerNode.next);
+      filterPoints(b, b.next);
+    }
+  }
+  function findHoleBridge(hole, outerNode) {
+    let p = outerNode;
+    const hx = hole.x;
+    const hy = hole.y;
+    let qx = -Infinity;
+    let m;
+    do {
+      if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
+        const x3 = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
+        if (x3 <= hx && x3 > qx) {
+          qx = x3;
+          if (x3 === hx) {
+            if (hy === p.y)
+              return p;
+            if (hy === p.next.y)
+              return p.next;
+          }
+          m = p.x < p.next.x ? p : p.next;
+        }
+      }
+      p = p.next;
+    } while (p !== outerNode);
+    if (!m)
+      return null;
+    if (hx === qx)
+      return m;
+    const stop = m;
+    const mx = m.x;
+    const my = m.y;
+    let tanMin = Infinity;
+    let tan;
+    p = m;
+    do {
+      if (hx >= p.x && p.x >= mx && hx !== p.x && pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
+        tan = Math.abs(hy - p.y) / (hx - p.x);
+        if (locallyInside(p, hole) && (tan < tanMin || tan === tanMin && (p.x > m.x || p.x === m.x && sectorContainsSector(m, p)))) {
+          m = p;
+          tanMin = tan;
+        }
+      }
+      p = p.next;
+    } while (p !== stop);
+    return m;
+  }
+  function sectorContainsSector(m, p) {
+    return area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0;
+  }
+  function indexCurve(start, minX, minY, invSize) {
+    let p = start;
+    do {
+      if (p.z === null)
+        p.z = zOrder(p.x, p.y, minX, minY, invSize);
+      p.prevZ = p.prev;
+      p.nextZ = p.next;
+      p = p.next;
+    } while (p !== start);
+    p.prevZ.nextZ = null;
+    p.prevZ = null;
+    sortLinked(p);
+  }
+  function sortLinked(list) {
+    let e;
+    let i3;
+    let inSize = 1;
+    let numMerges;
+    let p;
+    let pSize;
+    let q;
+    let qSize;
+    let tail;
+    do {
+      p = list;
+      list = null;
+      tail = null;
+      numMerges = 0;
+      while (p) {
+        numMerges++;
+        q = p;
+        pSize = 0;
+        for (i3 = 0; i3 < inSize; i3++) {
+          pSize++;
+          q = q.nextZ;
+          if (!q)
+            break;
+        }
+        qSize = inSize;
+        while (pSize > 0 || qSize > 0 && q) {
+          if (pSize !== 0 && (qSize === 0 || !q || p.z <= q.z)) {
+            e = p;
+            p = p.nextZ;
+            pSize--;
+          } else {
+            e = q;
+            q = q.nextZ;
+            qSize--;
+          }
+          if (tail)
+            tail.nextZ = e;
+          else
+            list = e;
+          e.prevZ = tail;
+          tail = e;
+        }
+        p = q;
+      }
+      tail.nextZ = null;
+      inSize *= 2;
+    } while (numMerges > 1);
+    return list;
+  }
+  function zOrder(x3, y2, minX, minY, invSize) {
+    x3 = 32767 * (x3 - minX) * invSize;
+    y2 = 32767 * (y2 - minY) * invSize;
+    x3 = (x3 | x3 << 8) & 16711935;
+    x3 = (x3 | x3 << 4) & 252645135;
+    x3 = (x3 | x3 << 2) & 858993459;
+    x3 = (x3 | x3 << 1) & 1431655765;
+    y2 = (y2 | y2 << 8) & 16711935;
+    y2 = (y2 | y2 << 4) & 252645135;
+    y2 = (y2 | y2 << 2) & 858993459;
+    y2 = (y2 | y2 << 1) & 1431655765;
+    return x3 | y2 << 1;
+  }
+  function getLeftmost(start) {
+    let p = start;
+    let leftmost = start;
+    do {
+      if (p.x < leftmost.x || p.x === leftmost.x && p.y < leftmost.y)
+        leftmost = p;
+      p = p.next;
+    } while (p !== start);
+    return leftmost;
+  }
+  function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
+    return (cx - px) * (ay - py) - (ax - px) * (cy - py) >= 0 && (ax - px) * (by - py) - (bx - px) * (ay - py) >= 0 && (bx - px) * (cy - py) - (cx - px) * (by - py) >= 0;
+  }
+  function isValidDiagonal(a, b) {
+    return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && (locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && (area(a.prev, a, b.prev) || area(a, b.prev, b)) || equals(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0);
+  }
+  function area(p, q, r) {
+    return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
+  }
+  function equals(p1, p2) {
+    return p1.x === p2.x && p1.y === p2.y;
+  }
+  function intersects(p1, q1, p2, q2) {
+    const o1 = sign(area(p1, q1, p2));
+    const o2 = sign(area(p1, q1, q2));
+    const o3 = sign(area(p2, q2, p1));
+    const o4 = sign(area(p2, q2, q1));
+    if (o1 !== o2 && o3 !== o4)
+      return true;
+    if (o1 === 0 && onSegment(p1, p2, q1))
+      return true;
+    if (o2 === 0 && onSegment(p1, q2, q1))
+      return true;
+    if (o3 === 0 && onSegment(p2, p1, q2))
+      return true;
+    if (o4 === 0 && onSegment(p2, q1, q2))
+      return true;
+    return false;
+  }
+  function onSegment(p, q, r) {
+    return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
+  }
+  function sign(num) {
+    return num > 0 ? 1 : num < 0 ? -1 : 0;
+  }
+  function intersectsPolygon(a, b) {
+    let p = a;
+    do {
+      if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i && intersects(p, p.next, a, b))
+        return true;
+      p = p.next;
+    } while (p !== a);
+    return false;
+  }
+  function locallyInside(a, b) {
+    return area(a.prev, a, a.next) < 0 ? area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 : area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;
+  }
+  function middleInside(a, b) {
+    let p = a;
+    let inside = false;
+    const px = (a.x + b.x) / 2;
+    const py = (a.y + b.y) / 2;
+    do {
+      if (p.y > py !== p.next.y > py && p.next.y !== p.y && px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x)
+        inside = !inside;
+      p = p.next;
+    } while (p !== a);
+    return inside;
+  }
+  function splitPolygon(a, b) {
+    const a2 = new Node(a.i, a.x, a.y);
+    const b2 = new Node(b.i, b.x, b.y);
+    const an = a.next;
+    const bp = b.prev;
+    a.next = b;
+    b.prev = a;
+    a2.next = an;
+    an.prev = a2;
+    b2.next = a2;
+    a2.prev = b2;
+    bp.next = b2;
+    b2.prev = bp;
+    return b2;
+  }
+  function insertNode(i3, x3, y2, last) {
+    const p = new Node(i3, x3, y2);
+    if (!last) {
+      p.prev = p;
+      p.next = p;
+    } else {
+      p.next = last.next;
+      p.prev = last;
+      last.next.prev = p;
+      last.next = p;
+    }
+    return p;
+  }
+  function removeNode(p) {
+    p.next.prev = p.prev;
+    p.prev.next = p.next;
+    if (p.prevZ)
+      p.prevZ.nextZ = p.nextZ;
+    if (p.nextZ)
+      p.nextZ.prevZ = p.prevZ;
+  }
+  function Node(i3, x3, y2) {
+    this.i = i3;
+    this.x = x3;
+    this.y = y2;
+    this.prev = null;
+    this.next = null;
+    this.z = null;
+    this.prevZ = null;
+    this.nextZ = null;
+    this.steiner = false;
+  }
+  var init_earcut = __esm({
+    "../../node_modules/@math.gl/polygon/dist/esm/earcut.js"() {
+      init_polygon_utils();
+    }
+  });
+
+  // ../../node_modules/@math.gl/polygon/dist/esm/utils.js
+  var init_utils = __esm({
+    "../../node_modules/@math.gl/polygon/dist/esm/utils.js"() {
+    }
+  });
+
+  // ../../node_modules/@math.gl/polygon/dist/esm/lineclip.js
+  var init_lineclip = __esm({
+    "../../node_modules/@math.gl/polygon/dist/esm/lineclip.js"() {
+      init_utils();
+    }
+  });
+
+  // ../../node_modules/@math.gl/polygon/dist/esm/cut-by-grid.js
+  var init_cut_by_grid = __esm({
+    "../../node_modules/@math.gl/polygon/dist/esm/cut-by-grid.js"() {
+      init_lineclip();
+      init_utils();
+    }
+  });
+
+  // ../../node_modules/@math.gl/polygon/dist/esm/cut-by-mercator-bounds.js
+  var init_cut_by_mercator_bounds = __esm({
+    "../../node_modules/@math.gl/polygon/dist/esm/cut-by-mercator-bounds.js"() {
+      init_cut_by_grid();
+      init_utils();
+    }
+  });
+
+  // ../../node_modules/@math.gl/polygon/dist/esm/index.js
+  var init_esm = __esm({
+    "../../node_modules/@math.gl/polygon/dist/esm/index.js"() {
+      init_polygon();
+      init_polygon_utils();
+      init_earcut();
+      init_lineclip();
+      init_cut_by_grid();
+      init_cut_by_mercator_bounds();
+      init_polygon();
+    }
+  });
+
+  // ../gis/src/lib/flat-geojson-to-binary.ts
+  function flatGeojsonToBinary(features, geometryInfo, options) {
+    const propArrayTypes = extractNumericPropTypes(features);
+    const numericPropKeys = Object.keys(propArrayTypes).filter((k) => propArrayTypes[k] !== Array);
+    return fillArrays(features, {
+      propArrayTypes,
+      ...geometryInfo
+    }, {
+      numericPropKeys: options && options.numericPropKeys || numericPropKeys,
+      PositionDataType: options ? options.PositionDataType : Float32Array,
+      triangulate: options ? options.triangulate : true
+    });
+  }
+  function extractNumericPropTypes(features) {
+    const propArrayTypes = {};
+    for (const feature of features) {
+      if (feature.properties) {
+        for (const key in feature.properties) {
+          const val = feature.properties[key];
+          propArrayTypes[key] = deduceArrayType(val, propArrayTypes[key]);
+        }
+      }
+    }
+    return propArrayTypes;
+  }
+  function fillArrays(features, geometryInfo, options) {
+    const {
+      pointPositionsCount,
+      pointFeaturesCount,
+      linePositionsCount,
+      linePathsCount,
+      lineFeaturesCount,
+      polygonPositionsCount,
+      polygonObjectsCount,
+      polygonRingsCount,
+      polygonFeaturesCount,
+      propArrayTypes,
+      coordLength
+    } = geometryInfo;
+    const { numericPropKeys = [], PositionDataType = Float32Array, triangulate = true } = options;
+    const hasGlobalId = features[0] && "id" in features[0];
+    const GlobalFeatureIdsDataType = features.length > 65535 ? Uint32Array : Uint16Array;
+    const points = {
+      type: "Point",
+      positions: new PositionDataType(pointPositionsCount * coordLength),
+      globalFeatureIds: new GlobalFeatureIdsDataType(pointPositionsCount),
+      featureIds: pointFeaturesCount > 65535 ? new Uint32Array(pointPositionsCount) : new Uint16Array(pointPositionsCount),
+      numericProps: {},
+      properties: [],
+      fields: []
+    };
+    const lines = {
+      type: "LineString",
+      pathIndices: linePositionsCount > 65535 ? new Uint32Array(linePathsCount + 1) : new Uint16Array(linePathsCount + 1),
+      positions: new PositionDataType(linePositionsCount * coordLength),
+      globalFeatureIds: new GlobalFeatureIdsDataType(linePositionsCount),
+      featureIds: lineFeaturesCount > 65535 ? new Uint32Array(linePositionsCount) : new Uint16Array(linePositionsCount),
+      numericProps: {},
+      properties: [],
+      fields: []
+    };
+    const polygons = {
+      type: "Polygon",
+      polygonIndices: polygonPositionsCount > 65535 ? new Uint32Array(polygonObjectsCount + 1) : new Uint16Array(polygonObjectsCount + 1),
+      primitivePolygonIndices: polygonPositionsCount > 65535 ? new Uint32Array(polygonRingsCount + 1) : new Uint16Array(polygonRingsCount + 1),
+      positions: new PositionDataType(polygonPositionsCount * coordLength),
+      globalFeatureIds: new GlobalFeatureIdsDataType(polygonPositionsCount),
+      featureIds: polygonFeaturesCount > 65535 ? new Uint32Array(polygonPositionsCount) : new Uint16Array(polygonPositionsCount),
+      numericProps: {},
+      properties: [],
+      fields: []
+    };
+    if (triangulate) {
+      polygons.triangles = [];
+    }
+    for (const object of [points, lines, polygons]) {
+      for (const propName of numericPropKeys) {
+        const T = propArrayTypes[propName];
+        object.numericProps[propName] = new T(object.positions.length / coordLength);
+      }
+    }
+    lines.pathIndices[linePathsCount] = linePositionsCount;
+    polygons.polygonIndices[polygonObjectsCount] = polygonPositionsCount;
+    polygons.primitivePolygonIndices[polygonRingsCount] = polygonPositionsCount;
+    const indexMap = {
+      pointPosition: 0,
+      pointFeature: 0,
+      linePosition: 0,
+      linePath: 0,
+      lineFeature: 0,
+      polygonPosition: 0,
+      polygonObject: 0,
+      polygonRing: 0,
+      polygonFeature: 0,
+      feature: 0
+    };
+    for (const feature of features) {
+      const geometry = feature.geometry;
+      const properties = feature.properties || {};
+      switch (geometry.type) {
+        case "Point":
+          handlePoint(geometry, points, indexMap, coordLength, properties);
+          points.properties.push(keepStringProperties(properties, numericPropKeys));
+          if (hasGlobalId) {
+            points.fields.push({ id: feature.id });
+          }
+          indexMap.pointFeature++;
+          break;
+        case "LineString":
+          handleLineString(geometry, lines, indexMap, coordLength, properties);
+          lines.properties.push(keepStringProperties(properties, numericPropKeys));
+          if (hasGlobalId) {
+            lines.fields.push({ id: feature.id });
+          }
+          indexMap.lineFeature++;
+          break;
+        case "Polygon":
+          handlePolygon(geometry, polygons, indexMap, coordLength, properties);
+          polygons.properties.push(keepStringProperties(properties, numericPropKeys));
+          if (hasGlobalId) {
+            polygons.fields.push({ id: feature.id });
+          }
+          indexMap.polygonFeature++;
+          break;
+        default:
+          throw new Error("Invalid geometry type");
+      }
+      indexMap.feature++;
+    }
+    return makeAccessorObjects(points, lines, polygons, coordLength);
+  }
+  function handlePoint(geometry, points, indexMap, coordLength, properties) {
+    points.positions.set(geometry.data, indexMap.pointPosition * coordLength);
+    const nPositions = geometry.data.length / coordLength;
+    fillNumericProperties(points, properties, indexMap.pointPosition, nPositions);
+    points.globalFeatureIds.fill(indexMap.feature, indexMap.pointPosition, indexMap.pointPosition + nPositions);
+    points.featureIds.fill(indexMap.pointFeature, indexMap.pointPosition, indexMap.pointPosition + nPositions);
+    indexMap.pointPosition += nPositions;
+  }
+  function handleLineString(geometry, lines, indexMap, coordLength, properties) {
+    lines.positions.set(geometry.data, indexMap.linePosition * coordLength);
+    const nPositions = geometry.data.length / coordLength;
+    fillNumericProperties(lines, properties, indexMap.linePosition, nPositions);
+    lines.globalFeatureIds.fill(indexMap.feature, indexMap.linePosition, indexMap.linePosition + nPositions);
+    lines.featureIds.fill(indexMap.lineFeature, indexMap.linePosition, indexMap.linePosition + nPositions);
+    for (let i3 = 0, il = geometry.indices.length; i3 < il; ++i3) {
+      const start = geometry.indices[i3];
+      const end = i3 === il - 1 ? geometry.data.length : geometry.indices[i3 + 1];
+      lines.pathIndices[indexMap.linePath++] = indexMap.linePosition;
+      indexMap.linePosition += (end - start) / coordLength;
+    }
+  }
+  function handlePolygon(geometry, polygons, indexMap, coordLength, properties) {
+    polygons.positions.set(geometry.data, indexMap.polygonPosition * coordLength);
+    const nPositions = geometry.data.length / coordLength;
+    fillNumericProperties(polygons, properties, indexMap.polygonPosition, nPositions);
+    polygons.globalFeatureIds.fill(indexMap.feature, indexMap.polygonPosition, indexMap.polygonPosition + nPositions);
+    polygons.featureIds.fill(indexMap.polygonFeature, indexMap.polygonPosition, indexMap.polygonPosition + nPositions);
+    for (let l = 0, ll = geometry.indices.length; l < ll; ++l) {
+      const startPosition = indexMap.polygonPosition;
+      polygons.polygonIndices[indexMap.polygonObject++] = startPosition;
+      const areas = geometry.areas[l];
+      const indices = geometry.indices[l];
+      const nextIndices = geometry.indices[l + 1];
+      for (let i3 = 0, il = indices.length; i3 < il; ++i3) {
+        const start = indices[i3];
+        const end = i3 === il - 1 ? nextIndices === void 0 ? geometry.data.length : nextIndices[0] : indices[i3 + 1];
+        polygons.primitivePolygonIndices[indexMap.polygonRing++] = indexMap.polygonPosition;
+        indexMap.polygonPosition += (end - start) / coordLength;
+      }
+      const endPosition = indexMap.polygonPosition;
+      triangulatePolygon(polygons, areas, indices, { startPosition, endPosition, coordLength });
+    }
+  }
+  function triangulatePolygon(polygons, areas, indices, {
+    startPosition,
+    endPosition,
+    coordLength
+  }) {
+    if (!polygons.triangles) {
+      return;
+    }
+    const start = startPosition * coordLength;
+    const end = endPosition * coordLength;
+    const polygonPositions = polygons.positions.subarray(start, end);
+    const offset = indices[0];
+    const holes = indices.slice(1).map((n) => (n - offset) / coordLength);
+    const triangles = earcut(polygonPositions, holes, coordLength, areas);
+    for (let t = 0, tl = triangles.length; t < tl; ++t) {
+      polygons.triangles.push(startPosition + triangles[t]);
+    }
+  }
+  function wrapProps(obj, size) {
+    const returnObj = {};
+    for (const key in obj) {
+      returnObj[key] = { value: obj[key], size };
+    }
+    return returnObj;
+  }
+  function makeAccessorObjects(points, lines, polygons, coordLength) {
+    const binaryFeatures = {
+      points: {
+        ...points,
+        positions: { value: points.positions, size: coordLength },
+        globalFeatureIds: { value: points.globalFeatureIds, size: 1 },
+        featureIds: { value: points.featureIds, size: 1 },
+        numericProps: wrapProps(points.numericProps, 1)
+      },
+      lines: {
+        ...lines,
+        positions: { value: lines.positions, size: coordLength },
+        pathIndices: { value: lines.pathIndices, size: 1 },
+        globalFeatureIds: { value: lines.globalFeatureIds, size: 1 },
+        featureIds: { value: lines.featureIds, size: 1 },
+        numericProps: wrapProps(lines.numericProps, 1)
+      },
+      polygons: {
+        ...polygons,
+        positions: { value: polygons.positions, size: coordLength },
+        polygonIndices: { value: polygons.polygonIndices, size: 1 },
+        primitivePolygonIndices: { value: polygons.primitivePolygonIndices, size: 1 },
+        globalFeatureIds: { value: polygons.globalFeatureIds, size: 1 },
+        featureIds: { value: polygons.featureIds, size: 1 },
+        numericProps: wrapProps(polygons.numericProps, 1)
+      }
+    };
+    if (binaryFeatures.polygons && polygons.triangles) {
+      binaryFeatures.polygons.triangles = { value: new Uint32Array(polygons.triangles), size: 1 };
+    }
+    return binaryFeatures;
+  }
+  function fillNumericProperties(object, properties, index, length2) {
+    for (const numericPropName in object.numericProps) {
+      if (numericPropName in properties) {
+        const value = properties[numericPropName];
+        object.numericProps[numericPropName].fill(value, index, index + length2);
+      }
+    }
+  }
+  function keepStringProperties(properties, numericKeys) {
+    const props = {};
+    for (const key in properties) {
+      if (!numericKeys.includes(key)) {
+        props[key] = properties[key];
+      }
+    }
+    return props;
+  }
+  function deduceArrayType(x3, constructor) {
+    if (constructor === Array || !Number.isFinite(x3)) {
+      return Array;
+    }
+    return constructor === Float64Array || Math.fround(x3) !== x3 ? Float64Array : Float32Array;
+  }
+  var init_flat_geojson_to_binary = __esm({
+    "../gis/src/lib/flat-geojson-to-binary.ts"() {
+      init_esm();
+    }
+  });
+
+  // ../gis/src/index.ts
+  var init_src3 = __esm({
+    "../gis/src/index.ts"() {
+      init_flat_geojson_to_binary();
+    }
+  });
+
+  // ../../node_modules/ieee754/index.js
+  var require_ieee754 = __commonJS({
+    "../../node_modules/ieee754/index.js"(exports) {
+      exports.read = function(buffer, offset, isLE, mLen, nBytes) {
+        var e, m;
+        var eLen = nBytes * 8 - mLen - 1;
+        var eMax = (1 << eLen) - 1;
+        var eBias = eMax >> 1;
+        var nBits = -7;
+        var i3 = isLE ? nBytes - 1 : 0;
+        var d = isLE ? -1 : 1;
+        var s = buffer[offset + i3];
+        i3 += d;
+        e = s & (1 << -nBits) - 1;
+        s >>= -nBits;
+        nBits += eLen;
+        for (; nBits > 0; e = e * 256 + buffer[offset + i3], i3 += d, nBits -= 8) {
+        }
+        m = e & (1 << -nBits) - 1;
+        e >>= -nBits;
+        nBits += mLen;
+        for (; nBits > 0; m = m * 256 + buffer[offset + i3], i3 += d, nBits -= 8) {
+        }
+        if (e === 0) {
+          e = 1 - eBias;
+        } else if (e === eMax) {
+          return m ? NaN : (s ? -1 : 1) * Infinity;
+        } else {
+          m = m + Math.pow(2, mLen);
+          e = e - eBias;
+        }
+        return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
+      };
+      exports.write = function(buffer, value, offset, isLE, mLen, nBytes) {
+        var e, m, c;
+        var eLen = nBytes * 8 - mLen - 1;
+        var eMax = (1 << eLen) - 1;
+        var eBias = eMax >> 1;
+        var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
+        var i3 = isLE ? 0 : nBytes - 1;
+        var d = isLE ? 1 : -1;
+        var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
+        value = Math.abs(value);
+        if (isNaN(value) || value === Infinity) {
+          m = isNaN(value) ? 1 : 0;
+          e = eMax;
+        } else {
+          e = Math.floor(Math.log(value) / Math.LN2);
+          if (value * (c = Math.pow(2, -e)) < 1) {
+            e--;
+            c *= 2;
+          }
+          if (e + eBias >= 1) {
+            value += rt / c;
+          } else {
+            value += rt * Math.pow(2, 1 - eBias);
+          }
+          if (value * c >= 2) {
+            e++;
+            c /= 2;
+          }
+          if (e + eBias >= eMax) {
+            m = 0;
+            e = eMax;
+          } else if (e + eBias >= 1) {
+            m = (value * c - 1) * Math.pow(2, mLen);
+            e = e + eBias;
+          } else {
+            m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+            e = 0;
+          }
+        }
+        for (; mLen >= 8; buffer[offset + i3] = m & 255, i3 += d, m /= 256, mLen -= 8) {
+        }
+        e = e << mLen | m;
+        eLen += mLen;
+        for (; eLen > 0; buffer[offset + i3] = e & 255, i3 += d, e /= 256, eLen -= 8) {
+        }
+        buffer[offset + i3 - d] |= s * 128;
+      };
+    }
+  });
+
+  // ../../node_modules/pbf/index.js
+  var require_pbf = __commonJS({
+    "../../node_modules/pbf/index.js"(exports, module) {
+      "use strict";
+      module.exports = Pbf;
+      var ieee754 = require_ieee754();
+      function Pbf(buf) {
+        this.buf = ArrayBuffer.isView && ArrayBuffer.isView(buf) ? buf : new Uint8Array(buf || 0);
+        this.pos = 0;
+        this.type = 0;
+        this.length = this.buf.length;
+      }
+      Pbf.Varint = 0;
+      Pbf.Fixed64 = 1;
+      Pbf.Bytes = 2;
+      Pbf.Fixed32 = 5;
+      var SHIFT_LEFT_32 = (1 << 16) * (1 << 16);
+      var SHIFT_RIGHT_32 = 1 / SHIFT_LEFT_32;
+      var TEXT_DECODER_MIN_LENGTH = 12;
+      var utf8TextDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder("utf8");
+      Pbf.prototype = {
+        destroy: function() {
+          this.buf = null;
+        },
+        readFields: function(readField, result, end) {
+          end = end || this.length;
+          while (this.pos < end) {
+            var val = this.readVarint(), tag = val >> 3, startPos = this.pos;
+            this.type = val & 7;
+            readField(tag, result, this);
+            if (this.pos === startPos)
+              this.skip(val);
+          }
+          return result;
+        },
+        readMessage: function(readField, result) {
+          return this.readFields(readField, result, this.readVarint() + this.pos);
+        },
+        readFixed32: function() {
+          var val = readUInt32(this.buf, this.pos);
+          this.pos += 4;
+          return val;
+        },
+        readSFixed32: function() {
+          var val = readInt32(this.buf, this.pos);
+          this.pos += 4;
+          return val;
+        },
+        readFixed64: function() {
+          var val = readUInt32(this.buf, this.pos) + readUInt32(this.buf, this.pos + 4) * SHIFT_LEFT_32;
+          this.pos += 8;
+          return val;
+        },
+        readSFixed64: function() {
+          var val = readUInt32(this.buf, this.pos) + readInt32(this.buf, this.pos + 4) * SHIFT_LEFT_32;
+          this.pos += 8;
+          return val;
+        },
+        readFloat: function() {
+          var val = ieee754.read(this.buf, this.pos, true, 23, 4);
+          this.pos += 4;
+          return val;
+        },
+        readDouble: function() {
+          var val = ieee754.read(this.buf, this.pos, true, 52, 8);
+          this.pos += 8;
+          return val;
+        },
+        readVarint: function(isSigned) {
+          var buf = this.buf, val, b;
+          b = buf[this.pos++];
+          val = b & 127;
+          if (b < 128)
+            return val;
+          b = buf[this.pos++];
+          val |= (b & 127) << 7;
+          if (b < 128)
+            return val;
+          b = buf[this.pos++];
+          val |= (b & 127) << 14;
+          if (b < 128)
+            return val;
+          b = buf[this.pos++];
+          val |= (b & 127) << 21;
+          if (b < 128)
+            return val;
+          b = buf[this.pos];
+          val |= (b & 15) << 28;
+          return readVarintRemainder2(val, isSigned, this);
+        },
+        readVarint64: function() {
+          return this.readVarint(true);
+        },
+        readSVarint: function() {
+          var num = this.readVarint();
+          return num % 2 === 1 ? (num + 1) / -2 : num / 2;
+        },
+        readBoolean: function() {
+          return Boolean(this.readVarint());
+        },
+        readString: function() {
+          var end = this.readVarint() + this.pos;
+          var pos = this.pos;
+          this.pos = end;
+          if (end - pos >= TEXT_DECODER_MIN_LENGTH && utf8TextDecoder) {
+            return readUtf8TextDecoder(this.buf, pos, end);
+          }
+          return readUtf8(this.buf, pos, end);
+        },
+        readBytes: function() {
+          var end = this.readVarint() + this.pos, buffer = this.buf.subarray(this.pos, end);
+          this.pos = end;
+          return buffer;
+        },
+        readPackedVarint: function(arr, isSigned) {
+          if (this.type !== Pbf.Bytes)
+            return arr.push(this.readVarint(isSigned));
+          var end = readPackedEnd(this);
+          arr = arr || [];
+          while (this.pos < end)
+            arr.push(this.readVarint(isSigned));
+          return arr;
+        },
+        readPackedSVarint: function(arr) {
+          if (this.type !== Pbf.Bytes)
+            return arr.push(this.readSVarint());
+          var end = readPackedEnd(this);
+          arr = arr || [];
+          while (this.pos < end)
+            arr.push(this.readSVarint());
+          return arr;
+        },
+        readPackedBoolean: function(arr) {
+          if (this.type !== Pbf.Bytes)
+            return arr.push(this.readBoolean());
+          var end = readPackedEnd(this);
+          arr = arr || [];
+          while (this.pos < end)
+            arr.push(this.readBoolean());
+          return arr;
+        },
+        readPackedFloat: function(arr) {
+          if (this.type !== Pbf.Bytes)
+            return arr.push(this.readFloat());
+          var end = readPackedEnd(this);
+          arr = arr || [];
+          while (this.pos < end)
+            arr.push(this.readFloat());
+          return arr;
+        },
+        readPackedDouble: function(arr) {
+          if (this.type !== Pbf.Bytes)
+            return arr.push(this.readDouble());
+          var end = readPackedEnd(this);
+          arr = arr || [];
+          while (this.pos < end)
+            arr.push(this.readDouble());
+          return arr;
+        },
+        readPackedFixed32: function(arr) {
+          if (this.type !== Pbf.Bytes)
+            return arr.push(this.readFixed32());
+          var end = readPackedEnd(this);
+          arr = arr || [];
+          while (this.pos < end)
+            arr.push(this.readFixed32());
+          return arr;
+        },
+        readPackedSFixed32: function(arr) {
+          if (this.type !== Pbf.Bytes)
+            return arr.push(this.readSFixed32());
+          var end = readPackedEnd(this);
+          arr = arr || [];
+          while (this.pos < end)
+            arr.push(this.readSFixed32());
+          return arr;
+        },
+        readPackedFixed64: function(arr) {
+          if (this.type !== Pbf.Bytes)
+            return arr.push(this.readFixed64());
+          var end = readPackedEnd(this);
+          arr = arr || [];
+          while (this.pos < end)
+            arr.push(this.readFixed64());
+          return arr;
+        },
+        readPackedSFixed64: function(arr) {
+          if (this.type !== Pbf.Bytes)
+            return arr.push(this.readSFixed64());
+          var end = readPackedEnd(this);
+          arr = arr || [];
+          while (this.pos < end)
+            arr.push(this.readSFixed64());
+          return arr;
+        },
+        skip: function(val) {
+          var type = val & 7;
+          if (type === Pbf.Varint)
+            while (this.buf[this.pos++] > 127) {
+            }
+          else if (type === Pbf.Bytes)
+            this.pos = this.readVarint() + this.pos;
+          else if (type === Pbf.Fixed32)
+            this.pos += 4;
+          else if (type === Pbf.Fixed64)
+            this.pos += 8;
+          else
+            throw new Error("Unimplemented type: " + type);
+        },
+        writeTag: function(tag, type) {
+          this.writeVarint(tag << 3 | type);
+        },
+        realloc: function(min) {
+          var length2 = this.length || 16;
+          while (length2 < this.pos + min)
+            length2 *= 2;
+          if (length2 !== this.length) {
+            var buf = new Uint8Array(length2);
+            buf.set(this.buf);
+            this.buf = buf;
+            this.length = length2;
+          }
+        },
+        finish: function() {
+          this.length = this.pos;
+          this.pos = 0;
+          return this.buf.subarray(0, this.length);
+        },
+        writeFixed32: function(val) {
+          this.realloc(4);
+          writeInt32(this.buf, val, this.pos);
+          this.pos += 4;
+        },
+        writeSFixed32: function(val) {
+          this.realloc(4);
+          writeInt32(this.buf, val, this.pos);
+          this.pos += 4;
+        },
+        writeFixed64: function(val) {
+          this.realloc(8);
+          writeInt32(this.buf, val & -1, this.pos);
+          writeInt32(this.buf, Math.floor(val * SHIFT_RIGHT_32), this.pos + 4);
+          this.pos += 8;
+        },
+        writeSFixed64: function(val) {
+          this.realloc(8);
+          writeInt32(this.buf, val & -1, this.pos);
+          writeInt32(this.buf, Math.floor(val * SHIFT_RIGHT_32), this.pos + 4);
+          this.pos += 8;
+        },
+        writeVarint: function(val) {
+          val = +val || 0;
+          if (val > 268435455 || val < 0) {
+            writeBigVarint(val, this);
+            return;
+          }
+          this.realloc(4);
+          this.buf[this.pos++] = val & 127 | (val > 127 ? 128 : 0);
+          if (val <= 127)
+            return;
+          this.buf[this.pos++] = (val >>>= 7) & 127 | (val > 127 ? 128 : 0);
+          if (val <= 127)
+            return;
+          this.buf[this.pos++] = (val >>>= 7) & 127 | (val > 127 ? 128 : 0);
+          if (val <= 127)
+            return;
+          this.buf[this.pos++] = val >>> 7 & 127;
+        },
+        writeSVarint: function(val) {
+          this.writeVarint(val < 0 ? -val * 2 - 1 : val * 2);
+        },
+        writeBoolean: function(val) {
+          this.writeVarint(Boolean(val));
+        },
+        writeString: function(str) {
+          str = String(str);
+          this.realloc(str.length * 4);
+          this.pos++;
+          var startPos = this.pos;
+          this.pos = writeUtf8(this.buf, str, this.pos);
+          var len = this.pos - startPos;
+          if (len >= 128)
+            makeRoomForExtraLength(startPos, len, this);
+          this.pos = startPos - 1;
+          this.writeVarint(len);
+          this.pos += len;
+        },
+        writeFloat: function(val) {
+          this.realloc(4);
+          ieee754.write(this.buf, val, this.pos, true, 23, 4);
+          this.pos += 4;
+        },
+        writeDouble: function(val) {
+          this.realloc(8);
+          ieee754.write(this.buf, val, this.pos, true, 52, 8);
+          this.pos += 8;
+        },
+        writeBytes: function(buffer) {
+          var len = buffer.length;
+          this.writeVarint(len);
+          this.realloc(len);
+          for (var i3 = 0; i3 < len; i3++)
+            this.buf[this.pos++] = buffer[i3];
+        },
+        writeRawMessage: function(fn, obj) {
+          this.pos++;
+          var startPos = this.pos;
+          fn(obj, this);
+          var len = this.pos - startPos;
+          if (len >= 128)
+            makeRoomForExtraLength(startPos, len, this);
+          this.pos = startPos - 1;
+          this.writeVarint(len);
+          this.pos += len;
+        },
+        writeMessage: function(tag, fn, obj) {
+          this.writeTag(tag, Pbf.Bytes);
+          this.writeRawMessage(fn, obj);
+        },
+        writePackedVarint: function(tag, arr) {
+          if (arr.length)
+            this.writeMessage(tag, writePackedVarint, arr);
+        },
+        writePackedSVarint: function(tag, arr) {
+          if (arr.length)
+            this.writeMessage(tag, writePackedSVarint, arr);
+        },
+        writePackedBoolean: function(tag, arr) {
+          if (arr.length)
+            this.writeMessage(tag, writePackedBoolean, arr);
+        },
+        writePackedFloat: function(tag, arr) {
+          if (arr.length)
+            this.writeMessage(tag, writePackedFloat, arr);
+        },
+        writePackedDouble: function(tag, arr) {
+          if (arr.length)
+            this.writeMessage(tag, writePackedDouble, arr);
+        },
+        writePackedFixed32: function(tag, arr) {
+          if (arr.length)
+            this.writeMessage(tag, writePackedFixed32, arr);
+        },
+        writePackedSFixed32: function(tag, arr) {
+          if (arr.length)
+            this.writeMessage(tag, writePackedSFixed32, arr);
+        },
+        writePackedFixed64: function(tag, arr) {
+          if (arr.length)
+            this.writeMessage(tag, writePackedFixed64, arr);
+        },
+        writePackedSFixed64: function(tag, arr) {
+          if (arr.length)
+            this.writeMessage(tag, writePackedSFixed64, arr);
+        },
+        writeBytesField: function(tag, buffer) {
+          this.writeTag(tag, Pbf.Bytes);
+          this.writeBytes(buffer);
+        },
+        writeFixed32Field: function(tag, val) {
+          this.writeTag(tag, Pbf.Fixed32);
+          this.writeFixed32(val);
+        },
+        writeSFixed32Field: function(tag, val) {
+          this.writeTag(tag, Pbf.Fixed32);
+          this.writeSFixed32(val);
+        },
+        writeFixed64Field: function(tag, val) {
+          this.writeTag(tag, Pbf.Fixed64);
+          this.writeFixed64(val);
+        },
+        writeSFixed64Field: function(tag, val) {
+          this.writeTag(tag, Pbf.Fixed64);
+          this.writeSFixed64(val);
+        },
+        writeVarintField: function(tag, val) {
+          this.writeTag(tag, Pbf.Varint);
+          this.writeVarint(val);
+        },
+        writeSVarintField: function(tag, val) {
+          this.writeTag(tag, Pbf.Varint);
+          this.writeSVarint(val);
+        },
+        writeStringField: function(tag, str) {
+          this.writeTag(tag, Pbf.Bytes);
+          this.writeString(str);
+        },
+        writeFloatField: function(tag, val) {
+          this.writeTag(tag, Pbf.Fixed32);
+          this.writeFloat(val);
+        },
+        writeDoubleField: function(tag, val) {
+          this.writeTag(tag, Pbf.Fixed64);
+          this.writeDouble(val);
+        },
+        writeBooleanField: function(tag, val) {
+          this.writeVarintField(tag, Boolean(val));
+        }
+      };
+      function readVarintRemainder2(l, s, p) {
+        var buf = p.buf, h, b;
+        b = buf[p.pos++];
+        h = (b & 112) >> 4;
+        if (b < 128)
+          return toNum2(l, h, s);
+        b = buf[p.pos++];
+        h |= (b & 127) << 3;
+        if (b < 128)
+          return toNum2(l, h, s);
+        b = buf[p.pos++];
+        h |= (b & 127) << 10;
+        if (b < 128)
+          return toNum2(l, h, s);
+        b = buf[p.pos++];
+        h |= (b & 127) << 17;
+        if (b < 128)
+          return toNum2(l, h, s);
+        b = buf[p.pos++];
+        h |= (b & 127) << 24;
+        if (b < 128)
+          return toNum2(l, h, s);
+        b = buf[p.pos++];
+        h |= (b & 1) << 31;
+        if (b < 128)
+          return toNum2(l, h, s);
+        throw new Error("Expected varint not more than 10 bytes");
+      }
+      function readPackedEnd(pbf) {
+        return pbf.type === Pbf.Bytes ? pbf.readVarint() + pbf.pos : pbf.pos + 1;
+      }
+      function toNum2(low, high, isSigned) {
+        if (isSigned) {
+          return high * 4294967296 + (low >>> 0);
+        }
+        return (high >>> 0) * 4294967296 + (low >>> 0);
+      }
+      function writeBigVarint(val, pbf) {
+        var low, high;
+        if (val >= 0) {
+          low = val % 4294967296 | 0;
+          high = val / 4294967296 | 0;
+        } else {
+          low = ~(-val % 4294967296);
+          high = ~(-val / 4294967296);
+          if (low ^ 4294967295) {
+            low = low + 1 | 0;
+          } else {
+            low = 0;
+            high = high + 1 | 0;
+          }
+        }
+        if (val >= 18446744073709552e3 || val < -18446744073709552e3) {
+          throw new Error("Given varint doesn't fit into 10 bytes");
+        }
+        pbf.realloc(10);
+        writeBigVarintLow(low, high, pbf);
+        writeBigVarintHigh(high, pbf);
+      }
+      function writeBigVarintLow(low, high, pbf) {
+        pbf.buf[pbf.pos++] = low & 127 | 128;
+        low >>>= 7;
+        pbf.buf[pbf.pos++] = low & 127 | 128;
+        low >>>= 7;
+        pbf.buf[pbf.pos++] = low & 127 | 128;
+        low >>>= 7;
+        pbf.buf[pbf.pos++] = low & 127 | 128;
+        low >>>= 7;
+        pbf.buf[pbf.pos] = low & 127;
+      }
+      function writeBigVarintHigh(high, pbf) {
+        var lsb = (high & 7) << 4;
+        pbf.buf[pbf.pos++] |= lsb | ((high >>>= 3) ? 128 : 0);
+        if (!high)
+          return;
+        pbf.buf[pbf.pos++] = high & 127 | ((high >>>= 7) ? 128 : 0);
+        if (!high)
+          return;
+        pbf.buf[pbf.pos++] = high & 127 | ((high >>>= 7) ? 128 : 0);
+        if (!high)
+          return;
+        pbf.buf[pbf.pos++] = high & 127 | ((high >>>= 7) ? 128 : 0);
+        if (!high)
+          return;
+        pbf.buf[pbf.pos++] = high & 127 | ((high >>>= 7) ? 128 : 0);
+        if (!high)
+          return;
+        pbf.buf[pbf.pos++] = high & 127;
+      }
+      function makeRoomForExtraLength(startPos, len, pbf) {
+        var extraLen = len <= 16383 ? 1 : len <= 2097151 ? 2 : len <= 268435455 ? 3 : Math.floor(Math.log(len) / (Math.LN2 * 7));
+        pbf.realloc(extraLen);
+        for (var i3 = pbf.pos - 1; i3 >= startPos; i3--)
+          pbf.buf[i3 + extraLen] = pbf.buf[i3];
+      }
+      function writePackedVarint(arr, pbf) {
+        for (var i3 = 0; i3 < arr.length; i3++)
+          pbf.writeVarint(arr[i3]);
+      }
+      function writePackedSVarint(arr, pbf) {
+        for (var i3 = 0; i3 < arr.length; i3++)
+          pbf.writeSVarint(arr[i3]);
+      }
+      function writePackedFloat(arr, pbf) {
+        for (var i3 = 0; i3 < arr.length; i3++)
+          pbf.writeFloat(arr[i3]);
+      }
+      function writePackedDouble(arr, pbf) {
+        for (var i3 = 0; i3 < arr.length; i3++)
+          pbf.writeDouble(arr[i3]);
+      }
+      function writePackedBoolean(arr, pbf) {
+        for (var i3 = 0; i3 < arr.length; i3++)
+          pbf.writeBoolean(arr[i3]);
+      }
+      function writePackedFixed32(arr, pbf) {
+        for (var i3 = 0; i3 < arr.length; i3++)
+          pbf.writeFixed32(arr[i3]);
+      }
+      function writePackedSFixed32(arr, pbf) {
+        for (var i3 = 0; i3 < arr.length; i3++)
+          pbf.writeSFixed32(arr[i3]);
+      }
+      function writePackedFixed64(arr, pbf) {
+        for (var i3 = 0; i3 < arr.length; i3++)
+          pbf.writeFixed64(arr[i3]);
+      }
+      function writePackedSFixed64(arr, pbf) {
+        for (var i3 = 0; i3 < arr.length; i3++)
+          pbf.writeSFixed64(arr[i3]);
+      }
+      function readUInt32(buf, pos) {
+        return (buf[pos] | buf[pos + 1] << 8 | buf[pos + 2] << 16) + buf[pos + 3] * 16777216;
+      }
+      function writeInt32(buf, val, pos) {
+        buf[pos] = val;
+        buf[pos + 1] = val >>> 8;
+        buf[pos + 2] = val >>> 16;
+        buf[pos + 3] = val >>> 24;
+      }
+      function readInt32(buf, pos) {
+        return (buf[pos] | buf[pos + 1] << 8 | buf[pos + 2] << 16) + (buf[pos + 3] << 24);
+      }
+      function readUtf8(buf, pos, end) {
+        var str = "";
+        var i3 = pos;
+        while (i3 < end) {
+          var b0 = buf[i3];
+          var c = null;
+          var bytesPerSequence = b0 > 239 ? 4 : b0 > 223 ? 3 : b0 > 191 ? 2 : 1;
+          if (i3 + bytesPerSequence > end)
+            break;
+          var b1, b2, b3;
+          if (bytesPerSequence === 1) {
+            if (b0 < 128) {
+              c = b0;
+            }
+          } else if (bytesPerSequence === 2) {
+            b1 = buf[i3 + 1];
+            if ((b1 & 192) === 128) {
+              c = (b0 & 31) << 6 | b1 & 63;
+              if (c <= 127) {
+                c = null;
+              }
+            }
+          } else if (bytesPerSequence === 3) {
+            b1 = buf[i3 + 1];
+            b2 = buf[i3 + 2];
+            if ((b1 & 192) === 128 && (b2 & 192) === 128) {
+              c = (b0 & 15) << 12 | (b1 & 63) << 6 | b2 & 63;
+              if (c <= 2047 || c >= 55296 && c <= 57343) {
+                c = null;
+              }
+            }
+          } else if (bytesPerSequence === 4) {
+            b1 = buf[i3 + 1];
+            b2 = buf[i3 + 2];
+            b3 = buf[i3 + 3];
+            if ((b1 & 192) === 128 && (b2 & 192) === 128 && (b3 & 192) === 128) {
+              c = (b0 & 15) << 18 | (b1 & 63) << 12 | (b2 & 63) << 6 | b3 & 63;
+              if (c <= 65535 || c >= 1114112) {
+                c = null;
+              }
+            }
+          }
+          if (c === null) {
+            c = 65533;
+            bytesPerSequence = 1;
+          } else if (c > 65535) {
+            c -= 65536;
+            str += String.fromCharCode(c >>> 10 & 1023 | 55296);
+            c = 56320 | c & 1023;
+          }
+          str += String.fromCharCode(c);
+          i3 += bytesPerSequence;
+        }
+        return str;
+      }
+      function readUtf8TextDecoder(buf, pos, end) {
+        return utf8TextDecoder.decode(buf.subarray(pos, end));
+      }
+      function writeUtf8(buf, str, pos) {
+        for (var i3 = 0, c, lead; i3 < str.length; i3++) {
+          c = str.charCodeAt(i3);
+          if (c > 55295 && c < 57344) {
+            if (lead) {
+              if (c < 56320) {
+                buf[pos++] = 239;
+                buf[pos++] = 191;
+                buf[pos++] = 189;
+                lead = c;
+                continue;
+              } else {
+                c = lead - 55296 << 10 | c - 56320 | 65536;
+                lead = null;
+              }
+            } else {
+              if (c > 56319 || i3 + 1 === str.length) {
+                buf[pos++] = 239;
+                buf[pos++] = 191;
+                buf[pos++] = 189;
+              } else {
+                lead = c;
+              }
+              continue;
+            }
+          } else if (lead) {
+            buf[pos++] = 239;
+            buf[pos++] = 191;
+            buf[pos++] = 189;
+            lead = null;
+          }
+          if (c < 128) {
+            buf[pos++] = c;
+          } else {
+            if (c < 2048) {
+              buf[pos++] = c >> 6 | 192;
+            } else {
+              if (c < 65536) {
+                buf[pos++] = c >> 12 | 224;
+              } else {
+                buf[pos++] = c >> 18 | 240;
+                buf[pos++] = c >> 12 & 63 | 128;
+              }
+              buf[pos++] = c >> 6 & 63 | 128;
+            }
+            buf[pos++] = c & 63 | 128;
+          }
+        }
+        return pos;
+      }
+    }
+  });
+
+  // ../mvt/src/helpers/mapbox-util-functions.ts
+  function classifyRings(rings) {
+    const len = rings.length;
+    if (len <= 1)
+      return [rings];
+    const polygons = [];
+    let polygon;
+    let ccw;
+    for (let i3 = 0; i3 < len; i3++) {
+      const area2 = signedArea(rings[i3]);
+      if (area2 === 0)
+        continue;
+      if (ccw === void 0)
+        ccw = area2 < 0;
+      if (ccw === area2 < 0) {
+        if (polygon)
+          polygons.push(polygon);
+        polygon = [rings[i3]];
+      } else if (polygon)
+        polygon.push(rings[i3]);
+    }
+    if (polygon)
+      polygons.push(polygon);
+    return polygons;
+  }
+  function signedArea(ring) {
+    let sum = 0;
+    for (let i3 = 0, j = ring.length - 1, p1, p2; i3 < ring.length; j = i3++) {
+      p1 = ring[i3];
+      p2 = ring[j];
+      sum += (p2[0] - p1[0]) * (p1[1] + p2[1]);
+    }
+    return sum;
+  }
+  function readFeature(tag, feature, pbf) {
+    if (feature && pbf) {
+      if (tag === 1)
+        feature.id = pbf.readVarint();
+      else if (tag === 2)
+        readTag(pbf, feature);
+      else if (tag === 3)
+        feature.type = pbf.readVarint();
+      else if (tag === 4)
+        feature._geometry = pbf.pos;
+    }
+  }
+  function readTag(pbf, feature) {
+    const end = pbf.readVarint() + pbf.pos;
+    while (pbf.pos < end) {
+      const key = feature._keys[pbf.readVarint()];
+      const value = feature._values[pbf.readVarint()];
+      feature.properties[key] = value;
+    }
+  }
+  var init_mapbox_util_functions = __esm({
+    "../mvt/src/helpers/mapbox-util-functions.ts"() {
+    }
+  });
+
+  // ../mvt/src/lib/mapbox-vector-tile/vector-tile-feature.ts
+  var VectorTileFeature;
+  var init_vector_tile_feature = __esm({
+    "../mvt/src/lib/mapbox-vector-tile/vector-tile-feature.ts"() {
+      init_mapbox_util_functions();
+      VectorTileFeature = class {
+        static get types() {
+          return ["Unknown", "Point", "LineString", "Polygon"];
+        }
+        constructor(pbf, end, extent, keys, values) {
+          this.properties = {};
+          this.extent = extent;
+          this.type = 0;
+          this.id = null;
+          this._pbf = pbf;
+          this._geometry = -1;
+          this._keys = keys;
+          this._values = values;
+          pbf.readFields(readFeature, this, end);
+        }
+        loadGeometry() {
+          const pbf = this._pbf;
+          pbf.pos = this._geometry;
+          const end = pbf.readVarint() + pbf.pos;
+          let cmd2 = 1;
+          let length2 = 0;
+          let x3 = 0;
+          let y2 = 0;
+          const lines = [];
+          let line;
+          while (pbf.pos < end) {
+            if (length2 <= 0) {
+              const cmdLen2 = pbf.readVarint();
+              cmd2 = cmdLen2 & 7;
+              length2 = cmdLen2 >> 3;
+            }
+            length2--;
+            if (cmd2 === 1 || cmd2 === 2) {
+              x3 += pbf.readSVarint();
+              y2 += pbf.readSVarint();
+              if (cmd2 === 1) {
+                if (line)
+                  lines.push(line);
+                line = [];
+              }
+              if (line)
+                line.push([x3, y2]);
+            } else if (cmd2 === 7) {
+              if (line) {
+                line.push(line[0].slice());
+              }
+            } else {
+              throw new Error(`unknown command ${cmd2}`);
+            }
+          }
+          if (line)
+            lines.push(line);
+          return lines;
+        }
+        bbox() {
+          const pbf = this._pbf;
+          pbf.pos = this._geometry;
+          const end = pbf.readVarint() + pbf.pos;
+          let cmd2 = 1;
+          let length2 = 0;
+          let x3 = 0;
+          let y2 = 0;
+          let x1 = Infinity;
+          let x22 = -Infinity;
+          let y1 = Infinity;
+          let y22 = -Infinity;
+          while (pbf.pos < end) {
+            if (length2 <= 0) {
+              const cmdLen2 = pbf.readVarint();
+              cmd2 = cmdLen2 & 7;
+              length2 = cmdLen2 >> 3;
+            }
+            length2--;
+            if (cmd2 === 1 || cmd2 === 2) {
+              x3 += pbf.readSVarint();
+              y2 += pbf.readSVarint();
+              if (x3 < x1)
+                x1 = x3;
+              if (x3 > x22)
+                x22 = x3;
+              if (y2 < y1)
+                y1 = y2;
+              if (y2 > y22)
+                y22 = y2;
+            } else if (cmd2 !== 7) {
+              throw new Error(`unknown command ${cmd2}`);
+            }
+          }
+          return [x1, y1, x22, y22];
+        }
+        _toGeoJSON(transform) {
+          let coords = this.loadGeometry();
+          let type = VectorTileFeature.types[this.type];
+          let i3;
+          let j;
+          switch (this.type) {
+            case 1:
+              const points = [];
+              for (i3 = 0; i3 < coords.length; i3++) {
+                points[i3] = coords[i3][0];
+              }
+              coords = points;
+              transform(coords, this);
+              break;
+            case 2:
+              for (i3 = 0; i3 < coords.length; i3++) {
+                transform(coords[i3], this);
+              }
+              break;
+            case 3:
+              coords = classifyRings(coords);
+              for (i3 = 0; i3 < coords.length; i3++) {
+                for (j = 0; j < coords[i3].length; j++) {
+                  transform(coords[i3][j], this);
+                }
+              }
+              break;
+          }
+          if (coords.length === 1) {
+            coords = coords[0];
+          } else {
+            type = `Multi${type}`;
+          }
+          const result = {
+            type: "Feature",
+            geometry: {
+              type,
+              coordinates: coords
+            },
+            properties: this.properties
+          };
+          if (this.id !== null) {
+            result.id = this.id;
+          }
+          return result;
+        }
+        toGeoJSON(options) {
+          if (typeof options === "function") {
+            return this._toGeoJSON(options);
+          }
+          const { x: x3, y: y2, z } = options;
+          const size = this.extent * Math.pow(2, z);
+          const x0 = this.extent * x3;
+          const y0 = this.extent * y2;
+          function project2(line) {
+            for (let j = 0; j < line.length; j++) {
+              const p = line[j];
+              p[0] = (p[0] + x0) * 360 / size - 180;
+              const y22 = 180 - (p[1] + y0) * 360 / size;
+              p[1] = 360 / Math.PI * Math.atan(Math.exp(y22 * Math.PI / 180)) - 90;
+            }
+          }
+          return this._toGeoJSON(project2);
+        }
+      };
+    }
+  });
+
+  // ../mvt/src/lib/mapbox-vector-tile/vector-tile-layer.ts
+  function readLayer(tag, layer, pbf) {
+    if (layer && pbf) {
+      if (tag === 15)
+        layer.version = pbf.readVarint();
+      else if (tag === 1)
+        layer.name = pbf.readString();
+      else if (tag === 5)
+        layer.extent = pbf.readVarint();
+      else if (tag === 2)
+        layer._features.push(pbf.pos);
+      else if (tag === 3)
+        layer._keys.push(pbf.readString());
+      else if (tag === 4)
+        layer._values.push(readValueMessage(pbf));
+    }
+  }
+  function readValueMessage(pbf) {
+    let value = null;
+    const end = pbf.readVarint() + pbf.pos;
+    while (pbf.pos < end) {
+      const tag = pbf.readVarint() >> 3;
+      value = tag === 1 ? pbf.readString() : tag === 2 ? pbf.readFloat() : tag === 3 ? pbf.readDouble() : tag === 4 ? pbf.readVarint64() : tag === 5 ? pbf.readVarint() : tag === 6 ? pbf.readSVarint() : tag === 7 ? pbf.readBoolean() : null;
+    }
+    return value;
+  }
+  var VectorTileLayer;
+  var init_vector_tile_layer = __esm({
+    "../mvt/src/lib/mapbox-vector-tile/vector-tile-layer.ts"() {
+      init_vector_tile_feature();
+      VectorTileLayer = class {
+        constructor(pbf, end) {
+          this.version = 1;
+          this.name = "";
+          this.extent = 4096;
+          this.length = 0;
+          this._pbf = pbf;
+          this._keys = [];
+          this._values = [];
+          this._features = [];
+          pbf.readFields(readLayer, this, end);
+          this.length = this._features.length;
+        }
+        feature(i3) {
+          if (i3 < 0 || i3 >= this._features.length) {
+            throw new Error("feature index out of bounds");
+          }
+          this._pbf.pos = this._features[i3];
+          const end = this._pbf.readVarint() + this._pbf.pos;
+          return new VectorTileFeature(this._pbf, end, this.extent, this._keys, this._values);
+        }
+      };
+    }
+  });
+
+  // ../mvt/src/lib/mapbox-vector-tile/vector-tile.ts
+  function readTile(tag, layers, pbf) {
+    if (tag === 3) {
+      if (pbf) {
+        const layer = new VectorTileLayer(pbf, pbf.readVarint() + pbf.pos);
+        if (layer.length && layers) {
+          layers[layer.name] = layer;
+        }
+      }
+    }
+  }
+  var VectorTile;
+  var init_vector_tile = __esm({
+    "../mvt/src/lib/mapbox-vector-tile/vector-tile.ts"() {
+      init_vector_tile_layer();
+      VectorTile = class {
+        constructor(pbf, end) {
+          this.layers = pbf.readFields(readTile, {}, end);
+        }
+      };
+    }
+  });
+
+  // ../mvt/src/helpers/binary-util-functions.ts
+  function classifyRings2(geom) {
+    const len = geom.indices.length;
+    const type = "Polygon";
+    if (len <= 1) {
+      return {
+        type,
+        data: geom.data,
+        areas: [[getPolygonSignedArea(geom.data)]],
+        indices: [geom.indices]
+      };
+    }
+    const areas = [];
+    const polygons = [];
+    let ringAreas = [];
+    let polygon = [];
+    let ccw;
+    let offset = 0;
+    for (let endIndex, i3 = 0, startIndex; i3 < len; i3++) {
+      startIndex = geom.indices[i3] - offset;
+      endIndex = geom.indices[i3 + 1] - offset || geom.data.length;
+      const shape = geom.data.slice(startIndex, endIndex);
+      const area2 = getPolygonSignedArea(shape);
+      if (area2 === 0) {
+        const before = geom.data.slice(0, startIndex);
+        const after = geom.data.slice(endIndex);
+        geom.data = before.concat(after);
+        offset += endIndex - startIndex;
+        continue;
+      }
+      if (ccw === void 0)
+        ccw = area2 < 0;
+      if (ccw === area2 < 0) {
+        if (polygon.length) {
+          areas.push(ringAreas);
+          polygons.push(polygon);
+        }
+        polygon = [startIndex];
+        ringAreas = [area2];
+      } else {
+        ringAreas.push(area2);
+        polygon.push(startIndex);
+      }
+    }
+    if (ringAreas)
+      areas.push(ringAreas);
+    if (polygon.length)
+      polygons.push(polygon);
+    return { type, areas, indices: polygons, data: geom.data };
+  }
+  function project(data, x0, y0, size) {
+    for (let j = 0, jl = data.length; j < jl; j += 2) {
+      data[j] = (data[j] + x0) * 360 / size - 180;
+      const y2 = 180 - (data[j + 1] + y0) * 360 / size;
+      data[j + 1] = 360 / Math.PI * Math.atan(Math.exp(y2 * Math.PI / 180)) - 90;
+    }
+  }
+  function readFeature2(tag, feature, pbf) {
+    if (feature && pbf) {
+      if (tag === 1)
+        feature.id = pbf.readVarint();
+      else if (tag === 2)
+        readTag2(pbf, feature);
+      else if (tag === 3)
+        feature.type = pbf.readVarint();
+      else if (tag === 4)
+        feature._geometry = pbf.pos;
+    }
+  }
+  function readTag2(pbf, feature) {
+    const end = pbf.readVarint() + pbf.pos;
+    while (pbf.pos < end) {
+      const key = feature._keys[pbf.readVarint()];
+      const value = feature._values[pbf.readVarint()];
+      feature.properties[key] = value;
+    }
+  }
+  var init_binary_util_functions = __esm({
+    "../mvt/src/helpers/binary-util-functions.ts"() {
+      init_esm();
+    }
+  });
+
+  // ../mvt/src/lib/binary-vector-tile/vector-tile-feature.ts
+  var endPos, cmd, cmdLen, length, x, y, i, VectorTileFeature2;
+  var init_vector_tile_feature2 = __esm({
+    "../mvt/src/lib/binary-vector-tile/vector-tile-feature.ts"() {
+      init_binary_util_functions();
+      VectorTileFeature2 = class {
+        constructor(pbf, end, extent, keys, values, geometryInfo) {
+          this.properties = {};
+          this.extent = extent;
+          this.type = 0;
+          this.id = null;
+          this._pbf = pbf;
+          this._geometry = -1;
+          this._keys = keys;
+          this._values = values;
+          this._geometryInfo = geometryInfo;
+          pbf.readFields(readFeature2, this, end);
+        }
+        loadGeometry() {
+          const pbf = this._pbf;
+          pbf.pos = this._geometry;
+          endPos = pbf.readVarint() + pbf.pos;
+          cmd = 1;
+          length = 0;
+          x = 0;
+          y = 0;
+          i = 0;
+          const indices = [];
+          const data = [];
+          while (pbf.pos < endPos) {
+            if (length <= 0) {
+              cmdLen = pbf.readVarint();
+              cmd = cmdLen & 7;
+              length = cmdLen >> 3;
+            }
+            length--;
+            if (cmd === 1 || cmd === 2) {
+              x += pbf.readSVarint();
+              y += pbf.readSVarint();
+              if (cmd === 1) {
+                indices.push(i);
+              }
+              data.push(x, y);
+              i += 2;
+            } else if (cmd === 7) {
+              if (i > 0) {
+                const start = indices[indices.length - 1];
+                data.push(data[start], data[start + 1]);
+                i += 2;
+              }
+            } else {
+              throw new Error(`unknown command ${cmd}`);
+            }
+          }
+          return { data, indices };
+        }
+        _toBinaryCoordinates(transform) {
+          const geom = this.loadGeometry();
+          let geometry;
+          transform(geom.data, this);
+          const coordLength = 2;
+          switch (this.type) {
+            case 1:
+              this._geometryInfo.pointFeaturesCount++;
+              this._geometryInfo.pointPositionsCount += geom.indices.length;
+              geometry = { type: "Point", ...geom };
+              break;
+            case 2:
+              this._geometryInfo.lineFeaturesCount++;
+              this._geometryInfo.linePathsCount += geom.indices.length;
+              this._geometryInfo.linePositionsCount += geom.data.length / coordLength;
+              geometry = { type: "LineString", ...geom };
+              break;
+            case 3:
+              geometry = classifyRings2(geom);
+              this._geometryInfo.polygonFeaturesCount++;
+              this._geometryInfo.polygonObjectsCount += geometry.indices.length;
+              for (const indices of geometry.indices) {
+                this._geometryInfo.polygonRingsCount += indices.length;
+              }
+              this._geometryInfo.polygonPositionsCount += geometry.data.length / coordLength;
+              break;
+            default:
+              throw new Error(`Invalid geometry type: ${this.type}`);
+          }
+          const result = { type: "Feature", geometry, properties: this.properties };
+          if (this.id !== null) {
+            result.id = this.id;
+          }
+          return result;
+        }
+        toBinaryCoordinates(options) {
+          if (typeof options === "function") {
+            return this._toBinaryCoordinates(options);
+          }
+          const { x: x3, y: y2, z } = options;
+          const size = this.extent * Math.pow(2, z);
+          const x0 = this.extent * x3;
+          const y0 = this.extent * y2;
+          return this._toBinaryCoordinates((data) => project(data, x0, y0, size));
+        }
+      };
+    }
+  });
+
+  // ../mvt/src/lib/binary-vector-tile/vector-tile-layer.ts
+  function readLayer2(tag, layer, pbf) {
+    if (layer && pbf) {
+      if (tag === 15)
+        layer.version = pbf.readVarint();
+      else if (tag === 1)
+        layer.name = pbf.readString();
+      else if (tag === 5)
+        layer.extent = pbf.readVarint();
+      else if (tag === 2)
+        layer._features.push(pbf.pos);
+      else if (tag === 3)
+        layer._keys.push(pbf.readString());
+      else if (tag === 4)
+        layer._values.push(readValueMessage2(pbf));
+    }
+  }
+  function readValueMessage2(pbf) {
+    let value = null;
+    const end = pbf.readVarint() + pbf.pos;
+    while (pbf.pos < end) {
+      const tag = pbf.readVarint() >> 3;
+      value = tag === 1 ? pbf.readString() : tag === 2 ? pbf.readFloat() : tag === 3 ? pbf.readDouble() : tag === 4 ? pbf.readVarint64() : tag === 5 ? pbf.readVarint() : tag === 6 ? pbf.readSVarint() : tag === 7 ? pbf.readBoolean() : null;
+    }
+    return value;
+  }
+  var VectorTileLayer2;
+  var init_vector_tile_layer2 = __esm({
+    "../mvt/src/lib/binary-vector-tile/vector-tile-layer.ts"() {
+      init_vector_tile_feature2();
+      VectorTileLayer2 = class {
+        constructor(pbf, end) {
+          this.version = 1;
+          this.name = "";
+          this.extent = 4096;
+          this.length = 0;
+          this._pbf = pbf;
+          this._keys = [];
+          this._values = [];
+          this._features = [];
+          pbf.readFields(readLayer2, this, end);
+          this.length = this._features.length;
+        }
+        feature(i3, geometryInfo) {
+          if (i3 < 0 || i3 >= this._features.length) {
+            throw new Error("feature index out of bounds");
+          }
+          this._pbf.pos = this._features[i3];
+          const end = this._pbf.readVarint() + this._pbf.pos;
+          return new VectorTileFeature2(this._pbf, end, this.extent, this._keys, this._values, geometryInfo);
+        }
+      };
+    }
+  });
+
+  // ../mvt/src/lib/binary-vector-tile/vector-tile.ts
+  function readTile2(tag, layers, pbf) {
+    if (tag === 3) {
+      if (pbf) {
+        const layer = new VectorTileLayer2(pbf, pbf.readVarint() + pbf.pos);
+        if (layer.length && layers) {
+          layers[layer.name] = layer;
+        }
+      }
+    }
+  }
+  var VectorTile2;
+  var init_vector_tile2 = __esm({
+    "../mvt/src/lib/binary-vector-tile/vector-tile.ts"() {
+      init_vector_tile_layer2();
+      VectorTile2 = class {
+        constructor(pbf, end) {
+          this.layers = pbf.readFields(readTile2, {}, end);
+        }
+      };
+    }
+  });
+
+  // ../mvt/src/lib/parse-mvt.ts
+  function parseMVT(arrayBuffer, options) {
+    const mvtOptions = normalizeOptions(options);
+    const shape = options?.gis?.format || options?.mvt?.shape || options?.shape;
+    switch (shape) {
+      case "columnar-table":
+        return { shape: "columnar-table", data: parseToBinary(arrayBuffer, mvtOptions) };
+      case "geojson-table": {
+        const table = {
+          shape: "geojson-table",
+          type: "FeatureCollection",
+          features: parseToGeojsonFeatures(arrayBuffer, mvtOptions)
+        };
+        return table;
+      }
+      case "geojson":
+        return parseToGeojsonFeatures(arrayBuffer, mvtOptions);
+      case "binary-geometry":
+        return parseToBinary(arrayBuffer, mvtOptions);
+      case "binary":
+        return parseToBinary(arrayBuffer, mvtOptions);
+      default:
+        throw new Error(shape || "undefined shape");
+    }
+  }
+  function parseToBinary(arrayBuffer, options) {
+    const [flatGeoJsonFeatures, geometryInfo] = parseToFlatGeoJson(arrayBuffer, options);
+    const binaryData = flatGeojsonToBinary(flatGeoJsonFeatures, geometryInfo);
+    binaryData.byteLength = arrayBuffer.byteLength;
+    return binaryData;
+  }
+  function parseToFlatGeoJson(arrayBuffer, options) {
+    const features = [];
+    const geometryInfo = {
+      coordLength: 2,
+      pointPositionsCount: 0,
+      pointFeaturesCount: 0,
+      linePositionsCount: 0,
+      linePathsCount: 0,
+      lineFeaturesCount: 0,
+      polygonPositionsCount: 0,
+      polygonObjectsCount: 0,
+      polygonRingsCount: 0,
+      polygonFeaturesCount: 0
+    };
+    if (arrayBuffer.byteLength <= 0) {
+      return [features, geometryInfo];
+    }
+    const tile = new VectorTile2(new import_pbf.default(arrayBuffer));
+    const selectedLayers = options && Array.isArray(options.layers) ? options.layers : Object.keys(tile.layers);
+    selectedLayers.forEach((layerName) => {
+      const vectorTileLayer = tile.layers[layerName];
+      if (!vectorTileLayer) {
+        return;
+      }
+      for (let i3 = 0; i3 < vectorTileLayer.length; i3++) {
+        const vectorTileFeature = vectorTileLayer.feature(i3, geometryInfo);
+        const decodedFeature = getDecodedFeatureBinary(vectorTileFeature, options, layerName);
+        features.push(decodedFeature);
+      }
+    });
+    return [features, geometryInfo];
+  }
+  function parseToGeojsonFeatures(arrayBuffer, options) {
+    if (arrayBuffer.byteLength <= 0) {
+      return [];
+    }
+    const features = [];
+    const tile = new VectorTile(new import_pbf.default(arrayBuffer));
+    const selectedLayers = Array.isArray(options.layers) ? options.layers : Object.keys(tile.layers);
+    selectedLayers.forEach((layerName) => {
+      const vectorTileLayer = tile.layers[layerName];
+      if (!vectorTileLayer) {
+        return;
+      }
+      for (let i3 = 0; i3 < vectorTileLayer.length; i3++) {
+        const vectorTileFeature = vectorTileLayer.feature(i3);
+        const decodedFeature = getDecodedFeature(vectorTileFeature, options, layerName);
+        features.push(decodedFeature);
+      }
+    });
+    return features;
+  }
+  function normalizeOptions(options) {
+    if (!options?.mvt) {
+      throw new Error("mvt options required");
+    }
+    const wgs84Coordinates = options.mvt?.coordinates === "wgs84";
+    const { tileIndex } = options.mvt;
+    const hasTileIndex = tileIndex && Number.isFinite(tileIndex.x) && Number.isFinite(tileIndex.y) && Number.isFinite(tileIndex.z);
+    if (wgs84Coordinates && !hasTileIndex) {
+      throw new Error("MVT Loader: WGS84 coordinates need tileIndex property");
+    }
+    return options.mvt;
+  }
+  function getDecodedFeature(feature, options, layerName) {
+    const decodedFeature = feature.toGeoJSON(options.coordinates === "wgs84" ? options.tileIndex : transformToLocalCoordinates);
+    if (options.layerProperty) {
+      decodedFeature.properties[options.layerProperty] = layerName;
+    }
+    return decodedFeature;
+  }
+  function getDecodedFeatureBinary(feature, options, layerName) {
+    const decodedFeature = feature.toBinaryCoordinates(options.coordinates === "wgs84" ? options.tileIndex : transformToLocalCoordinatesBinary);
+    if (options.layerProperty && decodedFeature.properties) {
+      decodedFeature.properties[options.layerProperty] = layerName;
+    }
+    return decodedFeature;
+  }
+  function transformToLocalCoordinates(line, feature) {
+    const { extent } = feature;
+    for (let i3 = 0; i3 < line.length; i3++) {
+      const p = line[i3];
+      p[0] /= extent;
+      p[1] /= extent;
+    }
+  }
+  function transformToLocalCoordinatesBinary(data, feature) {
+    const { extent } = feature;
+    for (let i3 = 0, il = data.length; i3 < il; ++i3) {
+      data[i3] /= extent;
+    }
+  }
+  var import_pbf;
+  var init_parse_mvt = __esm({
+    "../mvt/src/lib/parse-mvt.ts"() {
+      init_src3();
+      import_pbf = __toModule(require_pbf());
+      init_vector_tile();
+      init_vector_tile2();
+    }
+  });
+
+  // ../mvt/src/mvt-loader.ts
+  var VERSION2, MVTWorkerLoader, MVTLoader;
+  var init_mvt_loader = __esm({
+    "../mvt/src/mvt-loader.ts"() {
+      init_parse_mvt();
+      VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      MVTWorkerLoader = {
+        name: "Mapbox Vector Tile",
+        id: "mvt",
+        module: "mvt",
+        version: VERSION2,
+        extensions: ["mvt", "pbf"],
+        mimeTypes: [
+          "application/vnd.mapbox-vector-tile",
+          "application/x-protobuf"
+        ],
+        worker: true,
+        category: "geometry",
+        options: {
+          mvt: {
+            shape: "geojson",
+            coordinates: "local",
+            layerProperty: "layerName",
+            layers: void 0,
+            tileIndex: null
+          }
+        }
+      };
+      MVTLoader = {
+        ...MVTWorkerLoader,
+        parse: async (arrayBuffer, options) => parseMVT(arrayBuffer, options),
+        parseSync: parseMVT,
+        binary: true
+      };
+    }
+  });
+
+  // ../mvt/src/lib/parse-tilejson.ts
+  function parseTileJSON(jsonMetadata) {
+    if (!jsonMetadata || !isObject(jsonMetadata)) {
+      return null;
+    }
+    const boundingBox = parseBounds(jsonMetadata.bounds);
+    const center = parseCenter(jsonMetadata.center);
+    const maxZoom = safeParseFloat(jsonMetadata.maxzoom);
+    const minZoom = safeParseFloat(jsonMetadata.minzoom);
+    let tileJSON = {
+      name: jsonMetadata.name || "",
+      description: jsonMetadata.description || "",
+      boundingBox,
+      center,
+      maxZoom,
+      minZoom,
+      layers: []
+    };
+    if (typeof jsonMetadata?.json === "string") {
+      try {
+        tileJSON.metaJson = JSON.parse(jsonMetadata.json);
+      } catch (err2) {
+      }
+    }
+    let layers = parseTilestatsLayers(tileJSON.metaJson?.tilestats);
+    if (layers.length === 0) {
+      layers = parseTileJSONLayers(jsonMetadata.vector_layers);
+    }
+    tileJSON = {
+      ...tileJSON,
+      layers
+    };
+    return tileJSON;
+  }
+  function parseTileJSONLayers(layers) {
+    if (!Array.isArray(layers)) {
+      return [];
+    }
+    return layers.map((layer) => ({
+      name: layer.id || "",
+      fields: Object.entries(layer.fields || []).map(([key, datatype]) => ({
+        name: key,
+        ...attributeTypeToFieldType(String(datatype))
+      }))
+    }));
+  }
+  function parseTilestatsLayers(tilestats) {
+    if (isObject(tilestats) && Array.isArray(tilestats.layers)) {
+      return tilestats.layers.map((layer) => parseTilestatsForLayer(layer));
+    }
+    return [];
+  }
+  function parseTilestatsForLayer(layer) {
+    const fields = [];
+    const indexedAttributes = {};
+    const attributes = layer.attributes || [];
+    for (const attr of attributes) {
+      const name = attr.attribute;
+      if (typeof name === "string") {
+        if (name.split("|").length > 1) {
+          const fname = name.split("|")[0];
+          indexedAttributes[fname] = indexedAttributes[fname] || [];
+          indexedAttributes[fname].push(attr);
+        } else if (!fields[name]) {
+          fields[name] = attributeToField(attr);
+        } else {
+        }
+      }
+    }
+    return {
+      name: layer.layer || "",
+      dominantGeometry: layer.geometry,
+      fields
+    };
+  }
+  function parseBounds(bounds) {
+    const result = fromArrayOrString(bounds);
+    if (Array.isArray(result) && result.length === 4 && [result[0], result[2]].every(isLng) && [result[1], result[3]].every(isLat)) {
+      return [
+        [result[0], result[1]],
+        [result[2], result[3]]
+      ];
+    }
+    return void 0;
+  }
+  function parseCenter(center) {
+    const result = fromArrayOrString(center);
+    if (Array.isArray(result) && result.length === 3 && isLng(result[0]) && isLat(result[1]) && isZoom(result[2])) {
+      return result;
+    }
+    return null;
+  }
+  function safeParseFloat(input) {
+    const result = typeof input === "string" ? parseFloat(input) : typeof input === "number" ? input : null;
+    return result === null || isNaN(result) ? null : result;
+  }
+  function isLat(num) {
+    return Number.isFinite(num) && num <= 90 && num >= -90;
+  }
+  function isLng(num) {
+    return Number.isFinite(num) && num <= 180 && num >= -180;
+  }
+  function isZoom(num) {
+    return Number.isFinite(num) && num >= 0 && num <= 22;
+  }
+  function fromArrayOrString(data) {
+    if (typeof data === "string") {
+      return data.split(",").map(parseFloat);
+    } else if (Array.isArray(data)) {
+      return data;
+    }
+    return null;
+  }
+  function attributeToField(attribute = {}) {
+    const fieldTypes = attributeTypeToFieldType(attribute.type);
+    return {
+      name: attribute.attribute,
+      ...fieldTypes
+    };
+  }
+  function attributeTypeToFieldType(aType) {
+    const type = aType.toLowerCase();
+    if (!type || !attrTypeMap[type]) {
+    }
+    return attrTypeMap[type] || { type: "string" };
+  }
+  var isObject, attrTypeMap;
+  var init_parse_tilejson = __esm({
+    "../mvt/src/lib/parse-tilejson.ts"() {
+      isObject = (x3) => x3 !== null && typeof x3 === "object";
+      attrTypeMap = {
+        number: {
+          type: "float32"
+        },
+        numeric: {
+          type: "float32"
+        },
+        string: {
+          type: "utf8"
+        },
+        vachar: {
+          type: "utf8"
+        },
+        float: {
+          type: "float32"
+        },
+        int: {
+          type: "int32"
+        },
+        int4: {
+          type: "int32"
+        },
+        boolean: {
+          type: "boolean"
+        },
+        bool: {
+          type: "boolean"
+        }
+      };
+    }
+  });
+
+  // ../mvt/src/tilejson-loader.ts
+  var VERSION3, TileJSONLoader;
+  var init_tilejson_loader = __esm({
+    "../mvt/src/tilejson-loader.ts"() {
+      init_parse_tilejson();
+      VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      TileJSONLoader = {
+        name: "TileJSON",
+        id: "tilejson",
+        module: "pmtiles",
+        version: VERSION3,
+        worker: true,
+        extensions: ["json"],
+        mimeTypes: ["application/json"],
+        text: true,
+        options: {
+          tilejson: {}
+        },
+        parse: async (arrayBuffer, options) => {
+          const jsonString = new TextDecoder().decode(arrayBuffer);
+          const json = JSON.parse(jsonString);
+          return parseTileJSON(json);
+        },
+        parseTextSync: (text, options) => {
+          const json = JSON.parse(text);
+          return parseTileJSON(json);
+        }
+      };
+    }
+  });
+
+  // ../mvt/src/index.ts
+  var init_src4 = __esm({
+    "../mvt/src/index.ts"() {
+      init_mvt_loader();
+      init_tilejson_loader();
+    }
+  });
+
+  // ../../node_modules/pmtiles/dist/index.mjs
+  function inflateSync(data, opts) {
+    return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary);
+  }
+  function gunzipSync(data, opts) {
+    var st = gzs(data);
+    if (st + 8 > data.length)
+      err(6, "invalid gzip data");
+    return inflt(data.subarray(st, -8), { i: 2 }, opts && opts.out || new u8(gzl(data)), opts && opts.dictionary);
+  }
+  function unzlibSync(data, opts) {
+    return inflt(data.subarray(zls(data, opts && opts.dictionary), -4), { i: 2 }, opts && opts.out, opts && opts.dictionary);
+  }
+  function decompressSync(data, opts) {
+    return data[0] == 31 && data[1] == 139 && data[2] == 8 ? gunzipSync(data, opts) : (data[0] & 15) != 8 || data[0] >> 4 > 7 || (data[0] << 8 | data[1]) % 31 ? inflateSync(data, opts) : unzlibSync(data, opts);
+  }
+  function getHeader(source) {
+    return __async(this, null, function* () {
+      const resp = yield source.getBytes(0, 512e3);
+      const dataview = new DataView(resp.data);
+      const json_size = dataview.getUint32(4, true);
+      const root_entries = dataview.getUint16(8, true);
+      const dec = new TextDecoder("utf-8");
+      const json_metadata = JSON.parse(dec.decode(new DataView(resp.data, 10, json_size)));
+      let tile_compression = 0;
+      if (json_metadata.compression === "gzip") {
+        tile_compression = 2;
+      }
+      let minzoom = 0;
+      if ("minzoom" in json_metadata) {
+        minzoom = +json_metadata.minzoom;
+      }
+      let maxzoom = 0;
+      if ("maxzoom" in json_metadata) {
+        maxzoom = +json_metadata.maxzoom;
+      }
+      let center_lon = 0;
+      let center_lat = 0;
+      let center_zoom = 0;
+      let min_lon = -180;
+      let min_lat = -85;
+      let max_lon = 180;
+      let max_lat = 85;
+      if (json_metadata.bounds) {
+        const split = json_metadata.bounds.split(",");
+        min_lon = +split[0];
+        min_lat = +split[1];
+        max_lon = +split[2];
+        max_lat = +split[3];
+      }
+      if (json_metadata.center) {
+        const split = json_metadata.center.split(",");
+        center_lon = +split[0];
+        center_lat = +split[1];
+        center_zoom = +split[2];
+      }
+      const header = {
+        specVersion: dataview.getUint16(2, true),
+        rootDirectoryOffset: 10 + json_size,
+        rootDirectoryLength: root_entries * 17,
+        jsonMetadataOffset: 10,
+        jsonMetadataLength: json_size,
+        leafDirectoryOffset: 0,
+        leafDirectoryLength: void 0,
+        tileDataOffset: 0,
+        tileDataLength: void 0,
+        numAddressedTiles: 0,
+        numTileEntries: 0,
+        numTileContents: 0,
+        clustered: false,
+        internalCompression: 1,
+        tileCompression: tile_compression,
+        tileType: 1,
+        minZoom: minzoom,
+        maxZoom: maxzoom,
+        minLon: min_lon,
+        minLat: min_lat,
+        maxLon: max_lon,
+        maxLat: max_lat,
+        centerZoom: center_zoom,
+        centerLon: center_lon,
+        centerLat: center_lat,
+        etag: resp.etag
+      };
+      return header;
+    });
+  }
+  function getZxy(header, source, cache, z, x3, y2, signal) {
+    return __async(this, null, function* () {
+      let root_dir = yield cache.getArrayBuffer(source, header.rootDirectoryOffset, header.rootDirectoryLength, header);
+      if (header.specVersion === 1) {
+        root_dir = sortDir(root_dir);
+      }
+      const entry = queryTile(new DataView(root_dir), z, x3, y2);
+      if (entry) {
+        const resp = yield source.getBytes(entry.offset, entry.length, signal);
+        let tile_data = resp.data;
+        const view = new DataView(tile_data);
+        if (view.getUint8(0) == 31 && view.getUint8(1) == 139) {
+          tile_data = decompressSync(new Uint8Array(tile_data));
+        }
+        return {
+          data: tile_data
+        };
+      }
+      const leafcoords = deriveLeaf(new DataView(root_dir), { z, x: x3, y: y2 });
+      if (leafcoords) {
+        const leafdir_entry = queryLeafdir(new DataView(root_dir), leafcoords.z, leafcoords.x, leafcoords.y);
+        if (leafdir_entry) {
+          let leaf_dir = yield cache.getArrayBuffer(source, leafdir_entry.offset, leafdir_entry.length, header);
+          if (header.specVersion === 1) {
+            leaf_dir = sortDir(leaf_dir);
+          }
+          const tile_entry = queryTile(new DataView(leaf_dir), z, x3, y2);
+          if (tile_entry) {
+            const resp = yield source.getBytes(tile_entry.offset, tile_entry.length, signal);
+            let tile_data = resp.data;
+            const view = new DataView(tile_data);
+            if (view.getUint8(0) == 31 && view.getUint8(1) == 139) {
+              tile_data = decompressSync(new Uint8Array(tile_data));
+            }
+            return {
+              data: tile_data
+            };
+          }
+        }
+      }
+      return void 0;
+    });
+  }
+  function toNum(low, high) {
+    return (high >>> 0) * 4294967296 + (low >>> 0);
+  }
+  function readVarintRemainder(l, p) {
+    const buf = p.buf;
+    let h, b;
+    b = buf[p.pos++];
+    h = (b & 112) >> 4;
+    if (b < 128)
+      return toNum(l, h);
+    b = buf[p.pos++];
+    h |= (b & 127) << 3;
+    if (b < 128)
+      return toNum(l, h);
+    b = buf[p.pos++];
+    h |= (b & 127) << 10;
+    if (b < 128)
+      return toNum(l, h);
+    b = buf[p.pos++];
+    h |= (b & 127) << 17;
+    if (b < 128)
+      return toNum(l, h);
+    b = buf[p.pos++];
+    h |= (b & 127) << 24;
+    if (b < 128)
+      return toNum(l, h);
+    b = buf[p.pos++];
+    h |= (b & 1) << 31;
+    if (b < 128)
+      return toNum(l, h);
+    throw new Error("Expected varint not more than 10 bytes");
+  }
+  function readVarint(p) {
+    const buf = p.buf;
+    let val, b;
+    b = buf[p.pos++];
+    val = b & 127;
+    if (b < 128)
+      return val;
+    b = buf[p.pos++];
+    val |= (b & 127) << 7;
+    if (b < 128)
+      return val;
+    b = buf[p.pos++];
+    val |= (b & 127) << 14;
+    if (b < 128)
+      return val;
+    b = buf[p.pos++];
+    val |= (b & 127) << 21;
+    if (b < 128)
+      return val;
+    b = buf[p.pos];
+    val |= (b & 15) << 28;
+    return readVarintRemainder(val, p);
+  }
+  function rotate(n, xy, rx, ry) {
+    if (ry == 0) {
+      if (rx == 1) {
+        xy[0] = n - 1 - xy[0];
+        xy[1] = n - 1 - xy[1];
+      }
+      const t = xy[0];
+      xy[0] = xy[1];
+      xy[1] = t;
+    }
+  }
+  function zxyToTileId(z, x3, y2) {
+    if (z > 26) {
+      throw Error("Tile zoom level exceeds max safe number limit (26)");
+    }
+    if (x3 > Math.pow(2, z) - 1 || y2 > Math.pow(2, z) - 1) {
+      throw Error("tile x/y outside zoom level bounds");
+    }
+    const acc = tzValues[z];
+    const n = Math.pow(2, z);
+    let rx = 0;
+    let ry = 0;
+    let d = 0;
+    const xy = [x3, y2];
+    let s = n / 2;
+    while (s > 0) {
+      rx = (xy[0] & s) > 0 ? 1 : 0;
+      ry = (xy[1] & s) > 0 ? 1 : 0;
+      d += s * s * (3 * rx ^ ry);
+      rotate(s, xy, rx, ry);
+      s = s / 2;
+    }
+    return acc + d;
+  }
+  function defaultDecompress(buf, compression) {
+    return __async(this, null, function* () {
+      if (compression === 1 || compression === 0) {
+        return buf;
+      } else if (compression === 2) {
+        if (typeof globalThis.DecompressionStream == "undefined") {
+          return decompressSync(new Uint8Array(buf));
+        } else {
+          let stream = new Response(buf).body;
+          let result = stream.pipeThrough(new globalThis.DecompressionStream("gzip"));
+          return new Response(result).arrayBuffer();
+        }
+      } else {
+        throw Error("Compression method not supported");
+      }
+    });
+  }
+  function findTile(entries, tileId) {
+    let m = 0;
+    let n = entries.length - 1;
+    while (m <= n) {
+      const k = n + m >> 1;
+      const cmp = tileId - entries[k].tileId;
+      if (cmp > 0) {
+        m = k + 1;
+      } else if (cmp < 0) {
+        n = k - 1;
+      } else {
+        return entries[k];
+      }
+    }
+    if (n >= 0) {
+      if (entries[n].runLength === 0) {
+        return entries[n];
+      }
+      if (tileId - entries[n].tileId < entries[n].runLength) {
+        return entries[n];
+      }
+    }
+    return null;
+  }
+  function getUint64(v, offset) {
+    const wh = v.getUint32(offset + 4, true);
+    const wl = v.getUint32(offset + 0, true);
+    return wh * Math.pow(2, 32) + wl;
+  }
+  function bytesToHeader(bytes, etag) {
+    const v = new DataView(bytes);
+    const spec_version = v.getUint8(7);
+    if (spec_version > 3) {
+      throw Error(`Archive is spec version ${spec_version} but this library supports up to spec version 3`);
+    }
+    return {
+      specVersion: spec_version,
+      rootDirectoryOffset: getUint64(v, 8),
+      rootDirectoryLength: getUint64(v, 16),
+      jsonMetadataOffset: getUint64(v, 24),
+      jsonMetadataLength: getUint64(v, 32),
+      leafDirectoryOffset: getUint64(v, 40),
+      leafDirectoryLength: getUint64(v, 48),
+      tileDataOffset: getUint64(v, 56),
+      tileDataLength: getUint64(v, 64),
+      numAddressedTiles: getUint64(v, 72),
+      numTileEntries: getUint64(v, 80),
+      numTileContents: getUint64(v, 88),
+      clustered: v.getUint8(96) === 1,
+      internalCompression: v.getUint8(97),
+      tileCompression: v.getUint8(98),
+      tileType: v.getUint8(99),
+      minZoom: v.getUint8(100),
+      maxZoom: v.getUint8(101),
+      minLon: v.getInt32(102, true) / 1e7,
+      minLat: v.getInt32(106, true) / 1e7,
+      maxLon: v.getInt32(110, true) / 1e7,
+      maxLat: v.getInt32(114, true) / 1e7,
+      centerZoom: v.getUint8(118),
+      centerLon: v.getInt32(119, true) / 1e7,
+      centerLat: v.getInt32(123, true) / 1e7,
+      etag
+    };
+  }
+  function deserializeIndex(buffer) {
+    const p = { buf: new Uint8Array(buffer), pos: 0 };
+    const numEntries = readVarint(p);
+    const entries = [];
+    let lastId = 0;
+    for (let i3 = 0; i3 < numEntries; i3++) {
+      const v = readVarint(p);
+      entries.push({ tileId: lastId + v, offset: 0, length: 0, runLength: 1 });
+      lastId += v;
+    }
+    for (let i3 = 0; i3 < numEntries; i3++) {
+      entries[i3].runLength = readVarint(p);
+    }
+    for (let i3 = 0; i3 < numEntries; i3++) {
+      entries[i3].length = readVarint(p);
+    }
+    for (let i3 = 0; i3 < numEntries; i3++) {
+      const v = readVarint(p);
+      if (v === 0 && i3 > 0) {
+        entries[i3].offset = entries[i3 - 1].offset + entries[i3 - 1].length;
+      } else {
+        entries[i3].offset = v - 1;
+      }
+    }
+    return entries;
+  }
+  function detectVersion(a) {
+    const v = new DataView(a);
+    if (v.getUint16(2, true) === 2) {
+      console.warn("PMTiles spec version 2 has been deprecated; please see github.com/protomaps/PMTiles for tools to upgrade");
+      return 2;
+    } else if (v.getUint16(2, true) === 1) {
+      console.warn("PMTiles spec version 1 has been deprecated; please see github.com/protomaps/PMTiles for tools to upgrade");
+      return 1;
+    }
+    return 3;
+  }
+  function getHeaderAndRoot(source, decompress, prefetch, current_etag) {
+    return __async(this, null, function* () {
+      const resp = yield source.getBytes(0, 16384);
+      const v = new DataView(resp.data);
+      if (v.getUint16(0, true) !== 19792) {
+        throw new Error("Wrong magic number for PMTiles archive");
+      }
+      if (detectVersion(resp.data) < 3) {
+        return [yield v2_default.getHeader(source)];
+      }
+      const headerData = resp.data.slice(0, HEADER_SIZE_BYTES);
+      let resp_etag = resp.etag;
+      if (current_etag && resp.etag != current_etag) {
+        console.warn("ETag conflict detected; your HTTP server might not support content-based ETag headers. ETags disabled for " + source.getKey());
+        resp_etag = void 0;
+      }
+      const header = bytesToHeader(headerData, resp_etag);
+      if (prefetch) {
+        const rootDirData = resp.data.slice(header.rootDirectoryOffset, header.rootDirectoryOffset + header.rootDirectoryLength);
+        const dirKey = source.getKey() + "|" + (header.etag || "") + "|" + header.rootDirectoryOffset + "|" + header.rootDirectoryLength;
+        const rootDir = deserializeIndex(yield decompress(rootDirData, header.internalCompression));
+        return [header, [dirKey, rootDir.length, rootDir]];
+      }
+      return [header, void 0];
+    });
+  }
+  function getDirectory(source, decompress, offset, length2, header) {
+    return __async(this, null, function* () {
+      const resp = yield source.getBytes(offset, length2);
+      if (header.etag && header.etag !== resp.etag) {
+        throw new EtagMismatch(resp.etag);
+      }
+      const data = yield decompress(resp.data, header.internalCompression);
+      const directory = deserializeIndex(data);
+      if (directory.length === 0) {
+        throw new Error("Empty directory is invalid");
+      }
+      return directory;
+    });
+  }
+  var __async, u8, u16, i32, fleb, fdeb, clim, freb, _a, fl, revfl, _b, fd, revfd, rev, x2, i2, hMap, flt, i2, i2, i2, i2, fdt, i2, flrm, fdrm, max, bits, bits16, shft, slc, ec, err, inflt, et, gzs, gzl, zls, td, tds, shift, unshift, getUint24, getUint48, compare, queryLeafdir, queryTile, queryView, entrySort, parseEntry, sortDir, createDirectory, deriveLeaf, v2_default, tzValues, TileType, HEADER_SIZE_BYTES, FetchSource, EtagMismatch, SharedPromiseCache, PMTiles;
+  var init_dist = __esm({
+    "../../node_modules/pmtiles/dist/index.mjs"() {
+      __async = (__this, __arguments, generator) => {
+        return new Promise((resolve, reject) => {
+          var fulfilled = (value) => {
+            try {
+              step(generator.next(value));
+            } catch (e) {
+              reject(e);
+            }
+          };
+          var rejected = (value) => {
+            try {
+              step(generator.throw(value));
+            } catch (e) {
+              reject(e);
+            }
+          };
+          var step = (x3) => x3.done ? resolve(x3.value) : Promise.resolve(x3.value).then(fulfilled, rejected);
+          step((generator = generator.apply(__this, __arguments)).next());
+        });
+      };
+      u8 = Uint8Array;
+      u16 = Uint16Array;
+      i32 = Int32Array;
+      fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0, 0]);
+      fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 0, 0]);
+      clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+      freb = function(eb, start) {
+        var b = new u16(31);
+        for (var i3 = 0; i3 < 31; ++i3) {
+          b[i3] = start += 1 << eb[i3 - 1];
+        }
+        var r = new i32(b[30]);
+        for (var i3 = 1; i3 < 30; ++i3) {
+          for (var j = b[i3]; j < b[i3 + 1]; ++j) {
+            r[j] = j - b[i3] << 5 | i3;
+          }
+        }
+        return { b, r };
+      };
+      _a = freb(fleb, 2);
+      fl = _a.b;
+      revfl = _a.r;
+      fl[28] = 258, revfl[258] = 28;
+      _b = freb(fdeb, 0);
+      fd = _b.b;
+      revfd = _b.r;
+      rev = new u16(32768);
+      for (i2 = 0; i2 < 32768; ++i2) {
+        x2 = (i2 & 43690) >> 1 | (i2 & 21845) << 1;
+        x2 = (x2 & 52428) >> 2 | (x2 & 13107) << 2;
+        x2 = (x2 & 61680) >> 4 | (x2 & 3855) << 4;
+        rev[i2] = ((x2 & 65280) >> 8 | (x2 & 255) << 8) >> 1;
+      }
+      hMap = function(cd, mb, r) {
+        var s = cd.length;
+        var i3 = 0;
+        var l = new u16(mb);
+        for (; i3 < s; ++i3) {
+          if (cd[i3])
+            ++l[cd[i3] - 1];
+        }
+        var le = new u16(mb);
+        for (i3 = 1; i3 < mb; ++i3) {
+          le[i3] = le[i3 - 1] + l[i3 - 1] << 1;
+        }
+        var co;
+        if (r) {
+          co = new u16(1 << mb);
+          var rvb = 15 - mb;
+          for (i3 = 0; i3 < s; ++i3) {
+            if (cd[i3]) {
+              var sv = i3 << 4 | cd[i3];
+              var r_1 = mb - cd[i3];
+              var v = le[cd[i3] - 1]++ << r_1;
+              for (var m = v | (1 << r_1) - 1; v <= m; ++v) {
+                co[rev[v] >> rvb] = sv;
+              }
+            }
+          }
+        } else {
+          co = new u16(s);
+          for (i3 = 0; i3 < s; ++i3) {
+            if (cd[i3]) {
+              co[i3] = rev[le[cd[i3] - 1]++] >> 15 - cd[i3];
+            }
+          }
+        }
+        return co;
+      };
+      flt = new u8(288);
+      for (i2 = 0; i2 < 144; ++i2)
+        flt[i2] = 8;
+      for (i2 = 144; i2 < 256; ++i2)
+        flt[i2] = 9;
+      for (i2 = 256; i2 < 280; ++i2)
+        flt[i2] = 7;
+      for (i2 = 280; i2 < 288; ++i2)
+        flt[i2] = 8;
+      fdt = new u8(32);
+      for (i2 = 0; i2 < 32; ++i2)
+        fdt[i2] = 5;
+      flrm = /* @__PURE__ */ hMap(flt, 9, 1);
+      fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
+      max = function(a) {
+        var m = a[0];
+        for (var i3 = 1; i3 < a.length; ++i3) {
+          if (a[i3] > m)
+            m = a[i3];
+        }
+        return m;
+      };
+      bits = function(d, p, m) {
+        var o = p / 8 | 0;
+        return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
+      };
+      bits16 = function(d, p) {
+        var o = p / 8 | 0;
+        return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
+      };
+      shft = function(p) {
+        return (p + 7) / 8 | 0;
+      };
+      slc = function(v, s, e) {
+        if (s == null || s < 0)
+          s = 0;
+        if (e == null || e > v.length)
+          e = v.length;
+        var n = new u8(e - s);
+        n.set(v.subarray(s, e));
+        return n;
+      };
+      ec = [
+        "unexpected EOF",
+        "invalid block type",
+        "invalid length/literal",
+        "invalid distance",
+        "stream finished",
+        "no stream handler",
+        ,
+        "no callback",
+        "invalid UTF-8 data",
+        "extra field too long",
+        "date not in range 1980-2099",
+        "filename too long",
+        "stream finishing",
+        "invalid zip data"
+      ];
+      err = function(ind, msg, nt) {
+        var e = new Error(msg || ec[ind]);
+        e.code = ind;
+        if (Error.captureStackTrace)
+          Error.captureStackTrace(e, err);
+        if (!nt)
+          throw e;
+        return e;
+      };
+      inflt = function(dat, st, buf, dict) {
+        var sl = dat.length, dl = dict ? dict.length : 0;
+        if (!sl || st.f && !st.l)
+          return buf || new u8(0);
+        var noBuf = !buf || st.i != 2;
+        var noSt = st.i;
+        if (!buf)
+          buf = new u8(sl * 3);
+        var cbuf = function(l2) {
+          var bl = buf.length;
+          if (l2 > bl) {
+            var nbuf = new u8(Math.max(bl * 2, l2));
+            nbuf.set(buf);
+            buf = nbuf;
+          }
+        };
+        var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+        var tbts = sl * 8;
+        do {
+          if (!lm) {
+            final = bits(dat, pos, 1);
+            var type = bits(dat, pos + 1, 3);
+            pos += 3;
+            if (!type) {
+              var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
+              if (t > sl) {
+                if (noSt)
+                  err(0);
+                break;
+              }
+              if (noBuf)
+                cbuf(bt + l);
+              buf.set(dat.subarray(s, t), bt);
+              st.b = bt += l, st.p = pos = t * 8, st.f = final;
+              continue;
+            } else if (type == 1)
+              lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+            else if (type == 2) {
+              var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+              var tl = hLit + bits(dat, pos + 5, 31) + 1;
+              pos += 14;
+              var ldt = new u8(tl);
+              var clt = new u8(19);
+              for (var i3 = 0; i3 < hcLen; ++i3) {
+                clt[clim[i3]] = bits(dat, pos + i3 * 3, 7);
+              }
+              pos += hcLen * 3;
+              var clb = max(clt), clbmsk = (1 << clb) - 1;
+              var clm = hMap(clt, clb, 1);
+              for (var i3 = 0; i3 < tl; ) {
+                var r = clm[bits(dat, pos, clbmsk)];
+                pos += r & 15;
+                var s = r >> 4;
+                if (s < 16) {
+                  ldt[i3++] = s;
+                } else {
+                  var c = 0, n = 0;
+                  if (s == 16)
+                    n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i3 - 1];
+                  else if (s == 17)
+                    n = 3 + bits(dat, pos, 7), pos += 3;
+                  else if (s == 18)
+                    n = 11 + bits(dat, pos, 127), pos += 7;
+                  while (n--)
+                    ldt[i3++] = c;
+                }
+              }
+              var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+              lbt = max(lt);
+              dbt = max(dt);
+              lm = hMap(lt, lbt, 1);
+              dm = hMap(dt, dbt, 1);
+            } else
+              err(1);
+            if (pos > tbts) {
+              if (noSt)
+                err(0);
+              break;
+            }
+          }
+          if (noBuf)
+            cbuf(bt + 131072);
+          var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+          var lpos = pos;
+          for (; ; lpos = pos) {
+            var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
+            pos += c & 15;
+            if (pos > tbts) {
+              if (noSt)
+                err(0);
+              break;
+            }
+            if (!c)
+              err(2);
+            if (sym < 256)
+              buf[bt++] = sym;
+            else if (sym == 256) {
+              lpos = pos, lm = null;
+              break;
+            } else {
+              var add = sym - 254;
+              if (sym > 264) {
+                var i3 = sym - 257, b = fleb[i3];
+                add = bits(dat, pos, (1 << b) - 1) + fl[i3];
+                pos += b;
+              }
+              var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
+              if (!d)
+                err(3);
+              pos += d & 15;
+              var dt = fd[dsym];
+              if (dsym > 3) {
+                var b = fdeb[dsym];
+                dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+              }
+              if (pos > tbts) {
+                if (noSt)
+                  err(0);
+                break;
+              }
+              if (noBuf)
+                cbuf(bt + 131072);
+              var end = bt + add;
+              if (bt < dt) {
+                var shift2 = dl - dt, dend = Math.min(dt, end);
+                if (shift2 + bt < 0)
+                  err(3);
+                for (; bt < dend; ++bt)
+                  buf[bt] = dict[shift2 + bt];
+              }
+              for (; bt < end; bt += 4) {
+                buf[bt] = buf[bt - dt];
+                buf[bt + 1] = buf[bt + 1 - dt];
+                buf[bt + 2] = buf[bt + 2 - dt];
+                buf[bt + 3] = buf[bt + 3 - dt];
+              }
+              bt = end;
+            }
+          }
+          st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+          if (lm)
+            final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+        } while (!final);
+        return bt == buf.length ? buf : slc(buf, 0, bt);
+      };
+      et = /* @__PURE__ */ new u8(0);
+      gzs = function(d) {
+        if (d[0] != 31 || d[1] != 139 || d[2] != 8)
+          err(6, "invalid gzip data");
+        var flg = d[3];
+        var st = 10;
+        if (flg & 4)
+          st += (d[10] | d[11] << 8) + 2;
+        for (var zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++])
+          ;
+        return st + (flg & 2);
+      };
+      gzl = function(d) {
+        var l = d.length;
+        return (d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16 | d[l - 1] << 24) >>> 0;
+      };
+      zls = function(d, dict) {
+        if ((d[0] & 15) != 8 || d[0] >> 4 > 7 || (d[0] << 8 | d[1]) % 31)
+          err(6, "invalid zlib data");
+        if ((d[1] >> 5 & 1) == +!dict)
+          err(6, "invalid zlib data: " + (d[1] & 32 ? "need" : "unexpected") + " dictionary");
+        return (d[1] >> 3 & 4) + 2;
+      };
+      td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder();
+      tds = 0;
+      try {
+        td.decode(et, { stream: true });
+        tds = 1;
+      } catch (e) {
+      }
+      shift = (n, shift2) => {
+        return n * Math.pow(2, shift2);
+      };
+      unshift = (n, shift2) => {
+        return Math.floor(n / Math.pow(2, shift2));
+      };
+      getUint24 = (view, pos) => {
+        return shift(view.getUint16(pos + 1, true), 8) + view.getUint8(pos);
+      };
+      getUint48 = (view, pos) => {
+        return shift(view.getUint32(pos + 2, true), 16) + view.getUint16(pos, true);
+      };
+      compare = (tz, tx, ty, view, i3) => {
+        if (tz != view.getUint8(i3))
+          return tz - view.getUint8(i3);
+        const x3 = getUint24(view, i3 + 1);
+        if (tx != x3)
+          return tx - x3;
+        const y2 = getUint24(view, i3 + 4);
+        if (ty != y2)
+          return ty - y2;
+        return 0;
+      };
+      queryLeafdir = (view, z, x3, y2) => {
+        const offset_len = queryView(view, z | 128, x3, y2);
+        if (offset_len) {
+          return {
+            z,
+            x: x3,
+            y: y2,
+            offset: offset_len[0],
+            length: offset_len[1],
+            is_dir: true
+          };
+        }
+        return null;
+      };
+      queryTile = (view, z, x3, y2) => {
+        const offset_len = queryView(view, z, x3, y2);
+        if (offset_len) {
+          return {
+            z,
+            x: x3,
+            y: y2,
+            offset: offset_len[0],
+            length: offset_len[1],
+            is_dir: false
+          };
+        }
+        return null;
+      };
+      queryView = (view, z, x3, y2) => {
+        let m = 0;
+        let n = view.byteLength / 17 - 1;
+        while (m <= n) {
+          const k = n + m >> 1;
+          const cmp = compare(z, x3, y2, view, k * 17);
+          if (cmp > 0) {
+            m = k + 1;
+          } else if (cmp < 0) {
+            n = k - 1;
+          } else {
+            return [getUint48(view, k * 17 + 7), view.getUint32(k * 17 + 13, true)];
+          }
+        }
+        return null;
+      };
+      entrySort = (a, b) => {
+        if (a.is_dir && !b.is_dir) {
+          return 1;
+        }
+        if (!a.is_dir && b.is_dir) {
+          return -1;
+        }
+        if (a.z !== b.z) {
+          return a.z - b.z;
+        }
+        if (a.x !== b.x) {
+          return a.x - b.x;
+        }
+        return a.y - b.y;
+      };
+      parseEntry = (dataview, i3) => {
+        const z_raw = dataview.getUint8(i3 * 17);
+        const z = z_raw & 127;
+        return {
+          z,
+          x: getUint24(dataview, i3 * 17 + 1),
+          y: getUint24(dataview, i3 * 17 + 4),
+          offset: getUint48(dataview, i3 * 17 + 7),
+          length: dataview.getUint32(i3 * 17 + 13, true),
+          is_dir: z_raw >> 7 === 1
+        };
+      };
+      sortDir = (a) => {
+        const entries = [];
+        const view = new DataView(a);
+        for (let i3 = 0; i3 < view.byteLength / 17; i3++) {
+          entries.push(parseEntry(view, i3));
+        }
+        return createDirectory(entries);
+      };
+      createDirectory = (entries) => {
+        entries.sort(entrySort);
+        const buffer = new ArrayBuffer(17 * entries.length);
+        const arr = new Uint8Array(buffer);
+        for (let i3 = 0; i3 < entries.length; i3++) {
+          const entry = entries[i3];
+          let z = entry.z;
+          if (entry.is_dir)
+            z = z | 128;
+          arr[i3 * 17] = z;
+          arr[i3 * 17 + 1] = entry.x & 255;
+          arr[i3 * 17 + 2] = entry.x >> 8 & 255;
+          arr[i3 * 17 + 3] = entry.x >> 16 & 255;
+          arr[i3 * 17 + 4] = entry.y & 255;
+          arr[i3 * 17 + 5] = entry.y >> 8 & 255;
+          arr[i3 * 17 + 6] = entry.y >> 16 & 255;
+          arr[i3 * 17 + 7] = entry.offset & 255;
+          arr[i3 * 17 + 8] = unshift(entry.offset, 8) & 255;
+          arr[i3 * 17 + 9] = unshift(entry.offset, 16) & 255;
+          arr[i3 * 17 + 10] = unshift(entry.offset, 24) & 255;
+          arr[i3 * 17 + 11] = unshift(entry.offset, 32) & 255;
+          arr[i3 * 17 + 12] = unshift(entry.offset, 48) & 255;
+          arr[i3 * 17 + 13] = entry.length & 255;
+          arr[i3 * 17 + 14] = entry.length >> 8 & 255;
+          arr[i3 * 17 + 15] = entry.length >> 16 & 255;
+          arr[i3 * 17 + 16] = entry.length >> 24 & 255;
+        }
+        return buffer;
+      };
+      deriveLeaf = (view, tile) => {
+        if (view.byteLength < 17)
+          return null;
+        const numEntries = view.byteLength / 17;
+        const entry = parseEntry(view, numEntries - 1);
+        if (entry.is_dir) {
+          const leaf_level = entry.z;
+          const level_diff = tile.z - leaf_level;
+          const leaf_x = Math.trunc(tile.x / (1 << level_diff));
+          const leaf_y = Math.trunc(tile.y / (1 << level_diff));
+          return { z: leaf_level, x: leaf_x, y: leaf_y };
+        }
+        return null;
+      };
+      v2_default = {
+        getHeader,
+        getZxy
+      };
+      tzValues = [
+        0,
+        1,
+        5,
+        21,
+        85,
+        341,
+        1365,
+        5461,
+        21845,
+        87381,
+        349525,
+        1398101,
+        5592405,
+        22369621,
+        89478485,
+        357913941,
+        1431655765,
+        5726623061,
+        22906492245,
+        91625968981,
+        366503875925,
+        1466015503701,
+        5864062014805,
+        23456248059221,
+        93824992236885,
+        375299968947541,
+        1501199875790165
+      ];
+      TileType = /* @__PURE__ */ ((TileType2) => {
+        TileType2[TileType2["Unknown"] = 0] = "Unknown";
+        TileType2[TileType2["Mvt"] = 1] = "Mvt";
+        TileType2[TileType2["Png"] = 2] = "Png";
+        TileType2[TileType2["Jpeg"] = 3] = "Jpeg";
+        TileType2[TileType2["Webp"] = 4] = "Webp";
+        TileType2[TileType2["Avif"] = 5] = "Avif";
+        return TileType2;
+      })(TileType || {});
+      HEADER_SIZE_BYTES = 127;
+      FetchSource = class {
+        constructor(url) {
+          this.url = url;
+        }
+        getKey() {
+          return this.url;
+        }
+        getBytes(offset, length2, signal) {
+          return __async(this, null, function* () {
+            let controller;
+            if (!signal) {
+              controller = new AbortController();
+              signal = controller.signal;
+            }
+            let resp = yield fetch(this.url, {
+              signal,
+              headers: { Range: "bytes=" + offset + "-" + (offset + length2 - 1) }
+            });
+            if (resp.status === 416 && offset === 0) {
+              const content_range = resp.headers.get("Content-Range");
+              if (!content_range || !content_range.startsWith("bytes */")) {
+                throw Error("Missing content-length on 416 response");
+              }
+              const actual_length = +content_range.substr(8);
+              resp = yield fetch(this.url, {
+                signal,
+                headers: { Range: "bytes=0-" + (actual_length - 1) }
+              });
+            }
+            if (resp.status >= 300) {
+              throw Error("Bad response code: " + resp.status);
+            }
+            const content_length = resp.headers.get("Content-Length");
+            if (resp.status === 200 && (!content_length || +content_length > length2)) {
+              if (controller)
+                controller.abort();
+              throw Error("Server returned no content-length header or content-length exceeding request. Check that your storage backend supports HTTP Byte Serving.");
+            }
+            const a = yield resp.arrayBuffer();
+            return {
+              data: a,
+              etag: resp.headers.get("ETag") || void 0,
+              cacheControl: resp.headers.get("Cache-Control") || void 0,
+              expires: resp.headers.get("Expires") || void 0
+            };
+          });
+        }
+      };
+      EtagMismatch = class extends Error {
+      };
+      SharedPromiseCache = class {
+        constructor(maxCacheEntries = 100, prefetch = true, decompress = defaultDecompress) {
+          this.cache = /* @__PURE__ */ new Map();
+          this.maxCacheEntries = maxCacheEntries;
+          this.counter = 1;
+          this.prefetch = prefetch;
+          this.decompress = decompress;
+        }
+        getHeader(source, current_etag) {
+          return __async(this, null, function* () {
+            const cacheKey = source.getKey();
+            if (this.cache.has(cacheKey)) {
+              this.cache.get(cacheKey).lastUsed = this.counter++;
+              const data = yield this.cache.get(cacheKey).data;
+              return data;
+            }
+            const p = new Promise((resolve, reject) => {
+              getHeaderAndRoot(source, this.decompress, this.prefetch, current_etag).then((res) => {
+                if (res[1]) {
+                  this.cache.set(res[1][0], {
+                    lastUsed: this.counter++,
+                    data: Promise.resolve(res[1][2])
+                  });
+                }
+                resolve(res[0]);
+                this.prune();
+              }).catch((e) => {
+                reject(e);
+              });
+            });
+            this.cache.set(cacheKey, { lastUsed: this.counter++, data: p });
+            return p;
+          });
+        }
+        getDirectory(source, offset, length2, header) {
+          return __async(this, null, function* () {
+            const cacheKey = source.getKey() + "|" + (header.etag || "") + "|" + offset + "|" + length2;
+            if (this.cache.has(cacheKey)) {
+              this.cache.get(cacheKey).lastUsed = this.counter++;
+              const data = yield this.cache.get(cacheKey).data;
+              return data;
+            }
+            const p = new Promise((resolve, reject) => {
+              getDirectory(source, this.decompress, offset, length2, header).then((directory) => {
+                resolve(directory);
+                this.prune();
+              }).catch((e) => {
+                reject(e);
+              });
+            });
+            this.cache.set(cacheKey, { lastUsed: this.counter++, data: p });
+            return p;
+          });
+        }
+        getArrayBuffer(source, offset, length2, header) {
+          return __async(this, null, function* () {
+            const cacheKey = source.getKey() + "|" + (header.etag || "") + "|" + offset + "|" + length2;
+            if (this.cache.has(cacheKey)) {
+              this.cache.get(cacheKey).lastUsed = this.counter++;
+              const data = yield this.cache.get(cacheKey).data;
+              return data;
+            }
+            const p = new Promise((resolve, reject) => {
+              source.getBytes(offset, length2).then((resp) => {
+                if (header.etag && header.etag !== resp.etag) {
+                  throw new EtagMismatch(resp.etag);
+                }
+                resolve(resp.data);
+                if (this.cache.has(cacheKey)) {
+                }
+                this.prune();
+              }).catch((e) => {
+                reject(e);
+              });
+            });
+            this.cache.set(cacheKey, { lastUsed: this.counter++, data: p });
+            return p;
+          });
+        }
+        prune() {
+          if (this.cache.size >= this.maxCacheEntries) {
+            let minUsed = Infinity;
+            let minKey = void 0;
+            this.cache.forEach((cache_value, key) => {
+              if (cache_value.lastUsed < minUsed) {
+                minUsed = cache_value.lastUsed;
+                minKey = key;
+              }
+            });
+            if (minKey) {
+              this.cache.delete(minKey);
+            }
+          }
+        }
+        invalidate(source, current_etag) {
+          return __async(this, null, function* () {
+            this.cache.delete(source.getKey());
+            yield this.getHeader(source, current_etag);
+          });
+        }
+      };
+      PMTiles = class {
+        constructor(source, cache, decompress) {
+          if (typeof source === "string") {
+            this.source = new FetchSource(source);
+          } else {
+            this.source = source;
+          }
+          if (decompress) {
+            this.decompress = decompress;
+          } else {
+            this.decompress = defaultDecompress;
+          }
+          if (cache) {
+            this.cache = cache;
+          } else {
+            this.cache = new SharedPromiseCache();
+          }
+        }
+        getHeader() {
+          return __async(this, null, function* () {
+            return yield this.cache.getHeader(this.source);
+          });
+        }
+        getZxyAttempt(z, x3, y2, signal) {
+          return __async(this, null, function* () {
+            const tile_id = zxyToTileId(z, x3, y2);
+            const header = yield this.cache.getHeader(this.source);
+            if (header.specVersion < 3) {
+              return v2_default.getZxy(header, this.source, this.cache, z, x3, y2, signal);
+            }
+            if (z < header.minZoom || z > header.maxZoom) {
+              return void 0;
+            }
+            let d_o = header.rootDirectoryOffset;
+            let d_l = header.rootDirectoryLength;
+            for (let depth = 0; depth <= 3; depth++) {
+              const directory = yield this.cache.getDirectory(this.source, d_o, d_l, header);
+              const entry = findTile(directory, tile_id);
+              if (entry) {
+                if (entry.runLength > 0) {
+                  const resp = yield this.source.getBytes(header.tileDataOffset + entry.offset, entry.length, signal);
+                  if (header.etag && header.etag !== resp.etag) {
+                    throw new EtagMismatch(resp.etag);
+                  }
+                  return {
+                    data: yield this.decompress(resp.data, header.tileCompression),
+                    cacheControl: resp.cacheControl,
+                    expires: resp.expires
+                  };
+                } else {
+                  d_o = header.leafDirectoryOffset + entry.offset;
+                  d_l = entry.length;
+                }
+              } else {
+                return void 0;
+              }
+            }
+            throw Error("Maximum directory depth exceeded");
+          });
+        }
+        getZxy(z, x3, y2, signal) {
+          return __async(this, null, function* () {
+            try {
+              return yield this.getZxyAttempt(z, x3, y2, signal);
+            } catch (e) {
+              if (e instanceof EtagMismatch) {
+                this.cache.invalidate(this.source, e.message);
+                return yield this.getZxyAttempt(z, x3, y2, signal);
+              } else {
+                throw e;
+              }
+            }
+          });
+        }
+        getMetadataAttempt() {
+          return __async(this, null, function* () {
+            const header = yield this.cache.getHeader(this.source);
+            const resp = yield this.source.getBytes(header.jsonMetadataOffset, header.jsonMetadataLength);
+            if (header.etag && header.etag !== resp.etag) {
+              throw new EtagMismatch(resp.etag);
+            }
+            const decompressed = yield this.decompress(resp.data, header.internalCompression);
+            const dec = new TextDecoder("utf-8");
+            return JSON.parse(dec.decode(decompressed));
+          });
+        }
+        getMetadata() {
+          return __async(this, null, function* () {
+            try {
+              return yield this.getMetadataAttempt();
+            } catch (e) {
+              if (e instanceof EtagMismatch) {
+                this.cache.invalidate(this.source, e.message);
+                return yield this.getMetadataAttempt();
+              } else {
+                throw e;
+              }
+            }
+          });
+        }
+      };
+    }
+  });
+
+  // src/lib/parse-pmtiles.ts
+  function parsePMTilesHeader(header, tilejsonMetadata, options) {
+    const partialMetadata = {};
+    if (typeof tilejsonMetadata?.name === "string") {
+      partialMetadata.name = tilejsonMetadata.name;
+    }
+    if (typeof tilejsonMetadata?.attribution === "string") {
+      partialMetadata.attributions = [tilejsonMetadata.attribution];
+    }
+    const metadata = {
+      ...partialMetadata,
+      format: "pmtiles",
+      formatVersion: header.specVersion,
+      mimeType: decodeTileType(header.tileType),
+      tileType: header.tileType,
+      minZoom: header.minZoom,
+      maxZoom: header.maxZoom,
+      boundingBox: [
+        [header.minLon, header.minLat],
+        [header.maxLon, header.maxLat]
+      ],
+      center: [header.centerLon, header.centerLat],
+      centerZoom: header.centerZoom,
+      etag: header.etag
+    };
+    if (tilejsonMetadata) {
+      try {
+        metadata.tileJSON = TileJSONLoader.parseTextSync?.(JSON.stringify(tilejsonMetadata)) || void 0;
+      } catch (error) {
+        metadata.tilejsonMetadata = tilejsonMetadata;
+      }
+    }
+    if (options?.includeFormatHeader) {
+      metadata.formatHeader = header;
+    }
+    return metadata;
+  }
+  function decodeTileType(tileType) {
+    switch (tileType) {
+      case TileType.Mvt:
+        return "application/vnd.mapbox-vector-tile";
+      case TileType.Png:
+        return "image/png";
+      case TileType.Jpeg:
+        return "image/jpeg";
+      case TileType.Webp:
+        return "image/webp";
+      case TileType.Avif:
+        return "image/avif";
+      default:
+        return "application/octet-stream";
+    }
+  }
+  var init_parse_pmtiles = __esm({
+    "src/lib/parse-pmtiles.ts"() {
+      init_dist();
+      init_src4();
+    }
+  });
+
+  // src/pmtiles-source.ts
+  var BlobSource, PMTilesSource;
+  var init_pmtiles_source = __esm({
+    "src/pmtiles-source.ts"() {
+      init_src();
+      init_src2();
+      init_src4();
+      init_dist();
+      init_parse_pmtiles();
+      BlobSource = class {
+        constructor(blob, key) {
+          this.blob = blob;
+          this.key = key;
+        }
+        getKey() {
+          return this.blob.url || "";
+        }
+        async getBytes(offset, length2, signal) {
+          const slice = this.blob.slice(offset, offset + length2);
+          const data = await slice.arrayBuffer();
+          return {
+            data
+          };
+        }
+      };
+      PMTilesSource = class extends DataSource {
+        constructor(props) {
+          super(props);
+          this.props = props;
+          const url = typeof props.url === "string" ? resolvePath(props.url) : new BlobSource(props.url, "pmtiles");
+          this.pmtiles = new PMTiles(url);
+          this.getTileData = this.getTileData.bind(this);
+          this.metadata = this.getMetadata();
+        }
+        async getMetadata() {
+          const pmtilesHeader = await this.pmtiles.getHeader();
+          const pmtilesMetadata = await this.pmtiles.getMetadata();
+          const metadata = parsePMTilesHeader(pmtilesHeader, pmtilesMetadata);
+          if (this.props.attributions) {
+            metadata.attributions = [...this.props.attributions, ...metadata.attributions || []];
+          }
+          return metadata;
+        }
+        async getTile(tileParams) {
+          const { x: x3, y: y2, zoom: z } = tileParams;
+          const rangeResponse = await this.pmtiles.getZxy(z, x3, y2);
+          const arrayBuffer = rangeResponse?.data;
+          if (!arrayBuffer) {
+            return null;
+          }
+          return arrayBuffer;
+        }
+        async getTileData(tileParams) {
+          const { x: x3, y: y2, z } = tileParams.index;
+          const metadata = await this.metadata;
+          switch (metadata.mimeType) {
+            case "application/vnd.mapbox-vector-tile":
+              return await this.getVectorTile({ x: x3, y: y2, zoom: z, layers: [] });
+            default:
+              return await this.getImageTile({ x: x3, y: y2, zoom: z, layers: [] });
+          }
+        }
+        async getImageTile(tileParams) {
+          const arrayBuffer = await this.getTile(tileParams);
+          return arrayBuffer ? await ImageLoader.parse(arrayBuffer, this.loadOptions) : null;
+        }
+        async getVectorTile(tileParams) {
+          const arrayBuffer = await this.getTile(tileParams);
+          const loadOptions = {
+            shape: "geojson-table",
+            mvt: {
+              coordinates: "wgs84",
+              tileIndex: { x: tileParams.x, y: tileParams.y, z: tileParams.zoom },
+              ...this.loadOptions?.mvt
+            },
+            ...this.loadOptions
+          };
+          return arrayBuffer ? await MVTLoader.parse(arrayBuffer, loadOptions) : null;
+        }
+      };
+    }
+  });
+
+  // src/index.ts
+  var src_exports = {};
+  __export(src_exports, {
+    PMTilesSource: () => PMTilesSource
+  });
+  var init_src5 = __esm({
+    "src/index.ts"() {
+      init_pmtiles_source();
+    }
+  });
+
+  // src/bundle.ts
+  var require_bundle = __commonJS({
+    "src/bundle.ts"(exports, module) {
+      var moduleExports = (init_src5(), src_exports);
+      globalThis.loaders = globalThis.loaders || {};
+      module.exports = Object.assign(globalThis.loaders, moduleExports);
+    }
+  });
+  require_bundle();
+})();
+/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */