leaflet-city-mapper 0.0.3 → 0.0.5

package/src/animations/runCameraAnimations.js

@@ -0,0 +1,33 @@
+import { cameraAnimationByMap } from '../weakmaps/cameraAnimationByMap.js';
+import { cameraFrameByMap } from '../weakmaps/cameraFrameByMap.js';
+
+import { cameraAnimationFrame } from '../globals/cameraAnimationFrame.js';
+import { cameraAnimations } from '../globals/cameraAnimations.js';
+
+import { mapSetPitchAndBearing } from '../camera/mapSetPitchAndBearing.js';
+
+
+import { scheduleCameraAnimation } from './scheduleCameraAnimation.js';
+
+export function runCameraAnimations(now) {
+  cameraAnimationFrame.value = null;
+  const pending = /* alloc */ [...cameraAnimations];
+  cameraAnimations.clear();
+  let failure;
+  let map, animation, progress, eased;
+  for ([map, animation] of pending) {
+    cameraFrameByMap.set(map, null);
+    if (cameraAnimationByMap.get(map) !== animation) continue;
+    progress = animation.duration
+      ? Math.min(1, (now - animation.start) / (animation.duration * 1000)) : 1;
+    eased = 1 - (1 - progress) ** 3;
+    try {
+      mapSetPitchAndBearing(map, animation.fromPitch + (Math.max(0, Math.min(map.options.maxPitch, animation.pitch)) - animation.fromPitch) * eased, animation.fromBearing + animation.delta * eased);
+      if (progress < 1 && cameraAnimationByMap.get(map) === animation) scheduleCameraAnimation(map, animation);
+      else if (cameraAnimationByMap.get(map) === animation) cameraAnimationByMap.set(map, null);
+    } catch (error) {
+      failure ||= error;
+    }
+  }
+  if (failure) throw failure;
+}

package/src/animations/runGridFades.js

@@ -0,0 +1,20 @@
+import { fadeFrameByLayer } from '../weakmaps/fadeFrameByLayer.js';
+
+import { gridFadeFrame } from '../globals/gridFadeFrame.js';
+import { pendingGridFades } from '../globals/pendingGridFades.js';
+
+
+
+import { updateGridOpacity } from '../core/updateGridOpacity.js';
+
+export function runGridFades() {
+  gridFadeFrame.value = null;
+  const layers = /* alloc */ [...pendingGridFades];
+  let layer, version;
+  for ([layer, version] of layers) {
+    if (pendingGridFades.get(layer) !== version) continue;
+    pendingGridFades.delete(layer);
+    fadeFrameByLayer.set(layer, null);
+    updateGridOpacity.call(layer);
+  }
+}

package/src/animations/runMarkerPanFrame.js

@@ -0,0 +1,14 @@
+import { markerPanFrame } from '../globals/markerPanFrame.js';
+import { pendingMarkerPan } from '../globals/pendingMarkerPan.js';
+
+
+export function runMarkerPanFrame() {
+  markerPanFrame.value = null;
+  const pending = /* alloc */ [...pendingMarkerPan];
+  pendingMarkerPan.clear();
+  let drag, event;
+  for ([drag, event] of pending) {
+    drag._panRequest = null;
+    drag._adjustPan(event);
+  }
+}

package/src/animations/scheduleCameraAnimation.js

@@ -0,0 +1,14 @@
+import { cameraFrameByMap } from '../weakmaps/cameraFrameByMap.js';
+
+import { cameraAnimations } from '../globals/cameraAnimations.js';
+import { cameraAnimationFrame } from '../globals/cameraAnimationFrame.js';
+
+
+
+import { runCameraAnimations } from './runCameraAnimations.js';
+
+export function scheduleCameraAnimation(map, animation) {
+  cameraAnimations.set(map, animation);
+  if (cameraAnimationFrame.value === null) cameraAnimationFrame.value = requestAnimationFrame(runCameraAnimations);
+  cameraFrameByMap.set(map, cameraAnimationFrame.value);
+}

package/src/animations/scheduleGridFade.js

@@ -0,0 +1,16 @@
+import { fadeFrameByLayer } from '../weakmaps/fadeFrameByLayer.js';
+import { fadeVersionByLayer } from '../weakmaps/fadeVersionByLayer.js';
+
+import { pendingGridFades } from '../globals/pendingGridFades.js';
+import { gridFadeFrame } from '../globals/gridFadeFrame.js';
+
+
+
+import { runGridFades } from './runGridFades.js';
+
+export function scheduleGridFade(layer) {
+  fadeVersionByLayer.set(layer, (fadeVersionByLayer.get(layer) || 0) + 1);
+  pendingGridFades.set(layer, fadeVersionByLayer.get(layer));
+  if (gridFadeFrame.value === null) gridFadeFrame.value = requestAnimationFrame(runGridFades);
+  fadeFrameByLayer.set(layer, gridFadeFrame.value);
+}

package/src/animations/scheduleMarkerPan.js

@@ -0,0 +1,11 @@
+import { pendingMarkerPan } from '../globals/pendingMarkerPan.js';
+import { markerPanFrame } from '../globals/markerPanFrame.js';
+
+
+import { runMarkerPanFrame } from './runMarkerPanFrame.js';
+
+export function scheduleMarkerPan(drag, event) {
+  pendingMarkerPan.set(drag, event);
+  if (markerPanFrame.value === null) markerPanFrame.value = requestAnimationFrame(runMarkerPanFrame);
+  drag._panRequest = markerPanFrame.value;
+}

package/src/{scene → animations}/startZoom.js

@@ -1,5 +1,9 @@
+import { zoomLevelByLayer } from '../weakmaps/zoomLevelByLayer.js';
+
+
+
 /** Preserve the outgoing tile level before Leaflet changes its logical zoom. */
 
 export function startZoom() {
-  this._zoomLevel = null;
+  zoomLevelByLayer.set(this, null);
 }

package/src/animations/synchronizeZoomView.js

@@ -0,0 +1,28 @@
+import { zoomTransitionsByLayer } from '../weakmaps/zoomTransitionsByLayer.js';
+import { zoomViewByLayer } from '../weakmaps/zoomViewByLayer.js';
+
+import { meshStack } from '../globals/meshStack.js';
+import { updateZoomCamera } from './updateZoomCamera.js';
+
+export function synchronizeZoomView(layer, now) {
+  const map = layer._map;
+  let animation, time, start;
+  if (map._animatingZoom) {
+    if (!zoomTransitionsByLayer.get(layer)) zoomTransitionsByLayer.set(layer, /* alloc */ new Map());
+    for (animation of map.getContainer().getAnimations(meshStack)) {
+      if (!(animation instanceof CSSTransition) || animation.transitionProperty !== 'transform' ||
+        !animation.effect.target.classList.contains('leaflet-zoom-animated') ||
+        zoomTransitionsByLayer.get(layer).has(animation)) {
+        continue;
+      }
+      time = animation.currentTime || 0;
+      animation.pause();
+      zoomTransitionsByLayer.get(layer).set(animation, /* alloc */ { start: now, time });
+    }
+    // Freeze CSS between rendered frames: the compositor must not outrun the canvas.
+    for ([animation, { start, time }] of zoomTransitionsByLayer.get(layer)) {
+      animation.currentTime = Math.min(animation.effect.getComputedTiming().endTime, time + now - start);
+    }
+    if (zoomViewByLayer.get(layer)) updateZoomCamera(layer, now);
+  }
+}

package/src/animations/updateZoomCamera.js

@@ -0,0 +1,21 @@
+import { zoomTransitionsByLayer } from '../weakmaps/zoomTransitionsByLayer.js';
+import { zoomViewByLayer } from '../weakmaps/zoomViewByLayer.js';
+import { cameraViewByMap } from '../weakmaps/cameraViewByMap.js';
+
+
+import { mapUpdateCameraOverlays } from '../camera/mapUpdateCameraOverlays.js';
+
+export function updateZoomCamera(layer, now) {
+  const map = layer._map;
+  const view = zoomViewByLayer.get(layer);
+  let proxy, animation;
+  for (animation of zoomTransitionsByLayer.get(layer).keys()) {
+    if (animation.effect.target === map._proxy) { proxy = animation; break; }
+  }
+  const progress = proxy?.effect.getComputedTiming().progress ?? Math.min(1, (now - view.start) / 250);
+  const targetScale = map.getZoomScale(view.targetZoom, view.zoom), scale = 1 + (targetScale - 1) * progress;
+  const from = map.project(view.from, view.zoom), to = map.project(view.to, view.zoom);
+  cameraViewByMap.set(map, /* alloc */ { zoom: map.getScaleZoom(scale, view.zoom),
+    center: map.unproject(from.add(to.subtract(from).multiplyBy(targetScale * progress / scale)), view.zoom) });
+  mapUpdateCameraOverlays(map);
+}

package/src/archives/decodeDirectory.js

@@ -1,32 +1,50 @@
-import { varint } from './varint.js';
+import { directoryReader } from '../globals/directoryReader.js';
+import { varint } from './readVarint.js';
+
 /** Decode delta/varint directory columns, rejecting malformed entries. */
 
 export function decodeDirectory(data) {
-  const bytes = new Uint8Array(data);
-  const reader = { bytes, cursor: 0 };
-  const count = varint(reader);
-  if (count > (bytes.length - reader.cursor) / 4) throw new Error('Invalid PMTiles directory count');
-  const entries = [];
-  let tileId = 0;
-  let i, entry, value;
-  for (i = 0; i < count; i++) {
-    tileId += varint(reader);
-    if (!Number.isSafeInteger(tileId) || (i && tileId <= entries[i - 1].tileId)) {
-      throw new Error('Invalid PMTiles directory tile IDs');
+  const reader = directoryReader;
+  const bytes = /* alloc */ new Uint8Array(data);
+  reader.bytes = bytes;
+  reader.cursor = 0;
+  try {
+    const count = varint(reader);
+    if (count > (bytes.length - reader.cursor) / 4) {
+      throw /* alloc */ new Error('Invalid PMTiles directory count');
     }
-    entries.push({ tileId });
-  }
-  for (entry of entries) entry.runLength = varint(reader);
-  for (entry of entries) {
-    entry.length = varint(reader);
-    if (!entry.length) throw new Error('Invalid PMTiles directory length');
-  }
-  for (i = 0; i < entries.length; i++) {
-    entry = entries[i];
-    value = varint(reader);
-    if (!value && !i) throw new Error('Invalid PMTiles directory offset');
-    entry.offset = value ? value - 1 : entries[i - 1].offset + entries[i - 1].length;
+    const entries = /* alloc */ new Array(count);
+    let tileId = 0;
+    let i, entry, value;
+    for (i = 0; i < count; i++) {
+      tileId += varint(reader);
+      if (!Number.isSafeInteger(tileId) || (i && tileId <= entries[i - 1].tileId)) {
+        throw /* alloc */ new Error('Invalid PMTiles directory tile IDs');
+      }
+      entries[i] = /* alloc */ { tileId, runLength: 0, length: 0, offset: 0 };
+    }
+    for (entry of entries) entry.runLength = varint(reader);
+    for (entry of entries) {
+      entry.length = varint(reader);
+      if (!entry.length) {
+        throw /* alloc */ new Error('Invalid PMTiles directory length');
+      }
+    }
+    for (i = 0; i < entries.length; i++) {
+      entry = entries[i];
+      value = varint(reader);
+      if (!value && !i) {
+        throw /* alloc */ new Error('Invalid PMTiles directory offset');
+      }
+      entry.offset = value ? value - 1 : entries[i - 1].offset + entries[i - 1].length;
+    }
+    if (reader.cursor !== bytes.length) {
+      throw /* alloc */ new Error('Trailing PMTiles directory data');
+    }
+    return entries;
+  } finally {
+    // Decoding is synchronous; release the input before reusing this reader.
+    reader.bytes = null;
+    reader.cursor = 0;
   }
-  if (reader.cursor !== bytes.length) throw new Error('Trailing PMTiles directory data');
-  return entries;
 }

package/src/archives/decodeHeader.js

@@ -1,17 +1,21 @@
-/** Decode the PMTiles v3 header. */
+import { headerOffsets } from '../globals/headerOffsets.js';
+import { headerFlags } from '../globals/headerFlags.js';
+import { headerBounds } from '../globals/headerBounds.js';
+
 
+/** Decode the PMTiles v3 header. */
 export function decodeHeader(data) {
-  if (data.byteLength < 127 || new TextDecoder().decode(new Uint8Array(data, 0, 7)) !== 'PMTiles' ||
-    new Uint8Array(data)[7] !== 3) throw new Error('Expected a PMTiles v3 archive');
-  const view = new DataView(data);
-  const header = {};
-  const offsets = ['rootDirectoryOffset', 'rootDirectoryLength', 'jsonMetadataOffset', 'jsonMetadataLength', 'leafDirectoryOffset', 'leafDirectoryLength', 'tileDataOffset', 'tileDataLength', 'numAddressedTiles', 'numTileEntries', 'numTileContents'];
-  const flags = ['clustered', 'internalCompression', 'tileCompression', 'tileType', 'minZoom', 'maxZoom'];
-  const bounds = ['minLon', 'minLat', 'maxLon', 'maxLat'];
+  const view = data.byteLength >= 127
+    ? /* alloc */ new DataView(data) : null;
+  // "PMTiles" followed by version 3, read as two little-endian words.
+  if (!view || view.getUint32(0, true) !== 0x69544d50 || view.getUint32(4, true) !== 0x0373656c) {
+    throw /* alloc */ new Error('Expected a PMTiles v3 archive');
+  }
+  const header = /* alloc */ {};
   let i;
-  for (i = 0; i < offsets.length; i++) header[offsets[i]] = Number(view.getBigUint64(8 + i * 8, true));
-  for (i = 0; i < flags.length; i++) header[flags[i]] = view.getUint8(96 + i);
-  for (i = 0; i < bounds.length; i++) header[bounds[i]] = view.getInt32(102 + i * 4, true) / 1e7;
+  for (i = 0; i < headerOffsets.length; i++) header[headerOffsets[i]] = Number(view.getBigUint64(8 + i * 8, true));
+  for (i = 0; i < headerFlags.length; i++) header[headerFlags[i]] = view.getUint8(96 + i);
+  for (i = 0; i < headerBounds.length; i++) header[headerBounds[i]] = view.getInt32(102 + i * 4, true) / 1e7;
   header.centerZoom = view.getUint8(118);
   header.centerLon = view.getInt32(119, true) / 1e7;
   header.centerLat = view.getInt32(123, true) / 1e7;

package/src/archives/decompress.js

@@ -1,5 +1,10 @@
 export async function decompress(data, compression) {
   if (compression === 1) return data;
-  if (compression !== 2) throw new Error(`Unsupported PMTiles compression: ${compression}`);
-  return new Response(new Blob([data]).stream().pipeThrough(new DecompressionStream('gzip'))).arrayBuffer();
+  if (compression !== 2) {
+    throw /* alloc */ new Error(`Unsupported PMTiles compression: ${compression}`);
+  }
+  const blob = /* alloc */ new Blob(
+    /* alloc */ [data]);
+  const stream = /* alloc */ new DecompressionStream('gzip');
+  return /* alloc */ new Response(blob.stream().pipeThrough(stream)).arrayBuffer();
 }

package/src/archives/findDirectoryEntry.js

@@ -0,0 +1,9 @@
+export function findDirectoryEntry(entries, id) {
+  let low = 0, high = entries.length - 1, mid;
+  while (low <= high) {
+    mid = (low + high) >> 1;
+    if (entries[mid].tileId <= id) low = mid + 1;
+    else high = mid - 1;
+  }
+  return entries[high];
+}

package/src/archives/findTile.js

@@ -0,0 +1,31 @@
+import { getDirectoryEntries } from './getDirectoryEntries.js';
+import { findDirectoryEntry } from './findDirectoryEntry.js';
+import { getTileData } from './getTileData.js';
+
+export async function findTile(layer, header, id, signal) {
+  let offset = header.rootDirectoryOffset, length = header.rootDirectoryLength;
+  let firstOffset = -1, secondOffset = -1, thirdOffset = -1;
+  let depth, entries, entry, tile;
+  for (depth = 0; depth < 4; depth++) {
+    if (offset === firstOffset || offset === secondOffset || offset === thirdOffset) {
+      throw /* alloc */ new Error('Cyclic PMTiles directory');
+    }
+    if (depth === 0) firstOffset = offset;
+    else if (depth === 1) secondOffset = offset;
+    else if (depth === 2) thirdOffset = offset;
+    entries = await getDirectoryEntries(layer, offset, length, header.internalCompression);
+    signal?.throwIfAborted();
+    entry = findDirectoryEntry(entries, id);
+    if (!entry) return;
+    if (entry.runLength) {
+      tile = await getTileData(layer, header, entry, id, signal);
+      return tile;
+    }
+    if (entry.offset + entry.length > header.leafDirectoryLength) {
+      throw /* alloc */ new Error('PMTiles directory outside leaf section');
+    }
+    offset = header.leafDirectoryOffset + entry.offset;
+    length = entry.length;
+  }
+  throw /* alloc */ new Error('PMTiles directory depth exceeds four levels');
+}

package/src/archives/getDirectoryEntries.js

@@ -0,0 +1,19 @@
+import { directoriesByLayer } from '../weakmaps/directoriesByLayer.js';
+
+import { loadDirectory } from './loadDirectory.js';
+
+export async function getDirectoryEntries(layer, offset, length, compression) {
+  const directories = directoriesByLayer.get(layer);
+  const key = `${offset}:${length}`;
+  if (!directories.has(key)) {
+    if (directories.size >= 32) directories.delete(directories.keys().next().value);
+    directories.set(key, loadDirectory(layer, offset, length, compression));
+  }
+  const pending = directories.get(key);
+  try {
+    return await pending;
+  } catch (error) {
+    if (directories.get(key) === pending) directories.delete(key);
+    throw error;
+  }
+}

package/src/archives/getHeader.js

@@ -1,9 +1,17 @@
+import { archiveHeaderByLayer } from '../weakmaps/archiveHeaderByLayer.js';
+import { sceneLayers } from '../weakmaps/sceneLayers.js';
 import { decodeHeader } from './decodeHeader.js';
-import { read } from './read.js';
+import { read } from './readArchiveRange.js';
 
 /** Cache header initialization; failures remain visible to all callers. */
 
-export function getHeader(backend) {
-  if (backend.options.archive && backend.options.archive !== backend) return backend.options.archive.getHeader();
-  return backend._header ||= read(backend, 0, 127).then(decodeHeader);
+export function getHeader(layer) {
+  if (!sceneLayers.has(layer)) return layer.getHeader();
+  if (layer.options.archive && layer.options.archive !== layer) return getHeader(layer.options.archive);
+  let header = archiveHeaderByLayer.get(layer);
+  if (!header) {
+    header = read(layer, 0, 127).then(decodeHeader);
+    archiveHeaderByLayer.set(layer, header);
+  }
+  return header;
 }

package/src/archives/getTileData.js

@@ -0,0 +1,13 @@
+import { decompress } from './decompress.js';
+import { read } from './readArchiveRange.js';
+
+export async function getTileData(layer, header, entry, id, signal) {
+  if (id - entry.tileId >= entry.runLength) return;
+  if (entry.offset + entry.length > header.tileDataLength) {
+    throw /* alloc */ new Error('PMTiles tile outside data section');
+  }
+  const data = await decompress(await read(layer, header.tileDataOffset + entry.offset, entry.length, signal),
+    header.tileCompression);
+  signal?.throwIfAborted();
+  return /* alloc */ { data };
+}

package/src/archives/getZxy.js

@@ -1,75 +1,20 @@
-import { loadDirectory } from './loadDirectory.js';
-import { decompress } from './decompress.js';
+import { sceneLayers } from '../weakmaps/sceneLayers.js';
+
 import { tileId } from './tileId.js';
-import { read } from './read.js';
 import { getHeader } from './getHeader.js';
+import { findTile } from './findTile.js';
 
 /** Nearest directory entry at/before the Hilbert ID, then follow leaf pointers. */
 
-export async function getZxy(backend, z, x, y, signal) {
-  if (backend.options.archive && backend.options.archive !== backend && backend.options.archive.getZxy) {
-    return backend.options.archive.getZxy(z, x, y, signal);
+export async function getZxy(layer, z, x, y, signal) {
+  if (!sceneLayers.has(layer)) return layer.getZxy(z, x, y, signal);
+  if (layer.options.archive && layer.options.archive !== layer) {
+    return getZxy(layer.options.archive, z, x, y, signal);
   }
   const id = tileId(z, x, y);
   signal?.throwIfAborted();
-  const header = await getHeader(backend);
+  const header = await getHeader(layer);
   signal?.throwIfAborted();
-  if (z < header.minZoom || z > header.maxZoom) {
-    return;
-  }
-  let offset = header.rootDirectoryOffset, length = header.rootDirectoryLength;
-  const visited = new Set();
-  let depth, key, pending, entries, low, high, mid, entry, data;
-  for (depth = 0; depth < 4; depth++) {
-    if (visited.has(offset)) {
-      throw new Error('Cyclic PMTiles directory');
-    }
-    visited.add(offset);
-    key = `${offset}:${length}`;
-    if (!backend._directories.has(key)) {
-      if (backend._directories.size >= 32) {
-        backend._directories.delete(backend._directories.keys().next().value);
-      }
-      backend._directories.set(key, loadDirectory(backend, offset, length, header.internalCompression));
-    }
-    pending = backend._directories.get(key);
-    entries = void 0;
-    try {
-      entries = await pending;
-    } catch (error) {
-      if (backend._directories.get(key) === pending) backend._directories.delete(key);
-      throw error;
-    }
-    signal?.throwIfAborted();
-    low = 0, high = entries.length - 1;
-    while (low <= high) {
-      mid = (low + high) >> 1;
-      if (entries[mid].tileId <= id) {
-        low = mid + 1;
-      } else {
-        high = mid - 1;
-      }
-    }
-    entry = entries[high];
-    if (!entry) {
-      return;
-    }
-    if (entry.runLength) {
-      if (id - entry.tileId >= entry.runLength) {
-        return;
-      }
-      if (entry.offset + entry.length > header.tileDataLength) {
-        throw new Error('PMTiles tile outside data section');
-      }
-      data = await decompress(await read(backend, header.tileDataOffset + entry.offset, entry.length, signal), header.tileCompression);
-      signal?.throwIfAborted();
-      return { data };
-    }
-    if (entry.offset + entry.length > header.leafDirectoryLength) {
-      throw new Error('PMTiles directory outside leaf section');
-    }
-    offset = header.leafDirectoryOffset + entry.offset;
-    length = entry.length;
-  }
-  throw new Error('PMTiles directory depth exceeds four levels');
+  if (z < header.minZoom || z > header.maxZoom) return;
+  return findTile(layer, header, id, signal);
 }

package/src/archives/loadDirectory.js

@@ -1,7 +1,7 @@
 import { decodeDirectory } from "./decodeDirectory.js";
 import { decompress } from "./decompress.js";
-import { read } from "./read.js";
+import { read } from "./readArchiveRange.js";
 
-export async function loadDirectory(backend, offset, length, compression) {
-  return decodeDirectory(await decompress(await read(backend, offset, length), compression));
+export async function loadDirectory(layer, offset, length, compression) {
+  return decodeDirectory(await decompress(await read(layer, offset, length), compression));
 }

package/src/archives/loadSource.js

@@ -1,17 +1,32 @@
+import { geojsonByLayer } from '../weakmaps/geojsonByLayer.js';
+
+import { archiveDecoder } from '../globals/archiveDecoder.js';
+
 import { getZxy } from './getZxy.js';
 
-export async function loadSource(backend, area) {
-  if (backend._geojson) {
-    const { data, url } = backend.options;
-    if (data !== undefined && url) throw new Error('GeoJSON source requires either data or url');
+
+export async function loadSource(layer, area) {
+  if (geojsonByLayer.get(layer)) {
+    const { data, url } = layer.options;
+    if (data !== undefined && url) {
+      throw /* alloc */ new Error('GeoJSON source requires either data or url');
+    }
     if (data !== undefined) return data;
-    if (!url) throw new Error('GeoJSON source requires either data or url');
-    const response = await fetch(new URL(url, document.baseURI), { signal: area.request.signal });
-    if (!response.ok) throw new Error(`Unable to load GeoJSON: HTTP ${response.status}`);
+    if (!url) {
+      throw /* alloc */ new Error('GeoJSON source requires either data or url');
+    }
+    const sourceUrl = /* alloc */ new URL(url, document.baseURI);
+    const response = await fetch(sourceUrl, /* alloc */ { signal: area.request.signal });
+    if (!response.ok) {
+      throw /* alloc */ new Error(`Unable to load GeoJSON: HTTP ${response.status}`);
+    }
     return response.json();
   }
-  const result = await getZxy(backend, area.coords.z, area.coords.x, area.coords.y, area.request.signal);
+  const result = await getZxy(layer, area.coords.z, area.coords.x, area.coords.y, area.request.signal);
   return result
-    ? JSON.parse(new TextDecoder().decode(result.data))
-    : { type: 'FeatureCollection', features: [] };
+    ? JSON.parse(archiveDecoder.decode(result.data))
+    : /* alloc */ {
+      type: 'FeatureCollection',
+      features: /* alloc */ [],
+    };
 }

package/src/archives/readArchiveRange.js

@@ -0,0 +1,34 @@
+import { etagByLayer } from '../weakmaps/etagByLayer.js';
+import { urlByLayer } from '../weakmaps/urlByLayer.js';
+
+
+
+export async function read(layer, offset, length, signal) {
+  signal?.throwIfAborted();
+  if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) ||
+    offset < 0 || length <= 0 || !Number.isSafeInteger(offset + length)) {
+    throw /* alloc */ new Error('Invalid PMTiles byte range');
+  }
+  const response = await fetch(urlByLayer.get(layer), /* alloc */ {
+    headers: /* alloc */ { Range: `bytes=${offset}-${offset + length - 1}` }, signal,
+  });
+  if (!response.ok) {
+    throw /* alloc */ new Error(`Unable to read PMTiles: HTTP ${response.status}`);
+  }
+  const etag = response.headers.get('ETag');
+  if (etagByLayer.get(layer) && etag !== etagByLayer.get(layer)) {
+    throw /* alloc */ new Error('PMTiles archive changed; recreate the layer');
+  }
+  if (etag) etagByLayer.set(layer, etag);
+  let data = await response.arrayBuffer();
+  if (response.status === 200) {
+    data = data.slice(offset, offset + length);
+  } else if (response.status !== 206 ||
+    !response.headers.get('Content-Range')?.startsWith(`bytes ${offset}-${offset + length - 1}/`)) {
+    throw /* alloc */ new Error('Invalid PMTiles range response');
+  }
+  if (data.byteLength !== length) {
+    throw /* alloc */ new Error('Truncated PMTiles range');
+  }
+  return data;
+}

package/src/archives/readVarint.js

@@ -0,0 +1,19 @@
+
+
+export function varint(reader) {
+  const { bytes } = reader;
+  let value = 0;
+  let factor, byte;
+  for (factor = 1; factor <= 2 ** 49; factor *= 128) {
+    if (reader.cursor >= bytes.length) {
+      throw /* alloc */ new Error('Truncated PMTiles directory');
+    }
+    byte = bytes[reader.cursor++];
+    value += (byte & 127) * factor;
+    if (!Number.isSafeInteger(value)) {
+      throw /* alloc */ new Error('Invalid PMTiles directory integer');
+    }
+    if (byte < 128) return value;
+  }
+  throw /* alloc */ new Error('Invalid PMTiles directory integer');
+}

package/src/archives/tileId.js

@@ -2,17 +2,21 @@
 
 export function tileId(z, x, y) {
   if (!Number.isInteger(z) || !Number.isInteger(x) || !Number.isInteger(y) || z < 0 || z > 26 ||
-    x < 0 || y < 0 || x >= 2 ** z || y >= 2 ** z) throw new Error('Invalid PMTiles tile coordinates');
+    x < 0 || y < 0 || x >= 2 ** z || y >= 2 ** z) {
+    throw /* alloc */ new Error('Invalid PMTiles tile coordinates');
+  }
   let id = (4 ** z - 1) / 3;
   const n = 2 ** z;
   // Same cumulative Hilbert ordering used by build/pmtiles.js.
-  let s, rx, ry;
+  let s, rx, ry, swap;
   for (s = n / 2; s >= 1; s /= 2) {
     rx = (x & s) ? 1 : 0, ry = (y & s) ? 1 : 0;
     id += s * s * ((3 * rx) ^ ry);
     if (!ry) {
       if (rx) { x = n - 1 - x; y = n - 1 - y; }
-      [x, y] = [y, x];
+      swap = x;
+      x = y;
+      y = swap;
     }
   }
   return id;