leaflet-city-mapper 0.0.2 → 0.0.4

package/src/camera/mapPanInside.js

@@ -0,0 +1,20 @@
+import { mapMethods } from '../globals/mapMethods.js';
+import { cameraZeroPadding } from '../globals/cameraZeroPadding.js';
+
+import { mapGetPitch } from './mapGetPitch.js';
+import { mapGetBearing } from './mapGetBearing.js';
+
+import { pointOf } from './pointOf.js';
+
+export function mapPanInside(latlng, options = /* alloc */ {}) {
+  if (!mapGetPitch(this) && !mapGetBearing(this)) return mapMethods.value.panInside.call(this, latlng, options);
+  const min = pointOf(options.paddingTopLeft || options.padding || cameraZeroPadding);
+  const max = this.getSize().subtract(pointOf(options.paddingBottomRight || options.padding || cameraZeroPadding));
+  const screen = this.latLngToContainerPoint(latlng);
+  const safe = min;
+  safe.x = Math.max(min.x, Math.min(max.x, screen.x));
+  safe.y = Math.max(min.y, Math.min(max.y, screen.y));
+  if (safe.equals(screen)) return this;
+  const delta = this.latLngToLayerPoint(latlng).subtract(this.containerPointToLayerPoint(safe));
+  return this.panTo(this.unproject(this.project(this.getCenter()).add(delta)), options);
+}

package/src/camera/mapResetNorth.js

@@ -0,0 +1,4 @@
+import { cameraAnimatedOptions } from '../globals/cameraAnimatedOptions.js';
+import { mapSetBearing } from './mapSetBearing.js';
+
+export function mapResetNorth(map, options = cameraAnimatedOptions) { return mapSetBearing(map, 0, options); }

package/src/camera/mapResetNorthPitch.js

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

package/src/camera/mapSetBearing.js

@@ -0,0 +1,3 @@
+import { mapAnimateCamera } from './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

@@ -0,0 +1,3 @@
+import { mapAnimateCamera } from './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

@@ -0,0 +1,22 @@
+import { cameraByMap } from '../globals/cameraByMap.js';
+
+import { mapGetPitch } from './mapGetPitch.js';
+import { mapGetBearing } from './mapGetBearing.js';
+
+import { updateSky } from './updateSky.js';
+
+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);
+  cameraByMap.get(map)._cameraPitch = Math.max(0, Math.min(map.options.maxPitch, pitch));
+  cameraByMap.get(map)._cameraBearing = ((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

@@ -0,0 +1,15 @@
+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 (!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/mapStopPitchBearingAnimation.js

@@ -0,0 +1,6 @@
+import { cancelCameraAnimation } from './cancelCameraAnimation.js';
+
+export function mapStopPitchBearingAnimation(map) {
+  cancelCameraAnimation(map);
+  return map;
+}

package/src/camera/mapTryAnimatedPan.js

@@ -0,0 +1,10 @@
+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;
+  mapMethods.value.panBy.call(this, offset, options);
+  return true;
+}

package/src/camera/mapUpdateCameraOverlays.js

@@ -0,0 +1,8 @@
+import { L } from '../globals/L.js';
+export function mapUpdateCameraOverlays(map) {
+  let layer;
+  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/pointOf.js

@@ -0,0 +1,5 @@
+import { L } from '../globals/L.js';
+export function pointOf(point) {
+  return /* alloc */ new L.Point(
+    Array.isArray(point) ? point[0] : point.x, Array.isArray(point) ? point[1] : point.y);
+}

package/src/camera/project.js

@@ -0,0 +1,27 @@
+import { cameraAngles } from '../globals/cameraAngles.js';
+import { pointOf } from './pointOf.js';
+import { angles } from './angles.js';
+
+
+export function project(map, point, inverse = false, limit = false) {
+  const size = map.getSize(), halfX = size.x / 2, halfY = size.y / 2, distance = size.y * 1.5;
+  const result = pointOf(point);
+  if (!distance) return result;
+  const [cos, sin, tilt, rise] = angles(map, cameraAngles);
+  const x = result.x - halfX, y = result.y - halfY;
+  if (inverse) {
+    const far = size.y * map.options.pitchMaxDistance;
+    const denominator = tilt * distance + rise * y;
+    let v = denominator * tilt > 0 ? y * distance / denominator : -far;
+    if (limit) v = Math.max(-far, Math.min(far, v));
+    const u = x * (distance - rise * v) / distance;
+    result.x = cos * u + sin * v + halfX;
+    result.y = -sin * u + cos * v + halfY;
+    return result;
+  }
+  const u = cos * x - sin * y, v = sin * x + cos * y;
+  const scale = distance / (distance - rise * v);
+  result.x = u * scale + halfX;
+  result.y = tilt * v * scale + halfY;
+  return result;
+}

package/src/camera/runCameraAnimations.js

@@ -0,0 +1,31 @@
+import { cameraAnimationFrame } from '../globals/cameraAnimationFrame.js';
+import { cameraAnimations } from '../globals/cameraAnimations.js';
+import { cameraByMap } from '../globals/cameraByMap.js';
+
+import { mapSetPitchAndBearing } from './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) {
+    cameraByMap.get(map)._cameraFrame = null;
+    if (cameraByMap.get(map)._cameraAnimation !== 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 && cameraByMap.get(map)._cameraAnimation === animation) scheduleCameraAnimation(map, animation);
+      else if (cameraByMap.get(map)._cameraAnimation === animation) cameraByMap.get(map)._cameraAnimation = null;
+    } catch (error) {
+      failure ||= error;
+    }
+  }
+  if (failure) throw failure;
+}

package/src/camera/scheduleCameraAnimation.js

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

package/src/camera/updateSky.js

@@ -0,0 +1,22 @@
+import { L } from '../globals/L.js';
+import { radians } from '../globals/radians.js';
+import { cameraByMap } from '../globals/cameraByMap.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 && !cameraByMap.get(this)._pitchSky) {
+    cameraByMap.get(this)._pitchSky = L.DomUtil.create('div', 'leaflet-pitch-sky', this.getContainer());
+    cameraByMap.get(this)._pitchSky.setAttribute('aria-hidden', 'true');
+    cameraByMap.get(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 (cameraByMap.get(this)._pitchSky) {
+    cameraByMap.get(this)._pitchSky.style.inset = pitch > Math.PI / 2 ? 'auto 0 0' : '0 0 auto';
+    cameraByMap.get(this)._pitchSky.style.height = `${Math.max(0, Math.ceil(top))}px`;
+    cameraByMap.get(this)._pitchSky.style.display = top > 0 ? '' : 'none';
+  }
+}

package/src/camera/verticalGroundY.js

@@ -0,0 +1,4 @@
+export function verticalGroundY(y, tilt, distance, rise, far) {
+  return tilt * distance + rise * y > 0
+    ? Math.max(-far, Math.min(far, y * distance / (tilt * distance + rise * y))) : -far;
+}

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;
+}

package/src/cog/validCogEncoding.js

@@ -0,0 +1,5 @@
+export function validCogEncoding(tags, samples, bits, format, elevation, bytes, unsigned) {
+  if (elevation) return tags.get(262)?.[0] === 1;
+  return (samples === 3 || samples === 4) && bits?.length === samples && bytes && unsigned &&
+    tags.get(262)?.[0] === 2;
+}

package/src/cog/validCogGeoArrays.js

@@ -0,0 +1,8 @@
+import { finiteCogValues } from './finiteCogValues.js';
+
+export function validCogGeoArrays(keys, scale, tie) {
+  return !!keys && keys[0] === 1 && keys.length === 4 + keys[3] * 4 &&
+    !!scale && scale.length === 3 && finiteCogValues(scale) &&
+    scale[0] > 0 && Math.abs(scale[0] - scale[1]) <= 1e-8 &&
+    !!tie && tie.length === 6 && finiteCogValues(tie) && tie[0] === 0 && tie[1] === 0;
+}

package/src/cog/validCogGrid.js

@@ -0,0 +1,9 @@
+export function validCogGrid(source, base, profile, zoom, x, y, resolution) {
+  return zoom >= 0 && zoom <= 24 &&
+    Math.abs(20037508.342789244 * 2 / (256 * 2 ** zoom) - resolution) <= resolution * 1e-7 &&
+    (!profile.elevation || Number.isInteger(x) && Number.isInteger(y)) &&
+    Math.abs(base.width / profile.width - base.height / profile.height) <= 1e-7 &&
+    profile.elevation === base.elevation &&
+    x >= 0 && y >= 0 && x + profile.width / 256 <= 2 ** zoom && y + profile.height / 256 <= 2 ** zoom &&
+    !source.levels.has(zoom) && !(base.elevation && source.levels.size);
+}

package/src/cog/validCogTileCoordinates.js

@@ -0,0 +1,4 @@
+export function validCogTileCoordinates(z, x, y) {
+  return Number.isSafeInteger(z) && Number.isSafeInteger(x) && Number.isSafeInteger(y) &&
+    z >= 0 && z <= 24 && x >= 0 && y >= 0 && x < 2 ** z && y < 2 ** z;
+}