leaflet-city-mapper 0.0.3 → 0.0.5

package/src/camera/mapResetNorthPitch.js

@@ -1 +1,4 @@
-export function mapResetNorthPitch(options = { animate: true }) { return this._animateCamera(0, 0, options); }
+import { cameraAnimatedOptions } from '../globals/cameraAnimatedOptions.js';
+import { mapAnimateCamera } from '../animations/mapAnimateCamera.js';
+
+export function mapResetNorthPitch(map, options = cameraAnimatedOptions) { return mapAnimateCamera(map, 0, 0, options); }

package/src/camera/mapSetBearing.js

@@ -1 +1,3 @@
-export function mapSetBearing(bearing, options) { return this._animateCamera(this.getPitch(), bearing, options); }
+import { mapAnimateCamera } from '../animations/mapAnimateCamera.js';
+import { mapGetPitch } from './mapGetPitch.js';
+export function mapSetBearing(map, bearing, options) { return mapAnimateCamera(map, mapGetPitch(map), bearing, options); }

package/src/camera/mapSetPitch.js

@@ -1 +1,3 @@
-export function mapSetPitch(pitch, options) { return this._animateCamera(pitch, this.getBearing(), options); }
+import { mapAnimateCamera } from '../animations/mapAnimateCamera.js';
+import { mapGetBearing } from './mapGetBearing.js';
+export function mapSetPitch(map, pitch, options) { return mapAnimateCamera(map, pitch, mapGetBearing(map), options); }

package/src/camera/mapSetPitchAndBearing.js

@@ -1,14 +1,24 @@
+import { cameraBearingByMap } from '../weakmaps/cameraBearingByMap.js';
+import { cameraPitchByMap } from '../weakmaps/cameraPitchByMap.js';
+
+
+import { mapGetPitch } from './mapGetPitch.js';
+import { mapGetBearing } from './mapGetBearing.js';
+
 import { updateSky } from './updateSky.js';
 
-export function mapSetPitchAndBearing(pitch, bearing) {
-  if (!Number.isFinite(pitch) || !Number.isFinite(bearing)) throw new TypeError('Camera angles must be finite numbers');
-  const previousPitch = this.getPitch(), previousBearing = this.getBearing();
-  this._cameraPitch = Math.max(0, Math.min(85, pitch));
-  this._cameraBearing = ((bearing % 360) + 360) % 360;
-  if (this._loaded) {
-    updateSky.call(this);
-    if (previousBearing !== this.getBearing()) this.fire('rotate', { bearing: this.getBearing() });
-    if (previousPitch !== this.getPitch()) this.fire('pitch', { pitch: this.getPitch() });
-  }
-  return this;
+export function mapSetPitchAndBearing(map, pitch, bearing) {
+  if (!Number.isFinite(pitch) || !Number.isFinite(bearing)) throw /* alloc */ new TypeError('Camera angles must be finite numbers');
+  if (!Number.isFinite(map.options.maxPitch) || map.options.maxPitch < 0 || map.options.maxPitch > 180) {
+    throw /* alloc */ new TypeError('maxPitch must be between 0 and 180 degrees');
+  }
+  const previousPitch = mapGetPitch(map), previousBearing = mapGetBearing(map);
+  cameraPitchByMap.set(map, Math.max(0, Math.min(map.options.maxPitch, pitch)));
+  cameraBearingByMap.set(map, ((bearing % 360) + 360) % 360);
+  if (map._loaded) {
+    updateSky.call(map);
+    if (previousBearing !== mapGetBearing(map)) map.fire('rotate', /* alloc */ { bearing: mapGetBearing(map) });
+    if (previousPitch !== mapGetPitch(map)) map.fire('pitch', /* alloc */ { pitch: mapGetPitch(map) });
+  }
+  return map;
 }

package/src/camera/mapSetZoomAround.js

@@ -1,11 +1,15 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+import { L } from '../globals/L.js';
+import { mapMethods } from '../globals/mapMethods.js';
+
+import { mapGetPitch } from './mapGetPitch.js';
+import { mapGetBearing } from './mapGetBearing.js';
 
 export function mapSetZoomAround(latlng, zoom, options) {
-  if (!this.getPitch() && !this.getBearing()) return mapCameraState.mapMethods.setZoomAround.call(this, latlng, zoom, options);
-  zoom = this._limitZoom(zoom);
-  const scale = this.getZoomScale(zoom), half = this.getSize().divideBy(2);
-  const screen = latlng instanceof L.Point ? latlng : this.latLngToContainerPoint(latlng);
-  const center = this.containerPointToLayerPoint(half), anchor = this.containerPointToLayerPoint(screen);
-  const next = center.add(anchor.subtract(center).multiplyBy(1 - 1 / scale));
-  return this.setView(this.layerPointToLatLng(next), zoom, { zoom: options });
+  if (!mapGetPitch(this) && !mapGetBearing(this)) return mapMethods.value.setZoomAround.call(this, latlng, zoom, options);
+  zoom = this._limitZoom(zoom);
+  const scale = this.getZoomScale(zoom), half = this.getSize().divideBy(2);
+  const screen = latlng instanceof L.Point ? latlng : this.latLngToContainerPoint(latlng);
+  const center = this.containerPointToLayerPoint(half), anchor = this.containerPointToLayerPoint(screen);
+  const next = center.add(anchor.subtract(center).multiplyBy(1 - 1 / scale));
+  return this.setView(this.layerPointToLatLng(next), zoom, /* alloc */ { zoom: options });
 }

package/src/camera/mapTryAnimatedPan.js

@@ -1,9 +1,10 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+import { mapMethods } from '../globals/mapMethods.js';
+
 
 export function mapTryAnimatedPan(center, options) {
   // Leaflet's geographic recentering already supplies ground pixels, not screen pixels.
   const offset = this._getCenterOffset(center)._trunc();
   if (options?.animate !== true && !this.getSize().contains(offset)) return false;
-  mapCameraState.mapMethods.panBy.call(this, offset, options);
+  mapMethods.value.panBy.call(this, offset, options);
   return true;
 }

package/src/camera/mapUpdateCameraOverlays.js

@@ -1,6 +1,7 @@
-export function mapUpdateCameraOverlays() {
+import { L } from '../globals/L.js';
+export function mapUpdateCameraOverlays(map) {
   let layer;
-  for (layer of Object.values(this._layers)) {
+  for (layer of Object.values(map._layers)) {
     if (layer instanceof L.Marker) layer.update();
     else if (layer instanceof L.Popup || layer instanceof L.Tooltip) layer._updatePosition();
   }

package/src/camera/updateMapCamera.js

@@ -0,0 +1,50 @@
+import { cameraByLayer } from '../weakmaps/cameraByLayer.js';
+import { sceneOriginByLayer } from '../weakmaps/sceneOriginByLayer.js';
+import { cameraViewByMap } from '../weakmaps/cameraViewByMap.js';
+
+
+import { radians } from '../globals/radians.js';
+import { cameraFov } from '../globals/cameraFov.js';
+import { earthCirc } from '../globals/earthCirc.js';
+import { mapElevationOf } from '../terrain/mapElevationOf.js';
+import { mapMethods } from '../globals/mapMethods.js';
+import { walkByMap } from '../weakmaps/walkByMap.js';
+import { mapGetPitch } from './mapGetPitch.js';
+import { mapGetBearing } from './mapGetBearing.js';
+
+import { updateCamera } from "./updateSceneCamera.js";
+
+import { animationPoint } from '../projections/transformZoomAnimationPoint.js';
+
+export function updateMapCamera(layer, size) {
+  const map = layer._map;
+  // Match the map's perspective, including the intermediate view of an animated zoom.
+  const zoom = cameraViewByMap.get(map)?.zoom ?? map.getZoom();
+  const pixelsPerMeter = map.options.crs.scale(zoom) /
+    (earthCirc * Math.cos(sceneOriginByLayer.get(layer).lat * radians));
+  const origin = animationPoint(map, mapMethods.value.layerPointToContainerPoint.call(map,
+    map.project(sceneOriginByLayer.get(layer)).subtract(map.getPixelOrigin())));
+  const distance = size.y * 1.5 / pixelsPerMeter;
+  const targetX = (size.x / 2 - origin.x) / pixelsPerMeter;
+  // CSS zoom keeps the logical view's ground plane until zoomend.
+  const walker = walkByMap.get(map)?.control?._walk;
+  const targetY = (mapElevationOf(map, map.getCenter()) ?? 0) +
+    (walker?.saved ? walker.state.height : 0);
+  const targetZ = (size.y / 2 - origin.y) / pixelsPerMeter;
+  const pitch = mapGetPitch(map) * radians;
+  const bearing = mapGetBearing(map) * radians;
+  const camera = cameraByLayer.get(layer);
+  camera.fov = cameraFov;
+  camera.aspect = size.x / size.y;
+  camera.near = Math.max(0.1, distance / 10000);
+  camera.far = Math.max(10000, distance * 10);
+  camera.position[0] = targetX + Math.sin(bearing) * Math.sin(pitch) * distance;
+  camera.position[1] = targetY + Math.cos(pitch) * distance;
+  camera.position[2] = targetZ + Math.cos(bearing) * Math.sin(pitch) * distance;
+  camera.up[0] = -Math.sin(bearing) * Math.cos(pitch);
+  camera.up[1] = Math.sin(pitch);
+  camera.up[2] = -Math.cos(bearing) * Math.cos(pitch);
+  camera.target[0] = targetX; camera.target[1] = targetY; camera.target[2] = targetZ;
+  // Refresh the camera view, projection and combined projection-view matrices.
+  updateCamera(camera);
+}

package/src/camera/updateSceneCamera.js

@@ -0,0 +1,57 @@
+import { halfRadians } from '../globals/halfRadians.js';
+/** Orthonormal view basis plus perspective matrices, refreshed before projecting/drawing. */
+
+export function updateCamera(camera) {
+  camera.x ||= /* alloc */ [0, 0, 0];
+  camera.y ||= /* alloc */ [0, 0, 0];
+  camera.z ||= /* alloc */ [0, 0, 0];
+  camera.viewTransform ||= /* alloc */ new DOMMatrix();
+  camera.projectionTransform ||= /* alloc */ new DOMMatrix();
+  camera.projectionViewTransform ||= /* alloc */ new DOMMatrix();
+  const { position, target, up, x, y, z, viewMatrix, projectionMatrix, projectionViewMatrix } = camera;
+  let value;
+  z[0] = position[0] - target[0], z[1] = position[1] - target[1], z[2] = position[2] - target[2];
+  const zLength = Math.hypot(z[0], z[1], z[2]) || 1;
+  z[0] /= zLength, z[1] /= zLength, z[2] /= zLength;
+  x[0] = up[1] * z[2] - up[2] * z[1];
+  x[1] = up[2] * z[0] - up[0] * z[2];
+  x[2] = up[0] * z[1] - up[1] * z[0];
+  const xLength = Math.hypot(x[0], x[1], x[2]) || 1;
+  x[0] /= xLength, x[1] /= xLength, x[2] /= xLength;
+  y[0] = z[1] * x[2] - z[2] * x[1];
+  y[1] = z[2] * x[0] - z[0] * x[2];
+  y[2] = z[0] * x[1] - z[1] * x[0];
+  const viewTransform = camera.viewTransform;
+  viewTransform.m11 = x[0], viewTransform.m12 = x[1], viewTransform.m13 = x[2], viewTransform.m14 = 0;
+  viewTransform.m21 = y[0], viewTransform.m22 = y[1], viewTransform.m23 = y[2], viewTransform.m24 = 0;
+  viewTransform.m31 = z[0], viewTransform.m32 = z[1], viewTransform.m33 = z[2], viewTransform.m34 = 0;
+  viewTransform.m41 = position[0], viewTransform.m42 = position[1], viewTransform.m43 = position[2], viewTransform.m44 = 1;
+  viewTransform.invertSelf();
+  viewMatrix[0] = viewTransform.m11, viewMatrix[1] = viewTransform.m12, viewMatrix[2] = viewTransform.m13, viewMatrix[3] = viewTransform.m14;
+  viewMatrix[4] = viewTransform.m21, viewMatrix[5] = viewTransform.m22, viewMatrix[6] = viewTransform.m23, viewMatrix[7] = viewTransform.m24;
+  viewMatrix[8] = viewTransform.m31, viewMatrix[9] = viewTransform.m32, viewMatrix[10] = viewTransform.m33, viewMatrix[11] = viewTransform.m34;
+  viewMatrix[12] = viewTransform.m41, viewMatrix[13] = viewTransform.m42, viewMatrix[14] = viewTransform.m43, viewMatrix[15] = viewTransform.m44;
+  for (value of viewMatrix) {
+    if (!Number.isFinite(value)) throw /* alloc */ new Error('Singular 3D transform');
+  }
+  const f = 1 / Math.tan(camera.fov * halfRadians), n = camera.near, r = camera.far;
+  projectionMatrix[0] = f / camera.aspect, projectionMatrix[1] = 0, projectionMatrix[2] = 0, projectionMatrix[3] = 0;
+  projectionMatrix[4] = 0, projectionMatrix[5] = f, projectionMatrix[6] = 0, projectionMatrix[7] = 0;
+  projectionMatrix[8] = 0, projectionMatrix[9] = 0, projectionMatrix[10] = r / (n - r), projectionMatrix[11] = -1;
+  projectionMatrix[12] = 0, projectionMatrix[13] = 0, projectionMatrix[14] = r * n / (n - r), projectionMatrix[15] = 0;
+  const projectionTransform = camera.projectionTransform;
+  projectionTransform.m11 = projectionMatrix[0], projectionTransform.m12 = projectionMatrix[1], projectionTransform.m13 = projectionMatrix[2], projectionTransform.m14 = projectionMatrix[3];
+  projectionTransform.m21 = projectionMatrix[4], projectionTransform.m22 = projectionMatrix[5], projectionTransform.m23 = projectionMatrix[6], projectionTransform.m24 = projectionMatrix[7];
+  projectionTransform.m31 = projectionMatrix[8], projectionTransform.m32 = projectionMatrix[9], projectionTransform.m33 = projectionMatrix[10], projectionTransform.m34 = projectionMatrix[11];
+  projectionTransform.m41 = projectionMatrix[12], projectionTransform.m42 = projectionMatrix[13], projectionTransform.m43 = projectionMatrix[14], projectionTransform.m44 = projectionMatrix[15];
+  const combined = camera.projectionViewTransform;
+  combined.m11 = projectionTransform.m11, combined.m12 = projectionTransform.m12, combined.m13 = projectionTransform.m13, combined.m14 = projectionTransform.m14;
+  combined.m21 = projectionTransform.m21, combined.m22 = projectionTransform.m22, combined.m23 = projectionTransform.m23, combined.m24 = projectionTransform.m24;
+  combined.m31 = projectionTransform.m31, combined.m32 = projectionTransform.m32, combined.m33 = projectionTransform.m33, combined.m34 = projectionTransform.m34;
+  combined.m41 = projectionTransform.m41, combined.m42 = projectionTransform.m42, combined.m43 = projectionTransform.m43, combined.m44 = projectionTransform.m44;
+  combined.multiplySelf(viewTransform);
+  projectionViewMatrix[0] = combined.m11, projectionViewMatrix[1] = combined.m12, projectionViewMatrix[2] = combined.m13, projectionViewMatrix[3] = combined.m14;
+  projectionViewMatrix[4] = combined.m21, projectionViewMatrix[5] = combined.m22, projectionViewMatrix[6] = combined.m23, projectionViewMatrix[7] = combined.m24;
+  projectionViewMatrix[8] = combined.m31, projectionViewMatrix[9] = combined.m32, projectionViewMatrix[10] = combined.m33, projectionViewMatrix[11] = combined.m34;
+  projectionViewMatrix[12] = combined.m41, projectionViewMatrix[13] = combined.m42, projectionViewMatrix[14] = combined.m43, projectionViewMatrix[15] = combined.m44;
+}

package/src/camera/updateSky.js

@@ -1,16 +1,23 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+import { pitchSkyByMap } from '../weakmaps/pitchSkyByMap.js';
 
-export function updateSky() {
-  const height = this.getSize().y, pitch = this.getPitch() * mapCameraState.radians;
-  const far = height * this.options.pitchMaxDistance, distance = height * 1.5;
-  const top = height / 2 - far * Math.cos(pitch) * distance / (distance + Math.sin(pitch) * far);
-  if (top > 0 && !this._pitchSky) {
-    this._pitchSky = L.DomUtil.create('div', 'leaflet-pitch-sky', this.getContainer());
-    this._pitchSky.setAttribute('aria-hidden', 'true');
-    this._pitchSky.style.cssText = 'position:absolute;inset:0 0 auto;height:0;z-index:0;pointer-events:none;background:var(--leaflet-sky-background,linear-gradient(#9ec5e8,#dfe9f0))';
-  }
-  if (this._pitchSky) {
-    this._pitchSky.style.height = `${Math.max(0, Math.ceil(top))}px`;
-    this._pitchSky.style.display = top > 0 ? '' : 'none';
-  }
+import { L } from '../globals/L.js';
+import { radians } from '../globals/radians.js';
+
+import { mapGetPitch } from './mapGetPitch.js';
+
+
+export function updateSky() {
+  const height = this.getSize().y, pitch = mapGetPitch(this) * radians;
+  const far = height * this.options.pitchMaxDistance, distance = height * 1.5;
+  const top = height / 2 - far * Math.abs(Math.cos(pitch)) * distance / (distance + Math.sin(pitch) * far);
+  if (top > 0 && !pitchSkyByMap.get(this)) {
+    pitchSkyByMap.set(this, L.DomUtil.create('div', 'leaflet-pitch-sky', this.getContainer()));
+    pitchSkyByMap.get(this).setAttribute('aria-hidden', 'true');
+    pitchSkyByMap.get(this).style.cssText = 'position:absolute;inset:0 0 auto;height:0;z-index:0;pointer-events:none;background:var(--leaflet-sky-background,linear-gradient(#9ec5e8,#dfe9f0))';
+  }
+  if (pitchSkyByMap.get(this)) {
+    pitchSkyByMap.get(this).style.inset = pitch > Math.PI / 2 ? 'auto 0 0' : '0 0 auto';
+    pitchSkyByMap.get(this).style.height = `${Math.max(0, Math.ceil(top))}px`;
+    pitchSkyByMap.get(this).style.display = top > 0 ? '' : 'none';
+  }
 }

package/src/cog/decodeCogTile.js

@@ -0,0 +1,24 @@
+export async function decodeCogTile(data, length, compression) {
+  if (compression === 1) {
+    if (data.byteLength !== length) throw /* alloc */ new Error('Invalid uncompressed COG tile size');
+    return data;
+  }
+  const stream = /* alloc */ new Blob(/* alloc */ [data]).stream()
+    .pipeThrough(/* alloc */ new DecompressionStream('deflate'));
+  const reader = stream.getReader(), result = /* alloc */ new Uint8Array(length);
+  let offset = 0, chunk;
+  try {
+    while (!(chunk = await reader.read()).done) {
+      if (offset + chunk.value.length > length) {
+        await reader.cancel();
+        throw /* alloc */ new Error('Oversized decoded COG tile');
+      }
+      result.set(chunk.value, offset);
+      offset += chunk.value.length;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  if (offset !== length) throw /* alloc */ new Error('Truncated decoded COG tile');
+  return result.buffer;
+}

package/src/cog/finiteCogValues.js

@@ -0,0 +1,5 @@
+export function finiteCogValues(values) {
+  let value;
+  for (value of values || /* alloc */ []) if (!Number.isFinite(value)) return false;
+  return true;
+}

package/src/cog/getCogAssetEntry.js

@@ -0,0 +1,15 @@
+import { decompress } from '../archives/decompress.js';
+import { readCog } from './readCog.js';
+
+export async function getCogAssetEntry(container, header, asset) {
+  const metadata = JSON.parse(/* alloc */ new TextDecoder().decode(await decompress(
+    await readCog(container, header.jsonMetadataOffset, header.jsonMetadataLength), header.internalCompression)));
+  const assets = metadata.cog_assets || /* alloc */ {};
+  const entry = Object.hasOwn(assets, asset) ? metadata.cog_assets[asset] : null;
+  if (metadata.format !== 'cog-assets-v1' || !entry || !Number.isSafeInteger(entry.offset) ||
+    !Number.isSafeInteger(entry.length) || entry.offset < 0 || entry.length < 8 ||
+    entry.offset + entry.length > header.tileDataLength) {
+    throw /* alloc */ new Error(`Invalid or missing PMTiles COG asset: ${asset}`);
+  }
+  return entry;
+}

package/src/cog/getCogBase.js

@@ -0,0 +1,10 @@
+import { hasCogProjection } from './hasCogProjection.js';
+import { validCogGeoArrays } from './validCogGeoArrays.js';
+
+export function getCogBase(tags, width, height, elevation) {
+  const keys = tags.get(34735), scale = tags.get(33550), tie = tags.get(33922);
+  if (!validCogGeoArrays(keys, scale, tie) || !hasCogProjection(keys)) {
+    throw /* alloc */ new Error('COG must use north-up EPSG:3857 PixelIsArea georeferencing');
+  }
+  return /* alloc */ { width, height, resolution: scale[0], left: tie[3], top: tie[4], elevation };
+}

package/src/cog/getCogHeader.js

@@ -0,0 +1,3 @@
+export function getCogHeader(source) {
+  return source.header;
+}

package/src/cog/getCogProfile.js

@@ -0,0 +1,16 @@
+import { validCogDimensions } from './validCogDimensions.js';
+import { validCogEncoding } from './validCogEncoding.js';
+
+export function getCogProfile(tags) {
+  const width = tags.get(256)?.[0], height = tags.get(257)?.[0], samples = tags.get(277)?.[0] ?? 1;
+  const bits = tags.get(258), format = tags.get(339) || /* alloc */ [1];
+  let bytes = true, unsigned = true, floating = true, value;
+  for (value of bits || /* alloc */ []) bytes &&= value === 8;
+  for (value of format) { unsigned &&= value === 1; floating &&= value === 3; }
+  const elevation = samples === 1 && bits?.length === 1 && bits[0] === 32 && floating;
+  if (!validCogDimensions(tags, width, height) ||
+    !validCogEncoding(tags, samples, bits, format, elevation, bytes, unsigned)) {
+    throw /* alloc */ new Error('Unsupported COG profile: expected tiled 256px RGB(A) Uint8 or Float32, DEFLATE without predictor');
+  }
+  return /* alloc */ { width, height, samples, elevation };
+}

package/src/cog/getCogTile.js

@@ -0,0 +1,12 @@
+import { getElevationTile } from './getElevationTile.js';
+import { getColorTile } from './getColorTile.js';
+import { validCogTileCoordinates } from './validCogTileCoordinates.js';
+
+export async function getCogTile(source, z, x, y, signal) {
+  signal?.throwIfAborted();
+  if (!validCogTileCoordinates(z, x, y)) throw /* alloc */ new Error('Invalid COG tile coordinates');
+  const level = source.levels.get(z);
+  if (!level || x + 1 <= level.x || y + 1 <= level.y || x >= level.x + level.columns || y >= level.y + level.rows) return;
+  if (level.elevation) return getElevationTile(source, level, x, y, signal);
+  return getColorTile(source, level, x, y, signal);
+}

package/src/cog/getColorTile.js

@@ -0,0 +1,25 @@
+import { readCogBlock } from './readCogBlock.js';
+
+export async function getColorTile(source, level, x, y, signal) {
+  const canvas = /* alloc */ new OffscreenCanvas(256, 256), context = canvas.getContext('2d');
+  if (!context) throw /* alloc */ new Error('Unable to create COG tile canvas');
+  const left = (x - level.x) * 256, top = (y - level.y) * 256;
+  let bx, by, pixels, rgba, i, j, bitmap;
+  for (by = Math.max(0, Math.floor(top / 256)); by < Math.min(level.rows, Math.ceil(top / 256 + 1)); by++) {
+    for (bx = Math.max(0, Math.floor(left / 256)); bx < Math.min(level.columns, Math.ceil(left / 256 + 1)); bx++) {
+      pixels = /* alloc */ new Uint8Array(await readCogBlock(source, level, bx, by, signal));
+      signal?.throwIfAborted();
+      rgba = /* alloc */ new Uint8ClampedArray(256 * 256 * 4);
+      for (i = 0, j = 0; i < pixels.length; i += level.samples, j += 4) {
+        rgba[j] = pixels[i]; rgba[j + 1] = pixels[i + 1]; rgba[j + 2] = pixels[i + 2];
+        rgba[j + 3] = level.samples === 4 ? pixels[i + 3] : 255;
+      }
+      bitmap = await createImageBitmap(/* alloc */ new ImageData(rgba, 256, 256));
+      context.drawImage(bitmap, bx * 256 - left, by * 256 - top);
+      bitmap.close();
+    }
+  }
+  const image = canvas.transferToImageBitmap();
+  if (signal?.aborted) { image.close(); signal.throwIfAborted(); }
+  return /* alloc */ { image };
+}

package/src/cog/getElevationTile.js

@@ -0,0 +1,16 @@
+import { readCogBlock } from './readCogBlock.js';
+
+export async function getElevationTile(source, level, x, y, signal) {
+  const data = await readCogBlock(source, level, x - level.x, y - level.y, signal);
+  signal?.throwIfAborted();
+  const view = /* alloc */ new DataView(data), heights = /* alloc */ new Float32Array(256 * 256);
+  let i, height;
+  for (i = 0; i < heights.length; i++) {
+    height = view.getFloat32(i * 4, source.little);
+    if (!Number.isFinite(height) || height < -12000 || height > 10000) {
+      throw /* alloc */ new Error('Invalid or missing COG elevation sample');
+    }
+    heights[i] = height;
+  }
+  return /* alloc */ { data: heights.buffer };
+}

package/src/cog/hasCogProjection.js

@@ -0,0 +1,9 @@
+export function hasCogProjection(keys) {
+  let projected = false, area = false, i;
+  if (keys) for (i = 4; i < keys.length; i += 4) {
+    if (keys[i + 1] !== 0 || keys[i + 2] !== 1) continue;
+    if (keys[i] === 3072 && keys[i + 3] === 3857) projected = true;
+    if (keys[i] === 1025 && keys[i + 3] === 1) area = true;
+  }
+  return projected && area;
+}

package/src/cog/initCog.js

@@ -0,0 +1,7 @@
+import { initRaster } from '../raster/initRaster.js';
+import { openCog } from './openCog.js';
+
+export function initCog(layer, options) {
+  initRaster(layer, /* alloc */ { ariaLabel: 'COG raster', ...options,
+    archive: options.archive || openCog(/* alloc */ new URL(options.url, document.baseURI).href, options.asset) });
+}

package/src/cog/invalidCogFullResponse.js

@@ -0,0 +1,3 @@
+export function invalidCogFullResponse(response) {
+  return response.status !== 200 || Number(response.headers.get('Content-Length')) > 32000000;
+}

package/src/cog/openCog.js

@@ -0,0 +1,30 @@
+import { readCog } from './readCog.js';
+import { readCogDirectories } from './readCogDirectories.js';
+import { getCogTile } from './getCogTile.js';
+import { getCogHeader } from './getCogHeader.js';
+import { openCogAsset } from './openCogAsset.js';
+
+/** EPSG:3857 COGs, standalone or named assets in a PMTiles container. */
+export async function openCog(url, asset) {
+  const source = asset === undefined ? /* alloc */ { url } : await openCogAsset(url, asset);
+  source.levels = /* alloc */ new Map();
+  const header = /* alloc */ new DataView(await readCog(source, 0, 8));
+  const order = header.getUint16(0);
+  if (order !== 0x4949 && order !== 0x4d4d) throw /* alloc */ new Error('Invalid TIFF byte order');
+  source.little = order === 0x4949;
+  if (header.getUint16(2, source.little) !== 42) throw /* alloc */ new Error('Expected classic TIFF (BigTIFF is not supported)');
+  const { base, minZoom, maxZoom } = await readCogDirectories(source, header.getUint32(4, source.little));
+  const half = 20037508.342789244;
+  const left = base.left + base.resolution / 2, right = base.left + (base.width - 0.5) * base.resolution;
+  const top = base.top - base.resolution / 2, bottom = base.top - (base.height - 0.5) * base.resolution;
+  source.header = /* alloc */ {
+    minZoom, maxZoom, tileType: base.elevation ? 0 : 2,
+    minLon: left / half * 180, maxLon: right / half * 180,
+    minLat: Math.atan(Math.sinh(bottom / half * Math.PI)) * 180 / Math.PI,
+    maxLat: Math.atan(Math.sinh(top / half * Math.PI)) * 180 / Math.PI,
+  };
+  return /* alloc */ {
+    getHeader: getCogHeader.bind(null, source),
+    getZxy: getCogTile.bind(null, source),
+  };
+}

package/src/cog/openCogAsset.js

@@ -0,0 +1,14 @@
+import { decodeHeader } from '../archives/decodeHeader.js';
+import { readCog } from './readCog.js';
+import { validateCogContainer } from './validateCogContainer.js';
+import { getCogAssetEntry } from './getCogAssetEntry.js';
+
+export async function openCogAsset(url, asset) {
+  const container = /* alloc */ { url };
+  const header = decodeHeader(await readCog(container, 0, 127));
+  validateCogContainer(container, header);
+  const entry = await getCogAssetEntry(container, header, asset);
+  const baseOffset = header.tileDataOffset + entry.offset;
+  return /* alloc */ { url, baseOffset, size: entry.length, containerSize: container.size,
+    etag: container.etag, full: container.full?.slice(baseOffset, baseOffset + entry.length) };
+}

package/src/cog/readCog.js

@@ -0,0 +1,25 @@
+import { validateCogRange } from './validateCogRange.js';
+import { validateCogResponse } from './validateCogResponse.js';
+import { readCogBody } from './readCogBody.js';
+
+export async function readCog(source, offset, length, signal) {
+  signal?.throwIfAborted();
+  validateCogRange(source, offset, length);
+  if (source.full) return source.full.slice(offset, offset + length);
+  const rangeStart = (source.baseOffset || 0) + offset;
+  const response = await fetch(source.url, /* alloc */ {
+    headers: /* alloc */ { Range: `bytes=${rangeStart}-${rangeStart + length - 1}` }, signal,
+  });
+  if (!response.ok) throw /* alloc */ new Error(`Unable to read COG: HTTP ${response.status}`);
+  validateCogResponse(source, response, rangeStart, length);
+  const data = await readCogBody(response, length);
+  if (response.status === 200) {
+    if (source.baseOffset === undefined) source.size = data.byteLength;
+    else if (data.byteLength !== source.containerSize) throw /* alloc */ new Error('Truncated PMTiles COG container');
+    source.full = source.baseOffset === undefined ? data.buffer
+      : data.slice(source.baseOffset, source.baseOffset + source.size);
+  }
+  const result = response.status === 200 ? source.full.slice(offset, offset + length) : data.buffer;
+  if (result.byteLength !== length) throw /* alloc */ new Error('Truncated COG byte range');
+  return result;
+}

package/src/cog/readCogBlock.js

@@ -0,0 +1,8 @@
+import { readCog } from './readCog.js';
+import { decodeCogTile } from './decodeCogTile.js';
+
+export async function readCogBlock(source, level, x, y, signal) {
+  const index = y * level.columns + x;
+  return decodeCogTile(await readCog(source, level.offsets[index], level.lengths[index], signal),
+    256 * 256 * (level.elevation ? 4 : level.samples), level.compression);
+}

package/src/cog/readCogBody.js

@@ -0,0 +1,20 @@
+export async function readCogBody(response, length) {
+  const reader = response.body.getReader(), chunks = /* alloc */ [];
+  let total = 0, part;
+  try {
+    while (!(part = await reader.read()).done) {
+      total += part.value.byteLength;
+      if (total > (response.status === 206 ? length : 32000000)) {
+        await reader.cancel();
+        throw /* alloc */ new Error('Oversized COG response');
+      }
+      chunks.push(part.value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const data = /* alloc */ new Uint8Array(total);
+  let start = 0, chunk;
+  for (chunk of chunks) { data.set(chunk, start); start += chunk.length; }
+  return data;
+}

package/src/cog/readCogDirectories.js

@@ -0,0 +1,20 @@
+import { readCogDirectory } from './readCogDirectory.js';
+import { readCogLevel } from './readCogLevel.js';
+
+export async function readCogDirectories(source, offset) {
+  const state = /* alloc */ { base: null, minZoom: Infinity, maxZoom: -Infinity };
+  const seen = /* alloc */ new Set();
+  let directory;
+  while (offset) {
+    if (seen.has(offset) || seen.size >= 24) throw /* alloc */ new Error('Cyclic or excessive COG directories');
+    seen.add(offset);
+    directory = await readCogDirectory(source, offset);
+    readCogLevel(source, directory, state);
+    offset = directory.next;
+  }
+  if (!state.base) throw /* alloc */ new Error('COG has no image directory');
+  if (source.levels.size !== state.maxZoom - state.minZoom + 1) {
+    throw /* alloc */ new Error('COG overview zooms must be contiguous');
+  }
+  return /* alloc */ { base: state.base, minZoom: state.minZoom, maxZoom: state.maxZoom };
+}

package/src/cog/readCogDirectory.js

@@ -0,0 +1,21 @@
+import { readCog } from './readCog.js';
+import { cogTags } from '../globals/cogTags.js';
+import { readCogTag } from './readCogTag.js';
+
+export async function readCogDirectory(source, offset) {
+  const little = source.little;
+  const count = /* alloc */ new DataView(await readCog(source, offset, 2)).getUint16(0, little);
+  if (!count || count > 128) throw /* alloc */ new Error('Invalid COG directory size');
+  const entries = /* alloc */ new DataView(await readCog(source, offset + 2, count * 12 + 4));
+  const tags = /* alloc */ new Map();
+  let i, tag;
+  for (i = 0; i < count; i++) {
+    tag = entries.getUint16(i * 12, little);
+    if (tag === 42113) throw /* alloc */ new Error('COG nodata tags are not supported; export complete tiles');
+    if (tag === 34264) throw /* alloc */ new Error('COG affine transformation matrices are not supported');
+    if (!cogTags.includes(tag)) continue;
+    if (tags.has(tag)) throw /* alloc */ new Error('Duplicate COG tag');
+    tags.set(tag, await readCogTag(source, entries, i, tag, little));
+  }
+  return /* alloc */ { tags, next: entries.getUint32(count * 12, little) };
+}

package/src/cog/readCogLevel.js

@@ -0,0 +1,27 @@
+import { getCogProfile } from './getCogProfile.js';
+import { getCogBase } from './getCogBase.js';
+import { validCogGrid } from './validCogGrid.js';
+import { validateCogOffsets } from './validateCogOffsets.js';
+
+export function readCogLevel(source, directory, state) {
+  const tags = directory.tags, profile = getCogProfile(tags);
+  if (!state.base) state.base = getCogBase(tags, profile.width, profile.height, profile.elevation);
+  const base = state.base, resolution = base.resolution * base.width / profile.width;
+  const zoom = Math.round(Math.log2(20037508.342789244 * 2 / (256 * resolution)));
+  const span = 20037508.342789244 * 2 / 2 ** zoom;
+  let x = (base.left + 20037508.342789244) / span;
+  let y = (20037508.342789244 - base.top) / span;
+  if (Math.abs(x - Math.round(x)) < 1e-6) x = Math.round(x);
+  if (Math.abs(y - Math.round(y)) < 1e-6) y = Math.round(y);
+  if (!validCogGrid(source, base, profile, zoom, x, y, resolution)) {
+    throw /* alloc */ new Error('COG levels must align with the Web Mercator XYZ tile grid');
+  }
+  const level = /* alloc */ {
+    x, y, columns: profile.width / 256, rows: profile.height / 256, samples: profile.samples,
+    elevation: profile.elevation, compression: tags.get(259)[0], offsets: tags.get(324), lengths: tags.get(325),
+  };
+  validateCogOffsets(source, level);
+  source.levels.set(zoom, level);
+  state.minZoom = Math.min(state.minZoom, zoom);
+  state.maxZoom = Math.max(state.maxZoom, zoom);
+}

package/src/cog/readCogTag.js

@@ -0,0 +1,15 @@
+import { readCog } from './readCog.js';
+
+export async function readCogTag(source, entries, i, tag, little) {
+  const type = entries.getUint16(i * 12 + 2, little);
+  const size = type === 3 ? 2 : type === 4 ? 4 : type === 12 ? 8 : 0;
+  const length = entries.getUint32(i * 12 + 4, little);
+  if (!size || !length || length > 1048576) throw /* alloc */ new Error(`Unsupported COG tag ${tag}`);
+  const data = size * length <= 4 ? /* alloc */ new DataView(entries.buffer, i * 12 + 8, 4)
+    : /* alloc */ new DataView(await readCog(source, entries.getUint32(i * 12 + 8, little), size * length));
+  const values = /* alloc */ [];
+  let j;
+  for (j = 0; j < length; j++) values.push(type === 3 ? data.getUint16(j * size, little)
+    : type === 4 ? data.getUint32(j * size, little) : data.getFloat64(j * size, little));
+  return values;
+}

package/src/cog/validCogDimensions.js

@@ -0,0 +1,6 @@
+export function validCogDimensions(tags, width, height) {
+  return !!width && !!height && width % 256 === 0 && height % 256 === 0 &&
+    tags.get(322)?.[0] === 256 && tags.get(323)?.[0] === 256 &&
+    (tags.get(259)?.[0] === 1 || tags.get(259)?.[0] === 8) &&
+    (tags.get(284)?.[0] ?? 1) === 1 && (tags.get(317)?.[0] ?? 1) === 1;
+}