@tileflow/core 0.1.0-alpha.20 → 0.1.0-alpha.22

package/dist/browser.js

@@ -1,90 +1,4184 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err2) => function __init() {
+  if (err2) throw err2[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err2 = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/portable-identity-rules.ts
+function isTileflowPortableId(value) {
+  return typeof value === "string" && value.length <= tileflowPortableIdMaximumLength && tileflowPortableIdPattern.test(value) && !["constructor", "prototype"].includes(value) && !/^(?:AUX|CON|NUL|PRN|COM[1-9]|LPT[1-9])$/i.test(value);
+}
+function isTileflowThemeName(value) {
+  return isTileflowPortableId(value) && value !== "system";
+}
+var tileflowPortableIdMaximumLength, tileflowPortableIdPattern;
+var init_portable_identity_rules = __esm({
+  "src/portable-identity-rules.ts"() {
+    "use strict";
+    tileflowPortableIdMaximumLength = 64;
+    tileflowPortableIdPattern = /^[a-z][a-z0-9-]{0,63}$/u;
+  }
+});
+
+// ../../node_modules/.pnpm/maplibre-contour@0.1.0/node_modules/maplibre-contour/dist/index.mjs
+var dist_exports = {};
+__export(dist_exports, {
+  default: () => mlcontour$1
+});
+function define(_2, chunk) {
+  if (!shared) {
+    shared = chunk;
+  } else if (!worker) {
+    worker = chunk;
+  } else {
+    var workerBundleString = "var sharedChunk = {}; (" + shared + ")(sharedChunk); (" + worker + ")(sharedChunk);";
+    var sharedChunk = {};
+    shared(sharedChunk);
+    mlcontour = chunk(sharedChunk);
+    if (typeof window !== "undefined") {
+      mlcontour.workerUrl = window.URL.createObjectURL(
+        new Blob([workerBundleString], { type: "text/javascript" })
+      );
+    }
+  }
+}
+var shared, worker, mlcontour, mlcontour$1;
+var init_dist = __esm({
+  "../../node_modules/.pnpm/maplibre-contour@0.1.0/node_modules/maplibre-contour/dist/index.mjs"() {
+    "use strict";
+    define(["exports"], (function(exports) {
+      "use strict";
+      class Fragment {
+        constructor(start, end) {
+          this.start = start;
+          this.end = end;
+          this.points = [];
+          this.append = this.append.bind(this);
+          this.prepend = this.prepend.bind(this);
+        }
+        append(x3, y) {
+          this.points.push(Math.round(x3), Math.round(y));
+        }
+        prepend(x3, y) {
+          this.points.splice(0, 0, Math.round(x3), Math.round(y));
+        }
+        lineString() {
+          return this.toArray();
+        }
+        isEmpty() {
+          return this.points.length < 2;
+        }
+        appendFragment(other) {
+          this.points.push(...other.points);
+          this.end = other.end;
+        }
+        toArray() {
+          return this.points;
+        }
+      }
+      const CASES = [
+        [],
+        [
+          [
+            [1, 2],
+            [0, 1]
+          ]
+        ],
+        [
+          [
+            [2, 1],
+            [1, 2]
+          ]
+        ],
+        [
+          [
+            [2, 1],
+            [0, 1]
+          ]
+        ],
+        [
+          [
+            [1, 0],
+            [2, 1]
+          ]
+        ],
+        [
+          [
+            [1, 2],
+            [0, 1]
+          ],
+          [
+            [1, 0],
+            [2, 1]
+          ]
+        ],
+        [
+          [
+            [1, 0],
+            [1, 2]
+          ]
+        ],
+        [
+          [
+            [1, 0],
+            [0, 1]
+          ]
+        ],
+        [
+          [
+            [0, 1],
+            [1, 0]
+          ]
+        ],
+        [
+          [
+            [1, 2],
+            [1, 0]
+          ]
+        ],
+        [
+          [
+            [0, 1],
+            [1, 0]
+          ],
+          [
+            [2, 1],
+            [1, 2]
+          ]
+        ],
+        [
+          [
+            [2, 1],
+            [1, 0]
+          ]
+        ],
+        [
+          [
+            [0, 1],
+            [2, 1]
+          ]
+        ],
+        [
+          [
+            [1, 2],
+            [2, 1]
+          ]
+        ],
+        [
+          [
+            [0, 1],
+            [1, 2]
+          ]
+        ],
+        []
+      ];
+      function index(width, x3, y, point) {
+        x3 = x3 * 2 + point[0];
+        y = y * 2 + point[1];
+        return x3 + y * (width + 1) * 2;
+      }
+      function ratio(a, b2, c) {
+        return (b2 - a) / (c - a);
+      }
+      function generateIsolines(interval, tile, extent = 4096, buffer = 1) {
+        if (!interval) {
+          return {};
+        }
+        const multiplier = extent / (tile.width - 1);
+        let tld, trd, bld, brd;
+        let r, c;
+        const segments = {};
+        const fragmentByStartByLevel = /* @__PURE__ */ new Map();
+        const fragmentByEndByLevel = /* @__PURE__ */ new Map();
+        function interpolate(point, threshold, accept) {
+          if (point[0] === 0) {
+            accept(multiplier * (c - 1), multiplier * (r - ratio(bld, threshold, tld)));
+          } else if (point[0] === 2) {
+            accept(multiplier * c, multiplier * (r - ratio(brd, threshold, trd)));
+          } else if (point[1] === 0) {
+            accept(multiplier * (c - ratio(trd, threshold, tld)), multiplier * (r - 1));
+          } else {
+            accept(multiplier * (c - ratio(brd, threshold, bld)), multiplier * r);
+          }
+        }
+        for (r = 1 - buffer; r < tile.height + buffer; r++) {
+          trd = tile.get(0, r - 1);
+          brd = tile.get(0, r);
+          let minR = Math.min(trd, brd);
+          let maxR = Math.max(trd, brd);
+          for (c = 1 - buffer; c < tile.width + buffer; c++) {
+            tld = trd;
+            bld = brd;
+            trd = tile.get(c, r - 1);
+            brd = tile.get(c, r);
+            const minL = minR;
+            const maxL = maxR;
+            minR = Math.min(trd, brd);
+            maxR = Math.max(trd, brd);
+            if (isNaN(tld) || isNaN(trd) || isNaN(brd) || isNaN(bld)) {
+              continue;
+            }
+            const min = Math.min(minL, minR);
+            const max2 = Math.max(maxL, maxR);
+            const start = Math.ceil(min / interval) * interval;
+            const end = Math.floor(max2 / interval) * interval;
+            for (let threshold = start; threshold <= end; threshold += interval) {
+              const tl = tld > threshold;
+              const tr = trd > threshold;
+              const bl = bld > threshold;
+              const br = brd > threshold;
+              for (const segment of CASES[(tl ? 8 : 0) | (tr ? 4 : 0) | (br ? 2 : 0) | (bl ? 1 : 0)]) {
+                let fragmentByStart = fragmentByStartByLevel.get(threshold);
+                if (!fragmentByStart)
+                  fragmentByStartByLevel.set(threshold, fragmentByStart = /* @__PURE__ */ new Map());
+                let fragmentByEnd = fragmentByEndByLevel.get(threshold);
+                if (!fragmentByEnd)
+                  fragmentByEndByLevel.set(threshold, fragmentByEnd = /* @__PURE__ */ new Map());
+                const start2 = segment[0];
+                const end2 = segment[1];
+                const startIndex = index(tile.width, c, r, start2);
+                const endIndex = index(tile.width, c, r, end2);
+                let f, g2;
+                if (f = fragmentByEnd.get(startIndex)) {
+                  fragmentByEnd.delete(startIndex);
+                  if (g2 = fragmentByStart.get(endIndex)) {
+                    fragmentByStart.delete(endIndex);
+                    if (f === g2) {
+                      interpolate(end2, threshold, f.append);
+                      if (!f.isEmpty()) {
+                        let list = segments[threshold];
+                        if (!list) {
+                          segments[threshold] = list = [];
+                        }
+                        list.push(f.lineString());
+                      }
+                    } else {
+                      f.appendFragment(g2);
+                      fragmentByEnd.set(f.end = g2.end, f);
+                    }
+                  } else {
+                    interpolate(end2, threshold, f.append);
+                    fragmentByEnd.set(f.end = endIndex, f);
+                  }
+                } else if (f = fragmentByStart.get(endIndex)) {
+                  fragmentByStart.delete(endIndex);
+                  interpolate(start2, threshold, f.prepend);
+                  fragmentByStart.set(f.start = startIndex, f);
+                } else {
+                  const newFrag = new Fragment(startIndex, endIndex);
+                  interpolate(start2, threshold, newFrag.append);
+                  interpolate(end2, threshold, newFrag.append);
+                  fragmentByStart.set(startIndex, newFrag);
+                  fragmentByEnd.set(endIndex, newFrag);
+                }
+              }
+            }
+          }
+        }
+        for (const [level, fragmentByStart] of fragmentByStartByLevel.entries()) {
+          let list = null;
+          for (const value of fragmentByStart.values()) {
+            if (!value.isEmpty()) {
+              if (list == null) {
+                list = segments[level] || (segments[level] = []);
+              }
+              list.push(value.lineString());
+            }
+          }
+        }
+        return segments;
+      }
+      function __rest(s, e) {
+        var t = {};
+        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+          t[p] = s[p];
+        if (s != null && typeof Object.getOwnPropertySymbols === "function")
+          for (var i2 = 0, p = Object.getOwnPropertySymbols(s); i2 < p.length; i2++) {
+            if (e.indexOf(p[i2]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i2]))
+              t[p[i2]] = s[p[i2]];
+          }
+        return t;
+      }
+      function __awaiter(thisArg, _arguments, P2, generator) {
+        function adopt(value) {
+          return value instanceof P2 ? value : new P2(function(resolve) {
+            resolve(value);
+          });
+        }
+        return new (P2 || (P2 = Promise))(function(resolve, reject) {
+          function fulfilled(value) {
+            try {
+              step(generator.next(value));
+            } catch (e) {
+              reject(e);
+            }
+          }
+          function rejected(value) {
+            try {
+              step(generator["throw"](value));
+            } catch (e) {
+              reject(e);
+            }
+          }
+          function step(result) {
+            result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+          }
+          step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+      }
+      function sortedEntries(object) {
+        const entries = Object.entries(object);
+        entries.sort(([a], [b2]) => a < b2 ? -1 : a > b2 ? 1 : 0);
+        return entries;
+      }
+      function encodeThresholds(thresholds) {
+        return sortedEntries(thresholds).map(([key, value]) => [key, ...typeof value === "number" ? [value] : value].join("*")).join("~");
+      }
+      function decodeThresholds(thresholds) {
+        return Object.fromEntries(thresholds.split("~").map((part) => part.split("*").map(Number)).map(([key, ...values]) => [key, values]));
+      }
+      function encodeOptions(_a2) {
+        var { thresholds } = _a2, rest = __rest(_a2, ["thresholds"]);
+        return sortedEntries(Object.assign({ thresholds: encodeThresholds(thresholds) }, rest)).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&");
+      }
+      function decodeOptions(options) {
+        return Object.fromEntries(options.replace(/^.*\?/, "").split("&").map((part) => {
+          const parts = part.split("=").map(decodeURIComponent);
+          const k2 = parts[0];
+          let v2 = parts[1];
+          switch (k2) {
+            case "thresholds":
+              v2 = decodeThresholds(v2);
+              break;
+            case "extent":
+            case "multiplier":
+            case "overzoom":
+            case "buffer":
+              v2 = Number(v2);
+          }
+          return [k2, v2];
+        }));
+      }
+      function encodeIndividualOptions(options) {
+        return sortedEntries(options).map(([k2, v2]) => `${encodeURIComponent(k2)}=${encodeURIComponent(v2)}`).join(",");
+      }
+      function getOptionsForZoom(options, zoom) {
+        const { thresholds } = options, rest = __rest(options, ["thresholds"]);
+        let levels = [];
+        let maxLessThanOrEqualTo = -Infinity;
+        Object.entries(thresholds).forEach(([zString, value]) => {
+          const z = Number(zString);
+          if (z <= zoom && z > maxLessThanOrEqualTo) {
+            maxLessThanOrEqualTo = z;
+            levels = typeof value === "number" ? [value] : value;
+          }
+        });
+        return Object.assign({ levels }, rest);
+      }
+      function copy(src) {
+        const dst = new ArrayBuffer(src.byteLength);
+        new Uint8Array(dst).set(new Uint8Array(src));
+        return dst;
+      }
+      function prepareDemTile(promise, copy2) {
+        return promise.then((_a2) => {
+          var { data } = _a2, rest = __rest(_a2, ["data"]);
+          let newData = data;
+          if (copy2) {
+            newData = new Float32Array(data.length);
+            newData.set(data);
+          }
+          return Object.assign(Object.assign({}, rest), { data: newData, transferrables: [newData.buffer] });
+        });
+      }
+      function prepareContourTile(promise) {
+        return promise.then(({ arrayBuffer }) => {
+          const clone = copy(arrayBuffer);
+          return {
+            arrayBuffer: clone,
+            transferrables: [clone]
+          };
+        });
+      }
+      let supportsOffscreenCanvas = null;
+      function offscreenCanvasSupported() {
+        if (supportsOffscreenCanvas == null) {
+          supportsOffscreenCanvas = typeof OffscreenCanvas !== "undefined" && new OffscreenCanvas(1, 1).getContext("2d") && typeof createImageBitmap === "function";
+        }
+        return supportsOffscreenCanvas || false;
+      }
+      let useVideoFrame = null;
+      function shouldUseVideoFrame() {
+        if (useVideoFrame == null) {
+          useVideoFrame = false;
+          if (offscreenCanvasSupported() && typeof VideoFrame !== "undefined") {
+            const size = 5;
+            const canvas2 = new OffscreenCanvas(5, 5);
+            const context = canvas2.getContext("2d", { willReadFrequently: true });
+            if (context) {
+              for (let i2 = 0; i2 < size * size; i2++) {
+                const base = i2 * 4;
+                context.fillStyle = `rgb(${base},${base + 1},${base + 2})`;
+                context.fillRect(i2 % size, Math.floor(i2 / size), 1, 1);
+              }
+              const data = context.getImageData(0, 0, size, size).data;
+              for (let i2 = 0; i2 < size * size * 4; i2++) {
+                if (i2 % 4 !== 3 && data[i2] !== i2) {
+                  useVideoFrame = true;
+                  break;
+                }
+              }
+            }
+          }
+        }
+        return useVideoFrame || false;
+      }
+      function withTimeout(timeoutMs, value, abortController) {
+        let reject = () => {
+        };
+        const timeout = setTimeout(() => {
+          reject(new Error("timed out"));
+          abortController === null || abortController === void 0 ? void 0 : abortController.abort();
+        }, timeoutMs);
+        onAbort(abortController, () => {
+          reject(new Error("aborted"));
+          clearTimeout(timeout);
+        });
+        const cancelPromise = new Promise((_2, rej) => {
+          reject = rej;
+        });
+        return Promise.race([
+          cancelPromise,
+          value.finally(() => clearTimeout(timeout))
+        ]);
+      }
+      function onAbort(abortController, action) {
+        if (action) {
+          abortController === null || abortController === void 0 ? void 0 : abortController.signal.addEventListener("abort", action);
+        }
+      }
+      function isAborted(abortController) {
+        var _a2;
+        return Boolean((_a2 = abortController === null || abortController === void 0 ? void 0 : abortController.signal) === null || _a2 === void 0 ? void 0 : _a2.aborted);
+      }
+      let num = 0;
+      class AsyncCache {
+        constructor(maxSize = 100) {
+          this.size = () => this.items.size;
+          this.get = (key, supplier, abortController) => {
+            let result = this.items.get(key);
+            if (!result) {
+              const sharedAbortController = new AbortController();
+              const value2 = supplier(key, sharedAbortController);
+              result = {
+                abortController: sharedAbortController,
+                item: value2,
+                lastUsed: ++num,
+                waiting: 1
+              };
+              this.items.set(key, result);
+              this.prune();
+            } else {
+              result.lastUsed = ++num;
+              result.waiting++;
+            }
+            const items = this.items;
+            const value = result.item.then((r) => r, (e) => {
+              items.delete(key);
+              return Promise.reject(e);
+            });
+            let canceled = false;
+            onAbort(abortController, () => {
+              var _a2;
+              if (result && result.abortController && !canceled) {
+                canceled = true;
+                if (--result.waiting <= 0) {
+                  (_a2 = result.abortController) === null || _a2 === void 0 ? void 0 : _a2.abort();
+                  items.delete(key);
+                }
+              }
+            });
+            return value;
+          };
+          this.clear = () => this.items.clear();
+          this.maxSize = maxSize;
+          this.items = /* @__PURE__ */ new Map();
+        }
+        prune() {
+          if (this.items.size > this.maxSize) {
+            let minKey;
+            let minUse = Infinity;
+            this.items.forEach((value, key) => {
+              if (value.lastUsed < minUse) {
+                minUse = value.lastUsed;
+                minKey = key;
+              }
+            });
+            if (typeof minKey !== "undefined") {
+              this.items.delete(minKey);
+            }
+          }
+        }
+      }
+      let offscreenCanvas;
+      let offscreenContext;
+      let canvas;
+      let canvasContext;
+      function decodeImageModern(blob, encoding, abortController) {
+        return __awaiter(this, void 0, void 0, function* () {
+          const img = yield createImageBitmap(blob);
+          if (isAborted(abortController))
+            return null;
+          return decodeImageUsingOffscreenCanvas(img, encoding);
+        });
+      }
+      function decodeImageUsingOffscreenCanvas(img, encoding) {
+        if (!offscreenCanvas) {
+          offscreenCanvas = new OffscreenCanvas(img.width, img.height);
+          offscreenContext = offscreenCanvas.getContext("2d", {
+            willReadFrequently: true
+          });
+        }
+        return getElevations(img, encoding, offscreenCanvas, offscreenContext);
+      }
+      function decodeImageVideoFrame(blob, encoding, abortController) {
+        return __awaiter(this, void 0, void 0, function* () {
+          var _a2, _b2, _c;
+          const img = yield createImageBitmap(blob);
+          if (isAborted(abortController))
+            return null;
+          const vf = new VideoFrame(img, { timestamp: 0 });
+          try {
+            const valid = ((_a2 = vf === null || vf === void 0 ? void 0 : vf.format) === null || _a2 === void 0 ? void 0 : _a2.startsWith("BGR")) || ((_b2 = vf === null || vf === void 0 ? void 0 : vf.format) === null || _b2 === void 0 ? void 0 : _b2.startsWith("RGB"));
+            if (!valid) {
+              throw new Error(`Unrecognized format: ${vf === null || vf === void 0 ? void 0 : vf.format}`);
+            }
+            const swapBR = (_c = vf === null || vf === void 0 ? void 0 : vf.format) === null || _c === void 0 ? void 0 : _c.startsWith("BGR");
+            const size = vf.allocationSize();
+            const data = new Uint8ClampedArray(size);
+            yield vf.copyTo(data);
+            if (swapBR) {
+              for (let i2 = 0; i2 < data.length; i2 += 4) {
+                const tmp = data[i2];
+                data[i2] = data[i2 + 2];
+                data[i2 + 2] = tmp;
+              }
+            }
+            return decodeParsedImage(img.width, img.height, encoding, data);
+          } catch (_2) {
+            if (isAborted(abortController))
+              return null;
+            return decodeImageUsingOffscreenCanvas(img, encoding);
+          } finally {
+            vf.close();
+          }
+        });
+      }
+      function decodeImageOld(blob, encoding, abortController) {
+        return __awaiter(this, void 0, void 0, function* () {
+          if (!canvas) {
+            canvas = document.createElement("canvas");
+            canvasContext = canvas.getContext("2d", {
+              willReadFrequently: true
+            });
+          }
+          const img = new Image();
+          onAbort(abortController, () => img.src = "");
+          const fetchedImage = yield new Promise((resolve, reject) => {
+            img.onload = () => {
+              if (!isAborted(abortController))
+                resolve(img);
+              URL.revokeObjectURL(img.src);
+              img.onload = null;
+            };
+            img.onerror = () => reject(new Error("Could not load image."));
+            img.src = blob.size ? URL.createObjectURL(blob) : "";
+          });
+          return getElevations(fetchedImage, encoding, canvas, canvasContext);
+        });
+      }
+      function decodeImageOnMainThread(blob, encoding, abortController) {
+        return self.actor.send("decodeImage", [], abortController, void 0, blob, encoding);
+      }
+      function isWorker() {
+        return (
+          // @ts-expect-error WorkerGlobalScope defined
+          typeof WorkerGlobalScope !== "undefined" && typeof self !== "undefined" && // @ts-expect-error WorkerGlobalScope defined
+          self instanceof WorkerGlobalScope
+        );
+      }
+      const defaultDecoder = shouldUseVideoFrame() ? decodeImageVideoFrame : offscreenCanvasSupported() ? decodeImageModern : isWorker() ? decodeImageOnMainThread : decodeImageOld;
+      function getElevations(img, encoding, canvas2, canvasContext2) {
+        canvas2.width = img.width;
+        canvas2.height = img.height;
+        if (!canvasContext2)
+          throw new Error("failed to get context");
+        canvasContext2.drawImage(img, 0, 0, img.width, img.height);
+        const rgba = canvasContext2.getImageData(0, 0, img.width, img.height).data;
+        return decodeParsedImage(img.width, img.height, encoding, rgba);
+      }
+      function decodeParsedImage(width, height, encoding, input) {
+        const decoder = encoding === "mapbox" ? (r, g2, b2) => -1e4 + (r * 256 * 256 + g2 * 256 + b2) * 0.1 : (r, g2, b2) => r * 256 + g2 + b2 / 256 - 32768;
+        const data = new Float32Array(width * height);
+        for (let i2 = 0; i2 < input.length; i2 += 4) {
+          data[i2 / 4] = decoder(input[i2], input[i2 + 1], input[i2 + 2]);
+        }
+        return { width, height, data };
+      }
+      const MIN_VALID_M = -12e3;
+      const MAX_VALID_M = 9e3;
+      function defaultIsValid(number) {
+        return !isNaN(number) && number >= MIN_VALID_M && number <= MAX_VALID_M;
+      }
+      class HeightTile {
+        constructor(width, height, get) {
+          this.split = (subz, subx, suby) => {
+            if (subz === 0)
+              return this;
+            const by = 1 << subz;
+            const dx = subx * this.width / by;
+            const dy = suby * this.height / by;
+            return new HeightTile(this.width / by, this.height / by, (x3, y) => this.get(x3 + dx, y + dy));
+          };
+          this.subsamplePixelCenters = (factor) => {
+            const lerp = (a, b2, f) => isNaN(a) ? b2 : isNaN(b2) ? a : a + (b2 - a) * f;
+            if (factor <= 1)
+              return this;
+            const sub = 0.5 - 1 / (2 * factor);
+            const blerper = (x3, y) => {
+              const dx = x3 / factor - sub;
+              const dy = y / factor - sub;
+              const ox = Math.floor(dx);
+              const oy = Math.floor(dy);
+              const a = this.get(ox, oy);
+              const b2 = this.get(ox + 1, oy);
+              const c = this.get(ox, oy + 1);
+              const d = this.get(ox + 1, oy + 1);
+              const fx = dx - ox;
+              const fy = dy - oy;
+              const top = lerp(a, b2, fx);
+              const bottom = lerp(c, d, fx);
+              return lerp(top, bottom, fy);
+            };
+            return new HeightTile(this.width * factor, this.height * factor, blerper);
+          };
+          this.averagePixelCentersToGrid = (radius = 1) => new HeightTile(this.width + 1, this.height + 1, (x3, y) => {
+            let sum = 0, count = 0, v2 = 0;
+            for (let newX = x3 - radius; newX < x3 + radius; newX++) {
+              for (let newY = y - radius; newY < y + radius; newY++) {
+                if (!isNaN(v2 = this.get(newX, newY))) {
+                  count++;
+                  sum += v2;
+                }
+              }
+            }
+            return count === 0 ? NaN : sum / count;
+          });
+          this.scaleElevation = (multiplier) => multiplier === 1 ? this : new HeightTile(this.width, this.height, (x3, y) => this.get(x3, y) * multiplier);
+          this.materialize = (buffer = 2) => {
+            const stride = this.width + 2 * buffer;
+            const data = new Float32Array(stride * (this.height + 2 * buffer));
+            let idx = 0;
+            for (let y = -buffer; y < this.height + buffer; y++) {
+              for (let x3 = -buffer; x3 < this.width + buffer; x3++) {
+                data[idx++] = this.get(x3, y);
+              }
+            }
+            return new HeightTile(this.width, this.height, (x3, y) => data[(y + buffer) * stride + x3 + buffer]);
+          };
+          this.get = get;
+          this.width = width;
+          this.height = height;
+        }
+        /** Construct a height tile from raw DEM pixel values */
+        static fromRawDem(demTile) {
+          return new HeightTile(demTile.width, demTile.height, (x3, y) => {
+            const value = demTile.data[y * demTile.width + x3];
+            return defaultIsValid(value) ? value : NaN;
+          });
+        }
+        /**
+         * Construct a height tile from a DEM tile plus it's 8 neighbors, so that
+         * you can request `x` or `y` outside the bounds of the original tile.
+         *
+         * @param neighbors An array containing tiles: `[nw, n, ne, w, c, e, sw, s, se]`
+         */
+        static combineNeighbors(neighbors) {
+          if (neighbors.length !== 9) {
+            throw new Error("Must include a tile plus 8 neighbors");
+          }
+          const mainTile = neighbors[4];
+          if (!mainTile) {
+            return void 0;
+          }
+          const width = mainTile.width;
+          const height = mainTile.height;
+          return new HeightTile(width, height, (x3, y) => {
+            let gridIdx = 0;
+            if (y < 0) {
+              y += height;
+            } else if (y < height) {
+              gridIdx += 3;
+            } else {
+              y -= height;
+              gridIdx += 6;
+            }
+            if (x3 < 0) {
+              x3 += width;
+            } else if (x3 < width) {
+              gridIdx += 1;
+            } else {
+              x3 -= width;
+              gridIdx += 2;
+            }
+            const grid = neighbors[gridIdx];
+            return grid ? grid.get(x3, y) : NaN;
+          });
+        }
+      }
+      const SHIFT_LEFT_32 = (1 << 16) * (1 << 16);
+      const SHIFT_RIGHT_32 = 1 / SHIFT_LEFT_32;
+      const TEXT_DECODER_MIN_LENGTH = 12;
+      const utf8TextDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder("utf-8");
+      const PBF_VARINT = 0;
+      const PBF_FIXED64 = 1;
+      const PBF_BYTES = 2;
+      const PBF_FIXED32 = 5;
+      class Pbf {
+        /**
+         * @param {Uint8Array | ArrayBuffer} [buf]
+         */
+        constructor(buf = new Uint8Array(16)) {
+          this.buf = ArrayBuffer.isView(buf) ? buf : new Uint8Array(buf);
+          this.dataView = new DataView(this.buf.buffer);
+          this.pos = 0;
+          this.type = 0;
+          this.length = this.buf.length;
+        }
+        // === READING =================================================================
+        /**
+         * @template T
+         * @param {(tag: number, result: T, pbf: Pbf) => void} readField
+         * @param {T} result
+         * @param {number} [end]
+         */
+        readFields(readField, result, end = this.length) {
+          while (this.pos < end) {
+            const 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;
+        }
+        /**
+         * @template T
+         * @param {(tag: number, result: T, pbf: Pbf) => void} readField
+         * @param {T} result
+         */
+        readMessage(readField, result) {
+          return this.readFields(readField, result, this.readVarint() + this.pos);
+        }
+        readFixed32() {
+          const val = this.dataView.getUint32(this.pos, true);
+          this.pos += 4;
+          return val;
+        }
+        readSFixed32() {
+          const val = this.dataView.getInt32(this.pos, true);
+          this.pos += 4;
+          return val;
+        }
+        // 64-bit int handling is based on github.com/dpw/node-buffer-more-ints (MIT-licensed)
+        readFixed64() {
+          const val = this.dataView.getUint32(this.pos, true) + this.dataView.getUint32(this.pos + 4, true) * SHIFT_LEFT_32;
+          this.pos += 8;
+          return val;
+        }
+        readSFixed64() {
+          const val = this.dataView.getUint32(this.pos, true) + this.dataView.getInt32(this.pos + 4, true) * SHIFT_LEFT_32;
+          this.pos += 8;
+          return val;
+        }
+        readFloat() {
+          const val = this.dataView.getFloat32(this.pos, true);
+          this.pos += 4;
+          return val;
+        }
+        readDouble() {
+          const val = this.dataView.getFloat64(this.pos, true);
+          this.pos += 8;
+          return val;
+        }
+        /**
+         * @param {boolean} [isSigned]
+         */
+        readVarint(isSigned) {
+          const buf = this.buf;
+          let val, b2;
+          b2 = buf[this.pos++];
+          val = b2 & 127;
+          if (b2 < 128) return val;
+          b2 = buf[this.pos++];
+          val |= (b2 & 127) << 7;
+          if (b2 < 128) return val;
+          b2 = buf[this.pos++];
+          val |= (b2 & 127) << 14;
+          if (b2 < 128) return val;
+          b2 = buf[this.pos++];
+          val |= (b2 & 127) << 21;
+          if (b2 < 128) return val;
+          b2 = buf[this.pos];
+          val |= (b2 & 15) << 28;
+          return readVarintRemainder(val, isSigned, this);
+        }
+        readVarint64() {
+          return this.readVarint(true);
+        }
+        readSVarint() {
+          const num2 = this.readVarint();
+          return num2 % 2 === 1 ? (num2 + 1) / -2 : num2 / 2;
+        }
+        readBoolean() {
+          return Boolean(this.readVarint());
+        }
+        readString() {
+          const end = this.readVarint() + this.pos;
+          const pos = this.pos;
+          this.pos = end;
+          if (end - pos >= TEXT_DECODER_MIN_LENGTH && utf8TextDecoder) {
+            return utf8TextDecoder.decode(this.buf.subarray(pos, end));
+          }
+          return readUtf8(this.buf, pos, end);
+        }
+        readBytes() {
+          const end = this.readVarint() + this.pos, buffer = this.buf.subarray(this.pos, end);
+          this.pos = end;
+          return buffer;
+        }
+        // verbose for performance reasons; doesn't affect gzipped size
+        /**
+         * @param {number[]} [arr]
+         * @param {boolean} [isSigned]
+         */
+        readPackedVarint(arr = [], isSigned) {
+          const end = this.readPackedEnd();
+          while (this.pos < end) arr.push(this.readVarint(isSigned));
+          return arr;
+        }
+        /** @param {number[]} [arr] */
+        readPackedSVarint(arr = []) {
+          const end = this.readPackedEnd();
+          while (this.pos < end) arr.push(this.readSVarint());
+          return arr;
+        }
+        /** @param {boolean[]} [arr] */
+        readPackedBoolean(arr = []) {
+          const end = this.readPackedEnd();
+          while (this.pos < end) arr.push(this.readBoolean());
+          return arr;
+        }
+        /** @param {number[]} [arr] */
+        readPackedFloat(arr = []) {
+          const end = this.readPackedEnd();
+          while (this.pos < end) arr.push(this.readFloat());
+          return arr;
+        }
+        /** @param {number[]} [arr] */
+        readPackedDouble(arr = []) {
+          const end = this.readPackedEnd();
+          while (this.pos < end) arr.push(this.readDouble());
+          return arr;
+        }
+        /** @param {number[]} [arr] */
+        readPackedFixed32(arr = []) {
+          const end = this.readPackedEnd();
+          while (this.pos < end) arr.push(this.readFixed32());
+          return arr;
+        }
+        /** @param {number[]} [arr] */
+        readPackedSFixed32(arr = []) {
+          const end = this.readPackedEnd();
+          while (this.pos < end) arr.push(this.readSFixed32());
+          return arr;
+        }
+        /** @param {number[]} [arr] */
+        readPackedFixed64(arr = []) {
+          const end = this.readPackedEnd();
+          while (this.pos < end) arr.push(this.readFixed64());
+          return arr;
+        }
+        /** @param {number[]} [arr] */
+        readPackedSFixed64(arr = []) {
+          const end = this.readPackedEnd();
+          while (this.pos < end) arr.push(this.readSFixed64());
+          return arr;
+        }
+        readPackedEnd() {
+          return this.type === PBF_BYTES ? this.readVarint() + this.pos : this.pos + 1;
+        }
+        /** @param {number} val */
+        skip(val) {
+          const 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}`);
+        }
+        // === WRITING =================================================================
+        /**
+         * @param {number} tag
+         * @param {number} type
+         */
+        writeTag(tag, type) {
+          this.writeVarint(tag << 3 | type);
+        }
+        /** @param {number} min */
+        realloc(min) {
+          let length = this.length || 16;
+          while (length < this.pos + min) length *= 2;
+          if (length !== this.length) {
+            const buf = new Uint8Array(length);
+            buf.set(this.buf);
+            this.buf = buf;
+            this.dataView = new DataView(buf.buffer);
+            this.length = length;
+          }
+        }
+        finish() {
+          this.length = this.pos;
+          this.pos = 0;
+          return this.buf.subarray(0, this.length);
+        }
+        /** @param {number} val */
+        writeFixed32(val) {
+          this.realloc(4);
+          this.dataView.setInt32(this.pos, val, true);
+          this.pos += 4;
+        }
+        /** @param {number} val */
+        writeSFixed32(val) {
+          this.realloc(4);
+          this.dataView.setInt32(this.pos, val, true);
+          this.pos += 4;
+        }
+        /** @param {number} val */
+        writeFixed64(val) {
+          this.realloc(8);
+          this.dataView.setInt32(this.pos, val & -1, true);
+          this.dataView.setInt32(this.pos + 4, Math.floor(val * SHIFT_RIGHT_32), true);
+          this.pos += 8;
+        }
+        /** @param {number} val */
+        writeSFixed64(val) {
+          this.realloc(8);
+          this.dataView.setInt32(this.pos, val & -1, true);
+          this.dataView.setInt32(this.pos + 4, Math.floor(val * SHIFT_RIGHT_32), true);
+          this.pos += 8;
+        }
+        /** @param {number} val */
+        writeVarint(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;
+        }
+        /** @param {number} val */
+        writeSVarint(val) {
+          this.writeVarint(val < 0 ? -val * 2 - 1 : val * 2);
+        }
+        /** @param {boolean} val */
+        writeBoolean(val) {
+          this.writeVarint(+val);
+        }
+        /** @param {string} str */
+        writeString(str) {
+          str = String(str);
+          this.realloc(str.length * 4);
+          this.pos++;
+          const startPos = this.pos;
+          this.pos = writeUtf8(this.buf, str, this.pos);
+          const len = this.pos - startPos;
+          if (len >= 128) makeRoomForExtraLength(startPos, len, this);
+          this.pos = startPos - 1;
+          this.writeVarint(len);
+          this.pos += len;
+        }
+        /** @param {number} val */
+        writeFloat(val) {
+          this.realloc(4);
+          this.dataView.setFloat32(this.pos, val, true);
+          this.pos += 4;
+        }
+        /** @param {number} val */
+        writeDouble(val) {
+          this.realloc(8);
+          this.dataView.setFloat64(this.pos, val, true);
+          this.pos += 8;
+        }
+        /** @param {Uint8Array} buffer */
+        writeBytes(buffer) {
+          const len = buffer.length;
+          this.writeVarint(len);
+          this.realloc(len);
+          for (let i2 = 0; i2 < len; i2++) this.buf[this.pos++] = buffer[i2];
+        }
+        /**
+         * @template T
+         * @param {(obj: T, pbf: Pbf) => void} fn
+         * @param {T} obj
+         */
+        writeRawMessage(fn, obj) {
+          this.pos++;
+          const startPos = this.pos;
+          fn(obj, this);
+          const len = this.pos - startPos;
+          if (len >= 128) makeRoomForExtraLength(startPos, len, this);
+          this.pos = startPos - 1;
+          this.writeVarint(len);
+          this.pos += len;
+        }
+        /**
+         * @template T
+         * @param {number} tag
+         * @param {(obj: T, pbf: Pbf) => void} fn
+         * @param {T} obj
+         */
+        writeMessage(tag, fn, obj) {
+          this.writeTag(tag, PBF_BYTES);
+          this.writeRawMessage(fn, obj);
+        }
+        /**
+         * @param {number} tag
+         * @param {number[]} arr
+         */
+        writePackedVarint(tag, arr) {
+          if (arr.length) this.writeMessage(tag, writePackedVarint, arr);
+        }
+        /**
+         * @param {number} tag
+         * @param {number[]} arr
+         */
+        writePackedSVarint(tag, arr) {
+          if (arr.length) this.writeMessage(tag, writePackedSVarint, arr);
+        }
+        /**
+         * @param {number} tag
+         * @param {boolean[]} arr
+         */
+        writePackedBoolean(tag, arr) {
+          if (arr.length) this.writeMessage(tag, writePackedBoolean, arr);
+        }
+        /**
+         * @param {number} tag
+         * @param {number[]} arr
+         */
+        writePackedFloat(tag, arr) {
+          if (arr.length) this.writeMessage(tag, writePackedFloat, arr);
+        }
+        /**
+         * @param {number} tag
+         * @param {number[]} arr
+         */
+        writePackedDouble(tag, arr) {
+          if (arr.length) this.writeMessage(tag, writePackedDouble, arr);
+        }
+        /**
+         * @param {number} tag
+         * @param {number[]} arr
+         */
+        writePackedFixed32(tag, arr) {
+          if (arr.length) this.writeMessage(tag, writePackedFixed32, arr);
+        }
+        /**
+         * @param {number} tag
+         * @param {number[]} arr
+         */
+        writePackedSFixed32(tag, arr) {
+          if (arr.length) this.writeMessage(tag, writePackedSFixed32, arr);
+        }
+        /**
+         * @param {number} tag
+         * @param {number[]} arr
+         */
+        writePackedFixed64(tag, arr) {
+          if (arr.length) this.writeMessage(tag, writePackedFixed64, arr);
+        }
+        /**
+         * @param {number} tag
+         * @param {number[]} arr
+         */
+        writePackedSFixed64(tag, arr) {
+          if (arr.length) this.writeMessage(tag, writePackedSFixed64, arr);
+        }
+        /**
+         * @param {number} tag
+         * @param {Uint8Array} buffer
+         */
+        writeBytesField(tag, buffer) {
+          this.writeTag(tag, PBF_BYTES);
+          this.writeBytes(buffer);
+        }
+        /**
+         * @param {number} tag
+         * @param {number} val
+         */
+        writeFixed32Field(tag, val) {
+          this.writeTag(tag, PBF_FIXED32);
+          this.writeFixed32(val);
+        }
+        /**
+         * @param {number} tag
+         * @param {number} val
+         */
+        writeSFixed32Field(tag, val) {
+          this.writeTag(tag, PBF_FIXED32);
+          this.writeSFixed32(val);
+        }
+        /**
+         * @param {number} tag
+         * @param {number} val
+         */
+        writeFixed64Field(tag, val) {
+          this.writeTag(tag, PBF_FIXED64);
+          this.writeFixed64(val);
+        }
+        /**
+         * @param {number} tag
+         * @param {number} val
+         */
+        writeSFixed64Field(tag, val) {
+          this.writeTag(tag, PBF_FIXED64);
+          this.writeSFixed64(val);
+        }
+        /**
+         * @param {number} tag
+         * @param {number} val
+         */
+        writeVarintField(tag, val) {
+          this.writeTag(tag, PBF_VARINT);
+          this.writeVarint(val);
+        }
+        /**
+         * @param {number} tag
+         * @param {number} val
+         */
+        writeSVarintField(tag, val) {
+          this.writeTag(tag, PBF_VARINT);
+          this.writeSVarint(val);
+        }
+        /**
+         * @param {number} tag
+         * @param {string} str
+         */
+        writeStringField(tag, str) {
+          this.writeTag(tag, PBF_BYTES);
+          this.writeString(str);
+        }
+        /**
+         * @param {number} tag
+         * @param {number} val
+         */
+        writeFloatField(tag, val) {
+          this.writeTag(tag, PBF_FIXED32);
+          this.writeFloat(val);
+        }
+        /**
+         * @param {number} tag
+         * @param {number} val
+         */
+        writeDoubleField(tag, val) {
+          this.writeTag(tag, PBF_FIXED64);
+          this.writeDouble(val);
+        }
+        /**
+         * @param {number} tag
+         * @param {boolean} val
+         */
+        writeBooleanField(tag, val) {
+          this.writeVarintField(tag, +val);
+        }
+      }
+      function readVarintRemainder(l2, s, p) {
+        const buf = p.buf;
+        let h, b2;
+        b2 = buf[p.pos++];
+        h = (b2 & 112) >> 4;
+        if (b2 < 128) return toNum(l2, h, s);
+        b2 = buf[p.pos++];
+        h |= (b2 & 127) << 3;
+        if (b2 < 128) return toNum(l2, h, s);
+        b2 = buf[p.pos++];
+        h |= (b2 & 127) << 10;
+        if (b2 < 128) return toNum(l2, h, s);
+        b2 = buf[p.pos++];
+        h |= (b2 & 127) << 17;
+        if (b2 < 128) return toNum(l2, h, s);
+        b2 = buf[p.pos++];
+        h |= (b2 & 127) << 24;
+        if (b2 < 128) return toNum(l2, h, s);
+        b2 = buf[p.pos++];
+        h |= (b2 & 1) << 31;
+        if (b2 < 128) return toNum(l2, h, s);
+        throw new Error("Expected varint not more than 10 bytes");
+      }
+      function toNum(low, high, isSigned) {
+        return isSigned ? high * 4294967296 + (low >>> 0) : (high >>> 0) * 4294967296 + (low >>> 0);
+      }
+      function writeBigVarint(val, pbf) {
+        let 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) {
+        const 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) {
+        const extraLen = len <= 16383 ? 1 : len <= 2097151 ? 2 : len <= 268435455 ? 3 : Math.floor(Math.log(len) / (Math.LN2 * 7));
+        pbf.realloc(extraLen);
+        for (let i2 = pbf.pos - 1; i2 >= startPos; i2--) pbf.buf[i2 + extraLen] = pbf.buf[i2];
+      }
+      function writePackedVarint(arr, pbf) {
+        for (let i2 = 0; i2 < arr.length; i2++) pbf.writeVarint(arr[i2]);
+      }
+      function writePackedSVarint(arr, pbf) {
+        for (let i2 = 0; i2 < arr.length; i2++) pbf.writeSVarint(arr[i2]);
+      }
+      function writePackedFloat(arr, pbf) {
+        for (let i2 = 0; i2 < arr.length; i2++) pbf.writeFloat(arr[i2]);
+      }
+      function writePackedDouble(arr, pbf) {
+        for (let i2 = 0; i2 < arr.length; i2++) pbf.writeDouble(arr[i2]);
+      }
+      function writePackedBoolean(arr, pbf) {
+        for (let i2 = 0; i2 < arr.length; i2++) pbf.writeBoolean(arr[i2]);
+      }
+      function writePackedFixed32(arr, pbf) {
+        for (let i2 = 0; i2 < arr.length; i2++) pbf.writeFixed32(arr[i2]);
+      }
+      function writePackedSFixed32(arr, pbf) {
+        for (let i2 = 0; i2 < arr.length; i2++) pbf.writeSFixed32(arr[i2]);
+      }
+      function writePackedFixed64(arr, pbf) {
+        for (let i2 = 0; i2 < arr.length; i2++) pbf.writeFixed64(arr[i2]);
+      }
+      function writePackedSFixed64(arr, pbf) {
+        for (let i2 = 0; i2 < arr.length; i2++) pbf.writeSFixed64(arr[i2]);
+      }
+      function readUtf8(buf, pos, end) {
+        let str = "";
+        let i2 = pos;
+        while (i2 < end) {
+          const b0 = buf[i2];
+          let c = null;
+          let bytesPerSequence = b0 > 239 ? 4 : b0 > 223 ? 3 : b0 > 191 ? 2 : 1;
+          if (i2 + bytesPerSequence > end) break;
+          let b1, b2, b3;
+          if (bytesPerSequence === 1) {
+            if (b0 < 128) {
+              c = b0;
+            }
+          } else if (bytesPerSequence === 2) {
+            b1 = buf[i2 + 1];
+            if ((b1 & 192) === 128) {
+              c = (b0 & 31) << 6 | b1 & 63;
+              if (c <= 127) {
+                c = null;
+              }
+            }
+          } else if (bytesPerSequence === 3) {
+            b1 = buf[i2 + 1];
+            b2 = buf[i2 + 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[i2 + 1];
+            b2 = buf[i2 + 2];
+            b3 = buf[i2 + 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);
+          i2 += bytesPerSequence;
+        }
+        return str;
+      }
+      function writeUtf8(buf, str, pos) {
+        for (let i2 = 0, c, lead; i2 < str.length; i2++) {
+          c = str.charCodeAt(i2);
+          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 || i2 + 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;
+      }
+      var GeomType;
+      (function(GeomType2) {
+        GeomType2[GeomType2["UNKNOWN"] = 0] = "UNKNOWN";
+        GeomType2[GeomType2["POINT"] = 1] = "POINT";
+        GeomType2[GeomType2["LINESTRING"] = 2] = "LINESTRING";
+        GeomType2[GeomType2["POLYGON"] = 3] = "POLYGON";
+      })(GeomType || (GeomType = {}));
+      function encodeVectorTile(tile) {
+        const pbf = new Pbf();
+        for (const id2 in tile.layers) {
+          const layer = tile.layers[id2];
+          if (!layer.extent) {
+            layer.extent = tile.extent;
+          }
+          pbf.writeMessage(3, writeLayer, Object.assign(Object.assign({}, layer), { id: id2 }));
+        }
+        return pbf.finish();
+      }
+      function writeLayer(layer, pbf) {
+        if (!pbf)
+          throw new Error("pbf undefined");
+        pbf.writeVarintField(15, 2);
+        pbf.writeStringField(1, layer.id || "");
+        pbf.writeVarintField(5, layer.extent || 4096);
+        const context = {
+          keys: [],
+          values: [],
+          keycache: {},
+          valuecache: {}
+        };
+        for (const feature of layer.features) {
+          context.feature = feature;
+          pbf.writeMessage(2, writeFeature, context);
+        }
+        for (const key of context.keys) {
+          pbf.writeStringField(3, key);
+        }
+        for (const value of context.values) {
+          pbf.writeMessage(4, writeValue, value);
+        }
+      }
+      function writeFeature(context, pbf) {
+        const feature = context.feature;
+        if (!feature || !pbf)
+          throw new Error();
+        pbf.writeMessage(2, writeProperties, context);
+        pbf.writeVarintField(3, feature.type);
+        pbf.writeMessage(4, writeGeometry, feature);
+      }
+      function writeProperties(context, pbf) {
+        const feature = context.feature;
+        if (!feature || !pbf)
+          throw new Error();
+        const keys = context.keys;
+        const values = context.values;
+        const keycache = context.keycache;
+        const valuecache = context.valuecache;
+        for (const key in feature.properties) {
+          let value = feature.properties[key];
+          let keyIndex = keycache[key];
+          if (value === null)
+            continue;
+          if (typeof keyIndex === "undefined") {
+            keys.push(key);
+            keyIndex = keys.length - 1;
+            keycache[key] = keyIndex;
+          }
+          pbf.writeVarint(keyIndex);
+          const type = typeof value;
+          if (type !== "string" && type !== "boolean" && type !== "number") {
+            value = JSON.stringify(value);
+          }
+          const valueKey = `${type}:${value}`;
+          let valueIndex = valuecache[valueKey];
+          if (typeof valueIndex === "undefined") {
+            values.push(value);
+            valueIndex = values.length - 1;
+            valuecache[valueKey] = valueIndex;
+          }
+          pbf.writeVarint(valueIndex);
+        }
+      }
+      function command(cmd, length) {
+        return (length << 3) + (cmd & 7);
+      }
+      function zigzag(num2) {
+        return num2 << 1 ^ num2 >> 31;
+      }
+      function writeGeometry(feature, pbf) {
+        if (!pbf)
+          throw new Error();
+        const geometry = feature.geometry;
+        const type = feature.type;
+        let x3 = 0;
+        let y = 0;
+        for (const ring of geometry) {
+          let count = 1;
+          if (type === GeomType.POINT) {
+            count = ring.length / 2;
+          }
+          pbf.writeVarint(command(1, count));
+          const length = ring.length / 2;
+          const lineCount = type === GeomType.POLYGON ? length - 1 : length;
+          for (let i2 = 0; i2 < lineCount; i2++) {
+            if (i2 === 1 && type !== 1) {
+              pbf.writeVarint(command(2, lineCount - 1));
+            }
+            const dx = ring[i2 * 2] - x3;
+            const dy = ring[i2 * 2 + 1] - y;
+            pbf.writeVarint(zigzag(dx));
+            pbf.writeVarint(zigzag(dy));
+            x3 += dx;
+            y += dy;
+          }
+          if (type === GeomType.POLYGON) {
+            pbf.writeVarint(command(7, 1));
+          }
+        }
+      }
+      function writeValue(value, pbf) {
+        if (!pbf)
+          throw new Error();
+        if (typeof value === "string") {
+          pbf.writeStringField(1, value);
+        } else if (typeof value === "boolean") {
+          pbf.writeBooleanField(7, value);
+        } else if (typeof value === "number") {
+          if (value % 1 !== 0) {
+            pbf.writeDoubleField(3, value);
+          } else if (value < 0) {
+            pbf.writeSVarintField(6, value);
+          } else {
+            pbf.writeVarintField(5, value);
+          }
+        }
+      }
+      const perf = typeof performance !== "undefined" ? performance : void 0;
+      const timeOrigin = perf ? perf.timeOrigin || (/* @__PURE__ */ new Date()).getTime() - perf.now() : (/* @__PURE__ */ new Date()).getTime();
+      function getResourceTiming(url) {
+        var _a2;
+        return JSON.parse(JSON.stringify(((_a2 = perf === null || perf === void 0 ? void 0 : perf.getEntriesByName) === null || _a2 === void 0 ? void 0 : _a2.call(perf, url)) || []));
+      }
+      function now() {
+        return perf ? perf.now() : (/* @__PURE__ */ new Date()).getTime();
+      }
+      function flatten(input) {
+        const result = [];
+        for (const list of input) {
+          result.push(...list);
+        }
+        return result;
+      }
+      class Timer {
+        constructor(name) {
+          this.marks = {};
+          this.urls = [];
+          this.fetched = [];
+          this.resources = [];
+          this.tilesFetched = 0;
+          this.timeOrigin = timeOrigin;
+          this.finish = (url) => {
+            this.markFinish();
+            const get = (type) => {
+              const all = this.marks[type] || [];
+              const max2 = Math.max(...all.map((ns) => Math.max(...ns)));
+              const min = Math.min(...all.map((ns) => Math.min(...ns)));
+              return Number.isFinite(max2) ? max2 - min : void 0;
+            };
+            const duration = get("main") || 0;
+            const fetch2 = get("fetch");
+            const decode = get("decode");
+            const process = get("isoline");
+            return {
+              url,
+              tilesUsed: this.tilesFetched,
+              origin: this.timeOrigin,
+              marks: this.marks,
+              resources: [
+                ...this.resources,
+                ...flatten(this.fetched.map(getResourceTiming))
+              ],
+              duration,
+              fetch: fetch2,
+              decode,
+              process,
+              wait: duration - (fetch2 || 0) - (decode || 0) - (process || 0)
+            };
+          };
+          this.error = (url) => Object.assign(Object.assign({}, this.finish(url)), { error: true });
+          this.marker = (category) => {
+            var _a2;
+            if (!this.marks[category]) {
+              this.marks[category] = [];
+            }
+            const marks = [now()];
+            (_a2 = this.marks[category]) === null || _a2 === void 0 ? void 0 : _a2.push(marks);
+            return () => marks.push(now());
+          };
+          this.useTile = (url) => {
+            if (this.urls.indexOf(url) < 0) {
+              this.urls.push(url);
+              this.tilesFetched++;
+            }
+          };
+          this.fetchTile = (url) => {
+            if (this.fetched.indexOf(url) < 0) {
+              this.fetched.push(url);
+            }
+          };
+          this.addAll = (timings) => {
+            var _a2;
+            this.tilesFetched += timings.tilesUsed;
+            const offset = timings.origin - this.timeOrigin;
+            for (const category in timings.marks) {
+              const key = category;
+              const ourList = this.marks[key] || (this.marks[key] = []);
+              ourList.push(...((_a2 = timings.marks[key]) === null || _a2 === void 0 ? void 0 : _a2.map((ns) => ns.map((n) => n + offset))) || []);
+            }
+            this.resources.push(...timings.resources.map((rt) => applyOffset(rt, offset)));
+          };
+          this.markFinish = this.marker(name);
+        }
+      }
+      const startOrEnd = /(Start$|End$|^start|^end)/;
+      function applyOffset(obj, offset) {
+        const result = {};
+        for (const key in obj) {
+          if (obj[key] !== 0 && startOrEnd.test(key)) {
+            result[key] = Number(obj[key]) + offset;
+          } else {
+            result[key] = obj[key];
+          }
+        }
+        return result;
+      }
+      const defaultGetTile = (url, abortController) => __awaiter(void 0, void 0, void 0, function* () {
+        const options = {
+          signal: abortController.signal
+        };
+        const response = yield fetch(url, options);
+        if (!response.ok) {
+          throw new Error(`Bad response: ${response.status} for ${url}`);
+        }
+        return {
+          data: yield response.blob(),
+          expires: response.headers.get("expires") || void 0,
+          cacheControl: response.headers.get("cache-control") || void 0
+        };
+      });
+      class LocalDemManager {
+        constructor(options) {
+          this.loaded = Promise.resolve();
+          this.fetchAndParseTile = (z, x3, y, abortController, timer) => {
+            const self2 = this;
+            const url = this.demUrlPattern.replace("{z}", z.toString()).replace("{x}", x3.toString()).replace("{y}", y.toString());
+            timer === null || timer === void 0 ? void 0 : timer.useTile(url);
+            return this.parsedCache.get(url, (_2, childAbortController) => __awaiter(this, void 0, void 0, function* () {
+              const response = yield self2.fetchTile(z, x3, y, childAbortController, timer);
+              if (isAborted(childAbortController))
+                throw new Error("canceled");
+              const promise = self2.decodeImage(response.data, self2.encoding, childAbortController);
+              const mark = timer === null || timer === void 0 ? void 0 : timer.marker("decode");
+              const result = yield promise;
+              mark === null || mark === void 0 ? void 0 : mark();
+              return result;
+            }), abortController);
+          };
+          this.tileCache = new AsyncCache(options.cacheSize);
+          this.parsedCache = new AsyncCache(options.cacheSize);
+          this.contourCache = new AsyncCache(options.cacheSize);
+          this.timeoutMs = options.timeoutMs;
+          this.demUrlPattern = options.demUrlPattern;
+          this.encoding = options.encoding;
+          this.maxzoom = options.maxzoom;
+          this.decodeImage = options.decodeImage || defaultDecoder;
+          this.getTile = options.getTile || defaultGetTile;
+        }
+        fetchTile(z, x3, y, parentAbortController, timer) {
+          const url = this.demUrlPattern.replace("{z}", z.toString()).replace("{x}", x3.toString()).replace("{y}", y.toString());
+          timer === null || timer === void 0 ? void 0 : timer.useTile(url);
+          return this.tileCache.get(url, (_2, childAbortController) => {
+            timer === null || timer === void 0 ? void 0 : timer.fetchTile(url);
+            const mark = timer === null || timer === void 0 ? void 0 : timer.marker("fetch");
+            return withTimeout(this.timeoutMs, this.getTile(url, childAbortController).finally(() => mark === null || mark === void 0 ? void 0 : mark()), childAbortController);
+          }, parentAbortController);
+        }
+        fetchDem(z, x3, y, options, abortController, timer) {
+          return __awaiter(this, void 0, void 0, function* () {
+            const zoom = Math.min(z - (options.overzoom || 0), this.maxzoom);
+            const subZ = z - zoom;
+            const div = 1 << subZ;
+            const newX = Math.floor(x3 / div);
+            const newY = Math.floor(y / div);
+            const tile = yield this.fetchAndParseTile(zoom, newX, newY, abortController, timer);
+            return HeightTile.fromRawDem(tile).split(subZ, x3 % div, y % div);
+          });
+        }
+        fetchContourTile(z, x3, y, options, parentAbortController, timer) {
+          const { levels, multiplier = 1, buffer = 1, extent = 4096, contourLayer = "contours", elevationKey = "ele", levelKey = "level", subsampleBelow = 100 } = options;
+          if (!levels || levels.length === 0) {
+            return Promise.resolve({ arrayBuffer: new ArrayBuffer(0) });
+          }
+          const key = [z, x3, y, encodeIndividualOptions(options)].join("/");
+          return this.contourCache.get(key, (_2, childAbortController) => __awaiter(this, void 0, void 0, function* () {
+            const max2 = 1 << z;
+            const neighborPromises = [];
+            for (let iy = y - 1; iy <= y + 1; iy++) {
+              for (let ix = x3 - 1; ix <= x3 + 1; ix++) {
+                neighborPromises.push(iy < 0 || iy >= max2 ? void 0 : this.fetchDem(z, (ix + max2) % max2, iy, options, childAbortController, timer));
+              }
+            }
+            const neighbors = yield Promise.all(neighborPromises);
+            let virtualTile = HeightTile.combineNeighbors(neighbors);
+            if (!virtualTile || isAborted(childAbortController)) {
+              return { arrayBuffer: new Uint8Array().buffer };
+            }
+            const mark = timer === null || timer === void 0 ? void 0 : timer.marker("isoline");
+            if (virtualTile.width >= subsampleBelow) {
+              virtualTile = virtualTile.materialize(2);
+            } else {
+              while (virtualTile.width < subsampleBelow) {
+                virtualTile = virtualTile.subsamplePixelCenters(2).materialize(2);
+              }
+            }
+            virtualTile = virtualTile.averagePixelCentersToGrid().scaleElevation(multiplier).materialize(1);
+            const isolines = generateIsolines(levels[0], virtualTile, extent, buffer);
+            mark === null || mark === void 0 ? void 0 : mark();
+            const result = encodeVectorTile({
+              extent,
+              layers: {
+                [contourLayer]: {
+                  features: Object.entries(isolines).map(([eleString, geom]) => {
+                    const ele = Number(eleString);
+                    return {
+                      type: GeomType.LINESTRING,
+                      geometry: geom,
+                      properties: {
+                        [elevationKey]: ele,
+                        [levelKey]: Math.max(...levels.map((l2, i2) => ele % l2 === 0 ? i2 : 0))
+                      }
+                    };
+                  })
+                }
+              }
+            });
+            mark === null || mark === void 0 ? void 0 : mark();
+            return { arrayBuffer: result.buffer };
+          }), parentAbortController);
+        }
+      }
+      let id = 0;
+      class Actor {
+        constructor(dest, dispatcher, timeoutMs = 2e4) {
+          this.callbacks = {};
+          this.cancels = {};
+          this.dest = dest;
+          this.timeoutMs = timeoutMs;
+          this.dest.onmessage = (_a2) => __awaiter(this, [_a2], void 0, function* ({ data }) {
+            const message = data;
+            if (message.type === "cancel") {
+              const cancel = this.cancels[message.id];
+              delete this.cancels[message.id];
+              cancel === null || cancel === void 0 ? void 0 : cancel.abort();
+            } else if (message.type === "response") {
+              const callback = this.callbacks[message.id];
+              delete this.callbacks[message.id];
+              if (callback) {
+                callback(message.error ? new Error(message.error) : void 0, message.response, message.timings);
+              }
+            } else if (message.type === "request") {
+              const timer = new Timer("worker");
+              const handler = dispatcher[message.name];
+              const abortController = new AbortController();
+              const request = handler.apply(handler, [
+                ...message.args,
+                abortController,
+                timer
+              ]);
+              const url = `${message.name}_${message.id}`;
+              if (message.id && request) {
+                this.cancels[message.id] = abortController;
+                try {
+                  const response = yield request;
+                  const transferrables = response === null || response === void 0 ? void 0 : response.transferrables;
+                  this.postMessage({
+                    id: message.id,
+                    type: "response",
+                    response,
+                    timings: timer.finish(url)
+                  }, transferrables);
+                } catch (e) {
+                  this.postMessage({
+                    id: message.id,
+                    type: "response",
+                    error: (e === null || e === void 0 ? void 0 : e.toString()) || "error",
+                    timings: timer.finish(url)
+                  });
+                }
+                delete this.cancels[message.id];
+              }
+            }
+          });
+        }
+        postMessage(message, transferrables) {
+          this.dest.postMessage(message, transferrables || []);
+        }
+        /** Invokes a method by name with a set of arguments in the remote context. */
+        send(name, transferrables, abortController, timer, ...args) {
+          const thisId = ++id;
+          const value = new Promise((resolve, reject) => {
+            this.postMessage({ id: thisId, type: "request", name, args }, transferrables);
+            this.callbacks[thisId] = (error, result, timings) => {
+              timer === null || timer === void 0 ? void 0 : timer.addAll(timings);
+              if (error)
+                reject(error);
+              else
+                resolve(result);
+            };
+          });
+          onAbort(abortController, () => {
+            delete this.callbacks[thisId];
+            this.postMessage({ id: thisId, type: "cancel" });
+          });
+          return withTimeout(this.timeoutMs, value, abortController);
+        }
+      }
+      exports.A = Actor;
+      exports.H = HeightTile;
+      exports.L = LocalDemManager;
+      exports.T = Timer;
+      exports._ = __awaiter;
+      exports.a = decodeOptions;
+      exports.b = generateIsolines;
+      exports.c = decodeParsedImage;
+      exports.d = defaultDecoder;
+      exports.e = encodeOptions;
+      exports.f = prepareContourTile;
+      exports.g = getOptionsForZoom;
+      exports.p = prepareDemTile;
+    }));
+    define(["./shared"], (function(actor) {
+      "use strict";
+      const noManager = (managerId) => Promise.reject(new Error(`No manager registered for ${managerId}`));
+      class WorkerDispatch {
+        constructor() {
+          this.managers = {};
+          this.init = (message, _2) => {
+            this.managers[message.managerId] = new actor.L(message);
+            return Promise.resolve();
+          };
+          this.fetchTile = (managerId, z, x3, y, abortController, timer) => {
+            var _a2;
+            return ((_a2 = this.managers[managerId]) === null || _a2 === void 0 ? void 0 : _a2.fetchTile(z, x3, y, abortController, timer)) || noManager(managerId);
+          };
+          this.fetchAndParseTile = (managerId, z, x3, y, abortController, timer) => {
+            var _a2;
+            return actor.p(((_a2 = this.managers[managerId]) === null || _a2 === void 0 ? void 0 : _a2.fetchAndParseTile(z, x3, y, abortController, timer)) || noManager(managerId), true);
+          };
+          this.fetchContourTile = (managerId, z, x3, y, options, abortController, timer) => {
+            var _a2;
+            return actor.f(((_a2 = this.managers[managerId]) === null || _a2 === void 0 ? void 0 : _a2.fetchContourTile(z, x3, y, options, abortController, timer)) || noManager(managerId));
+          };
+        }
+      }
+      const g2 = typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : global;
+      g2.actor = new actor.A(g2, new WorkerDispatch());
+    }));
+    define(["./shared"], (function(actor) {
+      "use strict";
+      const CONFIG = { workerUrl: "" };
+      let _actor;
+      let id = 0;
+      class MainThreadDispatch {
+        constructor() {
+          this.decodeImage = (blob, encoding, abortController) => actor.p(actor.d(blob, encoding, abortController), false);
+        }
+      }
+      function defaultActor() {
+        if (!_actor) {
+          const worker2 = new Worker(CONFIG.workerUrl);
+          const dispatch = new MainThreadDispatch();
+          _actor = new actor.A(worker2, dispatch);
+        }
+        return _actor;
+      }
+      class RemoteDemManager {
+        constructor(options) {
+          this.fetchTile = (z, x3, y, abortController, timer) => this.actor.send("fetchTile", [], abortController, timer, this.managerId, z, x3, y);
+          this.fetchAndParseTile = (z, x3, y, abortController, timer) => this.actor.send("fetchAndParseTile", [], abortController, timer, this.managerId, z, x3, y);
+          this.fetchContourTile = (z, x3, y, options2, abortController, timer) => this.actor.send("fetchContourTile", [], abortController, timer, this.managerId, z, x3, y, options2);
+          const managerId = this.managerId = ++id;
+          this.actor = options.actor || defaultActor();
+          this.loaded = this.actor.send("init", [], new AbortController(), void 0, Object.assign(Object.assign({}, options), { managerId }));
+        }
+      }
+      if (!Blob.prototype.arrayBuffer) {
+        Blob.prototype.arrayBuffer = function arrayBuffer() {
+          return new Promise((resolve, reject) => {
+            const fileReader = new FileReader();
+            fileReader.onload = (event) => {
+              var _a2;
+              return resolve((_a2 = event.target) === null || _a2 === void 0 ? void 0 : _a2.result);
+            };
+            fileReader.onerror = reject;
+            fileReader.readAsArrayBuffer(this);
+          });
+        };
+      }
+      const v3compat = (v4) => (requestParameters, arg2) => {
+        if (arg2 instanceof AbortController) {
+          return v4(requestParameters, arg2);
+        } else {
+          const abortController = new AbortController();
+          v4(requestParameters, abortController).then((result) => arg2(void 0, result.data, result.cacheControl, result.expires), (err2) => arg2(err2)).catch((err2) => arg2(err2));
+          return { cancel: () => abortController.abort() };
+        }
+      };
+      const used = /* @__PURE__ */ new Set();
+      class DemSource {
+        constructor({ url, cacheSize = 100, id: id2 = "dem", encoding = "terrarium", maxzoom = 12, worker: worker2 = true, timeoutMs = 1e4, actor: actor$1 }) {
+          this.timingCallbacks = [];
+          this.onTiming = (callback) => {
+            this.timingCallbacks.push(callback);
+          };
+          this.setupMaplibre = (maplibre) => {
+            maplibre.addProtocol(this.sharedDemProtocolId, this.sharedDemProtocol);
+            maplibre.addProtocol(this.contourProtocolId, this.contourProtocol);
+          };
+          this.sharedDemProtocolV4 = (request, abortController) => actor._(this, void 0, void 0, function* () {
+            const [z, x3, y] = this.parseUrl(request.url);
+            const timer = new actor.T("main");
+            let timing;
+            try {
+              const data = yield this.manager.fetchTile(z, x3, y, abortController, timer);
+              timing = timer.finish(request.url);
+              const arrayBuffer = yield data.data.arrayBuffer();
+              return {
+                data: arrayBuffer,
+                cacheControl: data.cacheControl,
+                expires: data.expires
+              };
+            } catch (error) {
+              timing = timer.error(request.url);
+              throw error;
+            } finally {
+              this.timingCallbacks.forEach((cb) => cb(timing));
+            }
+          });
+          this.contourProtocolV4 = (request, abortController) => actor._(this, void 0, void 0, function* () {
+            const timer = new actor.T("main");
+            let timing;
+            try {
+              const [z, x3, y] = this.parseUrl(request.url);
+              const options = actor.a(request.url);
+              const data = yield this.manager.fetchContourTile(z, x3, y, actor.g(options, z), abortController, timer);
+              timing = timer.finish(request.url);
+              return { data: data.arrayBuffer };
+            } catch (error) {
+              timing = timer.error(request.url);
+              throw error;
+            } finally {
+              this.timingCallbacks.forEach((cb) => cb(timing));
+            }
+          });
+          this.contourProtocol = v3compat(this.contourProtocolV4);
+          this.sharedDemProtocol = v3compat(this.sharedDemProtocolV4);
+          this.contourProtocolUrl = (options) => `${this.contourProtocolUrlBase}?${actor.e(options)}`;
+          let protocolPrefix2 = id2;
+          let i2 = 1;
+          while (used.has(protocolPrefix2)) {
+            protocolPrefix2 = id2 + i2++;
+          }
+          used.add(protocolPrefix2);
+          this.sharedDemProtocolId = `${protocolPrefix2}-shared`;
+          this.contourProtocolId = `${protocolPrefix2}-contour`;
+          this.sharedDemProtocolUrl = `${this.sharedDemProtocolId}://{z}/{x}/{y}`;
+          this.contourProtocolUrlBase = `${this.contourProtocolId}://{z}/{x}/{y}`;
+          const ManagerClass = worker2 ? RemoteDemManager : actor.L;
+          this.manager = new ManagerClass({
+            demUrlPattern: url,
+            cacheSize,
+            encoding,
+            maxzoom,
+            timeoutMs,
+            actor: actor$1
+          });
+        }
+        getDemTile(z, x3, y, abortController) {
+          return this.manager.fetchAndParseTile(z, x3, y, abortController || new AbortController());
+        }
+        parseUrl(url) {
+          const [, z, x3, y] = /\/\/(\d+)\/(\d+)\/(\d+)/.exec(url) || [];
+          return [Number(z), Number(x3), Number(y)];
+        }
+      }
+      const exported = {
+        generateIsolines: actor.b,
+        DemSource,
+        HeightTile: actor.H,
+        LocalDemManager: actor.L,
+        decodeParsedImage: actor.c,
+        set workerUrl(url) {
+          CONFIG.workerUrl = url;
+        },
+        get workerUrl() {
+          return CONFIG.workerUrl;
+        }
+      };
+      return exported;
+    }));
+    mlcontour$1 = mlcontour;
+  }
+});
+
+// src/browser.ts
+init_portable_identity_rules();
+
 // src/runtime.ts
+var defaultTileflowRuntimeView = Object.freeze({
+  bearing: 0,
+  center: [0, 20],
+  pitch: 0,
+  zoom: 2
+});
+var tileflowSurfaceIdPattern = /^[a-z0-9](?:[a-z0-9._-]{0,62}[a-z0-9])?$/u;
+function normalizeTileflowSurfaceId(value) {
+  return typeof value === "string" && tileflowSurfaceIdPattern.test(value) ? value : "default";
+}
+var tileflowStyleFontFacesMetadataKey = "tileflow:fontFaces";
+var tileflowStyleFontFaceLimits = Object.freeze({
+  maximumCount: 16,
+  maximumSourceLength: 2048
+});
 var maxStaticImagePixels = 1280 * 1280;
+var maximumManifestBytes = 1024 * 1024;
+var maximumSessionGrantBytes = 64 * 1024;
 var manifestCache = new globalThis.Map();
+function getTileflowStyleFontFaces(style) {
+  const input = style.metadata?.[tileflowStyleFontFacesMetadataKey];
+  if (input === void 0) return [];
+  if (!Array.isArray(input) || input.length > tileflowStyleFontFaceLimits.maximumCount) {
+    throw new TypeError("Invalid Tileflow style fontFaces metadata.");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return input.map((value) => {
+    if (!isPlainRuntimeRecord(value)) {
+      throw new TypeError("Invalid Tileflow style fontFaces metadata.");
+    }
+    const keys = Object.keys(value);
+    if (keys.some((key2) => !["family", "source", "style", "weight"].includes(key2))) {
+      throw new TypeError("Invalid Tileflow style fontFaces metadata.");
+    }
+    const family = value.family;
+    const source = value.source;
+    const fontStyle = value.style;
+    const weight = value.weight;
+    if (typeof family !== "string" || family.length === 0 || family.length > 100 || family !== family.trim() || /[\p{Cc}\\]/u.test(family) || typeof source !== "string" || source.length === 0 || source.length > tileflowStyleFontFaceLimits.maximumSourceLength || source !== source.trim() || /[\p{Cc}\\]/u.test(source) || !isTileflowPublicFontUrl(source) || fontStyle !== void 0 && !["italic", "normal", "oblique"].includes(String(fontStyle)) || weight !== void 0 && !/^[1-9]00$/u.test(String(weight))) {
+      throw new TypeError("Invalid Tileflow style fontFaces metadata.");
+    }
+    const face = {
+      family,
+      source,
+      ...fontStyle === void 0 ? {} : { style: fontStyle },
+      ...weight === void 0 ? {} : { weight }
+    };
+    const key = `${face.family}\0${face.style ?? "normal"}\0${face.weight ?? "400"}`;
+    if (seen.has(key)) throw new TypeError("Invalid duplicate Tileflow style fontFace metadata.");
+    seen.add(key);
+    return face;
+  });
+}
 function normalizeTileflowUrl(value) {
   return value.replace(/\/+$/, "");
 }
-function resolveTileflowAnalyticsRequestUrl(url, analytics, sessionId) {
-  if (!analytics || analytics.enabled === false) {
-    return void 0;
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function isPlainRuntimeRecord(value) {
+  if (!isRecord(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function isTileflowPublicFontUrl(value) {
+  if (value.startsWith("//")) return false;
+  if (value.startsWith("/") || value.startsWith("./") || value.startsWith("../")) return true;
+  try {
+    const url = new URL(value);
+    return (url.protocol === "http:" || url.protocol === "https:") && !url.username && !url.password && !url.hash;
+  } catch {
+    return false;
+  }
+}
+function resolveTileflowAnalyticsRequestUrl(url, analytics, sessionId) {
+  if (!analytics || analytics.enabled === false) {
+    return void 0;
+  }
+  const apiUrl = getTileflowAnalyticsApiUrl(analytics);
+  if (!apiUrl || !isTileflowTileUrl(url, apiUrl)) {
+    return void 0;
+  }
+  const nextUrl = new URL(url);
+  nextUrl.searchParams.set("session", sessionId);
+  if (analytics.mapId) {
+    nextUrl.searchParams.set("map", analytics.mapId);
+  }
+  if (analytics.styleId) {
+    nextUrl.searchParams.set("styleId", analytics.styleId);
+  }
+  return nextUrl.toString();
+}
+function startTileflowSession(analytics, input) {
+  if (!analytics || analytics.enabled === false || !input.mapId || typeof navigator === "undefined") {
+    return;
+  }
+  const endpoint = analytics.endpoint ?? `${getTileflowAnalyticsApiUrl(analytics)}/v1/sessions/analytics`;
+  const payload = JSON.stringify({
+    mapId: input.mapId,
+    metadata: analytics.metadata,
+    referrer: typeof document === "undefined" ? void 0 : document.referrer || "",
+    sdkVersion: analytics.sdkVersion,
+    sessionId: input.sessionId,
+    source: analytics.source ?? input.source,
+    styleId: input.styleId,
+    surfaceId: normalizeTileflowSurfaceId(analytics.surfaceId),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const blob = new Blob([payload], { type: "application/json" });
+  if (navigator.sendBeacon?.(endpoint, blob)) {
+    return;
+  }
+  void fetch(endpoint, {
+    body: payload,
+    credentials: "omit",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    keepalive: true,
+    method: "POST"
+  }).catch(() => void 0);
+}
+function getTileflowAnalyticsApiUrl(analytics) {
+  if (analytics.apiUrl) {
+    return normalizeTileflowUrl(analytics.apiUrl);
+  }
+  if (analytics.endpoint) {
+    try {
+      const url = new URL(analytics.endpoint, getTileflowLocationOrigin());
+      return url.origin;
+    } catch {
+      return "https://api.tileflow.dev";
+    }
+  }
+  return "https://api.tileflow.dev";
+}
+function isTileflowTileUrl(url, apiUrl) {
+  try {
+    const parsedUrl = new URL(url);
+    const parsedApiUrl = new URL(apiUrl);
+    return parsedUrl.origin === parsedApiUrl.origin && isTilePath(parsedUrl);
+  } catch {
+    return false;
+  }
+}
+function isTilePath(url) {
+  return url.pathname.startsWith("/tiles/") || url.pathname.startsWith("/v1/tiles/");
+}
+function getTileflowLocationOrigin() {
+  if (typeof window === "undefined") {
+    return "http://localhost";
+  }
+  return window.location.origin;
+}
+
+// src/data/world-release-id-values.ts
+var tileflowWorldReleaseIdMinimumLength = 12;
+var tileflowWorldReleaseIdMaximumLength = 128;
+var tileflowWorldReleaseIdPatternSource = "^world-v1-[a-z0-9][a-z0-9._-]*[a-z0-9]$";
+var tileflowWorldReleaseIdPattern = new RegExp(tileflowWorldReleaseIdPatternSource, "u");
+function isTileflowWorldReleaseId(value) {
+  return typeof value === "string" && value.length >= tileflowWorldReleaseIdMinimumLength && value.length <= tileflowWorldReleaseIdMaximumLength && tileflowWorldReleaseIdPattern.test(value);
+}
+
+// src/fair-use-browser.ts
+var protocol = "tileflow-world";
+var defaultHelpUrl = "https://tileflow.dev/world/connect";
+var ownerAction = "Site owner: manage this map with Tileflow.";
+var maximumWorldTileBytes = 16 * 1024 * 1024;
+var oversizedWorldTileMessage = "Tileflow World tile exceeds the maximum response size";
+var unreadableWorldTileMessage = "Tileflow World tile response could not be read";
+var registrations = /* @__PURE__ */ new Map();
+var installed = false;
+var channelSequence = 0;
+function registerTileflowWorldRequestBridge(input) {
+  if (!installed) {
+    input.addProtocol(protocol, loadTileflowWorldRequest);
+    installed = true;
+  }
+  const channel = createChannel();
+  registrations.set(channel, {
+    currentNoticeState: null,
+    fetch: input.fetch ?? globalThis.fetch,
+    lastNoticeSequence: 0,
+    nextRequestSequence: 0,
+    onNotice: input.onNotice
+  });
+  let disposed = false;
+  return Object.freeze({
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      registrations.delete(channel);
+    },
+    rewriteUrl(url) {
+      if (disposed || !isCanonicalWorldTileUrl(url)) return url;
+      return `${protocol}://request/${channel}?url=${encodeURIComponent(url)}`;
+    }
+  });
+}
+function tileflowFairUseNoticeMessage(state) {
+  return state === "MANAGED_REQUIRED" ? "Map usage is temporarily limited." : "Map usage is approaching its temporary limit.";
+}
+function attachTileflowFairUseNotice(container) {
+  let element = null;
+  let current = null;
+  let disposed = false;
+  const remove = () => {
+    element?.remove();
+    element = null;
+    current = null;
+  };
+  return Object.freeze({
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      remove();
+    },
+    update(notice) {
+      if (disposed) return;
+      if (!notice) {
+        remove();
+        return;
+      }
+      if (current?.state === "MANAGED_REQUIRED" && notice.state === "GRACE") return;
+      if (element && current?.state !== notice.state) {
+        element.remove();
+        element = null;
+      }
+      current = notice;
+      if (!element) {
+        element = container.ownerDocument.createElement("div");
+        element.dataset.tileflowFairUseNotice = "";
+        element.setAttribute("aria-atomic", "true");
+        element.setAttribute("aria-live", "polite");
+        element.setAttribute("role", "status");
+        Object.assign(element.style, noticeContainerStyles(notice.state));
+        container.append(element);
+      }
+      element.dataset.tileflowFairUseNotice = notice.state.toLowerCase().replace("_", "-");
+      element.replaceChildren();
+      const indicator = container.ownerDocument.createElement("span");
+      indicator.setAttribute("aria-hidden", "true");
+      indicator.textContent = notice.state === "MANAGED_REQUIRED" ? "!" : "";
+      Object.assign(indicator.style, noticeIndicatorStyles(notice.state));
+      element.append(indicator);
+      const copy = container.ownerDocument.createElement("span");
+      copy.textContent = `${notice.message} `;
+      const link = container.ownerDocument.createElement("a");
+      link.href = notice.helpUrl;
+      link.rel = "noopener noreferrer";
+      link.target = "_blank";
+      link.textContent = notice.action;
+      Object.assign(link.style, {
+        color: "inherit",
+        fontWeight: "700",
+        textDecoration: "underline",
+        textDecorationThickness: "1px",
+        textUnderlineOffset: "2px"
+      });
+      copy.append(link);
+      element.append(copy);
+    }
+  });
+}
+async function loadTileflowWorldRequest(request, abortController) {
+  const wrapped = new URL(request.url);
+  const channel = wrapped.pathname.slice(1);
+  const registration = wrapped.hostname === "request" ? registrations.get(channel) : void 0;
+  const original = wrapped.searchParams.get("url") ?? "";
+  if (!registration || !isCanonicalWorldTileUrl(original)) {
+    throw new Error("Invalid Tileflow World request bridge");
+  }
+  registration.nextRequestSequence += 1;
+  const requestSequence = registration.nextRequestSequence;
+  const response = await registration.fetch(original, {
+    credentials: "omit",
+    method: "GET",
+    signal: abortController.signal
+  });
+  const registrationStillActive = registrations.get(channel) === registration;
+  const fairUse = parseFairUseState(response.headers.get("Tileflow-Fair-Use"));
+  const ownerNotice = response.headers.get("Tileflow-Fair-Use-Notice") === "owner";
+  if (registrationStillActive && fairUse !== null && requestSequence >= registration.lastNoticeSequence) {
+    if (fairUse === "OPEN") {
+      if (response.ok) {
+        registration.lastNoticeSequence = requestSequence;
+        registration.currentNoticeState = null;
+        registration.onNotice(null);
+      }
+    } else if (fairUse === "MANAGED_REQUIRED" || fairUse === "GRACE" && (ownerNotice || response.status === 429)) {
+      registration.lastNoticeSequence = requestSequence;
+      if (!(registration.currentNoticeState === "MANAGED_REQUIRED" && fairUse === "GRACE")) {
+        registration.currentNoticeState = fairUse;
+        registration.onNotice(
+          Object.freeze({
+            action: ownerAction,
+            helpUrl: parseHelpUrl(response.headers.get("Link")),
+            message: tileflowFairUseNoticeMessage(fairUse),
+            state: fairUse
+          })
+        );
+      }
+    } else if (fairUse === "GRACE" && response.ok) {
+      registration.lastNoticeSequence = requestSequence;
+      if (registration.currentNoticeState !== "MANAGED_REQUIRED") {
+        registration.currentNoticeState = null;
+        registration.onNotice(null);
+      }
+    }
+  }
+  if (response.status === 404 || response.status === 429 && (fairUse === "GRACE" || fairUse === "MANAGED_REQUIRED")) {
+    await cancelResponseBody(response.body);
+    return Object.freeze({
+      cacheControl: "private, no-store",
+      data: new ArrayBuffer(0)
+    });
+  }
+  if (!response.ok) {
+    await cancelResponseBody(response.body);
+    throw new Error(`Tileflow World request failed: ${response.status}`);
+  }
+  return Object.freeze({
+    ...response.headers.get("Cache-Control") ? { cacheControl: response.headers.get("Cache-Control") } : {},
+    data: await readWorldTileBody(response, abortController.signal),
+    ...response.headers.get("ETag") ? { etag: response.headers.get("ETag") } : {},
+    ...response.headers.get("Expires") ? { expires: response.headers.get("Expires") } : {}
+  });
+}
+async function readWorldTileBody(response, signal) {
+  if (signal.aborted) {
+    await cancelResponseBody(response.body);
+    throw abortReason(signal);
+  }
+  const declaredLength = parseContentLength(response.headers.get("Content-Length"));
+  if (declaredLength !== null && declaredLength > maximumWorldTileBytes) {
+    await cancelResponseBody(response.body);
+    throw new Error(oversizedWorldTileMessage);
+  }
+  if (!response.body) return new ArrayBuffer(0);
+  const reader = response.body.getReader();
+  const chunks = [];
+  let byteLength = 0;
+  let abortCancellation = null;
+  const cancelForAbort = () => {
+    abortCancellation ??= cancelReader(reader, signal.reason);
+  };
+  signal.addEventListener("abort", cancelForAbort, { once: true });
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      throwIfWorldRequestAborted(signal);
+      if (done) break;
+      if (value.byteLength > maximumWorldTileBytes - byteLength) {
+        await cancelReader(reader);
+        throw new Error(oversizedWorldTileMessage);
+      }
+      byteLength += value.byteLength;
+      chunks.push(Uint8Array.from(value));
+    }
+  } catch (error) {
+    if (signal.aborted) {
+      await (abortCancellation ?? cancelReader(reader, signal.reason));
+      throw abortReason(signal);
+    }
+    await cancelReader(reader);
+    if (error instanceof Error && error.message === oversizedWorldTileMessage) throw error;
+    throw new Error(unreadableWorldTileMessage);
+  } finally {
+    signal.removeEventListener("abort", cancelForAbort);
+    reader.releaseLock();
+  }
+  const data = new ArrayBuffer(byteLength);
+  const output = new Uint8Array(data);
+  let offset = 0;
+  for (const chunk of chunks) {
+    output.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return data;
+}
+function parseContentLength(value) {
+  const normalized = value?.trim();
+  if (!normalized || !/^\d+$/u.test(normalized)) return null;
+  const length = Number(normalized);
+  return Number.isSafeInteger(length) ? length : maximumWorldTileBytes + 1;
+}
+async function cancelResponseBody(body) {
+  if (!body) return;
+  try {
+    await body.cancel();
+  } catch {
+  }
+}
+async function cancelReader(reader, reason) {
+  try {
+    await reader.cancel(reason);
+  } catch {
+  }
+}
+function throwIfWorldRequestAborted(signal) {
+  if (signal.aborted) throw abortReason(signal);
+}
+function abortReason(signal) {
+  if (signal.reason !== void 0) return signal.reason;
+  return new DOMException("The Tileflow World request was aborted", "AbortError");
+}
+function parseFairUseState(value) {
+  if (value === "open") return "OPEN";
+  if (value === "grace") return "GRACE";
+  if (value === "managed-required") return "MANAGED_REQUIRED";
+  return null;
+}
+function noticeContainerStyles(state) {
+  const shared2 = {
+    display: "flex",
+    left: "50%",
+    position: "absolute",
+    transform: "translateX(-50%)",
+    zIndex: "3"
+  };
+  if (state === "GRACE") {
+    return {
+      ...shared2,
+      alignItems: "center",
+      background: "rgba(252, 250, 244, 0.96)",
+      border: "1px solid rgba(189, 138, 43, 0.28)",
+      borderRadius: "999px",
+      bottom: "24px",
+      boxSizing: "border-box",
+      boxShadow: "0 1px 5px rgba(17, 24, 39, 0.15)",
+      color: "#38433d",
+      font: "560 12px/1.35 system-ui, sans-serif",
+      gap: "7px",
+      maxWidth: "calc(100% - 24px)",
+      padding: "7px 11px 7px 9px",
+      textAlign: "center",
+      width: "max-content"
+    };
+  }
+  return {
+    ...shared2,
+    alignItems: "flex-start",
+    background: "rgba(25, 34, 29, 0.96)",
+    border: "1px solid rgba(255, 255, 255, 0.2)",
+    borderRadius: "8px",
+    boxShadow: "0 4px 18px rgba(0, 0, 0, 0.28)",
+    color: "#fff",
+    font: "500 13px/1.45 system-ui, sans-serif",
+    gap: "10px",
+    maxWidth: "min(39rem, calc(100% - 32px))",
+    padding: "12px 14px",
+    textAlign: "left",
+    top: "14px"
+  };
+}
+function noticeIndicatorStyles(state) {
+  if (state === "GRACE") {
+    return {
+      background: "#c58c28",
+      borderRadius: "999px",
+      flex: "0 0 auto",
+      height: "7px",
+      width: "7px"
+    };
+  }
+  return {
+    alignItems: "center",
+    background: "#d69e39",
+    borderRadius: "999px",
+    color: "#17201b",
+    display: "inline-flex",
+    flex: "0 0 auto",
+    font: "800 12px/1 system-ui, sans-serif",
+    height: "18px",
+    justifyContent: "center",
+    marginTop: "1px",
+    width: "18px"
+  };
+}
+function parseHelpUrl(value) {
+  const match = value?.match(/<([^>]+)>\s*;\s*rel=(?:"help"|help)(?:\s*;|\s*$)/iu);
+  if (!match?.[1]) return defaultHelpUrl;
+  try {
+    const url = new URL(match[1]);
+    if (url.protocol !== "https:" || url.username || url.password || url.hostname !== "tileflow.dev" && !url.hostname.endsWith(".tileflow.dev")) {
+      return defaultHelpUrl;
+    }
+    return url.toString();
+  } catch {
+    return defaultHelpUrl;
+  }
+}
+function isCanonicalWorldTileUrl(value) {
+  try {
+    const url = new URL(value);
+    const exactPath = url.pathname.match(
+      /^\/tiles\/world\/([^/]+)\/(?:0|[1-9]\d*)\/(?:0|[1-9]\d*)\/(?:0|[1-9]\d*)\.pbf$/u
+    );
+    if (url.protocol !== "https:" || url.hostname !== "tileflow.dev" && !url.hostname.endsWith(".tileflow.dev") || url.port || url.username || url.password || url.hash || !exactPath || !isTileflowWorldReleaseId(exactPath[1])) {
+      return false;
+    }
+    const allowedQueryKeys = /* @__PURE__ */ new Set([
+      "grant",
+      "map",
+      "renderExpires",
+      "renderSignature",
+      "session",
+      "styleId",
+      "worldDescriptorSha256"
+    ]);
+    if ([...url.searchParams.keys()].some((key) => !allowedQueryKeys.has(key))) return false;
+    const descriptorDigests = url.searchParams.getAll("worldDescriptorSha256");
+    return descriptorDigests.length === 1 && /^[0-9a-f]{64}$/u.test(descriptorDigests[0] ?? "");
+  } catch {
+    return false;
+  }
+}
+function createChannel() {
+  channelSequence += 1;
+  if (typeof crypto !== "undefined" && "randomUUID" in crypto) {
+    return `bridge_${crypto.randomUUID().replaceAll("-", "_")}`;
+  }
+  return `bridge_${Date.now().toString(36)}_${channelSequence.toString(36)}`;
+}
+
+// src/terrain/contour-protocol.ts
+var tileflowContourProtocol = "tileflow-contour";
+var tileflowContourSourceLayer = "contours";
+function minimumTileflowContourSourceInterval(zoom) {
+  if (zoom <= 4) return 250;
+  if (zoom <= 7) return 100;
+  if (zoom <= 10) return 50;
+  if (zoom <= 12) return 20;
+  return 10;
+}
+function isTileflowContourDensityWithinBudget(minorInterval, multiplier, zoom) {
+  const minimumScaledInterval = minimumTileflowContourSourceInterval(zoom) * multiplier;
+  const tolerance = Number.EPSILON * Math.max(1, minorInterval, minimumScaledInterval) * 8;
+  return minorInterval + tolerance >= minimumScaledInterval;
+}
+var maximumDemUrlLength = 2048;
+var maximumProtocolUrlLength = 8192;
+var contourTilePathPattern = /^\/(\d{1,2})\/(\d{1,8})\/(\d{1,8})\.pbf$/u;
+var allowedParameters = /* @__PURE__ */ new Set([
+  "demMaxzoom",
+  "demUrl",
+  "encoding",
+  "maxzoom",
+  "multiplier",
+  "overzoom",
+  "thresholds"
+]);
+function parseTileflowContourProtocolRequest(value) {
+  if (value.length > maximumProtocolUrlLength || /[\\\p{Cc}]/u.test(value)) {
+    throw new Error("Invalid Tileflow contour protocol URL.");
+  }
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error("Invalid Tileflow contour protocol URL.");
+  }
+  if (url.protocol !== `${tileflowContourProtocol}:` || url.hostname !== "tiles" || url.username || url.password || url.hash) {
+    throw new Error("Invalid Tileflow contour protocol URL.");
+  }
+  for (const key of url.searchParams.keys()) {
+    if (!allowedParameters.has(key) || url.searchParams.getAll(key).length !== 1) {
+      throw new Error("Invalid Tileflow contour protocol URL parameters.");
+    }
+  }
+  if ([...allowedParameters].some((key) => !url.searchParams.has(key))) {
+    throw new Error("Incomplete Tileflow contour protocol URL parameters.");
+  }
+  const tile = contourTilePathPattern.exec(url.pathname);
+  if (!tile) throw new Error("Invalid Tileflow contour tile coordinates.");
+  const z = Number(tile[1]);
+  const x3 = Number(tile[2]);
+  const y = Number(tile[3]);
+  const config = {
+    demMaxzoom: parseBoundedInteger(url.searchParams.get("demMaxzoom"), 0, 24),
+    demUrl: url.searchParams.get("demUrl") ?? "",
+    encoding: parseEncoding(url.searchParams.get("encoding")),
+    maxzoom: parseBoundedInteger(url.searchParams.get("maxzoom"), 0, 24),
+    multiplier: parseBoundedNumber(url.searchParams.get("multiplier"), 1e-3, 100),
+    overzoom: parseBoundedInteger(url.searchParams.get("overzoom"), 0, 8),
+    thresholds: parseThresholds(url.searchParams.get("thresholds") ?? "")
+  };
+  assertTileflowContourProtocolConfig(config);
+  const axisLimit = 2 ** z;
+  const minimumThresholdZoom = Math.min(...Object.keys(config.thresholds).map(Number));
+  if (z < minimumThresholdZoom || z > config.maxzoom || x3 >= axisLimit || y >= axisLimit) {
+    throw new Error("Invalid Tileflow contour tile coordinates.");
+  }
+  return { config, x: x3, y, z };
+}
+function isSafeTileflowDemUrlTemplate(value) {
+  if (value.length === 0 || value.length > maximumDemUrlLength || value.startsWith("//") || value.includes("#") || /[\\\p{Cc}]/u.test(value)) {
+    return false;
+  }
+  for (const placeholder of ["{z}", "{x}", "{y}"]) {
+    if (value.split(placeholder).length !== 2) return false;
+  }
+  if (/\{[^{}]*\}/u.test(value.replaceAll("{z}", "").replaceAll("{x}", "").replaceAll("{y}", ""))) {
+    return false;
+  }
+  try {
+    const url = new URL(value.replaceAll("{z}", "0").replaceAll("{x}", "0").replaceAll("{y}", "0"));
+    return (url.protocol === "https:" || url.protocol === "http:" && isLoopbackHostname(url.hostname)) && !url.username && !url.password && !url.hash;
+  } catch {
+    return false;
+  }
+}
+function assertTileflowContourProtocolConfig(config) {
+  if (!isSafeTileflowDemUrlTemplate(config.demUrl)) {
+    throw new Error(
+      "Tileflow contour demUrl must be a safe HTTP(S) template containing {z}, {x}, and {y}."
+    );
+  }
+  if (config.encoding !== "mapbox" && config.encoding !== "terrarium") {
+    throw new Error("Tileflow contour encoding must be mapbox or terrarium.");
+  }
+  assertBoundedInteger(config.demMaxzoom, 0, 24, "demMaxzoom");
+  assertBoundedInteger(config.maxzoom, 0, 24, "maxzoom");
+  assertBoundedInteger(config.overzoom, 0, 8, "overzoom");
+  assertBoundedNumber(config.multiplier, 1e-3, 100, "multiplier");
+  const entries = Object.entries(config.thresholds);
+  if (entries.length === 0 || entries.length > 25) {
+    throw new Error("Tileflow contour thresholds must contain between 1 and 25 zoom entries.");
+  }
+  for (const [zoom, pair] of entries) {
+    if (!/^(?:0|[1-9]\d?)$/u.test(zoom)) {
+      throw new Error("Tileflow contour threshold zooms must be integers from 0 to 24.");
+    }
+    assertBoundedInteger(Number(zoom), 0, 24, "threshold zoom");
+    if (!Array.isArray(pair) || pair.length !== 2) {
+      throw new Error("Tileflow contour thresholds must be [minor, index] pairs.");
+    }
+    const [minor, index] = pair;
+    assertBoundedNumber(minor, 1e-3, 1e5, "minor threshold");
+    assertBoundedNumber(index, minor, 1e5, "index threshold");
+    if (!isTileflowContourDensityWithinBudget(minor, config.multiplier, Number(zoom))) {
+      throw new Error("Tileflow contour threshold exceeds the supported density budget.");
+    }
+    if (!isWholeContourMultiple(index, minor)) {
+      throw new Error(
+        "Tileflow contour index threshold must be a whole multiple of the minor threshold."
+      );
+    }
+  }
+  const thresholdZooms = entries.map(([zoom]) => Number(zoom));
+  if (Math.max(...thresholdZooms) > config.maxzoom) {
+    throw new Error("Tileflow contour maxzoom must include every threshold zoom.");
+  }
+  if (config.overzoom > Math.min(...thresholdZooms)) {
+    throw new Error("Tileflow contour overzoom must not produce a negative DEM zoom.");
+  }
+}
+function parseThresholds(value) {
+  if (!value || value.length > 1024) {
+    throw new Error("Invalid Tileflow contour thresholds.");
+  }
+  const result = {};
+  for (const entry of value.split(";")) {
+    const match = /^(0|[1-9]\d?):([^,]+),([^,]+)$/u.exec(entry);
+    if (!match) throw new Error("Invalid Tileflow contour thresholds.");
+    const zoom = parseBoundedInteger(match[1], 0, 24);
+    if (Object.hasOwn(result, zoom)) throw new Error("Duplicate Tileflow contour threshold zoom.");
+    result[zoom] = [
+      parseBoundedNumber(match[2], 1e-3, 1e5),
+      parseBoundedNumber(match[3], 1e-3, 1e5)
+    ];
+  }
+  return result;
+}
+function parseEncoding(value) {
+  if (value !== "mapbox" && value !== "terrarium") {
+    throw new Error("Invalid Tileflow contour encoding.");
+  }
+  return value;
+}
+function parseBoundedInteger(value, minimum, maximum) {
+  if (value === null || !/^(?:0|[1-9]\d*)$/u.test(value)) {
+    throw new Error("Invalid Tileflow contour integer.");
+  }
+  const parsed = Number(value);
+  assertBoundedInteger(parsed, minimum, maximum, "integer");
+  return parsed;
+}
+function parseBoundedNumber(value, minimum, maximum) {
+  if (value === null || value.trim() !== value || value === "") {
+    throw new Error("Invalid Tileflow contour number.");
+  }
+  const parsed = Number(value);
+  assertBoundedNumber(parsed, minimum, maximum, "number");
+  return parsed;
+}
+function assertBoundedInteger(value, minimum, maximum, name) {
+  if (!Number.isInteger(value) || value < minimum || value > maximum) {
+    throw new Error(`Tileflow contour ${name} is outside its supported range.`);
+  }
+}
+function assertBoundedNumber(value, minimum, maximum, name) {
+  if (!Number.isFinite(value) || value < minimum || value > maximum) {
+    throw new Error(`Tileflow contour ${name} is outside its supported range.`);
+  }
+}
+function isWholeContourMultiple(value, interval) {
+  const ratio = value / interval;
+  return Math.abs(ratio - Math.round(ratio)) <= Number.EPSILON * Math.max(1, ratio) * 8;
+}
+function isLoopbackHostname(hostname) {
+  const normalized = hostname.toLowerCase().replace(/^\[|\]$/gu, "");
+  return normalized === "localhost" || normalized === "::1" || normalized === "0:0:0:0:0:0:0:1" || /^127(?:\.\d{1,3}){3}$/u.test(normalized);
+}
+
+// src/contour-browser.ts
+var tileflowMaplibreContourVersion = "0.1.0";
+var registeredContourProtocols = /* @__PURE__ */ new WeakSet();
+function registerTileflowContourProtocol(registry, options = {}) {
+  if (registeredContourProtocols.has(registry.addProtocol)) return;
+  const handler = createTileflowContourProtocolHandler(
+    options.loadMaplibreContour ?? loadPinnedMaplibreContour
+  );
+  registry.addProtocol(tileflowContourProtocol, handler);
+  registeredContourProtocols.add(registry.addProtocol);
+}
+function createTileflowContourProtocolHandler(loadModule) {
+  let library;
+  const sources = /* @__PURE__ */ new Map();
+  return async (request, abortController) => {
+    if (abortController.signal.aborted) throw new Error("Tileflow contour request aborted.");
+    const { config, x: x3, y, z } = parseTileflowContourProtocolRequest(request.url);
+    const sourceKey = JSON.stringify([config.demUrl, config.encoding, config.demMaxzoom]);
+    let source = sources.get(sourceKey);
+    if (!source) {
+      if (sources.size >= 16) sources.delete(sources.keys().next().value);
+      library ??= loadModule().then(resolveMaplibreContourLibrary);
+      source = library.then(
+        (module) => new module.DemSource({
+          encoding: config.encoding,
+          maxzoom: config.demMaxzoom,
+          url: config.demUrl,
+          // Upstream workers use a generated `blob:` URL. The main-thread manager keeps the
+          // protocol usable in strict-CSP applications and deterministic local captures.
+          worker: false
+        })
+      );
+      source = source.catch((error) => {
+        sources.delete(sourceKey);
+        library = void 0;
+        throw error;
+      });
+      sources.set(sourceKey, source);
+    }
+    const contourSource = await source;
+    if (abortController.signal.aborted) throw new Error("Tileflow contour request aborted.");
+    const contourUrl = contourSource.contourProtocolUrl({
+      contourLayer: tileflowContourSourceLayer,
+      elevationKey: "ele",
+      levelKey: "level",
+      multiplier: config.multiplier,
+      overzoom: config.overzoom,
+      thresholds: mutableThresholds(config.thresholds)
+    }).replace("{z}", String(z)).replace("{x}", String(x3)).replace("{y}", String(y));
+    return contourSource.contourProtocolV4({ url: contourUrl }, abortController);
+  };
+}
+async function loadPinnedMaplibreContour() {
+  return Promise.resolve().then(() => (init_dist(), dist_exports));
+}
+function resolveMaplibreContourLibrary(module) {
+  if (!module || typeof module !== "object") {
+    throw new Error("maplibre-contour 0.1.0 did not expose its browser module.");
+  }
+  const library = module.default;
+  if (!library || typeof library !== "object" || typeof library.DemSource !== "function") {
+    throw new Error("maplibre-contour 0.1.0 did not expose DemSource.");
+  }
+  return library;
+}
+function mutableThresholds(thresholds) {
+  return Object.fromEntries(
+    Object.entries(thresholds).map(([zoom, [minor, index]]) => [Number(zoom), [minor, index]])
+  );
+}
+
+// ../../node_modules/.pnpm/fflate@0.8.2/node_modules/fflate/esm/browser.js
+var u8 = Uint8Array;
+var u16 = Uint16Array;
+var i32 = Int32Array;
+var 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,
+  /* unused */
+  0,
+  0,
+  /* impossible */
+  0
+]);
+var 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,
+  /* unused */
+  0,
+  0
+]);
+var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+var freb = function(eb, start) {
+  var b2 = new u16(31);
+  for (var i2 = 0; i2 < 31; ++i2) {
+    b2[i2] = start += 1 << eb[i2 - 1];
+  }
+  var r = new i32(b2[30]);
+  for (var i2 = 1; i2 < 30; ++i2) {
+    for (var j2 = b2[i2]; j2 < b2[i2 + 1]; ++j2) {
+      r[j2] = j2 - b2[i2] << 5 | i2;
+    }
+  }
+  return { b: b2, r };
+};
+var _a = freb(fleb, 2);
+var fl = _a.b;
+var revfl = _a.r;
+fl[28] = 258, revfl[258] = 28;
+var _b = freb(fdeb, 0);
+var fd = _b.b;
+var revfd = _b.r;
+var rev = new u16(32768);
+for (i = 0; i < 32768; ++i) {
+  x = (i & 43690) >> 1 | (i & 21845) << 1;
+  x = (x & 52428) >> 2 | (x & 13107) << 2;
+  x = (x & 61680) >> 4 | (x & 3855) << 4;
+  rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
+}
+var x;
+var i;
+var hMap = (function(cd, mb, r) {
+  var s = cd.length;
+  var i2 = 0;
+  var l2 = new u16(mb);
+  for (; i2 < s; ++i2) {
+    if (cd[i2])
+      ++l2[cd[i2] - 1];
+  }
+  var le = new u16(mb);
+  for (i2 = 1; i2 < mb; ++i2) {
+    le[i2] = le[i2 - 1] + l2[i2 - 1] << 1;
+  }
+  var co;
+  if (r) {
+    co = new u16(1 << mb);
+    var rvb = 15 - mb;
+    for (i2 = 0; i2 < s; ++i2) {
+      if (cd[i2]) {
+        var sv = i2 << 4 | cd[i2];
+        var r_1 = mb - cd[i2];
+        var v2 = le[cd[i2] - 1]++ << r_1;
+        for (var m2 = v2 | (1 << r_1) - 1; v2 <= m2; ++v2) {
+          co[rev[v2] >> rvb] = sv;
+        }
+      }
+    }
+  } else {
+    co = new u16(s);
+    for (i2 = 0; i2 < s; ++i2) {
+      if (cd[i2]) {
+        co[i2] = rev[le[cd[i2] - 1]++] >> 15 - cd[i2];
+      }
+    }
+  }
+  return co;
+});
+var flt = new u8(288);
+for (i = 0; i < 144; ++i)
+  flt[i] = 8;
+var i;
+for (i = 144; i < 256; ++i)
+  flt[i] = 9;
+var i;
+for (i = 256; i < 280; ++i)
+  flt[i] = 7;
+var i;
+for (i = 280; i < 288; ++i)
+  flt[i] = 8;
+var i;
+var fdt = new u8(32);
+for (i = 0; i < 32; ++i)
+  fdt[i] = 5;
+var i;
+var flrm = /* @__PURE__ */ hMap(flt, 9, 1);
+var fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
+var max = function(a) {
+  var m2 = a[0];
+  for (var i2 = 1; i2 < a.length; ++i2) {
+    if (a[i2] > m2)
+      m2 = a[i2];
+  }
+  return m2;
+};
+var bits = function(d, p, m2) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8) >> (p & 7) & m2;
+};
+var bits16 = function(d, p) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
+};
+var shft = function(p) {
+  return (p + 7) / 8 | 0;
+};
+var slc = function(v2, s, e) {
+  if (s == null || s < 0)
+    s = 0;
+  if (e == null || e > v2.length)
+    e = v2.length;
+  return new u8(v2.subarray(s, e));
+};
+var 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"
+  // determined by unknown compression method
+];
+var 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;
+};
+var 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;
+  var resize = noBuf || st.i != 2;
+  var noSt = st.i;
+  if (noBuf)
+    buf = new u8(sl * 3);
+  var cbuf = function(l3) {
+    var bl = buf.length;
+    if (l3 > bl) {
+      var nbuf = new u8(Math.max(bl * 2, l3));
+      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, l2 = dat[s - 4] | dat[s - 3] << 8, t = s + l2;
+        if (t > sl) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt + l2);
+        buf.set(dat.subarray(s, t), bt);
+        st.b = bt += l2, 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 i2 = 0; i2 < hcLen; ++i2) {
+          clt[clim[i2]] = bits(dat, pos + i2 * 3, 7);
+        }
+        pos += hcLen * 3;
+        var clb = max(clt), clbmsk = (1 << clb) - 1;
+        var clm = hMap(clt, clb, 1);
+        for (var i2 = 0; i2 < tl; ) {
+          var r = clm[bits(dat, pos, clbmsk)];
+          pos += r & 15;
+          var s = r >> 4;
+          if (s < 16) {
+            ldt[i2++] = s;
+          } else {
+            var c = 0, n = 0;
+            if (s == 16)
+              n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i2 - 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[i2++] = 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 (resize)
+      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 i2 = sym - 257, b2 = fleb[i2];
+          add = bits(dat, pos, (1 << b2) - 1) + fl[i2];
+          pos += b2;
+        }
+        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 b2 = fdeb[dsym];
+          dt += bits16(dat, pos) & (1 << b2) - 1, pos += b2;
+        }
+        if (pos > tbts) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt + 131072);
+        var end = bt + add;
+        if (bt < dt) {
+          var shift = dl - dt, dend = Math.min(dt, end);
+          if (shift + bt < 0)
+            err(3);
+          for (; bt < dend; ++bt)
+            buf[bt] = dict[shift + bt];
+        }
+        for (; bt < end; ++bt)
+          buf[bt] = buf[bt - dt];
+      }
+    }
+    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 && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
+};
+var et = /* @__PURE__ */ new u8(0);
+var 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);
+};
+var gzl = function(d) {
+  var l2 = d.length;
+  return (d[l2 - 4] | d[l2 - 3] << 8 | d[l2 - 2] << 16 | d[l2 - 1] << 24) >>> 0;
+};
+var 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;
+};
+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);
+}
+var td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder();
+var tds = 0;
+try {
+  td.decode(et, { stream: true });
+  tds = 1;
+} catch (e) {
+}
+
+// ../../node_modules/.pnpm/pmtiles@4.4.0/node_modules/pmtiles/dist/esm/index.js
+var j = Object.defineProperty;
+var B = Math.pow;
+var l = (o, t) => j(o, "name", { value: t, configurable: true });
+var m = (o, t, e) => new Promise((r, n) => {
+  var s = (c) => {
+    try {
+      a(e.next(c));
+    } catch (u) {
+      n(u);
+    }
+  }, i2 = (c) => {
+    try {
+      a(e.throw(c));
+    } catch (u) {
+      n(u);
+    }
+  }, a = (c) => c.done ? r(c.value) : Promise.resolve(c.value).then(s, i2);
+  a((e = e.apply(o, t)).next());
+});
+var re = l((o, t) => {
+  let e = false, r = "", n = L.GridLayer.extend({ createTile: l((s, i2) => {
+    let a = document.createElement("img"), c = new AbortController(), u = c.signal;
+    return a.cancel = () => {
+      c.abort();
+    }, e || (o.getHeader().then((d) => {
+      d.tileType === 1 ? console.error("Error: archive contains MVT vector tiles, but leafletRasterLayer is for displaying raster tiles. See https://github.com/protomaps/PMTiles/tree/main/js for details.") : d.tileType === 2 ? r = "image/png" : d.tileType === 3 ? r = "image/jpeg" : d.tileType === 4 ? r = "image/webp" : d.tileType === 5 && (r = "image/avif");
+    }), e = true), o.getZxy(s.z, s.x, s.y, u).then((d) => {
+      if (d) {
+        let h = new Blob([d.data], { type: r }), p = window.URL.createObjectURL(h);
+        a.src = p;
+      } else a.style.display = "none";
+      a.cancel = void 0, i2(void 0, a);
+    }).catch((d) => {
+      if (d.name !== "AbortError") throw d;
+    }), a;
+  }, "createTile"), _removeTile: l(function(s) {
+    let i2 = this._tiles[s];
+    i2 && (i2.el.cancel && i2.el.cancel(), i2.el.width = 0, i2.el.height = 0, i2.el.deleted = true, L.DomUtil.remove(i2.el), delete this._tiles[s], this.fire("tileunload", { tile: i2.el, coords: this._keyToTileCoords(s) }));
+  }, "_removeTile") });
+  return new n(t);
+}, "leafletRasterLayer");
+var W = l((o) => (t, e) => {
+  if (e instanceof AbortController) return o(t, e);
+  let r = new AbortController();
+  return o(t, r).then((n) => e(void 0, n.data, n.cacheControl || "", n.expires || ""), (n) => e(n)).catch((n) => e(n)), { cancel: l(() => r.abort(), "cancel") };
+}, "v3compat");
+var E = class E2 {
+  constructor(t) {
+    this.tilev4 = l((t2, e) => m(this, null, function* () {
+      if (t2.type === "json") {
+        let p = t2.url.substr(10), y = this.tiles.get(p);
+        if (y || (y = new w(p), this.tiles.set(p, y)), this.metadata) {
+          let z = yield y.getTileJson(t2.url);
+          return e.signal.throwIfAborted(), { data: z };
+        }
+        let f = yield y.getHeader();
+        return e.signal.throwIfAborted(), (f.minLon >= f.maxLon || f.minLat >= f.maxLat) && console.error(`Bounds of PMTiles archive ${f.minLon},${f.minLat},${f.maxLon},${f.maxLat} are not valid.`), { data: { tiles: [`${t2.url}/{z}/{x}/{y}`], minzoom: f.minZoom, maxzoom: f.maxZoom, bounds: [f.minLon, f.minLat, f.maxLon, f.maxLat] } };
+      }
+      let r = new RegExp(/pmtiles:\/\/(.+)\/(\d+)\/(\d+)\/(\d+)/), n = t2.url.match(r);
+      if (!n) throw new Error("Invalid PMTiles protocol URL");
+      let s = n[1], i2 = this.tiles.get(s);
+      i2 || (i2 = new w(s), this.tiles.set(s, i2));
+      let a = n[2], c = n[3], u = n[4], d = yield i2.getHeader(), h = yield i2 == null ? void 0 : i2.getZxy(+a, +c, +u, e.signal);
+      if (e.signal.throwIfAborted(), h) return { data: new Uint8Array(h.data), cacheControl: h.cacheControl, expires: h.expires };
+      if (d.tileType === 1) {
+        if (this.errorOnMissingTile) throw new Error("Tile not found.");
+        return { data: new Uint8Array() };
+      }
+      return { data: null };
+    }), "tilev4");
+    this.tile = W(this.tilev4);
+    this.tiles = /* @__PURE__ */ new Map(), this.metadata = (t == null ? void 0 : t.metadata) || false, this.errorOnMissingTile = (t == null ? void 0 : t.errorOnMissingTile) || false;
+  }
+  add(t) {
+    this.tiles.set(t.source.getKey(), t);
+  }
+  get(t) {
+    return this.tiles.get(t);
+  }
+};
+l(E, "Protocol");
+function b(o, t) {
+  return (t >>> 0) * 4294967296 + (o >>> 0);
+}
+l(b, "toNum");
+function N(o, t) {
+  let e = t.buf, r = e[t.pos++], n = (r & 112) >> 4;
+  if (r < 128 || (r = e[t.pos++], n |= (r & 127) << 3, r < 128) || (r = e[t.pos++], n |= (r & 127) << 10, r < 128) || (r = e[t.pos++], n |= (r & 127) << 17, r < 128) || (r = e[t.pos++], n |= (r & 127) << 24, r < 128) || (r = e[t.pos++], n |= (r & 1) << 31, r < 128)) return b(o, n);
+  throw new Error("Expected varint not more than 10 bytes");
+}
+l(N, "readVarintRemainder");
+function x2(o) {
+  let t = o.buf, e = t[o.pos++], r = e & 127;
+  return e < 128 || (e = t[o.pos++], r |= (e & 127) << 7, e < 128) || (e = t[o.pos++], r |= (e & 127) << 14, e < 128) || (e = t[o.pos++], r |= (e & 127) << 21, e < 128) ? r : (e = t[o.pos], r |= (e & 15) << 28, N(r, o));
+}
+l(x2, "readVarint");
+function k(o, t, e, r, n) {
+  return n === 0 ? r !== 0 ? [o - 1 - e, o - 1 - t] : [e, t] : [t, e];
+}
+l(k, "rotate");
+function q(o, t, e) {
+  if (o > 26) throw new Error("Tile zoom level exceeds max safe number limit (26)");
+  if (t >= 1 << o || e >= 1 << o) throw new Error("tile x/y outside zoom level bounds");
+  let r = ((1 << o) * (1 << o) - 1) / 3, n = o - 1, [s, i2] = [t, e];
+  for (let a = 1 << n; a > 0; a >>= 1) {
+    let c = s & a, u = i2 & a;
+    r += (3 * c ^ u) * (1 << n), [s, i2] = k(a, s, i2, c, u), n--;
+  }
+  return r;
+}
+l(q, "zxyToTileId");
+function G(o) {
+  let t = 3 * o + 1;
+  return t < 4294967296 ? 31 - Math.clz32(t) : 63 - Math.clz32(t / 4294967296);
+}
+l(G, "tileIdToZ");
+function ie(o) {
+  let t = G(o) >> 1;
+  if (t > 26) throw new Error("Tile zoom level exceeds max safe number limit (26)");
+  let e = ((1 << t) * (1 << t) - 1) / 3, r = o - e, n = 0, s = 0, i2 = 1 << t;
+  for (let a = 1; a < i2; a <<= 1) {
+    let c = a & r / 2, u = a & (r ^ c);
+    [n, s] = k(a, n, s, c, u), r = r / 2, n += c, s += u;
+  }
+  return [t, n, s];
+}
+l(ie, "tileIdToZxy");
+var J = ((s) => (s[s.Unknown = 0] = "Unknown", s[s.None = 1] = "None", s[s.Gzip = 2] = "Gzip", s[s.Brotli = 3] = "Brotli", s[s.Zstd = 4] = "Zstd", s))(J || {});
+function D(o, t) {
+  return m(this, null, function* () {
+    if (t === 1 || t === 0) return o;
+    if (t === 2) {
+      if (typeof globalThis.DecompressionStream == "undefined") return decompressSync(new Uint8Array(o));
+      let e = new Response(o).body;
+      if (!e) throw new Error("Failed to read response stream");
+      let r = e.pipeThrough(new globalThis.DecompressionStream("gzip"));
+      return new Response(r).arrayBuffer();
+    }
+    throw new Error("Compression method not supported");
+  });
+}
+l(D, "defaultDecompress");
+var O = ((a) => (a[a.Unknown = 0] = "Unknown", a[a.Mvt = 1] = "Mvt", a[a.Png = 2] = "Png", a[a.Jpeg = 3] = "Jpeg", a[a.Webp = 4] = "Webp", a[a.Avif = 5] = "Avif", a[a.Mlt = 6] = "Mlt", a))(O || {});
+function _(o) {
+  return o === 1 ? ".mvt" : o === 2 ? ".png" : o === 3 ? ".jpg" : o === 4 ? ".webp" : o === 5 ? ".avif" : o === 6 ? ".mlt" : "";
+}
+l(_, "tileTypeExt");
+var Y = 127;
+function Q(o, t) {
+  let e = 0, r = o.length - 1;
+  for (; e <= r; ) {
+    let n = r + e >> 1, s = t - o[n].tileId;
+    if (s > 0) e = n + 1;
+    else if (s < 0) r = n - 1;
+    else return o[n];
+  }
+  return r >= 0 && (o[r].runLength === 0 || t - o[r].tileId < o[r].runLength) ? o[r] : null;
+}
+l(Q, "findTile");
+var A = class A2 {
+  constructor(t) {
+    this.file = t;
   }
-  const apiUrl = getTileflowAnalyticsApiUrl(analytics);
-  if (!apiUrl || !isTileflowTileUrl(url, apiUrl)) {
-    return void 0;
+  getKey() {
+    return this.file.name;
   }
-  const nextUrl = new URL(url);
-  nextUrl.searchParams.set("session", sessionId);
-  if (analytics.mapId) {
-    nextUrl.searchParams.set("map", analytics.mapId);
+  getBytes(t, e) {
+    return m(this, null, function* () {
+      return { data: yield this.file.slice(t, t + e).arrayBuffer() };
+    });
   }
-  if (analytics.styleId) {
-    nextUrl.searchParams.set("styleId", analytics.styleId);
+};
+l(A, "FileSource");
+var C = class C2 {
+  constructor(t, e = new Headers()) {
+    var i2, a;
+    this.url = t, this.customHeaders = e, this.mustReload = false;
+    let r = "";
+    "navigator" in globalThis && (r = (a = (i2 = globalThis.navigator) == null ? void 0 : i2.userAgent) != null ? a : "");
+    let n = r.indexOf("Windows") > -1, s = /Chrome|Chromium|Edg|OPR|Brave/.test(r);
+    this.chromeWindowsNoCache = false, n && s && (this.chromeWindowsNoCache = true);
   }
-  return nextUrl.toString();
+  getKey() {
+    return this.url;
+  }
+  setHeaders(t) {
+    this.customHeaders = t;
+  }
+  getBytes(t, e, r, n) {
+    return m(this, null, function* () {
+      let s, i2;
+      r ? i2 = r : (s = new AbortController(), i2 = s.signal);
+      let a = new Headers(this.customHeaders);
+      a.set("range", `bytes=${t}-${t + e - 1}`);
+      let c;
+      this.mustReload ? c = "reload" : this.chromeWindowsNoCache && (c = "no-store");
+      let u = yield fetch(this.url, { signal: i2, cache: c, headers: a });
+      if (t === 0 && u.status === 416) {
+        let y = u.headers.get("Content-Range");
+        if (!y || !y.startsWith("bytes */")) throw new Error("Missing content-length on 416 response");
+        let f = +y.substr(8);
+        u = yield fetch(this.url, { signal: i2, cache: "reload", headers: { range: `bytes=0-${f - 1}` } });
+      }
+      let d = u.headers.get("Etag");
+      if (d != null && d.startsWith("W/") && (d = null), u.status === 416 || n && d && d !== n) throw this.mustReload = true, new v(`Server returned non-matching ETag ${n} after one retry. Check browser extensions and servers for issues that may affect correct ETag headers.`);
+      if (u.status >= 300) throw new Error(`Bad response code: ${u.status}`);
+      let h = u.headers.get("Content-Length");
+      if (u.status === 200 && (!h || +h > e)) throw s && s.abort(), new Error("Server returned no content-length header or content-length exceeding request. Check that your storage backend supports HTTP Byte Serving.");
+      return { data: yield u.arrayBuffer(), etag: d || void 0, cacheControl: u.headers.get("Cache-Control") || void 0, expires: u.headers.get("Expires") || void 0 };
+    });
+  }
+};
+l(C, "FetchSource");
+var T = C;
+function g(o, t) {
+  let e = o.getUint32(t + 4, true), r = o.getUint32(t + 0, true);
+  return e * B(2, 32) + r;
 }
-function startTileflowSession(analytics, input) {
-  if (!analytics || analytics.enabled === false || !input.mapId || typeof navigator === "undefined") {
-    return;
+l(g, "getUint64");
+function X(o, t) {
+  let e = new DataView(o), r = e.getUint8(7);
+  if (r > 3) throw new Error(`Archive is spec version ${r} but this library supports up to spec version 3`);
+  return { specVersion: r, rootDirectoryOffset: g(e, 8), rootDirectoryLength: g(e, 16), jsonMetadataOffset: g(e, 24), jsonMetadataLength: g(e, 32), leafDirectoryOffset: g(e, 40), leafDirectoryLength: g(e, 48), tileDataOffset: g(e, 56), tileDataLength: g(e, 64), numAddressedTiles: g(e, 72), numTileEntries: g(e, 80), numTileContents: g(e, 88), clustered: e.getUint8(96) === 1, internalCompression: e.getUint8(97), tileCompression: e.getUint8(98), tileType: e.getUint8(99), minZoom: e.getUint8(100), maxZoom: e.getUint8(101), minLon: e.getInt32(102, true) / 1e7, minLat: e.getInt32(106, true) / 1e7, maxLon: e.getInt32(110, true) / 1e7, maxLat: e.getInt32(114, true) / 1e7, centerZoom: e.getUint8(118), centerLon: e.getInt32(119, true) / 1e7, centerLat: e.getInt32(123, true) / 1e7, etag: t };
+}
+l(X, "bytesToHeader");
+function Z(o) {
+  let t = { buf: new Uint8Array(o), pos: 0 }, e = x2(t), r = [], n = 0;
+  for (let s = 0; s < e; s++) {
+    let i2 = x2(t);
+    r.push({ tileId: n + i2, offset: 0, length: 0, runLength: 1 }), n += i2;
   }
-  const endpoint = analytics.endpoint ?? `${getTileflowAnalyticsApiUrl(analytics)}/v1/sessions/analytics`;
-  const payload = JSON.stringify({
-    mapId: input.mapId,
-    metadata: analytics.metadata,
-    referrer: typeof document === "undefined" ? void 0 : document.referrer || "",
-    sdkVersion: analytics.sdkVersion,
-    sessionId: input.sessionId,
-    source: analytics.source ?? input.source,
-    styleId: input.styleId,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  for (let s = 0; s < e; s++) r[s].runLength = x2(t);
+  for (let s = 0; s < e; s++) r[s].length = x2(t);
+  for (let s = 0; s < e; s++) {
+    let i2 = x2(t);
+    i2 === 0 && s > 0 ? r[s].offset = r[s - 1].offset + r[s - 1].length : r[s].offset = i2 - 1;
+  }
+  return r;
+}
+l(Z, "deserializeIndex");
+var U = class U2 extends Error {
+};
+l(U, "EtagMismatch");
+var v = U;
+function I(o, t) {
+  return m(this, null, function* () {
+    let e = yield o.getBytes(0, 16384);
+    if (new DataView(e.data).getUint16(0, true) !== 19792) throw new Error("Wrong magic number for PMTiles archive");
+    let n = e.data.slice(0, Y), s = X(n, e.etag), i2 = e.data.slice(s.rootDirectoryOffset, s.rootDirectoryOffset + s.rootDirectoryLength), a = `${o.getKey()}|${s.etag || ""}|${s.rootDirectoryOffset}|${s.rootDirectoryLength}`, c = Z(yield t(i2, s.internalCompression));
+    return [s, [a, c.length, c]];
   });
-  const blob = new Blob([payload], { type: "application/json" });
-  if (navigator.sendBeacon?.(endpoint, blob)) {
+}
+l(I, "getHeaderAndRoot");
+function K(o, t, e, r, n) {
+  return m(this, null, function* () {
+    let s = yield o.getBytes(e, r, void 0, n.etag), i2 = yield t(s.data, n.internalCompression), a = Z(i2);
+    if (a.length === 0) throw new Error("Empty directory is invalid");
+    return a;
+  });
+}
+l(K, "getDirectory");
+var R = class R2 {
+  constructor(t = 100, e = true, r = D) {
+    this.cache = /* @__PURE__ */ new Map(), this.maxCacheEntries = t, this.counter = 1, this.decompress = r;
+  }
+  getHeader(t) {
+    return m(this, null, function* () {
+      let e = t.getKey(), r = this.cache.get(e);
+      if (r) return r.lastUsed = this.counter++, r.data;
+      let n = yield I(t, this.decompress);
+      return n[1] && this.cache.set(n[1][0], { lastUsed: this.counter++, data: n[1][2] }), this.cache.set(e, { lastUsed: this.counter++, data: n[0] }), this.prune(), n[0];
+    });
+  }
+  getDirectory(t, e, r, n) {
+    return m(this, null, function* () {
+      let s = `${t.getKey()}|${n.etag || ""}|${e}|${r}`, i2 = this.cache.get(s);
+      if (i2) return i2.lastUsed = this.counter++, i2.data;
+      let a = yield K(t, this.decompress, e, r, n);
+      return this.cache.set(s, { lastUsed: this.counter++, data: a }), this.prune(), a;
+    });
+  }
+  prune() {
+    if (this.cache.size > this.maxCacheEntries) {
+      let t = 1 / 0, e;
+      this.cache.forEach((r, n) => {
+        r.lastUsed < t && (t = r.lastUsed, e = n);
+      }), e && this.cache.delete(e);
+    }
+  }
+  invalidate(t) {
+    return m(this, null, function* () {
+      this.cache.delete(t.getKey());
+    });
+  }
+};
+l(R, "ResolvedValueCache");
+var M = class M2 {
+  constructor(t = 100, e = true, r = D) {
+    this.cache = /* @__PURE__ */ new Map(), this.invalidations = /* @__PURE__ */ new Map(), this.maxCacheEntries = t, this.counter = 1, this.decompress = r;
+  }
+  getHeader(t) {
+    return m(this, null, function* () {
+      let e = t.getKey(), r = this.cache.get(e);
+      if (r) return r.lastUsed = this.counter++, yield r.data;
+      let n = new Promise((s, i2) => {
+        I(t, this.decompress).then((a) => {
+          a[1] && this.cache.set(a[1][0], { lastUsed: this.counter++, data: Promise.resolve(a[1][2]) }), s(a[0]), this.prune();
+        }).catch((a) => {
+          i2(a);
+        });
+      });
+      return this.cache.set(e, { lastUsed: this.counter++, data: n }), n;
+    });
+  }
+  getDirectory(t, e, r, n) {
+    return m(this, null, function* () {
+      let s = `${t.getKey()}|${n.etag || ""}|${e}|${r}`, i2 = this.cache.get(s);
+      if (i2) return i2.lastUsed = this.counter++, yield i2.data;
+      let a = new Promise((c, u) => {
+        K(t, this.decompress, e, r, n).then((d) => {
+          c(d), this.prune();
+        }).catch((d) => {
+          u(d);
+        });
+      });
+      return this.cache.set(s, { lastUsed: this.counter++, data: a }), a;
+    });
+  }
+  prune() {
+    if (this.cache.size >= this.maxCacheEntries) {
+      let t = 1 / 0, e;
+      this.cache.forEach((r, n) => {
+        r.lastUsed < t && (t = r.lastUsed, e = n);
+      }), e && this.cache.delete(e);
+    }
+  }
+  invalidate(t) {
+    return m(this, null, function* () {
+      let e = t.getKey();
+      if (this.invalidations.get(e)) return yield this.invalidations.get(e);
+      this.cache.delete(t.getKey());
+      let r = new Promise((n, s) => {
+        this.getHeader(t).then((i2) => {
+          n(), this.invalidations.delete(e);
+        }).catch((i2) => {
+          s(i2);
+        });
+      });
+      this.invalidations.set(e, r);
+    });
+  }
+};
+l(M, "SharedPromiseCache");
+var P = M;
+var H = class H2 {
+  constructor(t, e, r) {
+    typeof t == "string" ? this.source = new T(t) : this.source = t, r ? this.decompress = r : this.decompress = D, e ? this.cache = e : this.cache = new P();
+  }
+  getHeader() {
+    return m(this, null, function* () {
+      return yield this.cache.getHeader(this.source);
+    });
+  }
+  getZxyAttempt(t, e, r, n) {
+    return m(this, null, function* () {
+      let s = q(t, e, r), i2 = yield this.cache.getHeader(this.source);
+      if (t < i2.minZoom || t > i2.maxZoom) return;
+      let a = i2.rootDirectoryOffset, c = i2.rootDirectoryLength;
+      for (let u = 0; u <= 3; u++) {
+        let d = yield this.cache.getDirectory(this.source, a, c, i2), h = Q(d, s);
+        if (h) {
+          if (h.runLength > 0) {
+            let p = yield this.source.getBytes(i2.tileDataOffset + h.offset, h.length, n, i2.etag);
+            return { data: yield this.decompress(p.data, i2.tileCompression), cacheControl: p.cacheControl, expires: p.expires };
+          }
+          a = i2.leafDirectoryOffset + h.offset, c = h.length;
+        } else return;
+      }
+      throw new Error("Maximum directory depth exceeded");
+    });
+  }
+  getZxy(t, e, r, n) {
+    return m(this, null, function* () {
+      try {
+        return yield this.getZxyAttempt(t, e, r, n);
+      } catch (s) {
+        if (s instanceof v) return this.cache.invalidate(this.source), yield this.getZxyAttempt(t, e, r, n);
+        throw s;
+      }
+    });
+  }
+  getMetadataAttempt() {
+    return m(this, null, function* () {
+      let t = yield this.cache.getHeader(this.source), e = yield this.source.getBytes(t.jsonMetadataOffset, t.jsonMetadataLength, void 0, t.etag), r = yield this.decompress(e.data, t.internalCompression), n = new TextDecoder("utf-8");
+      return JSON.parse(n.decode(r));
+    });
+  }
+  getMetadata() {
+    return m(this, null, function* () {
+      try {
+        return yield this.getMetadataAttempt();
+      } catch (t) {
+        if (t instanceof v) return this.cache.invalidate(this.source), yield this.getMetadataAttempt();
+        throw t;
+      }
+    });
+  }
+  getTileJson(t) {
+    return m(this, null, function* () {
+      let e = yield this.getHeader(), r = yield this.getMetadata(), n = _(e.tileType);
+      return { tilejson: "3.0.0", scheme: "xyz", tiles: [`${t}/{z}/{x}/{y}${n}`], vector_layers: r.vector_layers, attribution: r.attribution, description: r.description, name: r.name, version: r.version, bounds: [e.minLon, e.minLat, e.maxLon, e.maxLat], center: [e.centerLon, e.centerLat, e.centerZoom], minzoom: e.minZoom, maxzoom: e.maxZoom };
+    });
+  }
+};
+l(H, "PMTiles");
+var w = H;
+
+// src/pmtiles-browser.ts
+var registeredPmtilesProtocols = /* @__PURE__ */ new WeakSet();
+var maximumSectionBytes = 16 * 1024 * 1024;
+var maximumParserBytes = 32 * 1024 * 1024;
+var estimatedEntryBytes = 128;
+var tileflowPmtilesMaximumDirectoryDepth = 32;
+var tileflowPmtilesProtocol = "tileflow-pmtiles";
+var protocolPrefix = `${tileflowPmtilesProtocol}://`;
+function registerTileflowPmtilesProtocol(registry, options = {}) {
+  if (registeredPmtilesProtocols.has(registry.addProtocol)) return;
+  const maximumDirectoryDepth = normalizeMaximumDirectoryDepth(options.maximumDirectoryDepth);
+  registry.addProtocol(
+    tileflowPmtilesProtocol,
+    new TileflowPmtilesProtocol(maximumDirectoryDepth).tile
+  );
+  registeredPmtilesProtocols.add(registry.addProtocol);
+}
+var TileflowPmtilesProtocol = class {
+  constructor(maximumDirectoryDepth) {
+    this.maximumDirectoryDepth = maximumDirectoryDepth;
+  }
+  maximumDirectoryDepth;
+  #archives = /* @__PURE__ */ new Map();
+  tilev4 = async (request, abortController) => {
+    if (request.type === "json") {
+      const archive2 = this.#archive(parseArchiveTarget(request.url));
+      const header2 = await archive2.getHeader();
+      const tileJson = await archive2.getTileJson(request.url);
+      const data = header2.tileType === O.Mlt && isRecord2(tileJson) ? { ...tileJson, encoding: "mlt" } : tileJson;
+      abortController.signal.throwIfAborted();
+      return { data };
+    }
+    const parsed = parseTileTarget(request.url);
+    const archive = this.#archive(parsed.archive);
+    const header = await archive.getHeader();
+    const response = await archive.getZxy(parsed.z, parsed.x, parsed.y, abortController.signal);
+    abortController.signal.throwIfAborted();
+    if (response) {
+      return {
+        data: new Uint8Array(response.data),
+        ...response.cacheControl ? { cacheControl: response.cacheControl } : {},
+        ...response.expires ? { expires: response.expires } : {}
+      };
+    }
+    return {
+      data: header.tileType === O.Mvt || header.tileType === O.Mlt ? new Uint8Array() : null
+    };
+  };
+  tile = protocolCompatibility(this.tilev4);
+  #archive(target) {
+    let archive = this.#archives.get(target);
+    if (!archive) {
+      archive = new TileflowPmtilesArchive(target, this.maximumDirectoryDepth);
+      this.#archives.set(target, archive);
+    }
+    return archive;
+  }
+};
+var TileflowPmtilesArchive = class extends w {
+  constructor(source, maximumDirectoryDepth) {
+    super(source, void 0, boundedDecompress);
+    this.maximumDirectoryDepth = maximumDirectoryDepth;
+  }
+  maximumDirectoryDepth;
+  async getZxyAttempt(z, x3, y, signal) {
+    const tileId = q(z, x3, y);
+    const header = await this.cache.getHeader(this.source);
+    signal?.throwIfAborted();
+    if (z < header.minZoom || z > header.maxZoom) return void 0;
+    let offset = header.rootDirectoryOffset;
+    let length = header.rootDirectoryLength;
+    const ancestors = /* @__PURE__ */ new Set();
+    let entriesRead = 0;
+    for (let depth = 0; depth <= this.maximumDirectoryDepth; depth += 1) {
+      const key = `${offset}:${length}`;
+      if (ancestors.has(key)) throw new Error("Tileflow PMTiles directory cycle is invalid.");
+      ancestors.add(key);
+      const directory = await this.cache.getDirectory(this.source, offset, length, header);
+      signal?.throwIfAborted();
+      entriesRead += directory.length;
+      if (entriesRead * estimatedEntryBytes > maximumParserBytes) {
+        throw new Error("Tileflow PMTiles traversal exceeded its memory budget.");
+      }
+      const entry = Q(directory, tileId);
+      if (!entry) return void 0;
+      if (entry.runLength > 0) {
+        assertRelativeRange(entry.offset, entry.length, header.tileDataLength ?? 0);
+        const response = await this.source.getBytes(
+          header.tileDataOffset + entry.offset,
+          entry.length,
+          signal,
+          header.etag
+        );
+        return {
+          data: await this.decompress(response.data, header.tileCompression),
+          cacheControl: response.cacheControl,
+          expires: response.expires
+        };
+      }
+      assertRelativeRange(entry.offset, entry.length, header.leafDirectoryLength ?? 0);
+      offset = header.leafDirectoryOffset + entry.offset;
+      length = entry.length;
+    }
+    throw new Error("Tileflow PMTiles directory depth exceeds its operational limit.");
+  }
+};
+async function boundedDecompress(buffer, compression) {
+  if (buffer.byteLength > maximumSectionBytes) {
+    throw new Error("Tileflow PMTiles section exceeds its operational limit.");
+  }
+  if (compression === J.None) return buffer;
+  if (compression !== J.Gzip) {
+    throw new Error("Tileflow PMTiles compression is unsupported.");
+  }
+  const stream = new Blob([buffer]).stream().pipeThrough(new DecompressionStream("gzip"));
+  const reader = stream.getReader();
+  const chunks = [];
+  let byteLength = 0;
+  try {
+    while (true) {
+      const result = await reader.read();
+      if (result.done) break;
+      byteLength += result.value.byteLength;
+      if (byteLength > maximumSectionBytes) {
+        await reader.cancel();
+        throw new Error("Tileflow PMTiles decompression exceeds its operational limit.");
+      }
+      chunks.push(result.value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const output = new Uint8Array(byteLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    output.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return output.buffer;
+}
+function parseArchiveTarget(url) {
+  if (!url.startsWith(protocolPrefix)) throw new Error("Invalid Tileflow PMTiles protocol URL.");
+  const target = url.slice(protocolPrefix.length);
+  if (!target) throw new Error("Invalid Tileflow PMTiles archive URL.");
+  return target;
+}
+function parseTileTarget(url) {
+  const target = parseArchiveTarget(url);
+  const match = /^(.*)\/(\d+)\/(\d+)\/(\d+)(?:\.[A-Za-z0-9]+)?$/u.exec(target);
+  if (!match?.[1] || !match[2] || !match[3] || !match[4]) {
+    throw new Error("Invalid Tileflow PMTiles tile URL.");
+  }
+  return { archive: match[1], x: Number(match[3]), y: Number(match[4]), z: Number(match[2]) };
+}
+function assertRelativeRange(offset, length, sectionLength) {
+  if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) || length < 1 || offset < 0 || offset > sectionLength - length || length > maximumSectionBytes) {
+    throw new Error("Tileflow PMTiles directory range is invalid.");
+  }
+}
+function normalizeMaximumDirectoryDepth(value) {
+  const depth = value ?? tileflowPmtilesMaximumDirectoryDepth;
+  if (!Number.isInteger(depth) || depth < 1 || depth > 64) {
+    throw new Error("Tileflow PMTiles maximumDirectoryDepth must be an integer from 1 to 64.");
+  }
+  return depth;
+}
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function protocolCompatibility(handler) {
+  return (request, controllerOrCallback) => {
+    if (controllerOrCallback instanceof AbortController) {
+      return handler(request, controllerOrCallback);
+    }
+    const controller = new AbortController();
+    void handler(request, controller).then(
+      (response) => controllerOrCallback(
+        void 0,
+        response.data,
+        response.cacheControl ?? "",
+        response.expires ?? ""
+      ),
+      (error) => controllerOrCallback(error instanceof Error ? error : new Error("PMTiles request failed."))
+    );
+    return { cancel: () => controller.abort() };
+  };
+}
+
+// src/browser.ts
+var systemColorSchemeListeners = /* @__PURE__ */ new Set();
+var systemColorSchemeQuery;
+var systemColorScheme = "light";
+function getTileflowSystemColorScheme() {
+  ensureSystemColorSchemeQuery();
+  return systemColorScheme;
+}
+function subscribeTileflowSystemColorScheme(listener) {
+  ensureSystemColorSchemeQuery();
+  systemColorSchemeListeners.add(listener);
+  return () => {
+    systemColorSchemeListeners.delete(listener);
+    if (systemColorSchemeListeners.size === 0 && systemColorSchemeQuery) {
+      systemColorSchemeQuery.removeEventListener?.("change", handleSystemColorSchemeChange);
+      systemColorSchemeQuery.removeListener?.(handleSystemColorSchemeChange);
+      systemColorSchemeQuery = void 0;
+    }
+  };
+}
+function ensureSystemColorSchemeQuery() {
+  if (systemColorSchemeQuery) return;
+  const browser = globalThis;
+  if (!browser.matchMedia) {
+    systemColorScheme = "light";
     return;
   }
-  void fetch(endpoint, {
-    body: payload,
-    credentials: "omit",
-    headers: {
-      "Content-Type": "application/json"
-    },
-    keepalive: true,
-    method: "POST"
-  }).catch(() => void 0);
+  systemColorSchemeQuery = browser.matchMedia("(prefers-color-scheme: dark)");
+  systemColorScheme = systemColorSchemeQuery.matches ? "dark" : "light";
+  systemColorSchemeQuery.addEventListener?.("change", handleSystemColorSchemeChange);
+  if (!systemColorSchemeQuery.addEventListener) {
+    systemColorSchemeQuery.addListener?.(handleSystemColorSchemeChange);
+  }
 }
-function getTileflowAnalyticsApiUrl(analytics) {
-  if (analytics.apiUrl) {
-    return normalizeTileflowUrl(analytics.apiUrl);
+function handleSystemColorSchemeChange() {
+  if (!systemColorSchemeQuery) return;
+  const next = systemColorSchemeQuery.matches ? "dark" : "light";
+  if (next === systemColorScheme) return;
+  systemColorScheme = next;
+  for (const listener of systemColorSchemeListeners) listener(next);
+}
+function createTileflowThemeController(options) {
+  assertConcreteRuntimeTheme(options.initial, "initial");
+  const loadFonts = options.loadFonts ?? ((runtimeStyle) => loadTileflowStyleFonts(runtimeStyle.style, { fontFaces: runtimeStyle.fontFaces }));
+  const timeoutMs = normalizeThemeTransitionTimeout(options.timeoutMs);
+  let current = options.initial;
+  let disposed = false;
+  let requestId = 0;
+  let applyQueue = Promise.resolve();
+  return {
+    dispose() {
+      disposed = true;
+      requestId += 1;
+    },
+    getCurrent() {
+      return current;
+    },
+    setTheme(style) {
+      const invalidTheme = validateConcreteRuntimeTheme(style, "target");
+      if (invalidTheme) {
+        return Promise.resolve({ error: invalidTheme, status: "failed", theme: style.theme });
+      }
+      if (disposed) {
+        return Promise.resolve({
+          error: new Error("Tileflow theme controller is disposed."),
+          status: "failed",
+          theme: style.theme
+        });
+      }
+      const runId = ++requestId;
+      options.onTransition?.({
+        currentTheme: current.theme,
+        phase: "preloading",
+        targetTheme: style.theme
+      });
+      let preloaded;
+      try {
+        preloaded = loadFonts(style);
+      } catch (error) {
+        return Promise.resolve(handlePreloadFailure(runId, style, error));
+      }
+      return preloaded.then(
+        () => enqueueTheme(runId, style),
+        (error) => handlePreloadFailure(runId, style, error)
+      );
+    }
+  };
+  function enqueueTheme(runId, style) {
+    const operation = applyQueue.then(
+      () => applyTheme(runId, style),
+      () => applyTheme(runId, style)
+    );
+    applyQueue = operation.then(
+      () => void 0,
+      () => void 0
+    );
+    return operation;
   }
-  if (analytics.endpoint) {
+  async function applyTheme(runId, style) {
+    if (disposed || runId !== requestId) return { status: "superseded", theme: style.theme };
+    const previous = current;
+    options.onTransition?.({
+      currentTheme: previous.theme,
+      phase: "applying",
+      targetTheme: style.theme
+    });
     try {
-      const url = new URL(analytics.endpoint, getTileflowLocationOrigin());
-      return url.origin;
-    } catch {
-      return "https://api.tileflow.dev";
+      await applyMapStyle(options.map, style.style, timeoutMs);
+      if (disposed) return { status: "superseded", theme: style.theme };
+      if (runId !== requestId) {
+        try {
+          await applyMapStyle(options.map, current.style, timeoutMs);
+        } catch {
+        }
+        return { status: "superseded", theme: style.theme };
+      }
+      current = style;
+      options.onTransition?.({
+        currentTheme: style.theme,
+        phase: "ready",
+        targetTheme: style.theme
+      });
+      return { status: "applied", theme: style.theme };
+    } catch (error) {
+      const normalized = normalizeThemeTransitionError(error, "Tileflow theme change failed.");
+      try {
+        await applyMapStyle(options.map, previous.style, timeoutMs);
+        current = previous;
+      } catch {
+      }
+      if (disposed || runId !== requestId) return { status: "superseded", theme: style.theme };
+      options.onTransition?.({
+        currentTheme: current.theme,
+        error: normalized,
+        phase: "error",
+        targetTheme: style.theme
+      });
+      return { error: normalized, status: "failed", theme: style.theme };
     }
   }
-  return "https://api.tileflow.dev";
+  function handlePreloadFailure(runId, style, error) {
+    if (disposed || runId !== requestId) return { status: "superseded", theme: style.theme };
+    const normalized = normalizeThemeTransitionError(error, "Tileflow theme preload failed.");
+    options.onTransition?.({
+      currentTheme: current.theme,
+      error: normalized,
+      phase: "error",
+      targetTheme: style.theme
+    });
+    return { error: normalized, status: "failed", theme: style.theme };
+  }
 }
-function isTileflowTileUrl(url, apiUrl) {
+function assertConcreteRuntimeTheme(style, role) {
+  const error = validateConcreteRuntimeTheme(style, role);
+  if (error) throw error;
+}
+function validateConcreteRuntimeTheme(style, role) {
+  if (isTileflowThemeName(style.theme)) return void 0;
+  return new TypeError(
+    `Tileflow theme controller ${role} style requires a concrete portable theme name; received ${JSON.stringify(style.theme)}.`
+  );
+}
+function applyMapStyle(map, style, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const cleanup = () => {
+      clearTimeout(timeout);
+      map.off("style.load", handleLoad);
+      map.off("error", handleError);
+    };
+    const settle = (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (error) reject(error);
+      else resolve();
+    };
+    const handleLoad = () => settle();
+    const handleError = (event) => settle(
+      normalizeThemeTransitionError(
+        isRecordWithError(event) ? event.error : event,
+        "MapLibre rejected the Tileflow theme."
+      )
+    );
+    const timeout = setTimeout(
+      () => settle(new Error(`Tileflow theme change timed out after ${timeoutMs}ms.`)),
+      timeoutMs
+    );
+    map.on("style.load", handleLoad);
+    map.on("error", handleError);
+    try {
+      if (typeof map.setStyle !== "function") {
+        throw new TypeError("Tileflow theme changes require MapLibre setStyle().");
+      }
+      const setStyle = map.setStyle;
+      setStyle.call(map, style, { diff: true });
+    } catch (error) {
+      settle(normalizeThemeTransitionError(error, "MapLibre rejected the Tileflow theme."));
+    }
+  });
+}
+function normalizeThemeTransitionTimeout(value) {
+  const resolved = value ?? 15e3;
+  if (!Number.isSafeInteger(resolved) || resolved < 100 || resolved > 6e4) {
+    throw new TypeError("Tileflow theme transition timeout must be an integer from 100 to 60000.");
+  }
+  return resolved;
+}
+function normalizeThemeTransitionError(error, fallback) {
+  return error instanceof Error ? error : new Error(fallback);
+}
+function isRecordWithError(value) {
+  return Boolean(value && typeof value === "object" && "error" in value);
+}
+var maximumTileflowFontBytes = 1024 * 1024;
+var maximumTileflowFontStyleBytes = 4 * 1024 * 1024;
+var loadedTileflowFontFaces = /* @__PURE__ */ new Map();
+async function loadTileflowStyleFonts(style, options = {}) {
+  const fetcher = options.fetch ?? globalThis.fetch;
+  const styleUrl = typeof style === "string" ? resolveTileflowBrowserResourceUrl(style) : void 0;
+  const fontFaces = options.fontFaces === void 0 ? typeof style === "string" ? await fetchTileflowStyleFontFaces(styleUrl, fetcher) : getTileflowStyleFontFaces(style) : getTileflowStyleFontFaces({
+    metadata: { "tileflow:fontFaces": [...options.fontFaces] }
+  });
+  if (fontFaces.length === 0) return;
+  const browser = globalThis;
+  const FontFaceConstructor = browser.FontFace;
+  const fontSet = browser.document?.fonts;
+  if (!FontFaceConstructor || !fontSet) {
+    throw new Error("Tileflow web fonts require the browser FontFace API.");
+  }
+  await Promise.all(
+    fontFaces.map(async (definition) => {
+      const source = resolveTileflowBrowserResourceUrl(definition.source, styleUrl);
+      const key = `${definition.family}\0${source}\0${definition.style ?? ""}\0${definition.weight ?? ""}`;
+      let loaded = loadedTileflowFontFaces.get(key);
+      if (!loaded) {
+        loaded = loadTileflowFontFace(
+          definition,
+          source,
+          fetcher,
+          FontFaceConstructor,
+          fontSet
+        ).catch((error) => {
+          loadedTileflowFontFaces.delete(key);
+          throw error;
+        });
+        loadedTileflowFontFaces.set(key, loaded);
+      }
+      await loaded;
+    })
+  );
+}
+async function fetchTileflowStyleFontFaces(styleUrl, fetcher) {
+  const response = await fetcher(styleUrl, {
+    cache: "default",
+    credentials: "same-origin",
+    redirect: "error"
+  });
+  if (!response.ok) throw new Error(`Tileflow style font metadata failed: ${response.status}`);
+  const source = await readBoundedTileflowBrowserResource(
+    response,
+    maximumTileflowFontStyleBytes,
+    "Tileflow style font metadata"
+  );
+  let input;
   try {
-    const parsedUrl = new URL(url);
-    const parsedApiUrl = new URL(apiUrl);
-    return parsedUrl.origin === parsedApiUrl.origin && isTilePath(parsedUrl);
+    input = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(source));
   } catch {
-    return false;
+    throw new Error("Tileflow style font metadata is not valid JSON.");
+  }
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    throw new Error("Tileflow style font metadata is invalid.");
   }
+  return getTileflowStyleFontFaces(input);
 }
-function isTilePath(url) {
-  return url.pathname.startsWith("/tiles/") || url.pathname.startsWith("/v1/tiles/");
+async function loadTileflowFontFace(definition, source, fetcher, FontFaceConstructor, fontSet) {
+  const response = await fetcher(source, {
+    cache: "force-cache",
+    credentials: "same-origin",
+    redirect: "error"
+  });
+  if (!response.ok) throw new Error(`Tileflow font failed: ${response.status}`);
+  const bytes = await readBoundedTileflowBrowserResource(
+    response,
+    maximumTileflowFontBytes,
+    "Tileflow font"
+  );
+  const fontFace = new FontFaceConstructor(definition.family, bytes.buffer, {
+    ...definition.style ? { style: definition.style } : {},
+    ...definition.weight ? { weight: definition.weight } : {}
+  });
+  await fontFace.load();
+  fontSet.add(fontFace);
 }
-function getTileflowLocationOrigin() {
-  if (typeof window === "undefined") {
-    return "http://localhost";
+async function readBoundedTileflowBrowserResource(response, maximumBytes, label) {
+  const contentLength = response.headers.get("content-length");
+  if (contentLength && /^\d+$/u.test(contentLength) && Number(contentLength) > maximumBytes) {
+    await response.body?.cancel().catch(() => void 0);
+    throw new Error(`${label} exceeds the maximum response size.`);
   }
-  return window.location.origin;
+  if (!response.body) return new Uint8Array();
+  const reader = response.body.getReader();
+  const chunks = [];
+  let byteLength = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!value) continue;
+      byteLength += value.byteLength;
+      if (byteLength > maximumBytes) {
+        await reader.cancel().catch(() => void 0);
+        throw new Error(`${label} exceeds the maximum response size.`);
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(byteLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return bytes;
+}
+function resolveTileflowBrowserResourceUrl(value, baseUrl) {
+  const browser = globalThis;
+  const base = baseUrl ?? browser.document?.baseURI ?? "http://localhost/";
+  let url;
+  try {
+    url = new URL(value, base);
+  } catch {
+    throw new TypeError("Tileflow font resource URL is invalid.");
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:" || url.username || url.password || url.hash) {
+    throw new TypeError("Tileflow font resource URL is invalid.");
+  }
+  return url.toString();
 }
-
-// src/browser.ts
 function createTileflowSessionStarter(options) {
   const starts = /* @__PURE__ */ new Set();
   const send = options.startSession ?? startTileflowSession;
@@ -215,7 +4309,7 @@ function attachTileflowMapLifecycle(options) {
   };
 }
 function createTileflowTransformRequest(options) {
-  if (!options.always && !options.transformRequest) {
+  if (!options.always && !options.transformRequest && !options.worldRequestBridge) {
     const analytics = options.getAnalytics();
     const requiresCommercialSession = Boolean(options.sessionController && analytics?.mapId);
     if (!requiresCommercialSession && (!analytics || analytics.enabled === false)) {
@@ -233,7 +4327,8 @@ function createTileflowTransformRequest(options) {
           resolvedRequest,
           asyncAnalyticsTiming === "resolution" ? options.getAnalytics() : analyticsAtRequest,
           options.sessionId,
-          options.sessionController
+          options.sessionController,
+          options.worldRequestBridge
         ) ?? resolvedRequest
       );
     }
@@ -242,54 +4337,36 @@ function createTileflowTransformRequest(options) {
       request,
       asyncAnalyticsTiming === "resolution" ? options.getAnalytics() : analyticsAtRequest,
       options.sessionId,
-      options.sessionController
+      options.sessionController,
+      options.worldRequestBridge
     );
   };
 }
-function createTileflowMarkerController(options) {
-  let markers = [];
-  const clear = () => {
-    const previousMarkers = markers;
-    markers = [];
-    removeMarkers(previousMarkers, options.remove);
-  };
-  return {
-    clear,
-    dispose: clear,
-    replace(map, definitions) {
-      clear();
-      const nextMarkers = [];
-      try {
-        for (const definition of definitions) {
-          const marker = options.create(definition);
-          nextMarkers.push(marker);
-          options.attach(marker, map, definition);
-        }
-      } catch (error) {
-        try {
-          removeMarkers(nextMarkers, options.remove);
-        } catch {
-        }
-        throw error;
-      }
-      markers = nextMarkers;
-    }
-  };
-}
-function applyTileflowRequest(url, request, analytics, sessionId, sessionController) {
+function applyTileflowRequest(url, request, analytics, sessionId, sessionController, worldRequestBridge) {
   const requestUrl = request?.url ?? url;
   if (sessionController) {
     return sessionController.resolveRequestUrl(requestUrl, analytics).then(
-      (nextUrl) => composeTileflowRequest(url, request, nextUrl, true) ?? { url }
+      (nextUrl) => applyWorldRequestBridge(
+        composeTileflowRequest(url, request, nextUrl, true) ?? { url },
+        worldRequestBridge
+      ) ?? { url }
     );
   }
-  return composeTileflowRequest(
-    url,
-    request,
-    resolveTileflowAnalyticsRequestUrl(requestUrl, analytics, sessionId),
-    false
+  return applyWorldRequestBridge(
+    composeTileflowRequest(
+      url,
+      request,
+      resolveTileflowAnalyticsRequestUrl(requestUrl, analytics, sessionId),
+      Boolean(worldRequestBridge)
+    ),
+    worldRequestBridge
   );
 }
+function applyWorldRequestBridge(request, bridge) {
+  if (!request || !bridge) return request;
+  const url = bridge.rewriteUrl(request.url);
+  return url === request.url ? request : { ...request, url };
+}
 function composeTileflowRequest(originalUrl, request, nextUrl, ensureRequest) {
   if (!nextUrl) {
     return request ?? (ensureRequest ? { url: originalUrl } : void 0);
@@ -314,24 +4391,38 @@ function disposeFunctions(disposers) {
 function isPromiseLike(value) {
   return Boolean(value && typeof value.then === "function");
 }
-function removeMarkers(markers, remove) {
-  let firstError;
-  let failed = false;
-  for (const marker of markers) {
-    try {
-      remove(marker);
-    } catch (error) {
-      if (!failed) firstError = error;
-      failed = true;
-    }
-  }
-  if (failed) {
-    throw firstError;
-  }
-}
 export {
+  attachTileflowFairUseNotice,
   attachTileflowMapLifecycle,
-  createTileflowMarkerController,
   createTileflowSessionStarter,
-  createTileflowTransformRequest
+  createTileflowThemeController,
+  createTileflowTransformRequest,
+  getTileflowSystemColorScheme,
+  loadTileflowStyleFonts,
+  registerTileflowContourProtocol,
+  registerTileflowPmtilesProtocol,
+  registerTileflowWorldRequestBridge,
+  subscribeTileflowSystemColorScheme,
+  tileflowFairUseNoticeMessage,
+  tileflowMaplibreContourVersion,
+  tileflowPmtilesMaximumDirectoryDepth,
+  tileflowPmtilesProtocol
 };
+/*! Bundled license information:
+
+maplibre-contour/dist/index.mjs:
+  (*! *****************************************************************************
+  Copyright (c) Microsoft Corporation.
+  
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+  
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** *)
+*/