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

package/dist/browser.js

@@ -1,9 +1,2121 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [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(_, 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(x, y) {
+          this.points.push(Math.round(x), Math.round(y));
+        }
+        prepend(x, y) {
+          this.points.splice(0, 0, Math.round(x), 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, x, y, point) {
+        x = x * 2 + point[0];
+        y = y * 2 + point[1];
+        return x + y * (width + 1) * 2;
+      }
+      function ratio(a, b, c) {
+        return (b - 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 max = Math.max(maxL, maxR);
+            const start = Math.ceil(min / interval) * interval;
+            const end = Math.floor(max / 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, g;
+                if (f = fragmentByEnd.get(startIndex)) {
+                  fragmentByEnd.delete(startIndex);
+                  if (g = fragmentByStart.get(endIndex)) {
+                    fragmentByStart.delete(endIndex);
+                    if (f === g) {
+                      interpolate(end2, threshold, f.append);
+                      if (!f.isEmpty()) {
+                        let list = segments[threshold];
+                        if (!list) {
+                          segments[threshold] = list = [];
+                        }
+                        list.push(f.lineString());
+                      }
+                    } else {
+                      f.appendFragment(g);
+                      fragmentByEnd.set(f.end = g.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 i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+              t[p[i]] = s[p[i]];
+          }
+        return t;
+      }
+      function __awaiter(thisArg, _arguments, P, generator) {
+        function adopt(value) {
+          return value instanceof P ? value : new P(function(resolve) {
+            resolve(value);
+          });
+        }
+        return new (P || (P = 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], [b]) => a < b ? -1 : a > b ? 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(_a) {
+        var { thresholds } = _a, rest = __rest(_a, ["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 k = parts[0];
+          let v = parts[1];
+          switch (k) {
+            case "thresholds":
+              v = decodeThresholds(v);
+              break;
+            case "extent":
+            case "multiplier":
+            case "overzoom":
+            case "buffer":
+              v = Number(v);
+          }
+          return [k, v];
+        }));
+      }
+      function encodeIndividualOptions(options) {
+        return sortedEntries(options).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).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((_a) => {
+          var { data } = _a, rest = __rest(_a, ["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 i = 0; i < size * size; i++) {
+                const base = i * 4;
+                context.fillStyle = `rgb(${base},${base + 1},${base + 2})`;
+                context.fillRect(i % size, Math.floor(i / size), 1, 1);
+              }
+              const data = context.getImageData(0, 0, size, size).data;
+              for (let i = 0; i < size * size * 4; i++) {
+                if (i % 4 !== 3 && data[i] !== i) {
+                  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((_, 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 _a;
+        return Boolean((_a = abortController === null || abortController === void 0 ? void 0 : abortController.signal) === null || _a === void 0 ? void 0 : _a.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 _a;
+              if (result && result.abortController && !canceled) {
+                canceled = true;
+                if (--result.waiting <= 0) {
+                  (_a = result.abortController) === null || _a === void 0 ? void 0 : _a.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 _a, _b, _c;
+          const img = yield createImageBitmap(blob);
+          if (isAborted(abortController))
+            return null;
+          const vf = new VideoFrame(img, { timestamp: 0 });
+          try {
+            const valid = ((_a = vf === null || vf === void 0 ? void 0 : vf.format) === null || _a === void 0 ? void 0 : _a.startsWith("BGR")) || ((_b = vf === null || vf === void 0 ? void 0 : vf.format) === null || _b === void 0 ? void 0 : _b.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 i = 0; i < data.length; i += 4) {
+                const tmp = data[i];
+                data[i] = data[i + 2];
+                data[i + 2] = tmp;
+              }
+            }
+            return decodeParsedImage(img.width, img.height, encoding, data);
+          } catch (_) {
+            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, g, b) => -1e4 + (r * 256 * 256 + g * 256 + b) * 0.1 : (r, g, b) => r * 256 + g + b / 256 - 32768;
+        const data = new Float32Array(width * height);
+        for (let i = 0; i < input.length; i += 4) {
+          data[i / 4] = decoder(input[i], input[i + 1], input[i + 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, (x, y) => this.get(x + dx, y + dy));
+          };
+          this.subsamplePixelCenters = (factor) => {
+            const lerp = (a, b, f) => isNaN(a) ? b : isNaN(b) ? a : a + (b - a) * f;
+            if (factor <= 1)
+              return this;
+            const sub = 0.5 - 1 / (2 * factor);
+            const blerper = (x, y) => {
+              const dx = x / factor - sub;
+              const dy = y / factor - sub;
+              const ox = Math.floor(dx);
+              const oy = Math.floor(dy);
+              const a = this.get(ox, oy);
+              const b = 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, b, 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, (x, y) => {
+            let sum = 0, count = 0, v = 0;
+            for (let newX = x - radius; newX < x + radius; newX++) {
+              for (let newY = y - radius; newY < y + radius; newY++) {
+                if (!isNaN(v = this.get(newX, newY))) {
+                  count++;
+                  sum += v;
+                }
+              }
+            }
+            return count === 0 ? NaN : sum / count;
+          });
+          this.scaleElevation = (multiplier) => multiplier === 1 ? this : new HeightTile(this.width, this.height, (x, y) => this.get(x, 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 x = -buffer; x < this.width + buffer; x++) {
+                data[idx++] = this.get(x, y);
+              }
+            }
+            return new HeightTile(this.width, this.height, (x, y) => data[(y + buffer) * stride + x + 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, (x, y) => {
+            const value = demTile.data[y * demTile.width + x];
+            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, (x, y) => {
+            let gridIdx = 0;
+            if (y < 0) {
+              y += height;
+            } else if (y < height) {
+              gridIdx += 3;
+            } else {
+              y -= height;
+              gridIdx += 6;
+            }
+            if (x < 0) {
+              x += width;
+            } else if (x < width) {
+              gridIdx += 1;
+            } else {
+              x -= width;
+              gridIdx += 2;
+            }
+            const grid = neighbors[gridIdx];
+            return grid ? grid.get(x, 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, b;
+          b = buf[this.pos++];
+          val = b & 127;
+          if (b < 128) return val;
+          b = buf[this.pos++];
+          val |= (b & 127) << 7;
+          if (b < 128) return val;
+          b = buf[this.pos++];
+          val |= (b & 127) << 14;
+          if (b < 128) return val;
+          b = buf[this.pos++];
+          val |= (b & 127) << 21;
+          if (b < 128) return val;
+          b = buf[this.pos];
+          val |= (b & 15) << 28;
+          return 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 i = 0; i < len; i++) this.buf[this.pos++] = buffer[i];
+        }
+        /**
+         * @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(l, s, p) {
+        const buf = p.buf;
+        let h, b;
+        b = buf[p.pos++];
+        h = (b & 112) >> 4;
+        if (b < 128) return toNum(l, h, s);
+        b = buf[p.pos++];
+        h |= (b & 127) << 3;
+        if (b < 128) return toNum(l, h, s);
+        b = buf[p.pos++];
+        h |= (b & 127) << 10;
+        if (b < 128) return toNum(l, h, s);
+        b = buf[p.pos++];
+        h |= (b & 127) << 17;
+        if (b < 128) return toNum(l, h, s);
+        b = buf[p.pos++];
+        h |= (b & 127) << 24;
+        if (b < 128) return toNum(l, h, s);
+        b = buf[p.pos++];
+        h |= (b & 1) << 31;
+        if (b < 128) return toNum(l, 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 i = pbf.pos - 1; i >= startPos; i--) pbf.buf[i + extraLen] = pbf.buf[i];
+      }
+      function writePackedVarint(arr, pbf) {
+        for (let i = 0; i < arr.length; i++) pbf.writeVarint(arr[i]);
+      }
+      function writePackedSVarint(arr, pbf) {
+        for (let i = 0; i < arr.length; i++) pbf.writeSVarint(arr[i]);
+      }
+      function writePackedFloat(arr, pbf) {
+        for (let i = 0; i < arr.length; i++) pbf.writeFloat(arr[i]);
+      }
+      function writePackedDouble(arr, pbf) {
+        for (let i = 0; i < arr.length; i++) pbf.writeDouble(arr[i]);
+      }
+      function writePackedBoolean(arr, pbf) {
+        for (let i = 0; i < arr.length; i++) pbf.writeBoolean(arr[i]);
+      }
+      function writePackedFixed32(arr, pbf) {
+        for (let i = 0; i < arr.length; i++) pbf.writeFixed32(arr[i]);
+      }
+      function writePackedSFixed32(arr, pbf) {
+        for (let i = 0; i < arr.length; i++) pbf.writeSFixed32(arr[i]);
+      }
+      function writePackedFixed64(arr, pbf) {
+        for (let i = 0; i < arr.length; i++) pbf.writeFixed64(arr[i]);
+      }
+      function writePackedSFixed64(arr, pbf) {
+        for (let i = 0; i < arr.length; i++) pbf.writeSFixed64(arr[i]);
+      }
+      function readUtf8(buf, pos, end) {
+        let str = "";
+        let i = pos;
+        while (i < end) {
+          const b0 = buf[i];
+          let c = null;
+          let bytesPerSequence = b0 > 239 ? 4 : b0 > 223 ? 3 : b0 > 191 ? 2 : 1;
+          if (i + bytesPerSequence > end) break;
+          let b1, b2, b3;
+          if (bytesPerSequence === 1) {
+            if (b0 < 128) {
+              c = b0;
+            }
+          } else if (bytesPerSequence === 2) {
+            b1 = buf[i + 1];
+            if ((b1 & 192) === 128) {
+              c = (b0 & 31) << 6 | b1 & 63;
+              if (c <= 127) {
+                c = null;
+              }
+            }
+          } else if (bytesPerSequence === 3) {
+            b1 = buf[i + 1];
+            b2 = buf[i + 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[i + 1];
+            b2 = buf[i + 2];
+            b3 = buf[i + 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);
+          i += bytesPerSequence;
+        }
+        return str;
+      }
+      function writeUtf8(buf, str, pos) {
+        for (let i = 0, c, lead; i < str.length; i++) {
+          c = str.charCodeAt(i);
+          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 || i + 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 x = 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 i = 0; i < lineCount; i++) {
+            if (i === 1 && type !== 1) {
+              pbf.writeVarint(command(2, lineCount - 1));
+            }
+            const dx = ring[i * 2] - x;
+            const dy = ring[i * 2 + 1] - y;
+            pbf.writeVarint(zigzag(dx));
+            pbf.writeVarint(zigzag(dy));
+            x += 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 _a;
+        return JSON.parse(JSON.stringify(((_a = perf === null || perf === void 0 ? void 0 : perf.getEntriesByName) === null || _a === void 0 ? void 0 : _a.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 max = Math.max(...all.map((ns) => Math.max(...ns)));
+              const min = Math.min(...all.map((ns) => Math.min(...ns)));
+              return Number.isFinite(max) ? max - 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 _a;
+            if (!this.marks[category]) {
+              this.marks[category] = [];
+            }
+            const marks = [now()];
+            (_a = this.marks[category]) === null || _a === void 0 ? void 0 : _a.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 _a;
+            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(...((_a = timings.marks[key]) === null || _a === void 0 ? void 0 : _a.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, x, y, abortController, timer) => {
+            const self2 = this;
+            const url = this.demUrlPattern.replace("{z}", z.toString()).replace("{x}", x.toString()).replace("{y}", y.toString());
+            timer === null || timer === void 0 ? void 0 : timer.useTile(url);
+            return this.parsedCache.get(url, (_, childAbortController) => __awaiter(this, void 0, void 0, function* () {
+              const response = yield self2.fetchTile(z, x, 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, x, y, parentAbortController, timer) {
+          const url = this.demUrlPattern.replace("{z}", z.toString()).replace("{x}", x.toString()).replace("{y}", y.toString());
+          timer === null || timer === void 0 ? void 0 : timer.useTile(url);
+          return this.tileCache.get(url, (_, 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, x, 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(x / div);
+            const newY = Math.floor(y / div);
+            const tile = yield this.fetchAndParseTile(zoom, newX, newY, abortController, timer);
+            return HeightTile.fromRawDem(tile).split(subZ, x % div, y % div);
+          });
+        }
+        fetchContourTile(z, x, 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, x, y, encodeIndividualOptions(options)].join("/");
+          return this.contourCache.get(key, (_, childAbortController) => __awaiter(this, void 0, void 0, function* () {
+            const max = 1 << z;
+            const neighborPromises = [];
+            for (let iy = y - 1; iy <= y + 1; iy++) {
+              for (let ix = x - 1; ix <= x + 1; ix++) {
+                neighborPromises.push(iy < 0 || iy >= max ? void 0 : this.fetchDem(z, (ix + max) % max, 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((l, i) => ele % l === 0 ? i : 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 = (_a) => __awaiter(this, [_a], 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, _) => {
+            this.managers[message.managerId] = new actor.L(message);
+            return Promise.resolve();
+          };
+          this.fetchTile = (managerId, z, x, y, abortController, timer) => {
+            var _a;
+            return ((_a = this.managers[managerId]) === null || _a === void 0 ? void 0 : _a.fetchTile(z, x, y, abortController, timer)) || noManager(managerId);
+          };
+          this.fetchAndParseTile = (managerId, z, x, y, abortController, timer) => {
+            var _a;
+            return actor.p(((_a = this.managers[managerId]) === null || _a === void 0 ? void 0 : _a.fetchAndParseTile(z, x, y, abortController, timer)) || noManager(managerId), true);
+          };
+          this.fetchContourTile = (managerId, z, x, y, options, abortController, timer) => {
+            var _a;
+            return actor.f(((_a = this.managers[managerId]) === null || _a === void 0 ? void 0 : _a.fetchContourTile(z, x, y, options, abortController, timer)) || noManager(managerId));
+          };
+        }
+      }
+      const g = typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : global;
+      g.actor = new actor.A(g, 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, x, y, abortController, timer) => this.actor.send("fetchTile", [], abortController, timer, this.managerId, z, x, y);
+          this.fetchAndParseTile = (z, x, y, abortController, timer) => this.actor.send("fetchAndParseTile", [], abortController, timer, this.managerId, z, x, y);
+          this.fetchContourTile = (z, x, y, options2, abortController, timer) => this.actor.send("fetchContourTile", [], abortController, timer, this.managerId, z, x, 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 _a;
+              return resolve((_a = event.target) === null || _a === void 0 ? void 0 : _a.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), (err) => arg2(err)).catch((err) => arg2(err));
+          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, x, y] = this.parseUrl(request.url);
+            const timer = new actor.T("main");
+            let timing;
+            try {
+              const data = yield this.manager.fetchTile(z, x, 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, x, y] = this.parseUrl(request.url);
+              const options = actor.a(request.url);
+              const data = yield this.manager.fetchContourTile(z, x, 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 protocolPrefix = id2;
+          let i = 1;
+          while (used.has(protocolPrefix)) {
+            protocolPrefix = id2 + i++;
+          }
+          used.add(protocolPrefix);
+          this.sharedDemProtocolId = `${protocolPrefix}-shared`;
+          this.contourProtocolId = `${protocolPrefix}-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, x, y, abortController) {
+          return this.manager.fetchAndParseTile(z, x, y, abortController || new AbortController());
+        }
+        parseUrl(url) {
+          const [, z, x, y] = /\/\/(\d+)\/(\d+)\/(\d+)/.exec(url) || [];
+          return [Number(z), Number(x), 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 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 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;
@@ -84,7 +2196,979 @@ function getTileflowLocationOrigin() {
   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/claim";
+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 === "CLAIM_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 === "CLAIM_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 === "CLAIM_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 === "CLAIM_REQUIRED" || fairUse === "GRACE" && (ownerNotice || response.status === 429)) {
+      registration.lastNoticeSequence = requestSequence;
+      if (!(registration.currentNoticeState === "CLAIM_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 !== "CLAIM_REQUIRED") {
+        registration.currentNoticeState = null;
+        registration.onNotice(null);
+      }
+    }
+  }
+  if (response.status === 404 || response.status === 429 && (fairUse === "GRACE" || fairUse === "CLAIM_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 === "claim-required") return "CLAIM_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 x = 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 || x >= axisLimit || y >= axisLimit) {
+    throw new Error("Invalid Tileflow contour tile coordinates.");
+  }
+  return { config, x, 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, 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(x)).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]])
+  );
+}
+
 // 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;
+  }
+  systemColorSchemeQuery = browser.matchMedia("(prefers-color-scheme: dark)");
+  systemColorScheme = systemColorSchemeQuery.matches ? "dark" : "light";
+  systemColorSchemeQuery.addEventListener?.("change", handleSystemColorSchemeChange);
+  if (!systemColorSchemeQuery.addEventListener) {
+    systemColorSchemeQuery.addListener?.(handleSystemColorSchemeChange);
+  }
+}
+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;
+  }
+  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 {
+      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 };
+    }
+  }
+  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 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 {
+    input = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(source));
+  } catch {
+    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);
+}
+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);
+}
+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.`);
+  }
+  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();
+}
 function createTileflowSessionStarter(options) {
   const starts = /* @__PURE__ */ new Set();
   const send = options.startSession ?? startTileflowSession;
@@ -215,7 +3299,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 +3317,8 @@ function createTileflowTransformRequest(options) {
           resolvedRequest,
           asyncAnalyticsTiming === "resolution" ? options.getAnalytics() : analyticsAtRequest,
           options.sessionId,
-          options.sessionController
+          options.sessionController,
+          options.worldRequestBridge
         ) ?? resolvedRequest
       );
     }
@@ -242,7 +3327,8 @@ function createTileflowTransformRequest(options) {
       request,
       asyncAnalyticsTiming === "resolution" ? options.getAnalytics() : analyticsAtRequest,
       options.sessionId,
-      options.sessionController
+      options.sessionController,
+      options.worldRequestBridge
     );
   };
 }
@@ -276,20 +3362,31 @@ function createTileflowMarkerController(options) {
     }
   };
 }
-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);
@@ -330,8 +3427,35 @@ function removeMarkers(markers, remove) {
   }
 }
 export {
+  attachTileflowFairUseNotice,
   attachTileflowMapLifecycle,
   createTileflowMarkerController,
   createTileflowSessionStarter,
-  createTileflowTransformRequest
+  createTileflowThemeController,
+  createTileflowTransformRequest,
+  getTileflowSystemColorScheme,
+  loadTileflowStyleFonts,
+  registerTileflowContourProtocol,
+  registerTileflowWorldRequestBridge,
+  subscribeTileflowSystemColorScheme,
+  tileflowFairUseNoticeMessage,
+  tileflowMaplibreContourVersion
 };
+/*! 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.
+  ***************************************************************************** *)
+*/