@deck.gl-community/geo-layers 9.2.8 → 9.3.0-beta.1

package/dist/index.cjs

@@ -30,7 +30,12 @@ __export(dist_exports, {
   H3Grid: () => H3Grid,
   QuadkeyGrid: () => QuadkeyGrid,
   S2Grid: () => S2Grid,
-  TileSourceLayer: () => TileSourceLayer
+  SharedTile2DHeader: () => SharedTile2DHeader,
+  SharedTile2DLayer: () => SharedTile2DLayer,
+  SharedTileset2D: () => SharedTileset2D,
+  TileGridLayer: () => TileGridLayer,
+  TileSourceLayer: () => TileSourceLayer,
+  sharedTile2DDeckAdapter: () => sharedTile2DDeckAdapter
 });
 module.exports = __toCommonJS(dist_exports);
 
@@ -133,6 +138,1793 @@ function renderSubLayers(props) {
   return layers;
 }
 
+// dist/shared-tile-2d-layer/shared-tile-2d-layer.js
+var import_core4 = require("@deck.gl/core");
+var import_layers2 = require("@deck.gl/layers");
+var import_core5 = require("@math.gl/core");
+
+// dist/tileset/tileset-2d.js
+var import_loader_utils = require("@loaders.gl/loader-utils");
+var import_stats = require("@probe.gl/stats");
+
+// dist/tileset/tile-2d-header.js
+var SharedTile2DHeader = class {
+  /** x/y/z tile coordinate. */
+  index;
+  /** Closest cached ancestor tile in the current tree. */
+  parent;
+  /** Cached child tiles beneath this tile. */
+  children;
+  /** Loaded tile payload. */
+  content;
+  /** Stable tile cache id. */
+  id;
+  /** Resolved zoom level for the tile. */
+  zoom;
+  /** Optional application data associated with the tile. */
+  userData;
+  /** Bounds represented as `[[minX, minY], [maxX, maxY]]` for loaders.gl compatibility. */
+  boundingBox;
+  /** Abort controller for the current request, if one exists. */
+  _abortController;
+  /** Promise tracking the in-flight tile load, if any. */
+  _loader;
+  /** Monotonic request id used to ignore stale responses. */
+  _loaderId;
+  /** Indicates whether the last request completed successfully. */
+  _isLoaded;
+  /** Indicates whether the current request was cancelled. */
+  _isCancelled;
+  /** Indicates whether the tile should be refreshed. */
+  _needsReload;
+  /** Structured bounds assigned when the tile is created. */
+  _bbox;
+  /** Creates a tile header for a specific tile index. */
+  constructor(index) {
+    this.index = index;
+    this.parent = null;
+    this.children = [];
+    this.content = null;
+    this._loader = void 0;
+    this._abortController = null;
+    this._loaderId = 0;
+    this._isLoaded = false;
+    this._isCancelled = false;
+    this._needsReload = false;
+  }
+  /** Structured bounds for the tile in the active coordinate system. */
+  get bbox() {
+    return this._bbox;
+  }
+  /** Initializes the tile bounds once during tile creation. */
+  set bbox(value) {
+    if (this._bbox)
+      return;
+    this._bbox = value;
+    if ("west" in value) {
+      this.boundingBox = [
+        [value.west, value.south],
+        [value.east, value.north]
+      ];
+    } else {
+      this.boundingBox = [
+        [value.left, value.top],
+        [value.right, value.bottom]
+      ];
+    }
+  }
+  /** Resolves to loaded content while a request is in flight, otherwise returns the cached content. */
+  get data() {
+    const loader = this._loader;
+    if (!this._isCancelled && loader !== void 0) {
+      return loader.then(() => this.data);
+    }
+    return this.content;
+  }
+  /** Indicates whether tile content is available and up to date. */
+  get isLoaded() {
+    return this._isLoaded && !this._needsReload;
+  }
+  /** Indicates whether a tile request is currently in flight. */
+  get isLoading() {
+    return Boolean(this._loader) && !this._isCancelled;
+  }
+  /** Indicates whether the tile should be requested again. */
+  get needsReload() {
+    return this._needsReload || this._isCancelled;
+  }
+  /** Estimated byte size of the cached payload. */
+  get byteLength() {
+    const result = this.content ? this.content.byteLength : 0;
+    return Number.isFinite(result) ? result : 0;
+  }
+  /** Internal request pipeline used by {@link loadData}. */
+  async _loadData({ getData, requestScheduler, onLoad, onError }) {
+    const completeLoad = (tileData2, error2, loaderId2) => {
+      if (loaderId2 !== this._loaderId) {
+        return;
+      }
+      this._loader = void 0;
+      this.content = tileData2;
+      if (this._isCancelled && !tileData2) {
+        this._isLoaded = false;
+        return;
+      }
+      this._isLoaded = true;
+      this._isCancelled = false;
+      if (error2) {
+        onError(error2, this);
+        return;
+      }
+      onLoad(this);
+    };
+    const { index, id, bbox, userData, zoom } = this;
+    const loaderId = this._loaderId;
+    this._abortController = new AbortController();
+    const { signal } = this._abortController;
+    const requestToken = await requestScheduler.scheduleRequest(this, () => 1);
+    if (!requestToken) {
+      this._isCancelled = true;
+      return;
+    }
+    if (this._isCancelled) {
+      requestToken.done();
+      return;
+    }
+    let tileData = null;
+    let error;
+    try {
+      tileData = await getData({ index, id, bbox, userData, zoom, signal });
+    } catch (err) {
+      error = err || true;
+    } finally {
+      requestToken.done();
+    }
+    completeLoad(tileData, error, loaderId);
+  }
+  /** Loads tile data through the shared scheduler. */
+  loadData(opts) {
+    this._isLoaded = false;
+    this._isCancelled = false;
+    this._needsReload = false;
+    this._loaderId++;
+    this._loader = this._loadData(opts);
+    return this._loader;
+  }
+  /** Marks the tile stale so it is refreshed on the next traversal. */
+  setNeedsReload() {
+    if (this.isLoading) {
+      this.abort();
+      this._loader = void 0;
+    }
+    this._needsReload = true;
+  }
+  /** Cancels an in-flight tile request. */
+  abort() {
+    var _a;
+    if (this.isLoaded) {
+      return;
+    }
+    this._isCancelled = true;
+    (_a = this._abortController) == null ? void 0 : _a.abort();
+  }
+};
+
+// dist/tileset/tileset-2d.js
+var STRATEGY_NEVER = "never";
+var STRATEGY_REPLACE = "no-overlap";
+var STRATEGY_DEFAULT = "best-available";
+var DEFAULT_TILESET2D_PROPS = {
+  adapter: null,
+  extent: null,
+  tileSize: 512,
+  maxZoom: null,
+  minZoom: null,
+  maxCacheSize: 100,
+  maxCacheByteSize: null,
+  refinementStrategy: "best-available",
+  zRange: null,
+  maxRequests: 6,
+  debounceTime: 0,
+  zoomOffset: 0,
+  onTileLoad: () => {
+  },
+  onTileUnload: () => {
+  },
+  onTileError: () => {
+  }
+};
+var SharedTileset2D = class {
+  /** Live counters describing shared tileset state. */
+  stats;
+  /** Effective runtime options after defaults and metadata overrides have been applied. */
+  opts;
+  /** Cached metadata returned by the backing TileSource, if any. */
+  sourceMetadata = null;
+  /** Scheduler shared across all tile requests for this tileset. */
+  _requestScheduler;
+  /** Shared tile cache keyed by tile id. */
+  _cache;
+  /** Tracks whether parent/child links need rebuilding. */
+  _dirty;
+  /** Cached tiles sorted by zoom for traversal and rendering. */
+  _tiles;
+  /** Running total of cached payload byte size. */
+  _cacheByteSize;
+  /** Cumulative number of tiles evicted from the shared cache. */
+  _unloadedTileCount;
+  /** Subscribers watching tileset lifecycle events. */
+  _listeners = /* @__PURE__ */ new Set();
+  /** Selected and visible tiles tracked per consumer. */
+  _consumers = /* @__PURE__ */ new Map();
+  /** Option names explicitly set by the caller. */
+  _explicitOptionKeys = /* @__PURE__ */ new Set();
+  /** Caller-provided options before metadata-derived overrides are applied. */
+  _baseOpts = {};
+  /** Derived overrides sourced from TileSource metadata. */
+  _sourceMetadataOverrides = {};
+  /** Resolved maximum zoom level used by traversal. */
+  _maxZoom;
+  /** Resolved minimum zoom level used by traversal. */
+  _minZoom;
+  /** Most recent traversal context used to derive tile metadata. */
+  _lastTileContext = null;
+  /** Creates a tileset from either `getTileData` or a loaders.gl `TileSource`. */
+  constructor(opts) {
+    this.stats = new import_stats.Stats({
+      id: "SharedTileset2D",
+      stats: [
+        { name: "Tiles In Cache" },
+        { name: "Cache Size" },
+        { name: "Visible Tiles" },
+        { name: "Selected Tiles" },
+        { name: "Loading Tiles" },
+        { name: "Unloaded Tiles" },
+        { name: "Consumers" }
+      ]
+    });
+    this.opts = {
+      ...DEFAULT_TILESET2D_PROPS,
+      ...opts,
+      getTileData: opts.getTileData || (() => null),
+      tileSource: opts.tileSource
+    };
+    this._requestScheduler = new import_loader_utils.RequestScheduler({
+      throttleRequests: this.opts.maxRequests > 0 || this.opts.debounceTime > 0,
+      maxRequests: this.opts.maxRequests,
+      debounceTime: this.opts.debounceTime
+    });
+    this._cache = /* @__PURE__ */ new Map();
+    this._tiles = [];
+    this._dirty = false;
+    this._cacheByteSize = 0;
+    this._unloadedTileCount = 0;
+    if (!this.opts.tileSource && !opts.getTileData) {
+      throw new Error("SharedTileset2D requires either `getTileData` or `tileSource`.");
+    }
+    this.setOptions(opts);
+    this._updateStats();
+    if (this.opts.tileSource) {
+      this._initializeTileSource(this.opts.tileSource).catch(() => {
+      });
+    }
+  }
+  /** Convenience factory for wrapping a loaders.gl `TileSource`. */
+  static fromTileSource(tileSource, opts = {}) {
+    return new SharedTileset2D({ ...opts, tileSource });
+  }
+  /** All tiles currently present in the shared cache. */
+  get tiles() {
+    return this._tiles;
+  }
+  /** Estimated byte size of all tile content currently retained in cache. */
+  get cacheByteSize() {
+    return this._cacheByteSize;
+  }
+  /** Union of tiles selected by all attached consumers. */
+  get selectedTiles() {
+    return Array.from(this._getSelectedTilesUnion());
+  }
+  /** Union of tiles contributing to the visible result across all consumers and views, including unloaded selected tiles. */
+  get visibleTiles() {
+    const union = this._getVisibleTilesUnion();
+    for (const tile of this._getSelectedTilesUnion()) {
+      union.add(tile);
+    }
+    return Array.from(union);
+  }
+  /** Tiles currently loading anywhere in the shared cache. */
+  get loadingTiles() {
+    return Array.from(this._cache.values()).filter((tile) => tile.isLoading);
+  }
+  /** Tiles retained in cache that do not currently have loaded content. */
+  get unloadedTiles() {
+    return Array.from(this._cache.values()).filter((tile) => !tile.isLoaded);
+  }
+  /** Maximum resolved zoom level after applying metadata and explicit options. */
+  get maxZoom() {
+    return this._maxZoom;
+  }
+  /** Minimum resolved zoom level after applying metadata and explicit options. */
+  get minZoom() {
+    return this._minZoom;
+  }
+  /** Active refinement strategy for placeholder handling. */
+  get refinementStrategy() {
+    return this.opts.refinementStrategy || STRATEGY_DEFAULT;
+  }
+  /** Adapter currently used for traversal and tile metadata. */
+  get adapter() {
+    return this.opts.adapter;
+  }
+  /** Subscribes to tileset lifecycle events. */
+  subscribe(listener) {
+    this._listeners.add(listener);
+    return () => this._listeners.delete(listener);
+  }
+  /** Registers a consumer so cache pruning can account for its selected tiles. */
+  attachConsumer(id) {
+    this._consumers.set(id, { selectedTiles: /* @__PURE__ */ new Set(), visibleTiles: /* @__PURE__ */ new Set() });
+    this._updateStats();
+  }
+  /** Unregisters a consumer and prunes unused requests and tiles. */
+  detachConsumer(id) {
+    this._consumers.delete(id);
+    this._pruneRequests();
+    this._resizeCache();
+    this._updateStats();
+  }
+  /** Updates tileset options and reapplies TileSource metadata overrides. */
+  setOptions(opts) {
+    this._rememberExplicitOptions(opts);
+    this._baseOpts = { ...this._baseOpts, ...opts };
+    this._applyResolvedOptions();
+  }
+  /** Aborts in-flight requests and clears the shared cache. */
+  finalize() {
+    for (const tile of this._cache.values()) {
+      if (tile.isLoading) {
+        tile.abort();
+      }
+    }
+    this._cache.clear();
+    this._tiles = [];
+    this._consumers.clear();
+    this._cacheByteSize = 0;
+    this._unloadedTileCount = 0;
+    this._updateStats();
+  }
+  /** Marks all retained tiles stale and drops unused cached tiles. */
+  reloadAll() {
+    const selectedTiles = this._getSelectedTilesUnion();
+    for (const id of this._cache.keys()) {
+      const tile = this._cache.get(id);
+      if (tile && !selectedTiles.has(tile)) {
+        this._cache.delete(id);
+      } else if (tile) {
+        tile.setNeedsReload();
+      }
+    }
+    this._cacheByteSize = this._getCacheByteSize();
+    this.prepareTiles();
+    this._updateStats();
+  }
+  /** Updates the selected and visible tile sets for one consumer. */
+  updateConsumer(id, selectedTiles, visibleTiles) {
+    this._consumers.set(id, {
+      selectedTiles: new Set(selectedTiles),
+      visibleTiles: new Set(visibleTiles)
+    });
+    this._pruneRequests();
+    this._resizeCache();
+    this._updateStats();
+  }
+  /** Rebuilds parent/child links if the cache changed since the last traversal. */
+  prepareTiles() {
+    if (this._dirty) {
+      this._rebuildTree();
+      this._syncTiles();
+      this._dirty = false;
+    }
+  }
+  /** Returns tile indices needed to cover a viewport. */
+  getTileIndices({ viewState, maxZoom, minZoom, zRange, modelMatrix, modelMatrixInverse }) {
+    const { adapter, tileSize, extent, zoomOffset } = this.opts;
+    if (!adapter) {
+      throw new Error("SharedTileset2D requires an adapter before tile traversal can be used.");
+    }
+    this._lastTileContext = { viewState, tileSize };
+    return adapter.getTileIndices({
+      viewState,
+      maxZoom,
+      minZoom,
+      zRange,
+      tileSize,
+      extent: normalizeBounds(extent),
+      modelMatrix,
+      modelMatrixInverse,
+      zoomOffset
+    });
+  }
+  /** Returns the stable cache id for a tile index. */
+  getTileId(index) {
+    return `${index.x}-${index.y}-${index.z}`;
+  }
+  /** Returns the zoom level represented by a tile index. */
+  getTileZoom(index) {
+    return index.z;
+  }
+  /** Returns derived metadata used to initialize a tile header. */
+  getTileMetadata(index) {
+    if (!this._lastTileContext) {
+      throw new Error("SharedTileset2D metadata requested before traversal context was set.");
+    }
+    if (!this.opts.adapter) {
+      throw new Error("SharedTileset2D requires an adapter before tile metadata can be derived.");
+    }
+    return { bbox: this.opts.adapter.getTileBoundingBox(this._lastTileContext, index) };
+  }
+  /** Returns the parent tile index in the quadtree. */
+  getParentIndex(index) {
+    return { x: Math.floor(index.x / 2), y: Math.floor(index.y / 2), z: index.z - 1 };
+  }
+  getTile(index, create) {
+    const id = this.getTileId(index);
+    let tile = this._cache.get(id);
+    let needsReload = false;
+    if (!tile && create) {
+      tile = new SharedTile2DHeader(index);
+      Object.assign(tile, this.getTileMetadata(tile.index));
+      Object.assign(tile, { id, zoom: this.getTileZoom(tile.index) });
+      needsReload = true;
+      this._cache.set(id, tile);
+      this._dirty = true;
+      this._updateStats();
+    } else if (tile && tile.needsReload) {
+      needsReload = true;
+    }
+    if (tile) {
+      this._touchTile(id, tile);
+    }
+    if (tile && needsReload) {
+      tile.loadData({
+        getData: this.opts.getTileData,
+        requestScheduler: this._requestScheduler,
+        onLoad: this._handleTileLoad.bind(this),
+        onError: this._handleTileError.bind(this)
+      }).catch(() => {
+      });
+      this._updateStats();
+    }
+    return tile;
+  }
+  /** Loads metadata from a TileSource and reapplies derived option overrides. */
+  async _initializeTileSource(tileSource) {
+    try {
+      this.sourceMetadata = await tileSource.getMetadata();
+      this._sourceMetadataOverrides = this._getMetadataOverrides(this.sourceMetadata);
+      this._applyResolvedOptions();
+      this._notifyUpdate();
+    } catch (error) {
+      const normalizedError = error instanceof Error ? error : new Error(`TileSource metadata error: ${String(error)}`);
+      this._notifyError(normalizedError);
+    }
+  }
+  /** Tracks which options were explicitly set by the caller. */
+  _rememberExplicitOptions(opts) {
+    for (const key of Object.keys(opts)) {
+      this._explicitOptionKeys.add(key);
+    }
+  }
+  /** Resolves defaults, metadata overrides, and caller options into runtime settings. */
+  _applyResolvedOptions() {
+    const resolvedOpts = {
+      ...DEFAULT_TILESET2D_PROPS,
+      ...this._sourceMetadataOverrides,
+      ...this._baseOpts
+    };
+    if (resolvedOpts.tileSource) {
+      const tileSource = resolvedOpts.tileSource;
+      resolvedOpts.getTileData = (loadProps) => tileSource.getTileData(loadProps);
+    }
+    this.opts = resolvedOpts;
+    this._maxZoom = typeof this.opts.maxZoom === "number" && Number.isFinite(this.opts.maxZoom) ? Math.floor(this.opts.maxZoom) : void 0;
+    this._minZoom = typeof this.opts.minZoom === "number" && Number.isFinite(this.opts.minZoom) ? Math.ceil(this.opts.minZoom) : void 0;
+  }
+  /** Maps TileSource metadata into supported tileset options. */
+  _getMetadataOverrides(metadata) {
+    if (!metadata) {
+      return {};
+    }
+    const overrides = {};
+    if (!this._explicitOptionKeys.has("minZoom") && Number.isFinite(metadata.minZoom)) {
+      overrides.minZoom = metadata.minZoom;
+    }
+    if (!this._explicitOptionKeys.has("maxZoom") && Number.isFinite(metadata.maxZoom)) {
+      overrides.maxZoom = metadata.maxZoom;
+    }
+    if (!this._explicitOptionKeys.has("extent") && metadata.boundingBox) {
+      overrides.extent = [
+        metadata.boundingBox[0][0],
+        metadata.boundingBox[0][1],
+        metadata.boundingBox[1][0],
+        metadata.boundingBox[1][1]
+      ];
+    }
+    return overrides;
+  }
+  /** Handles successful tile loads. */
+  _handleTileLoad(tile) {
+    var _a, _b, _c;
+    (_b = (_a = this.opts).onTileLoad) == null ? void 0 : _b.call(_a, tile);
+    this._cacheByteSize = this._getCacheByteSize();
+    this._resizeCache();
+    for (const listener of this._listeners) {
+      (_c = listener.onTileLoad) == null ? void 0 : _c.call(listener, tile);
+    }
+    this._updateStats();
+  }
+  /** Handles tile load failures. */
+  _handleTileError(error, tile) {
+    var _a, _b, _c;
+    (_b = (_a = this.opts).onTileError) == null ? void 0 : _b.call(_a, error, tile);
+    for (const listener of this._listeners) {
+      (_c = listener.onTileError) == null ? void 0 : _c.call(listener, error, tile);
+    }
+    this._updateStats();
+  }
+  /** Handles tile eviction from cache. */
+  _handleTileUnload(tile) {
+    var _a, _b, _c;
+    this._unloadedTileCount++;
+    (_b = (_a = this.opts).onTileUnload) == null ? void 0 : _b.call(_a, tile);
+    for (const listener of this._listeners) {
+      (_c = listener.onTileUnload) == null ? void 0 : _c.call(listener, tile);
+    }
+    this._updateStats();
+  }
+  /** Notifies listeners that metadata or effective options changed. */
+  _notifyUpdate() {
+    var _a;
+    for (const listener of this._listeners) {
+      (_a = listener.onUpdate) == null ? void 0 : _a.call(listener);
+    }
+  }
+  /** Notifies listeners about asynchronous metadata errors. */
+  _notifyError(error) {
+    var _a;
+    for (const listener of this._listeners) {
+      (_a = listener.onError) == null ? void 0 : _a.call(listener, error);
+    }
+  }
+  /** Recomputes absolute counter stats and notifies listeners. */
+  _updateStats() {
+    var _a;
+    this._setStatCount("Tiles In Cache", this._cache.size);
+    this._setStatCount("Cache Size", this.cacheByteSize);
+    this._setStatCount("Visible Tiles", this.visibleTiles.length);
+    this._setStatCount("Selected Tiles", this.selectedTiles.length);
+    this._setStatCount("Loading Tiles", this.loadingTiles.length);
+    this._setStatCount("Unloaded Tiles", this._unloadedTileCount);
+    this._setStatCount("Consumers", this._consumers.size);
+    for (const listener of this._listeners) {
+      (_a = listener.onStatsChange) == null ? void 0 : _a.call(listener, this.stats);
+    }
+  }
+  /** Writes an absolute count into a probe.gl stat. */
+  _setStatCount(name, value) {
+    this.stats.get(name).reset().addCount(value);
+  }
+  /** Returns the union of selected tiles across all consumers. */
+  _getSelectedTilesUnion() {
+    const union = /* @__PURE__ */ new Set();
+    for (const consumer of this._consumers.values()) {
+      for (const tile of consumer.selectedTiles) {
+        union.add(tile);
+      }
+    }
+    return union;
+  }
+  /** Returns the union of visible tiles across all consumers. */
+  _getVisibleTilesUnion() {
+    const union = /* @__PURE__ */ new Set();
+    for (const consumer of this._consumers.values()) {
+      for (const tile of consumer.visibleTiles) {
+        union.add(tile);
+      }
+    }
+    return union;
+  }
+  /** Moves a touched tile to the back of the cache map for LRU eviction ordering. */
+  _touchTile(id, tile) {
+    this._cache.delete(id);
+    this._cache.set(id, tile);
+  }
+  /** Computes the total byte size of all cached tile content. */
+  _getCacheByteSize() {
+    let byteLength = 0;
+    for (const tile of this._cache.values()) {
+      byteLength += tile.byteLength;
+    }
+    return byteLength;
+  }
+  /** Cancels low-priority requests when consumers no longer need them. */
+  _pruneRequests() {
+    const { maxRequests = 0 } = this.opts;
+    const selectedTiles = this._getSelectedTilesUnion();
+    const visibleTiles = this._getVisibleTilesUnion();
+    const abortCandidates = [];
+    let ongoingRequestCount = 0;
+    for (const tile of this._cache.values()) {
+      if (tile.isLoading) {
+        ongoingRequestCount++;
+        if (!selectedTiles.has(tile) && !visibleTiles.has(tile)) {
+          abortCandidates.push(tile);
+        }
+      }
+    }
+    while (maxRequests > 0 && ongoingRequestCount > maxRequests && abortCandidates.length > 0) {
+      const tile = abortCandidates.shift();
+      if (tile) {
+        tile.abort();
+      }
+      ongoingRequestCount--;
+    }
+  }
+  /** Rebuilds parent and child links for all cached tiles. */
+  _rebuildTree() {
+    for (const tile of this._cache.values()) {
+      tile.parent = null;
+      if (tile.children) {
+        tile.children.length = 0;
+      }
+    }
+    for (const tile of this._cache.values()) {
+      const parent = this._getNearestAncestor(tile);
+      tile.parent = parent;
+      if (parent == null ? void 0 : parent.children) {
+        parent.children.push(tile);
+      }
+    }
+  }
+  /** Updates the sorted tile list used by traversal and rendering. */
+  _syncTiles() {
+    this._tiles = Array.from(this._cache.values()).sort((t1, t2) => t1.zoom - t2.zoom);
+  }
+  /** Evicts unused cached tiles when configured cache limits are exceeded. */
+  _resizeCache() {
+    const maxCacheSize = this.opts.maxCacheSize ?? 100;
+    const maxCacheByteSize = this.opts.maxCacheByteSize ?? Infinity;
+    const visibleTiles = this._getVisibleTilesUnion();
+    const selectedTiles = this._getSelectedTilesUnion();
+    const overflown = this._cache.size > maxCacheSize || this._cacheByteSize > maxCacheByteSize;
+    if (overflown) {
+      for (const [id, tile] of this._cache) {
+        if (!visibleTiles.has(tile) && !selectedTiles.has(tile)) {
+          this._cache.delete(id);
+          this._cacheByteSize = this._getCacheByteSize();
+          this._handleTileUnload(tile);
+        }
+        if (this._cache.size <= maxCacheSize && this._cacheByteSize <= maxCacheByteSize) {
+          break;
+        }
+      }
+      this._dirty = true;
+    }
+    if (this._dirty) {
+      this._rebuildTree();
+      this._syncTiles();
+      this._dirty = false;
+    }
+  }
+  /** Finds the nearest cached ancestor tile for placeholder rendering. */
+  _getNearestAncestor(tile) {
+    const { _minZoom = 0 } = this;
+    let index = tile.index;
+    while (this.getTileZoom(index) > _minZoom) {
+      index = this.getParentIndex(index);
+      const parent = this.getTile(index);
+      if (parent) {
+        return parent;
+      }
+    }
+    return null;
+  }
+};
+function normalizeBounds(extent) {
+  return extent && extent.length === 4 ? extent : void 0;
+}
+
+// dist/shared-tile-2d-layer/shared-tile-2d-view.js
+var import_core3 = require("@math.gl/core");
+
+// dist/utils/memoize.js
+function memoize(compute) {
+  let cachedArgs = {};
+  let cachedResult;
+  return (args) => {
+    for (const key in args) {
+      if (!isEqual(args[key], cachedArgs[key])) {
+        cachedResult = compute(args);
+        cachedArgs = args;
+        break;
+      }
+    }
+    return cachedResult;
+  };
+}
+function isEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (Array.isArray(a)) {
+    const len = a.length;
+    if (!b || b.length !== len) {
+      return false;
+    }
+    for (let i = 0; i < len; i++) {
+      if (a[i] !== b[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
+}
+
+// dist/shared-tile-2d-layer/deck-tile-traversal.js
+var import_core2 = require("@deck.gl/core");
+var import_culling = require("@math.gl/culling");
+var import_web_mercator = require("@math.gl/web-mercator");
+var TILE_SIZE = 512;
+var MAX_MAPS = 3;
+var REF_POINTS_5 = [
+  [0.5, 0.5],
+  [0, 0],
+  [0, 1],
+  [1, 0],
+  [1, 1]
+];
+var REF_POINTS_9 = REF_POINTS_5.concat([
+  [0, 0.5],
+  [0.5, 0],
+  [1, 0.5],
+  [0.5, 1]
+]);
+var REF_POINTS_11 = REF_POINTS_9.concat([
+  [0.25, 0.5],
+  [0.75, 0.5]
+]);
+var OSMNode = class {
+  x;
+  y;
+  z;
+  childVisible;
+  selected;
+  _children;
+  constructor(x, y, z) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+  get children() {
+    if (!this._children) {
+      const x = this.x * 2;
+      const y = this.y * 2;
+      const z = this.z + 1;
+      this._children = [
+        new OSMNode(x, y, z),
+        new OSMNode(x, y + 1, z),
+        new OSMNode(x + 1, y, z),
+        new OSMNode(x + 1, y + 1, z)
+      ];
+    }
+    return this._children;
+  }
+  update(params) {
+    const { viewport, cullingVolume, elevationBounds, minZ, maxZ, bounds, offset, project } = params;
+    const boundingVolume = this.getBoundingVolume(elevationBounds, offset, project);
+    if (bounds && !this.insideBounds(bounds)) {
+      return false;
+    }
+    const isInside = cullingVolume.computeVisibility(boundingVolume);
+    if (isInside < 0) {
+      return false;
+    }
+    if (!this.childVisible) {
+      let { z } = this;
+      if (z < maxZ && z >= minZ) {
+        const distance = boundingVolume.distanceTo(viewport.cameraPosition) * viewport.scale / viewport.height;
+        z += Math.floor(Math.log2(distance));
+      }
+      if (z >= maxZ) {
+        this.selected = true;
+        return true;
+      }
+    }
+    this.selected = false;
+    this.childVisible = true;
+    for (const child of this.children) {
+      child.update(params);
+    }
+    return true;
+  }
+  getSelected(result = []) {
+    if (this.selected) {
+      result.push(this);
+    }
+    if (this._children) {
+      for (const node of this._children) {
+        node.getSelected(result);
+      }
+    }
+    return result;
+  }
+  insideBounds([minX, minY, maxX, maxY]) {
+    const scale = Math.pow(2, this.z);
+    const extent = TILE_SIZE / scale;
+    return this.x * extent < maxX && this.y * extent < maxY && (this.x + 1) * extent > minX && (this.y + 1) * extent > minY;
+  }
+  getBoundingVolume(zRange, worldOffset, project) {
+    if (project) {
+      const refPoints = this.z < 1 ? REF_POINTS_11 : this.z < 2 ? REF_POINTS_9 : REF_POINTS_5;
+      const refPointPositions = [];
+      for (const p of refPoints) {
+        const lngLat = osmTile2lngLat(this.x + p[0], this.y + p[1], this.z);
+        lngLat[2] = zRange[0];
+        refPointPositions.push(project(lngLat));
+        if (zRange[0] !== zRange[1]) {
+          lngLat[2] = zRange[1];
+          refPointPositions.push(project(lngLat));
+        }
+      }
+      return (0, import_culling.makeOrientedBoundingBoxFromPoints)(refPointPositions);
+    }
+    const scale = Math.pow(2, this.z);
+    const extent = TILE_SIZE / scale;
+    const originX = this.x * extent + worldOffset * TILE_SIZE;
+    const originY = TILE_SIZE - (this.y + 1) * extent;
+    return new import_culling.AxisAlignedBoundingBox([originX, originY, zRange[0]], [originX + extent, originY + extent, zRange[1]]);
+  }
+};
+function getOSMTileIndices(viewport, maxZ, zRange, bounds) {
+  const project = viewport instanceof import_core2._GlobeViewport && viewport.resolution ? (xyz) => viewport.projectPosition(xyz) : null;
+  const planes = Object.values(viewport.getFrustumPlanes()).map(({ normal, distance }) => new import_culling.Plane(normal.clone().negate(), distance));
+  const cullingVolume = new import_culling.CullingVolume(planes);
+  const unitsPerMeter = viewport.distanceScales.unitsPerMeter[2];
+  const elevationMin = zRange && zRange[0] * unitsPerMeter || 0;
+  const elevationMax = zRange && zRange[1] * unitsPerMeter || 0;
+  const minZ = viewport instanceof import_core2.WebMercatorViewport && viewport.pitch <= 60 ? maxZ : 0;
+  if (bounds) {
+    const [minLng, minLat, maxLng, maxLat] = bounds;
+    const topLeft = (0, import_web_mercator.lngLatToWorld)([minLng, maxLat]);
+    const bottomRight = (0, import_web_mercator.lngLatToWorld)([maxLng, minLat]);
+    bounds = [topLeft[0], TILE_SIZE - topLeft[1], bottomRight[0], TILE_SIZE - bottomRight[1]];
+  }
+  const root = new OSMNode(0, 0, 0);
+  const traversalParams = {
+    viewport,
+    project,
+    cullingVolume,
+    elevationBounds: [elevationMin, elevationMax],
+    minZ,
+    maxZ,
+    bounds,
+    offset: 0
+  };
+  root.update(traversalParams);
+  updateWrappedWorldCopies(root, traversalParams, viewport);
+  return root.getSelected();
+}
+function updateWrappedWorldCopies(root, traversalParams, viewport) {
+  if (!(viewport instanceof import_core2.WebMercatorViewport) || !viewport.subViewports || viewport.subViewports.length <= 1) {
+    return;
+  }
+  sweepOffsets(root, traversalParams, -1, -MAX_MAPS);
+  sweepOffsets(root, traversalParams, 1, MAX_MAPS);
+}
+function sweepOffsets(root, traversalParams, startOffset, limit) {
+  traversalParams.offset = startOffset;
+  while (root.update(traversalParams)) {
+    traversalParams.offset += Math.sign(startOffset);
+    if (startOffset < 0 && traversalParams.offset < limit || startOffset > 0 && traversalParams.offset > limit) {
+      break;
+    }
+  }
+}
+
+// dist/shared-tile-2d-layer/deck-tileset-adapter.js
+var TILE_SIZE2 = 512;
+var DEFAULT_EXTENT = [-Infinity, -Infinity, Infinity, Infinity];
+function transformBox(bbox, modelMatrix) {
+  const transformedCoords = [
+    modelMatrix.transformAsPoint([bbox[0], bbox[1]]),
+    modelMatrix.transformAsPoint([bbox[2], bbox[1]]),
+    modelMatrix.transformAsPoint([bbox[0], bbox[3]]),
+    modelMatrix.transformAsPoint([bbox[2], bbox[3]])
+  ];
+  return [
+    Math.min(...transformedCoords.map((i) => i[0])),
+    Math.min(...transformedCoords.map((i) => i[1])),
+    Math.max(...transformedCoords.map((i) => i[0])),
+    Math.max(...transformedCoords.map((i) => i[1]))
+  ];
+}
+function getBoundingBox(viewport, zRange, extent) {
+  let bounds;
+  if (zRange && zRange.length === 2) {
+    const [minZ, maxZ] = zRange;
+    const bounds0 = viewport.getBounds({ z: minZ });
+    const bounds1 = viewport.getBounds({ z: maxZ });
+    bounds = [
+      Math.min(bounds0[0], bounds1[0]),
+      Math.min(bounds0[1], bounds1[1]),
+      Math.max(bounds0[2], bounds1[2]),
+      Math.max(bounds0[3], bounds1[3])
+    ];
+  } else {
+    bounds = viewport.getBounds();
+  }
+  if (!viewport.isGeospatial) {
+    return [
+      Math.max(Math.min(bounds[0], extent[2]), extent[0]),
+      Math.max(Math.min(bounds[1], extent[3]), extent[1]),
+      Math.min(Math.max(bounds[2], extent[0]), extent[2]),
+      Math.min(Math.max(bounds[3], extent[1]), extent[3])
+    ];
+  }
+  return [
+    Math.max(bounds[0], extent[0]),
+    Math.max(bounds[1], extent[1]),
+    Math.min(bounds[2], extent[2]),
+    Math.min(bounds[3], extent[3])
+  ];
+}
+function getCullBounds({ viewport, z, cullRect }) {
+  const subViewports = viewport.subViewports || [viewport];
+  return subViewports.map((v) => getCullBoundsInViewport(v, z || 0, cullRect));
+}
+function getCullBoundsInViewport(viewport, z, cullRect) {
+  if (!Array.isArray(z)) {
+    const x = cullRect.x - viewport.x;
+    const y = cullRect.y - viewport.y;
+    const { width, height } = cullRect;
+    const unprojectOption = { targetZ: z };
+    const topLeft = viewport.unproject([x, y], unprojectOption);
+    const topRight = viewport.unproject([x + width, y], unprojectOption);
+    const bottomLeft = viewport.unproject([x, y + height], unprojectOption);
+    const bottomRight = viewport.unproject([x + width, y + height], unprojectOption);
+    return [
+      Math.min(topLeft[0], topRight[0], bottomLeft[0], bottomRight[0]),
+      Math.min(topLeft[1], topRight[1], bottomLeft[1], bottomRight[1]),
+      Math.max(topLeft[0], topRight[0], bottomLeft[0], bottomRight[0]),
+      Math.max(topLeft[1], topRight[1], bottomLeft[1], bottomRight[1])
+    ];
+  }
+  const bounds0 = getCullBoundsInViewport(viewport, z[0], cullRect);
+  const bounds1 = getCullBoundsInViewport(viewport, z[1], cullRect);
+  return [
+    Math.min(bounds0[0], bounds1[0]),
+    Math.min(bounds0[1], bounds1[1]),
+    Math.max(bounds0[2], bounds1[2]),
+    Math.max(bounds0[3], bounds1[3])
+  ];
+}
+function getIndexingCoords(bbox, scale, modelMatrixInverse) {
+  if (modelMatrixInverse) {
+    return transformBox(bbox, modelMatrixInverse).map((i) => i * scale / TILE_SIZE2);
+  }
+  return bbox.map((i) => i * scale / TILE_SIZE2);
+}
+function getScale(z, tileSize) {
+  return Math.pow(2, z) * TILE_SIZE2 / tileSize;
+}
+function osmTile2lngLat(x, y, z) {
+  const scale = getScale(z, TILE_SIZE2);
+  const lng = x / scale * 360 - 180;
+  const n = Math.PI - 2 * Math.PI * y / scale;
+  const lat = 180 / Math.PI * Math.atan(0.5 * (Math.exp(n) - Math.exp(-n)));
+  return [lng, lat];
+}
+function tile2XY(x, y, z, tileSize) {
+  const scale = getScale(z, tileSize);
+  return [x / scale * TILE_SIZE2, y / scale * TILE_SIZE2];
+}
+function tileToBoundingBox(viewport, x, y, z, tileSize = TILE_SIZE2) {
+  if (viewport.isGeospatial) {
+    const [west, north] = osmTile2lngLat(x, y, z);
+    const [east, south] = osmTile2lngLat(x + 1, y + 1, z);
+    return { west, north, east, south };
+  }
+  const [left, top] = tile2XY(x, y, z, tileSize);
+  const [right, bottom] = tile2XY(x + 1, y + 1, z, tileSize);
+  return { left, top, right, bottom };
+}
+function getIdentityTileIndices(viewport, z, tileSize, extent, modelMatrixInverse) {
+  const bbox = getBoundingBox(viewport, null, extent);
+  const scale = getScale(z, tileSize);
+  const [minX, minY, maxX, maxY] = getIndexingCoords(bbox, scale, modelMatrixInverse);
+  const indices = [];
+  for (let x = Math.floor(minX); x < maxX; x++) {
+    for (let y = Math.floor(minY); y < maxY; y++) {
+      indices.push({ x, y, z });
+    }
+  }
+  return indices;
+}
+function getTileZoomForViewport(viewport, tileSize, zoomOffset) {
+  return viewport.isGeospatial ? Math.round(viewport.zoom + Math.log2(TILE_SIZE2 / tileSize)) + zoomOffset : Math.ceil(viewport.zoom) + zoomOffset;
+}
+function applyZoomBounds(z, minZoom, maxZoom, extent) {
+  if (typeof minZoom === "number" && Number.isFinite(minZoom) && z < minZoom) {
+    if (!extent) {
+      return null;
+    }
+    z = minZoom;
+  }
+  if (typeof maxZoom === "number" && Number.isFinite(maxZoom) && z > maxZoom) {
+    z = maxZoom;
+  }
+  return z;
+}
+function getDeckTileIndices(context) {
+  const { viewState: viewport, maxZoom, minZoom, zRange = null, extent, tileSize = TILE_SIZE2, modelMatrix, modelMatrixInverse, zoomOffset = 0 } = context;
+  let z = getTileZoomForViewport(viewport, tileSize, zoomOffset);
+  z = applyZoomBounds(z, minZoom, maxZoom, extent);
+  if (z === null) {
+    return [];
+  }
+  let transformedExtent = extent || void 0;
+  if (modelMatrix && modelMatrixInverse && extent && !viewport.isGeospatial) {
+    transformedExtent = transformBox(extent, modelMatrix);
+  }
+  return viewport.isGeospatial ? getOSMTileIndices(viewport, z, zRange, extent || void 0) : getIdentityTileIndices(viewport, z, tileSize, transformedExtent || DEFAULT_EXTENT, modelMatrixInverse);
+}
+function getDeckTileBoundingBox(context, index) {
+  return tileToBoundingBox(context.viewState, index.x, index.y, index.z, context.tileSize);
+}
+var sharedTile2DDeckAdapter = {
+  getTileIndices: getDeckTileIndices,
+  getTileBoundingBox: getDeckTileBoundingBox
+};
+
+// dist/shared-tile-2d-layer/shared-tile-2d-view.js
+var TILE_STATE_VISITED = 1;
+var TILE_STATE_VISIBLE = 2;
+var STRATEGIES = {
+  [STRATEGY_DEFAULT]: updateTileStateDefault,
+  [STRATEGY_REPLACE]: updateTileStateReplace,
+  [STRATEGY_NEVER]: () => {
+  }
+};
+var SharedTile2DView = class {
+  /** Unique consumer identifier used by the shared tileset cache. */
+  id = Symbol("tile-2d-view");
+  /** Shared tileset queried by this view. */
+  _tileset;
+  /** Tiles selected during the latest traversal. */
+  _selectedTiles = null;
+  /** Incremented whenever this view's visible tile set changes. */
+  _frameNumber = 0;
+  /** Last viewport used to compute tile selection. */
+  _viewport = null;
+  /** Last z-range used during tile selection. */
+  _zRange = null;
+  /** Last model matrix applied to tile selection. */
+  _modelMatrix = new import_core3.Matrix4();
+  /** Inverse of the current model matrix. */
+  _modelMatrixInverse = new import_core3.Matrix4();
+  /** Per-tile visibility and selection flags for this view. */
+  _state = /* @__PURE__ */ new Map();
+  /** Creates a viewport-specific view of a shared tileset. */
+  constructor(tileset) {
+    this._tileset = tileset;
+    if (!this._tileset.adapter) {
+      this._tileset.setOptions({ adapter: sharedTile2DDeckAdapter });
+    }
+    this._tileset.attachConsumer(this.id);
+  }
+  /** Releases this view and detaches it from the shared tileset. */
+  finalize() {
+    this._tileset.detachConsumer(this.id);
+    this._selectedTiles = null;
+    this._state.clear();
+  }
+  /** Tiles selected for the last viewport update. */
+  get selectedTiles() {
+    return this._selectedTiles;
+  }
+  /** Indicates whether all selected tiles are fully loaded for this view. */
+  get isLoaded() {
+    return this._selectedTiles !== null && this._selectedTiles.every((tile) => tile.isLoaded);
+  }
+  /** Indicates whether any selected tile needs to be re-requested. */
+  get needsReload() {
+    return this._selectedTiles !== null && this._selectedTiles.some((tile) => tile.needsReload);
+  }
+  /** Updates tile selection and visibility for a viewport and returns the current frame number. */
+  update(viewport, { zRange, modelMatrix } = { zRange: null, modelMatrix: null }) {
+    const modelMatrixAsMatrix4 = modelMatrix ? new import_core3.Matrix4(modelMatrix) : new import_core3.Matrix4();
+    const isModelMatrixNew = !modelMatrixAsMatrix4.equals(this._modelMatrix);
+    if (!this._viewport || !viewport.equals(this._viewport) || !(0, import_core3.equals)(this._zRange, zRange) || isModelMatrixNew) {
+      if (isModelMatrixNew) {
+        this._modelMatrixInverse = modelMatrixAsMatrix4.clone().invert();
+        this._modelMatrix = modelMatrixAsMatrix4;
+      }
+      this._viewport = viewport;
+      this._zRange = zRange;
+      const tileIndices = this._tileset.getTileIndices({
+        viewState: viewport,
+        maxZoom: this._tileset.maxZoom,
+        minZoom: this._tileset.minZoom,
+        zRange,
+        modelMatrix: this._modelMatrix,
+        modelMatrixInverse: this._modelMatrixInverse
+      });
+      this._selectedTiles = tileIndices.map((index) => this._tileset.getTile(index, true));
+      this._tileset.prepareTiles();
+    } else if (this.needsReload) {
+      this._selectedTiles = (this._selectedTiles || []).map((tile) => this._tileset.getTile(tile.index, true));
+      this._tileset.prepareTiles();
+    }
+    const changed = this._updateTileStates();
+    this._tileset.updateConsumer(this.id, this._selectedTiles || [], this._getVisibleTiles());
+    if (changed) {
+      this._frameNumber++;
+    }
+    return this._frameNumber;
+  }
+  /** Tests whether a tile should render in the current viewport and culling rectangle. */
+  isTileVisible(tile, cullRect, modelMatrix) {
+    const state = this._state.get(tile);
+    if (!(state == null ? void 0 : state.isVisible)) {
+      return false;
+    }
+    if (!cullRect || !this._viewport) {
+      return true;
+    }
+    const boundsArr = this._getCullBounds({
+      viewport: this._viewport,
+      z: this._zRange,
+      cullRect
+    });
+    return boundsArr.some((bounds) => this._tileOverlapsBounds(tile, bounds, modelMatrix));
+  }
+  /** Collects tiles currently marked visible for this view. */
+  _getVisibleTiles() {
+    var _a;
+    const result = [];
+    for (const tile of this._tileset.tiles) {
+      if ((_a = this._state.get(tile)) == null ? void 0 : _a.isVisible) {
+        result.push(tile);
+      }
+    }
+    return result;
+  }
+  /** Memoized screen-space culling bounds helper. */
+  _getCullBounds = memoize(getCullBounds);
+  /** Recomputes selected and placeholder-visible tiles for the current view. */
+  _updateTileStates() {
+    const refinementStrategy = this._tileset.refinementStrategy || STRATEGY_DEFAULT;
+    const allTiles = this._tileset.tiles;
+    const previousVisibility = /* @__PURE__ */ new Map();
+    for (const tile of allTiles) {
+      const existing = this._state.get(tile);
+      previousVisibility.set(tile, (existing == null ? void 0 : existing.isVisible) || false);
+      this._state.set(tile, { isSelected: false, isVisible: false, state: 0 });
+    }
+    for (const tile of this._selectedTiles || []) {
+      const state = this._state.get(tile) || { isSelected: false, isVisible: false, state: 0 };
+      state.isSelected = true;
+      state.isVisible = true;
+      this._state.set(tile, state);
+    }
+    if (typeof refinementStrategy === "function") {
+      refinementStrategy(allTiles);
+    } else {
+      STRATEGIES[refinementStrategy](allTiles, this._state);
+    }
+    let changed = false;
+    for (const tile of allTiles) {
+      const state = this._state.get(tile);
+      if (state && state.isVisible !== previousVisibility.get(tile)) {
+        changed = true;
+      }
+    }
+    return changed;
+  }
+  /** Tests one tile against one culling bounds rectangle. */
+  _tileOverlapsBounds(tile, [minX, minY, maxX, maxY], modelMatrix) {
+    const bbox = this._getTileBoundingBox(tile, modelMatrix);
+    if ("west" in bbox) {
+      return bbox.west < maxX && bbox.east > minX && bbox.south < maxY && bbox.north > minY;
+    }
+    const y0 = Math.min(bbox.top, bbox.bottom);
+    const y1 = Math.max(bbox.top, bbox.bottom);
+    return bbox.left < maxX && bbox.right > minX && y0 < maxY && y1 > minY;
+  }
+  /** Applies model-matrix transforms to non-geospatial tile bounds when needed. */
+  _getTileBoundingBox(tile, modelMatrix) {
+    const { bbox } = tile;
+    if ("west" in bbox || !modelMatrix || import_core3.Matrix4.IDENTITY.equals(modelMatrix)) {
+      return bbox;
+    }
+    const [left, top, right, bottom] = transformBox([bbox.left, bbox.top, bbox.right, bbox.bottom], modelMatrix);
+    return { left, top, right, bottom };
+  }
+};
+function updateTileStateDefault(allTiles, stateMap) {
+  for (const tile of allTiles) {
+    getTileState(stateMap, tile).state = 0;
+  }
+  for (const tile of allTiles) {
+    if (getTileState(stateMap, tile).isSelected && !getPlaceholderInAncestors(tile, stateMap)) {
+      getPlaceholderInChildren(tile, stateMap);
+    }
+  }
+  for (const tile of allTiles) {
+    const state = getTileState(stateMap, tile);
+    state.isVisible = Boolean(state.state & TILE_STATE_VISIBLE);
+  }
+}
+function updateTileStateReplace(allTiles, stateMap) {
+  for (const tile of allTiles) {
+    getTileState(stateMap, tile).state = 0;
+  }
+  for (const tile of allTiles) {
+    if (getTileState(stateMap, tile).isSelected) {
+      getPlaceholderInAncestors(tile, stateMap);
+    }
+  }
+  const sortedTiles = Array.from(allTiles).sort((t1, t2) => t1.zoom - t2.zoom);
+  for (const tile of sortedTiles) {
+    const tileState = getTileState(stateMap, tile);
+    tileState.isVisible = Boolean(tileState.state & TILE_STATE_VISIBLE);
+    if (tile.children && (tileState.isVisible || tileState.state & TILE_STATE_VISITED)) {
+      for (const child of tile.children) {
+        getTileState(stateMap, child).state = TILE_STATE_VISITED;
+      }
+    } else if (tileState.isSelected) {
+      getPlaceholderInChildren(tile, stateMap);
+    }
+  }
+}
+function getPlaceholderInAncestors(startTile, stateMap) {
+  let tile = startTile;
+  while (tile = tile.parent) {
+    const state = getTileState(stateMap, tile);
+    state.state |= TILE_STATE_VISIBLE | TILE_STATE_VISITED;
+    if (tile.isLoaded || tile.content) {
+      return true;
+    }
+  }
+  return false;
+}
+function getPlaceholderInChildren(tile, stateMap) {
+  const state = getTileState(stateMap, tile);
+  state.state |= TILE_STATE_VISIBLE | TILE_STATE_VISITED;
+  if (!tile.children || !tile.children.length || tile.isLoaded || tile.content) {
+    return;
+  }
+  for (const child of tile.children) {
+    const childState = getTileState(stateMap, child);
+    if (!(childState.state & TILE_STATE_VISITED)) {
+      getPlaceholderInChildren(child, stateMap);
+    }
+  }
+}
+function getTileState(stateMap, tile) {
+  let tileState = stateMap.get(tile);
+  if (!tileState) {
+    tileState = { isSelected: false, isVisible: false, state: 0 };
+    stateMap.set(tile, tileState);
+  }
+  return tileState;
+}
+
+// dist/shared-tile-2d-layer/url-template.js
+function stringHash(s) {
+  return Math.abs(s.split("").reduce((a, b) => (a << 5) - a + b.charCodeAt(0) | 0, 0));
+}
+function getURLFromTemplate(template, tile) {
+  if (!template || !template.length) {
+    return null;
+  }
+  const { index, id } = tile;
+  if (Array.isArray(template)) {
+    template = template[stringHash(id) % template.length];
+  }
+  let url = template;
+  for (const key of Object.keys(index)) {
+    url = url.replace(new RegExp(`{${key}}`, "g"), String(index[key]));
+  }
+  if (Number.isInteger(index.y) && Number.isInteger(index.z)) {
+    url = url.replace(/\{-y\}/g, String(Math.pow(2, index.z) - index.y - 1));
+  }
+  return url;
+}
+
+// dist/shared-tile-2d-layer/shared-tile-2d-layer.js
+function isTileSource(value) {
+  return Boolean(value && typeof value === "object" && "getTileData" in value && typeof value.getTileData === "function" && "getMetadata" in value && typeof value.getMetadata === "function");
+}
+function isURLTemplate(value) {
+  return value === null || typeof value === "string" || Array.isArray(value) && value.every((url) => typeof url === "string");
+}
+var tile2DDataType = {
+  type: "object",
+  value: null,
+  validate: (value, propType) => propType.optional && value === null || value instanceof SharedTileset2D || isTileSource(value) || isURLTemplate(value),
+  equal: (value1, value2) => value1 === value2
+};
+var defaultProps = {
+  TilesetClass: SharedTileset2D,
+  data: tile2DDataType,
+  dataComparator: tile2DDataType.equal,
+  renderSubLayers: { type: "function", value: (props) => new import_layers2.GeoJsonLayer(props) },
+  getTileData: { type: "function", optional: true, value: null },
+  onViewportLoad: { type: "function", optional: true, value: null },
+  onTileLoad: { type: "function", value: () => {
+  } },
+  onTileUnload: { type: "function", value: () => {
+  } },
+  onTileError: { type: "function", value: () => {
+  } },
+  extent: { type: "array", optional: true, value: null, compare: true },
+  tileSize: 512,
+  maxZoom: null,
+  minZoom: 0,
+  maxCacheSize: null,
+  maxCacheByteSize: null,
+  refinementStrategy: STRATEGY_DEFAULT,
+  zRange: null,
+  maxRequests: 6,
+  debounceTime: 0,
+  zoomOffset: 0
+};
+var TILE2D_LAYER_DEFAULT_OPTION_VALUES = {
+  maxCacheSize: null,
+  maxCacheByteSize: null,
+  maxZoom: null,
+  minZoom: 0,
+  tileSize: 512,
+  refinementStrategy: STRATEGY_DEFAULT,
+  extent: null,
+  maxRequests: 6,
+  debounceTime: 0,
+  zoomOffset: 0
+};
+var SharedTile2DLayer = class extends import_core4.CompositeLayer {
+  /** Viewports currently known to this layer during multi-view rendering. */
+  _knownViewports = /* @__PURE__ */ new Map();
+  /** Internal layer state shared across render passes. */
+  state = null;
+  /** Initializes layer-owned tileset state. */
+  initializeState() {
+    this._knownViewports.clear();
+    if (this.context.viewport) {
+      this._knownViewports.set(this.context.viewport.id || "default", this.context.viewport);
+    }
+    this.state = {
+      tileset: null,
+      tilesetViews: /* @__PURE__ */ new Map(),
+      ownsTileset: false,
+      isLoaded: false,
+      frameNumbers: /* @__PURE__ */ new Map(),
+      tileLayers: /* @__PURE__ */ new Map(),
+      unsubscribeTilesetEvents: null
+    };
+  }
+  /** Finalizes owned resources and detaches from any shared tileset. */
+  finalizeState() {
+    var _a, _b, _c;
+    (_b = (_a = this.state).unsubscribeTilesetEvents) == null ? void 0 : _b.call(_a);
+    for (const tilesetView of this.state.tilesetViews.values()) {
+      tilesetView.finalize();
+    }
+    if (this.state.ownsTileset) {
+      (_c = this.state.tileset) == null ? void 0 : _c.finalize();
+    }
+  }
+  /** Returns whether all visible sub-layers for all tracked views are loaded. */
+  get isLoaded() {
+    const { tilesetViews, tileLayers } = this.state;
+    if (!tilesetViews.size) {
+      return false;
+    }
+    return Boolean(Array.from(tilesetViews.values()).every((tilesetView) => {
+      var _a;
+      return (_a = tilesetView.selectedTiles) == null ? void 0 : _a.every((tile) => {
+        const cachedLayers = tileLayers.get(tile.id);
+        return tile.isLoaded && (!tile.content || !cachedLayers || cachedLayers.every((layer) => layer.isLoaded));
+      });
+    }));
+  }
+  /** Triggers updates whenever props, data, or update triggers change. */
+  shouldUpdateState({ changeFlags }) {
+    return changeFlags.somethingChanged;
+  }
+  /** Creates, reuses, or reconfigures the backing shared tileset and per-view state. */
+  updateState({ changeFlags }) {
+    if (this.context.viewport) {
+      this._knownViewports.set(this._getViewportKey(), this.context.viewport);
+    }
+    const propsChanged = Boolean(changeFlags.propsOrDataChanged || changeFlags.updateTriggersChanged);
+    const dataChanged = changeFlags.dataChanged || changeFlags.updateTriggersChanged && (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged.getTileData);
+    let { tileset, ownsTileset } = this.state;
+    const nextExternalTileset = this.props.data instanceof SharedTileset2D ? this.props.data : null;
+    if (nextExternalTileset && !nextExternalTileset.adapter) {
+      nextExternalTileset.setOptions({ adapter: sharedTile2DDeckAdapter });
+    }
+    const nextOwnsTileset = !nextExternalTileset;
+    const nextTileset = this._resolveTileset(tileset, ownsTileset, nextExternalTileset);
+    const tilesetChanged = nextTileset !== tileset || nextOwnsTileset !== ownsTileset;
+    if (tilesetChanged) {
+      this._releaseTileset(tileset, ownsTileset);
+      tileset = nextTileset;
+      ownsTileset = nextOwnsTileset;
+      this.setState({
+        tileset,
+        tilesetViews: /* @__PURE__ */ new Map(),
+        ownsTileset,
+        tileLayers: /* @__PURE__ */ new Map(),
+        frameNumbers: /* @__PURE__ */ new Map(),
+        unsubscribeTilesetEvents: nextTileset.subscribe({
+          onTileLoad: this._onTileLoad.bind(this),
+          onTileError: this._onTileError.bind(this),
+          onTileUnload: this._onTileUnload.bind(this),
+          onUpdate: () => this.setNeedsUpdate(),
+          onError: (error) => this.raiseError(error, "loading TileSource metadata")
+        })
+      });
+    } else {
+      this._updateExistingTileset(propsChanged, ownsTileset, Boolean(dataChanged), nextTileset);
+    }
+    this._updateTileset();
+  }
+  /** Resolves whether to reuse a shared tileset, reuse an owned tileset, or create a new one. */
+  _resolveTileset(currentTileset, ownsCurrentTileset, nextExternalTileset) {
+    if (nextExternalTileset) {
+      return nextExternalTileset;
+    }
+    if (currentTileset && ownsCurrentTileset) {
+      return currentTileset;
+    }
+    return new this.props.TilesetClass(this._getTilesetOptions());
+  }
+  /** Tears down subscriptions and per-view state for the outgoing tileset. */
+  _releaseTileset(tileset, ownsTileset) {
+    var _a, _b;
+    (_b = (_a = this.state).unsubscribeTilesetEvents) == null ? void 0 : _b.call(_a);
+    for (const tilesetView of this.state.tilesetViews.values()) {
+      tilesetView.finalize();
+    }
+    if (ownsTileset) {
+      tileset == null ? void 0 : tileset.finalize();
+    }
+  }
+  /** Applies prop updates to an existing tileset without replacing it. */
+  _updateExistingTileset(propsChanged, ownsTileset, dataChanged, tileset) {
+    if (!propsChanged) {
+      return;
+    }
+    if (ownsTileset) {
+      tileset.setOptions(this._getTilesetOptions());
+      if (dataChanged) {
+        tileset.reloadAll();
+        return;
+      }
+    }
+    this.state.tileLayers.clear();
+  }
+  /** Resolves the current tileset configuration from layer props. */
+  _getTilesetOptions() {
+    const { tileSize, maxCacheSize, maxCacheByteSize, refinementStrategy, extent, maxZoom, minZoom, maxRequests, debounceTime, zoomOffset } = this.props;
+    const tileSource = isTileSource(this.props.data) ? this.props.data : void 0;
+    const options = {
+      tileSource,
+      adapter: sharedTile2DDeckAdapter,
+      getTileData: tileSource ? void 0 : this.getTileData.bind(this),
+      onTileLoad: () => {
+      },
+      onTileError: () => {
+      },
+      onTileUnload: () => {
+      }
+    };
+    this._assignTilesetOptionIfExplicit(options, "maxCacheSize", maxCacheSize, TILE2D_LAYER_DEFAULT_OPTION_VALUES.maxCacheSize);
+    this._assignTilesetOptionIfExplicit(options, "maxCacheByteSize", maxCacheByteSize, TILE2D_LAYER_DEFAULT_OPTION_VALUES.maxCacheByteSize);
+    this._assignTilesetOptionIfExplicit(options, "maxZoom", maxZoom, TILE2D_LAYER_DEFAULT_OPTION_VALUES.maxZoom);
+    this._assignTilesetOptionIfExplicit(options, "minZoom", minZoom, TILE2D_LAYER_DEFAULT_OPTION_VALUES.minZoom);
+    this._assignTilesetOptionIfExplicit(options, "tileSize", tileSize, TILE2D_LAYER_DEFAULT_OPTION_VALUES.tileSize);
+    this._assignTilesetOptionIfExplicit(options, "refinementStrategy", refinementStrategy, TILE2D_LAYER_DEFAULT_OPTION_VALUES.refinementStrategy);
+    this._assignTilesetOptionIfExplicit(options, "extent", extent, TILE2D_LAYER_DEFAULT_OPTION_VALUES.extent);
+    this._assignTilesetOptionIfExplicit(options, "maxRequests", maxRequests, TILE2D_LAYER_DEFAULT_OPTION_VALUES.maxRequests);
+    this._assignTilesetOptionIfExplicit(options, "debounceTime", debounceTime, TILE2D_LAYER_DEFAULT_OPTION_VALUES.debounceTime);
+    this._assignTilesetOptionIfExplicit(options, "zoomOffset", zoomOffset, TILE2D_LAYER_DEFAULT_OPTION_VALUES.zoomOffset);
+    return options;
+  }
+  /** Updates per-view traversal state for all known viewports. */
+  _updateTileset() {
+    const { zRange, modelMatrix } = this.props;
+    let anyTilesetChanged = false;
+    for (const [viewportKey, viewport] of this._knownViewports) {
+      this._prunePlaceholderViewportView(viewportKey);
+      const tilesetView = this._getOrCreateTilesetView(viewportKey);
+      const frameNumber = tilesetView.update(viewport, { zRange, modelMatrix });
+      const previousFrameNumber = this.state.frameNumbers.get(viewportKey);
+      const tilesetChanged = previousFrameNumber !== frameNumber;
+      anyTilesetChanged ||= tilesetChanged;
+      if (tilesetView.isLoaded && tilesetChanged) {
+        this._onViewportLoad(tilesetView);
+      }
+      if (tilesetChanged) {
+        this.state.frameNumbers.set(viewportKey, frameNumber);
+      }
+    }
+    const nextIsLoaded = this.isLoaded;
+    const loadingStateChanged = this.state.isLoaded !== nextIsLoaded;
+    if (loadingStateChanged) {
+      for (const tilesetView of this.state.tilesetViews.values()) {
+        if (tilesetView.isLoaded) {
+          this._onViewportLoad(tilesetView);
+        }
+      }
+    }
+    if (anyTilesetChanged) {
+      this.setState({ frameNumbers: new Map(this.state.frameNumbers) });
+    }
+    this.state.isLoaded = nextIsLoaded;
+  }
+  /** Emits the viewport-load callback for one view. */
+  _onViewportLoad(tilesetView) {
+    var _a, _b;
+    if (tilesetView.selectedTiles) {
+      (_b = (_a = this.props).onViewportLoad) == null ? void 0 : _b.call(_a, tilesetView.selectedTiles);
+    }
+  }
+  /** Clears cached sub-layers when a tile loads. */
+  _onTileLoad(tile) {
+    this.state.tileLayers.delete(tile.id);
+    this.props.onTileLoad(tile);
+    this.setNeedsUpdate();
+  }
+  /** Clears cached sub-layers when a tile errors. */
+  _onTileError(error, tile) {
+    this.state.tileLayers.delete(tile.id);
+    this.props.onTileError(error, tile);
+    this.setNeedsUpdate();
+  }
+  /** Removes cached sub-layers when a tile is evicted. */
+  _onTileUnload(tile) {
+    this.state.tileLayers.delete(tile.id);
+    this.props.onTileUnload(tile);
+  }
+  /** Calls the URL-template loader path for a tile when the layer owns the tileset. */
+  getTileData(tile) {
+    const { data, getTileData, fetch } = this.props;
+    const { signal } = tile;
+    if (!isURLTemplate(data)) {
+      return null;
+    }
+    tile.url = getURLFromTemplate(data, tile);
+    if (getTileData) {
+      return getTileData(tile);
+    }
+    if (fetch && tile.url) {
+      return fetch(tile.url, { propName: "data", layer: this, signal });
+    }
+    return null;
+  }
+  /** Default tile sub-layer renderer, delegating to `renderSubLayers`. */
+  renderSubLayers(props) {
+    return this.props.renderSubLayers(props);
+  }
+  /** Hook for subclasses to provide extra sub-layer props per tile. */
+  getSubLayerPropsByTile(_tile) {
+    return null;
+  }
+  /** Adds tile references to picking info returned from sub-layers. */
+  getPickingInfo(params) {
+    const { sourceLayer } = params;
+    if (!sourceLayer) {
+      throw new Error("SharedTile2DLayer picking info requires a source layer.");
+    }
+    const sourceTile = sourceLayer.props.tile;
+    const info = params.info;
+    if (info.picked) {
+      info.tile = sourceTile;
+    }
+    info.sourceTile = sourceTile;
+    info.sourceTileSubLayer = sourceLayer;
+    return info;
+  }
+  /** Forwards auto-highlight updates to the picked sub-layer. */
+  _updateAutoHighlight(info) {
+    info.sourceTileSubLayer.updateAutoHighlight(info);
+  }
+  /** Renders cached or newly generated sub-layers for each loaded tile. */
+  renderLayers() {
+    const { tileset, tileLayers } = this.state;
+    if (!tileset) {
+      return null;
+    }
+    return tileset.tiles.map((tile) => {
+      const subLayerProps = this.getSubLayerPropsByTile(tile);
+      let layers = tileLayers.get(tile.id);
+      if (!tile.isLoaded && !tile.content) {
+        return layers;
+      }
+      if (!layers) {
+        const rendered = this.renderSubLayers({
+          ...this.props,
+          ...this.getSubLayerProps({
+            id: tile.id,
+            updateTriggers: this.props.updateTriggers
+          }),
+          data: tile.content,
+          _offset: 0,
+          tile
+        });
+        layers = this._flattenTileLayers(rendered).map((layer) => layer.clone({ tile, ...subLayerProps }));
+        tileLayers.set(tile.id, layers);
+      } else if (subLayerProps && layers[0] && Object.keys(subLayerProps).some((propName) => layers[0].props[propName] !== subLayerProps[propName])) {
+        layers = layers.map((layer) => layer.clone(subLayerProps));
+        tileLayers.set(tile.id, layers);
+      }
+      return layers;
+    });
+  }
+  /** Filters tile sub-layers based on the active view-specific visibility state. */
+  filterSubLayer({ layer, cullRect }) {
+    const { tile } = layer.props;
+    const tilesetView = this._getOrCreateTilesetView(this._getViewportKey());
+    return tilesetView.isTileVisible(tile, cullRect, this.props.modelMatrix ? new import_core5.Matrix4(this.props.modelMatrix) : null);
+  }
+  /** Returns the active viewport key used to isolate per-view traversal state. */
+  _getViewportKey() {
+    var _a;
+    return ((_a = this.context.viewport) == null ? void 0 : _a.id) || "default";
+  }
+  /** Copies a tileset option only when the layer prop was explicitly set. */
+  _assignTilesetOptionIfExplicit(options, key, value, defaultValue) {
+    if (!this._isDefaultOptionValue(value, defaultValue)) {
+      options[key] = value;
+    }
+  }
+  /** Tests whether a layer prop still has its default value. */
+  _isDefaultOptionValue(value, defaultValue) {
+    if (Array.isArray(value) || Array.isArray(defaultValue)) {
+      return Array.isArray(value) && Array.isArray(defaultValue) && value.length === defaultValue.length && value.every((entry, index) => entry === defaultValue[index]);
+    }
+    return value === defaultValue;
+  }
+  /** Drops the bootstrap placeholder viewport after a real viewport is known. */
+  _prunePlaceholderViewportView(viewportKey) {
+    const placeholderViewportKey = "DEFAULT-INITIAL-VIEWPORT";
+    if (viewportKey !== placeholderViewportKey) {
+      const placeholderView = this.state.tilesetViews.get(placeholderViewportKey);
+      if (placeholderView) {
+        placeholderView.finalize();
+        this.state.tilesetViews.delete(placeholderViewportKey);
+        this.state.frameNumbers.delete(placeholderViewportKey);
+      }
+    }
+  }
+  /** Returns the per-viewport traversal state, creating it on demand. */
+  _getOrCreateTilesetView(viewportKey) {
+    let tilesetView = this.state.tilesetViews.get(viewportKey);
+    if (!tilesetView) {
+      const tileset = this.state.tileset;
+      if (!tileset) {
+        throw new Error("SharedTile2DLayer tileset was not initialized.");
+      }
+      tilesetView = new SharedTile2DView(tileset);
+      this.state.tilesetViews.set(viewportKey, tilesetView);
+    }
+    return tilesetView;
+  }
+  /** Registers additional viewports in multi-view rendering scenarios. */
+  activateViewport(viewport) {
+    const viewportKey = viewport.id || "default";
+    const previousViewport = this._knownViewports.get(viewportKey);
+    this._knownViewports.set(viewportKey, viewport);
+    if (!previousViewport || !viewport.equals(previousViewport)) {
+      this.setNeedsUpdate();
+    }
+    super.activateViewport(viewport);
+  }
+  /** Normalizes nested render output into a flat tile sub-layer array. */
+  _flattenTileLayers(rendered) {
+    return (0, import_core4._flatten)(rendered, Boolean);
+  }
+};
+/** Layer default props consumed by deck.gl prop management. */
+__publicField(SharedTile2DLayer, "defaultProps", defaultProps);
+/** Stable layer name used in logs and devtools. */
+__publicField(SharedTile2DLayer, "layerName", "SharedTile2DLayer");
+
+// dist/tile-grid-layer/tile-grid-layer.js
+var import_core6 = require("@deck.gl/core");
+var import_layers3 = require("@deck.gl/layers");
+var defaultProps2 = {
+  tile: { type: "object", value: void 0 },
+  showBorder: true,
+  showLabel: true,
+  getLabel: {
+    type: "function",
+    value: (tile) => `z${tile.index.z} x${tile.index.x} y${tile.index.y}`
+  },
+  borderColor: [255, 255, 255, 180],
+  labelColor: [255, 255, 255, 255],
+  labelBackgroundColor: [15, 23, 42, 210],
+  borderWidthMinPixels: 1,
+  labelSize: 12
+};
+function getTilePath(bbox) {
+  if ("west" in bbox) {
+    return [
+      [bbox.west, bbox.north],
+      [bbox.west, bbox.south],
+      [bbox.east, bbox.south],
+      [bbox.east, bbox.north],
+      [bbox.west, bbox.north]
+    ];
+  }
+  return [
+    [bbox.left, bbox.top],
+    [bbox.left, bbox.bottom],
+    [bbox.right, bbox.bottom],
+    [bbox.right, bbox.top],
+    [bbox.left, bbox.top]
+  ];
+}
+function getTileCenter(bbox) {
+  if ("west" in bbox) {
+    return [(bbox.west + bbox.east) / 2, (bbox.north + bbox.south) / 2];
+  }
+  return [(bbox.left + bbox.right) / 2, (bbox.top + bbox.bottom) / 2];
+}
+var TileGridLayer = class extends import_core6.CompositeLayer {
+  /** Builds the tile border and label sublayers. */
+  renderLayers() {
+    const { tile, showBorder, showLabel, getLabel, borderColor, labelColor, labelBackgroundColor, borderWidthMinPixels, labelSize } = this.props;
+    const item = {
+      path: getTilePath(tile.bbox),
+      center: getTileCenter(tile.bbox),
+      label: typeof getLabel === "function" ? getLabel(tile) : getLabel
+    };
+    return [
+      showBorder ? new import_layers3.PathLayer(this.getSubLayerProps({
+        id: "border"
+      }), {
+        data: [item],
+        getPath: (d) => d.path,
+        getColor: borderColor,
+        widthMinPixels: borderWidthMinPixels,
+        pickable: false
+      }) : null,
+      showLabel ? new import_layers3.TextLayer(this.getSubLayerProps({
+        id: "label"
+      }), {
+        data: [item],
+        getPosition: (d) => d.center,
+        getText: (d) => d.label,
+        getColor: labelColor,
+        getBackgroundColor: labelBackgroundColor,
+        getSize: labelSize,
+        sizeUnits: "pixels",
+        background: true,
+        getTextAnchor: "middle",
+        getAlignmentBaseline: "center",
+        pickable: false
+      }) : null
+    ];
+  }
+};
+__publicField(TileGridLayer, "layerName", "TileGridLayer");
+__publicField(TileGridLayer, "defaultProps", defaultProps2);
+
 // dist/global-grid-layer/global-grid-layer.js
 var import_geo_layers2 = require("@deck.gl/geo-layers");
 
@@ -575,7 +2367,7 @@ function getGeohashBounds(geohash) {
 }
 
 // dist/global-grid-systems/grids/quadkey-grid.js
-var TILE_SIZE = 512;
+var TILE_SIZE3 = 512;
 var QuadkeyGrid = {
   name: "quadkey",
   hasNumericRepresentation: true,
@@ -614,7 +2406,7 @@ function quadkeyToWorldBounds(quadkey) {
   let x = 0;
   let y = 0;
   let mask = 1 << quadkey.length;
-  const scale = mask / TILE_SIZE;
+  const scale = mask / TILE_SIZE3;
   for (let i = 0; i < quadkey.length; i++) {
     mask >>= 1;
     const q = parseInt(quadkey[i], 10);
@@ -624,8 +2416,8 @@ function quadkeyToWorldBounds(quadkey) {
       y |= mask;
   }
   return [
-    [x / scale, TILE_SIZE - y / scale],
-    [(x + 0.99) / scale, TILE_SIZE - (y + 0.99) / scale]
+    [x / scale, TILE_SIZE3 - y / scale],
+    [(x + 0.99) / scale, TILE_SIZE3 - (y + 0.99) / scale]
   ];
 }
 var PI = Math.PI;
@@ -633,8 +2425,8 @@ var PI_4 = PI / 4;
 var RADIANS_TO_DEGREES = 180 / PI;
 function worldToLngLat(xy) {
   const [x, y] = xy;
-  const lambda2 = x / TILE_SIZE * (2 * PI) - PI;
-  const phi2 = 2 * (Math.atan(Math.exp(y / TILE_SIZE * (2 * PI) - PI)) - PI_4);
+  const lambda2 = x / TILE_SIZE3 * (2 * PI) - PI;
+  const phi2 = 2 * (Math.atan(Math.exp(y / TILE_SIZE3 * (2 * PI) - PI)) - PI_4);
   return [lambda2 * RADIANS_TO_DEGREES, phi2 * RADIANS_TO_DEGREES];
 }
 //# sourceMappingURL=index.cjs.map