leaflet-city-mapper 0.0.3 → 0.0.4

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

package/src/cog/validateCogContainer.js

@@ -0,0 +1,9 @@
+export function validateCogContainer(container, header) {
+  if (header.tileType !== 0 || header.tileCompression !== 1 ||
+    !Number.isSafeInteger(header.jsonMetadataOffset) || !Number.isSafeInteger(header.jsonMetadataLength) ||
+    header.jsonMetadataLength <= 0 || header.jsonMetadataLength > 1048576 ||
+    !Number.isSafeInteger(header.tileDataOffset) || !Number.isSafeInteger(header.tileDataLength) ||
+    header.tileDataOffset < 127 || header.tileDataOffset + header.tileDataLength > container.size) {
+    throw /* alloc */ new Error('Invalid PMTiles COG asset container');
+  }
+}

package/src/cog/validateCogContentRange.js

@@ -0,0 +1,8 @@
+export function validateCogContentRange(source, range, rangeStart, length) {
+  if (!range || Number(range[1]) !== rangeStart || Number(range[2]) !== rangeStart + length - 1 ||
+    !Number.isSafeInteger(Number(range[3])) || Number(range[3]) < rangeStart + length ||
+    (source.containerSize ?? source.size) !== undefined &&
+      (source.containerSize ?? source.size) !== Number(range[3])) {
+    throw /* alloc */ new Error('Invalid COG range response');
+  }
+}

package/src/cog/validateCogOffsets.js

@@ -0,0 +1,10 @@
+export function validateCogOffsets(source, level) {
+  if (level.offsets?.length !== level.columns * level.rows || level.lengths?.length !== level.offsets.length) {
+    throw /* alloc */ new Error('Invalid COG tile offsets or lengths');
+  }
+  let i;
+  for (i = 0; i < level.offsets.length; i++) {
+    if (!level.offsets[i] || !level.lengths[i] || level.lengths[i] > 1048576 ||
+      level.offsets[i] + level.lengths[i] > source.size) throw /* alloc */ new Error('Invalid COG tile offsets or lengths');
+  }
+}

package/src/cog/validateCogRange.js

@@ -0,0 +1,7 @@
+export function validateCogRange(source, offset, length) {
+  if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) || offset < 0 ||
+    length <= 0 || length > 32000000 || !Number.isSafeInteger(offset + length) ||
+    source.size !== undefined && offset + length > source.size) {
+    throw /* alloc */ new Error('Invalid COG byte range');
+  }
+}

package/src/cog/validateCogResponse.js

@@ -0,0 +1,15 @@
+import { validateCogContentRange } from './validateCogContentRange.js';
+import { invalidCogFullResponse } from './invalidCogFullResponse.js';
+
+export function validateCogResponse(source, response, rangeStart, length) {
+  const etag = response.headers.get('ETag');
+  if (source.etag && source.etag !== etag) throw /* alloc */ new Error('COG changed; recreate the layer');
+  if (etag) source.etag = etag;
+  const range = /^bytes (\d+)-(\d+)\/(\d+)$/.exec(response.headers.get('Content-Range') || '');
+  if (response.status === 206) {
+    validateCogContentRange(source, range, rangeStart, length);
+    if (source.baseOffset === undefined) source.size = Number(range[3]);
+  } else if (invalidCogFullResponse(response)) {
+    throw /* alloc */ new Error('COG server must support byte ranges for files over 32 MB');
+  }
+}

package/src/collision/collider.js

@@ -1,5 +1,6 @@
-import { CELL } from '../constants/CELL.js';
-import { colliders } from '../constants/colliders.js';
+import { colliders } from '../globals/colliders.js';
+import { transformTriangle } from './transformTriangle.js';
+import { indexTriangle } from './indexTriangle.js';
 
 
 export function collider(mesh) {
@@ -7,21 +8,20 @@ export function collider(mesh) {
   if (c) return c;
   const m = mesh.worldMatrix, { position: { data: p }, index, normal, uv } = mesh.geometry.attributes;
 
-  const count = index ? index.count : p.length / 3, tri = [], nrm = [], cells = new Map(), v = [];
+  const count = index ? index.count : p.length / 3;
+  const tri = /* alloc */ [];
+  const nrm = /* alloc */ [];
+  const cells = /* alloc */ new Map();
+  const v = /* alloc */ [];
 
-  let i, first, k, j, x, y, z, ex, ey, ez, fx, fy, fz, nx, nz, ny, length, a, h, t, ix, iz, key;
+  let i, first, j, ex, ey, ez, fx, fy, fz, nx, nz, ny, length, a, h, t;
   for (i = 0; i < count; i += 3) {
     first = index ? index.data[i] : i;
     // Streetlight halos (uv.x <= 2, see scene/picking.js) are light, not matter.
     if (mesh.program.nightLight && uv && uv.data[first * 2] <= 2) {
       continue;
     }
-    for (k = 0; k < 3; k++) {
-      j = (index ? index.data[i + k] : i + k) * 3, x = p[j], y = p[j + 1], z = p[j + 2];
-      v[k * 3] = m[0] * x + m[4] * y + m[8] * z + m[12];
-      v[k * 3 + 1] = m[1] * x + m[5] * y + m[9] * z + m[13];
-      v[k * 3 + 2] = m[2] * x + m[6] * y + m[10] * z + m[14];
-    }
+    transformTriangle(v, p, index, i, m);
     ex = v[3] - v[0], ey = v[4] - v[1], ez = v[5] - v[2], fx = v[6] - v[0], fy = v[7] - v[1], fz = v[8] - v[2];
 
     nx = ey * fz - ez * fy, nz = ex * fy - ey * fx;
@@ -43,20 +43,13 @@ export function collider(mesh) {
     tri.push(...v);
     nrm.push(nx / h, nz / h);
 
-    for (ix = Math.floor(Math.min(v[0], v[3], v[6]) / CELL); ix <= Math.floor(Math.max(v[0], v[3], v[6]) / CELL); ix++)
-      for (iz = Math.floor(Math.min(v[2], v[5], v[8]) / CELL); iz <= Math.floor(Math.max(v[2], v[5], v[8]) / CELL); iz++) {
-        key = ix + ',' + iz;
-        if (!cells.has(key)) {
-          cells.set(key, []);
-        }
-        cells.get(key).push(t);
-      }
+    indexTriangle(cells, v, t);
   }
-  c = {
+  c = /* alloc */ {
     tri: Float32Array.from(tri),
     nrm: Float32Array.from(nrm),
     cells,
-    origin: [m[12], m[13], m[14]]
+    origin: /* alloc */ [m[12], m[13], m[14]]
   };
   colliders.set(mesh.geometry, c);
   return c;

package/src/collision/hiddenLightHit.js

@@ -0,0 +1,8 @@
+export function hiddenLightHit(mesh, i, u, v, night) {
+  if (!mesh.program.nightLight) return false;
+  const { index, uv: { data: uv } } = mesh.geometry.attributes;
+  const idA = index ? index.data[i] : i, idB = index ? index.data[i + 1] : i + 1, idC = index ? index.data[i + 2] : i + 2;
+  const x = uv[idA * 2] * (1 - u - v) + uv[idB * 2] * u + uv[idC * 2] * v;
+  const y = uv[idA * 2 + 1] * (1 - u - v) + uv[idB * 2 + 1] * u + uv[idC * 2 + 1] * v;
+  return x <= 2 && (!night || x * x + y * y > 0.9);
+}

package/src/collision/indexTriangle.js

@@ -0,0 +1,11 @@
+import { CELL } from '../globals/CELL.js';
+
+export function indexTriangle(cells, v, t) {
+  let ix, iz, key;
+  for (ix = Math.floor(Math.min(v[0], v[3], v[6]) / CELL); ix <= Math.floor(Math.max(v[0], v[3], v[6]) / CELL); ix++)
+    for (iz = Math.floor(Math.min(v[2], v[5], v[8]) / CELL); iz <= Math.floor(Math.max(v[2], v[5], v[8]) / CELL); iz++) {
+      key = ix + ',' + iz;
+      if (!cells.has(key)) cells.set(key, /* alloc */ []);
+      cells.get(key).push(t);
+    }
+}