leaflet-city-mapper 0.0.2 → 0.0.3

package/src/traffic/rebaseTraffic.js

@@ -0,0 +1,58 @@
+import { destroyTrafficGpu } from './destroyTrafficGpu.js';
+import { trafficStorage } from './trafficStorage.js';
+
+export function rebaseTraffic(state) {
+  const { device } = state.layer.renderer;
+  if (state.gpu?.device !== device) {
+    destroyTrafficGpu(state);
+    state.gpu = {
+      device,
+      pipeline: device.createComputePipeline({ layout: 'auto', compute: { module: device.createShaderModule({ code: state.shader }), entryPoint: 'main' } }),
+      params: device.createBuffer({ size: 16, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST }),
+      template: trafficStorage(device, new Float32Array([...state.template.position, ...state.template.normal])),
+    };
+    state.lanesDirty = true;
+  }
+  let lane, i, point, trip, binding;
+  if (state.lanesDirty) {
+    let count = 0;
+    for (lane of state.lanes) count += lane.points.length;
+    const data = new Float32Array(count * 4);
+    let offset = 0;
+    for (lane of state.lanes) {
+      lane.start = offset / 4;
+      for (i = 0; i < lane.points.length; i++) {
+        point = lane.points[i];
+        data[offset++] = point[0];
+        data[offset++] = point[1];
+        data[offset++] = point[2];
+        data[offset++] = lane.lengths[i];
+      }
+    }
+    state.gpu.points?.destroy();
+    state.gpu.points = trafficStorage(device, data);
+    state.lanesDirty = false;
+  }
+  const data = new Float32Array(state.trips.length * 4), index = new Uint32Array(data.buffer);
+  for (i = 0; i < state.trips.length; i++) {
+    trip = state.trips[i];
+    index[i * 4] = trip.lane.start;
+    index[i * 4 + 1] = trip.lane.points.length;
+    data[i * 4 + 2] = trip.distance;
+    data[i * 4 + 3] = trip.speed;
+    state.mesh.extras.featureFaces[i].properties = trip.properties;
+  }
+  if (state.gpu.vehicles?.size >= data.byteLength) device.queue.writeBuffer(state.gpu.vehicles, 0, data);
+  else {
+    state.gpu.vehicles?.destroy();
+    state.gpu.vehicles = trafficStorage(device, data);
+  }
+  const { position, normal } = state.mesh.geometry.attributes;
+  const buffers = [state.gpu.params, state.gpu.template, state.gpu.points, state.gpu.vehicles, position.buffer, normal.buffer];
+  const entries = [];
+  for (binding = 0; binding < buffers.length; binding++) entries.push({ binding, resource: { buffer: buffers[binding] } });
+  state.gpu.bindGroup = device.createBindGroup({
+    layout: state.gpu.pipeline.getBindGroupLayout(0),
+    entries,
+  });
+}

package/src/traffic/rebuildTrafficMesh.js

@@ -0,0 +1,28 @@
+import { build } from '../geometry/build.js';
+import { createTrafficMesh } from './createTrafficMesh.js';
+import { disposeTrafficObject } from './disposeTrafficObject.js';
+import { trafficBounds } from './trafficBounds.js';
+
+export function rebuildTrafficMesh(state) {
+  const { trips, model, vertices } = state;
+  disposeTrafficObject(state, state.mesh);
+  state.mesh = null;
+  if (!trips.length) return;
+  const color = [], featureFaces = [];
+  let i, trip, component;
+  for (i = 0; i < trips.length; i++) {
+    trip = trips[i];
+    for (component of build(model(i, trip.properties)).color) color.push(component);
+    featureFaces.push({
+      id: trip.id, properties: trip.properties, faceStart: i * vertices / 3, faceEnd: (i + 1) * vertices / 3,
+      vertexStart: i * vertices, vertexEnd: (i + 1) * vertices
+    });
+  }
+  const count = color.length / 3;
+  state.mesh = createTrafficMesh(state, {
+    position: new Array(color.length).fill(0), normal: new Array(color.length).fill(0), color,
+  }, featureFaces, {}, GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC);
+  state.mesh.geometry.drawRange.count = count;
+  state.mesh.extras.dynamicLights = true;
+  trafficBounds(state);
+}

package/src/traffic/removeTraffic.js

@@ -0,0 +1,17 @@
+import { disposeTrafficObject } from './disposeTrafficObject.js';
+import { destroyTrafficGpu } from './destroyTrafficGpu.js';
+
+export function removeTraffic(state) {
+  state.request?.abort();
+  cancelAnimationFrame(state.frame);
+  state.frame = undefined;
+  state.layer._map.off('simulationtimechange layerremove', state.update).off('terrainchange', state.terrain);
+  disposeTrafficObject(state, state.mesh);
+  disposeTrafficObject(state, state.route);
+  state.mesh = state.route = null;
+  delete state.layer._beforeRaycast;
+  destroyTrafficGpu(state);
+  state.lanes = [];
+  state.trips = [];
+  state.tripsKey = state.loaded = null;
+}

package/src/traffic/routeColor.js

@@ -0,0 +1,6 @@
+export function routeColor(properties) {
+  const color = properties?.route_color;
+  if (!/^[\da-f]{6}$/i.test(color)) return [0.1, 0.55, 0.65];
+  const value = Number.parseInt(color, 16);
+  return [(value >> 16 & 255) / 255, (value >> 8 & 255) / 255, (value & 255) / 255];
+}

package/src/traffic/routeGeometry.js

@@ -0,0 +1,31 @@
+/** Dashed lane outline, in layer-local metres. */
+
+export function routeGeometry(lanes) {
+  const position = [], normal = [], color = [];
+  let points, lengths, properties, raw, rgb, tint, i, a, b, dx, dz, length, x, z, distance, start, end;
+  let p, q, point;
+  for ({ points, lengths, properties } of lanes) {
+    raw = properties?.route_color;
+    rgb = /^[\da-f]{6}$/i.test(raw) ? Number.parseInt(raw, 16) : null;
+    tint = rgb === null ? [0.08, 0.7, 0.85]
+      : [(rgb >> 16 & 255) / 255, (rgb >> 8 & 255) / 255, (rgb & 255) / 255];
+    for (i = 1; i < points.length; i++) {
+      a = points[i - 1], b = points[i];
+      dx = b[0] - a[0], dz = b[1] - a[1], length = lengths[i] - lengths[i - 1];
+      if (!length) continue;
+      x = -dz / length * 2.5, z = dx / length * 2.5;
+      for (distance = Math.floor(lengths[i - 1] / 30) * 30; distance < lengths[i]; distance += 30) {
+        start = Math.max(0, (distance - lengths[i - 1]) / length);
+        end = Math.min(1, (distance + 18 - lengths[i - 1]) / length);
+        if (end <= start) continue;
+        p = [a[0] + dx * start, a[1] + dz * start, a[2] + (b[2] - a[2]) * start + 0.4];
+        q = [a[0] + dx * end, a[1] + dz * end, a[2] + (b[2] - a[2]) * end + 0.4];
+        for (point of [[p[0] - x, p[2], p[1] - z], [p[0] + x, p[2], p[1] + z], [q[0] + x, q[2], q[1] + z],
+        [p[0] - x, p[2], p[1] - z], [q[0] + x, q[2], q[1] + z], [q[0] - x, q[2], q[1] - z]]) {
+          position.push(...point); normal.push(0, 1, 0); color.push(...tint);
+        }
+      }
+    }
+  }
+  return { position, normal, color };
+}

package/src/traffic/scheduledTrips.js

@@ -0,0 +1,40 @@
+import { clockMinutes } from './clockMinutes.js';
+import { compareDepartures } from './compareDepartures.js';
+
+/**
+ * Trips of a frequency-based timetable (like GTFS frequencies.txt) underway at `date`, in the timetable's local time.
+ * @param {{timeZone: string, duration: number, services: Array<{from: string, to: string, every?: number, months?: number[], weekdays?: number[]}>}} timetable
+ * `duration` and `every` are minutes; `from`/`to` are 'HH:MM' first/last departures; months are 1-12, weekdays 0 (Sunday)-6.
+ * @returns {Array<{id: string, departure: string, progress: number}>} `progress` is 0-1 along the lane.
+ */
+
+export function scheduledTrips(date, { timeZone, duration, services }) {
+  const time = new Date(date);
+  if (!Number.isFinite(time.getTime())) throw new Error('Invalid date');
+  const clock = new Intl.DateTimeFormat('en-GB', {
+    timeZone, year: 'numeric', month: '2-digit', day: '2-digit',
+    hour: '2-digit', minute: '2-digit', second: '2-digit', hourCycle: 'h23',
+  });
+  const parts = {};
+  let part, from, to, every, months, weekdays, departure;
+  for (part of clock.formatToParts(time)) {
+    if (part.type !== 'literal') parts[part.type] = Number(part.value);
+  }
+  const minute = parts.hour * 60 + parts.minute + (parts.second + time.getUTCMilliseconds() / 1000) / 60;
+  const weekday = new Date(Date.UTC(parts.year, parts.month - 1, parts.day)).getUTCDay();
+  const departures = [];
+  for ({ from, to, every = Infinity, months, weekdays } of services) {
+    if (months?.includes(parts.month) === false || weekdays?.includes(weekday) === false) continue;
+    for (departure = clockMinutes(from); departure <= clockMinutes(to); departure += every) departures.push(departure);
+  }
+  departures.sort(compareDepartures);
+  const trips = [];
+  for (departure of departures) {
+    if (minute >= departure && minute < departure + duration) trips.push({
+      id: `${parts.year}-${parts.month}-${parts.day}-${departure}`,
+      departure: `${String(Math.floor(departure / 60)).padStart(2, '0')}:${String(departure % 60).padStart(2, '0')}`,
+      progress: (minute - departure) / duration,
+    });
+  }
+  return trips;
+}

package/src/traffic/startTraffic.js

@@ -0,0 +1,8 @@
+import { underEntry } from '../scene/underEntry.js';
+
+export function startTraffic(state) {
+  state.layer._map.off('simulationtimechange layerremove', state.update).on('simulationtimechange layerremove', state.update);
+  state.layer._map.off('terrainchange', state.terrain).on('terrainchange', state.terrain);
+  underEntry(state.layer, state.status);
+  state.update();
+}

package/src/traffic/tickTraffic.js

@@ -0,0 +1,57 @@
+import { update as updateScene } from '../scene/update.js';
+import { tripsAt } from './tripsAt.js';
+import { trafficNow } from './trafficNow.js';
+import { failTraffic } from './failTraffic.js';
+import { drawTrafficRoute } from './drawTrafficRoute.js';
+import { rebuildTrafficMesh } from './rebuildTrafficMesh.js';
+import { rebaseTraffic } from './rebaseTraffic.js';
+import { moveTraffic } from './moveTraffic.js';
+import { locateTraffic } from './locateTraffic.js';
+
+export function tickTraffic(state) {
+  state.frame = undefined;
+  if (!state.ready || !state.layer._map) return;
+  if (!state.layer.renderer) { state.frame = requestAnimationFrame(state.tick); return; }
+  if (state.mesh && !(state.mesh.geometry.attributes.position.buffer.usage & GPUBufferUsage.STORAGE)) {
+    state.tripsKey = null;
+    state.nextCheck = -Infinity;
+  }
+  const { live, time } = trafficNow(state), ms = time?.getTime(), valid = Number.isFinite(ms);
+  let changed = false;
+  let trip, x, y, z, dx, dz, lx, ly, lz, light;
+  if (!live || !valid || !(ms >= state.rebasedAt && ms < state.nextCheck)) {
+    let text;
+    try {
+      state.trips = valid ? tripsAt(time, state.lanes, state.velocity) : [];
+      text = !valid ? 'Select a valid simulation date' : !state.loaded ? 'Loading…' :
+        `${state.trips.length} ${state.vehicle === 'boat' ? 'boats' : state.vehicle}`;
+    } catch (error) { return failTraffic(state, error); }
+    state.rebasedAt = ms;
+    state.nextCheck = ms + 1000;
+    const ids = [];
+    for (trip of state.trips) ids.push(trip.id);
+    const key = ids.join();
+    changed = key !== state.tripsKey || (state.outline && !state.route && state.lanes.length);
+    if (state.outline && !state.route && state.lanes.length) drawTrafficRoute(state);
+    if (key !== state.tripsKey) { rebuildTrafficMesh(state); state.tripsKey = key; }
+    if (state.mesh) rebaseTraffic(state);
+    if (!state.error) {
+      if (state.status.textContent !== text) state.status.textContent = text;
+      state.status.removeAttribute('role');
+    }
+  }
+  if (state.mesh) moveTraffic(state, (ms - state.rebasedAt) / 1000);
+  if (state.mesh && state.lights && (!live || !(performance.now() - state.litAt < 100))) {
+    state.litAt = performance.now();
+    const lights = [];
+    for (trip of state.trips) {
+      ({ x, y, z, dx, dz } = locateTraffic(state, trip));
+      for ({ position: [lx, ly, lz], ...light } of state.lights) {
+        lights.push({ ...light, position: [x - lx * dz - lz * dx, y + ly, z + lx * dx - lz * dz] });
+      }
+    }
+    state.mesh.extras.lights = lights;
+  }
+  if (state.mesh || changed) updateScene(state.layer);
+  if (live && valid) state.frame = requestAnimationFrame(state.tick);
+}

package/src/traffic/toLanes.js

@@ -0,0 +1,16 @@
+// GeoJSON (Multi)LineStrings become lanes ({latlngs, properties, elevation?}); prepare() adds `points` ([x, z, ground]),
+// `lengths` and `length` in layer-local metres.
+
+export function toLanes({ features = [] }) {
+  const lanes = [];
+  let geometry, properties, lines, line, latlngs, lng, lat;
+  for ({ geometry, properties } of features) {
+    lines = geometry?.type === 'LineString' ? [geometry.coordinates] : geometry?.type === 'MultiLineString' ? geometry.coordinates : [];
+    for (line of lines) {
+      latlngs = [];
+      for ([lng, lat] of line) latlngs.push([lat, lng]);
+      lanes.push({ latlngs, properties: properties ?? {}, elevation: properties?.elevation });
+    }
+  }
+  return lanes;
+}

package/src/traffic/tooltip.js

@@ -0,0 +1,11 @@
+export function tooltip({ properties: p }) {
+  const content = document.createElement('div');
+  content.style.whiteSpace = 'pre-line';
+  const lines = [];
+  let line;
+  for (line of [p.name, p.departure && `Departure ${p.departure} ${p.timetable.timeZone}`, p.description]) {
+    if (line) lines.push(line);
+  }
+  content.textContent = lines.join('\n');
+  return content;
+}

package/src/traffic/trafficBounds.js

@@ -0,0 +1,17 @@
+import { computeBounds } from '../geometry/computeBounds.js';
+
+export function trafficBounds(state) {
+  let radius = 20, height = 5;
+  let i, lane, x, z, y;
+  for (i = 0; i < state.template.position.length; i += 3) {
+    radius = Math.max(radius, Math.hypot(state.template.position[i], state.template.position[i + 2]) + Math.abs(state.side));
+    height = Math.max(height, state.template.position[i + 1]);
+  }
+  const data = [];
+  for (lane of state.lanes) {
+    for ([x, z, y] of lane.points) data.push(x - radius, y, z - radius, x + radius, y + height, z + radius);
+  }
+  const extent = { attributes: { position: { data } } };
+  computeBounds(extent);
+  state.mesh.geometry.bounds = extent.bounds;
+}

package/src/traffic/trafficNow.js

@@ -0,0 +1,4 @@
+export function trafficNow(state) {
+  const control = state.layer._map?._timeControl || { live: true };
+  return { live: control.live, time: control.live ? new Date() : control.time };
+}

package/src/traffic/trafficStorage.js

@@ -0,0 +1,5 @@
+export function trafficStorage(device, data) {
+  const buffer = device.createBuffer({ size: Math.max(16, data.byteLength), usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST });
+  device.queue.writeBuffer(buffer, 0, data);
+  return buffer;
+}

package/src/traffic/tripsAt.js

@@ -0,0 +1,27 @@
+import { vehicleOffsets } from "./vehicleOffsets.js";
+import { scheduledTrips } from "./scheduledTrips.js";
+
+// A lane with a `timetable` runs scheduled trips end to end; one with a `flow` (vehicles/h) loops evenly spaced vehicles.
+
+export function tripsAt(time, lanes, velocity) {
+  const trips = [];
+  let l, lane, timetable, flow, trip, travelled, offsets, k;
+  for (l = 0; l < lanes.length; l++) {
+    lane = lanes[l];
+    ({ timetable, flow = 0 } = lane.properties);
+    if (!lane.length) continue;
+    if (timetable) {
+      for (trip of scheduledTrips(time, timetable)) trips.push({
+        id: `${l}-${trip.id}`, lane, distance: trip.progress * lane.length, speed: lane.length / (timetable.duration * 60),
+        properties: { ...lane.properties, departure: trip.departure },
+      });
+    } else {
+      travelled = time / 1000 * velocity;
+      offsets = lane.offsets ||= vehicleOffsets(lane.length, flow, velocity);
+      for (k = 0; k < offsets.length; k++) trips.push({
+        id: `${l}-${k}`, lane, distance: (offsets[k] + travelled) % lane.length, speed: velocity, properties: lane.properties,
+      });
+    }
+  }
+  return trips;
+}

package/src/traffic/updateTraffic.js

@@ -0,0 +1,8 @@
+import { loadTraffic } from './loadTraffic.js';
+
+export function updateTraffic(state, event) {
+  if (event?.layer && !event.layer.control?.time) return;
+  cancelAnimationFrame(state.frame);
+  loadTraffic(state);
+  state.tick();
+}

package/src/traffic/updateTrafficTerrain.js

@@ -0,0 +1,12 @@
+import { disposeTrafficObject } from './disposeTrafficObject.js';
+import { groundTraffic } from './groundTraffic.js';
+import { trafficBounds } from './trafficBounds.js';
+
+export function updateTrafficTerrain(state) {
+  if (!state.lanes.length) return;
+  groundTraffic(state);
+  disposeTrafficObject(state, state.route);
+  state.route = null;
+  if (state.mesh) trafficBounds(state);
+  if (!state.frame) state.tick();
+}

package/src/traffic/vehicleOffsets.js

@@ -0,0 +1,11 @@
+import { speed } from "../constants/speed.js";
+
+/** Evenly spaced starting offsets (metres) for `flow` vehicles/h moving at `velocity` m/s on a `length` metres lane. */
+
+export function vehicleOffsets(length, flow, velocity = speed) {
+  const count = Math.round(length * flow / 3600 / velocity);
+  const offsets = Array.from({ length: count });
+  let i;
+  for (i = 0; i < offsets.length; i++) offsets[i] = (i + 0.5) * length / count;
+  return offsets;
+}

package/src/triangulation/area.js

@@ -0,0 +1,9 @@
+export function area(ring) {
+  let sum = 0;
+  let i, p, q;
+  for (i = 0; i < ring.length; i++) {
+    p = ring[i], q = ring[(i + 1) % ring.length];
+    sum += p.x * q.y - q.x * p.y;
+  }
+  return Math.abs(sum) / 2;
+}

package/src/triangulation/clean.js

@@ -0,0 +1,18 @@
+import { cross } from './cross.js';
+import { equal } from './equal.js';
+
+export function clean(ring) {
+  let changed = true;
+  let i, a, b, c;
+  while (changed && ring.length > 3) {
+    changed = false;
+    for (i = 0; i < ring.length; i++) {
+      a = ring[(i + ring.length - 1) % ring.length], b = ring[i], c = ring[(i + 1) % ring.length];
+      if (equal(a, b) || Math.abs(cross(a, b, c)) < 1e-10) {
+        ring.splice(i, 1); changed = true; break;
+      }
+    }
+  }
+  if (ring.length < 3) throw new Error('Degenerate polygon ring');
+  return ring;
+}

package/src/triangulation/containsVertex.js

@@ -0,0 +1,11 @@
+import { equal } from './equal.js';
+import { cross } from './cross.js';
+
+export function containsVertex(polygon, a, b, c) {
+  let p;
+  for (p of polygon) {
+    if (!equal(p, a) && !equal(p, b) && !equal(p, c) &&
+      cross(a, b, p) >= 0 && cross(b, c, p) >= 0 && cross(c, a, p) >= 0) return true;
+  }
+  return false;
+}

package/src/triangulation/cross.js

@@ -0,0 +1,3 @@
+export function cross(a, b, c) {
+  return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
+}

package/src/triangulation/crossesBoundary.js

@@ -0,0 +1,8 @@
+import { crossesRing } from './crossesRing.js';
+
+export function crossesBoundary(a, b, polygon, rings) {
+  if (crossesRing(a, b, polygon)) return true;
+  let i;
+  for (i = 1; i < rings.length; i++) if (crossesRing(a, b, rings[i])) return true;
+  return false;
+}

package/src/triangulation/crossesRing.js

@@ -0,0 +1,9 @@
+import { intersects } from './intersects.js';
+
+export function crossesRing(a, b, ring) {
+  let i;
+  for (i = 0; i < ring.length; i++) {
+    if (intersects(a, b, ring[i], ring[(i + 1) % ring.length])) return true;
+  }
+  return false;
+}

package/src/triangulation/equal.js

@@ -0,0 +1,3 @@
+export function equal(a, b) {
+  return a.x === b.x && a.y === b.y;
+}

package/src/triangulation/inside.js

@@ -0,0 +1,10 @@
+export function inside(point, ring) {
+  let result = false;
+  let i, j, a, b;
+  for (i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+    a = ring[i], b = ring[j];
+    if ((a.y > point.y) !== (b.y > point.y) &&
+      point.x < (b.x - a.x) * (point.y - a.y) / (b.y - a.y) + a.x) result = !result;
+  }
+  return result;
+}

package/src/triangulation/insideHole.js

@@ -0,0 +1,7 @@
+import { inside } from './inside.js';
+
+export function insideHole(point, rings) {
+  let i;
+  for (i = 1; i < rings.length; i++) if (inside(point, rings[i])) return true;
+  return false;
+}

package/src/triangulation/intersects.js

@@ -0,0 +1,11 @@
+import { equal } from './equal.js';
+import { cross } from './cross.js';
+import { on } from './on.js';
+
+export function intersects(a, b, c, d) {
+  if (equal(a, c) || equal(a, d) || equal(b, c) || equal(b, d)) return false;
+  const abC = cross(a, b, c), abD = cross(a, b, d), cdA = cross(c, d, a), cdB = cross(c, d, b);
+  return abC * abD < 0 && cdA * cdB < 0 ||
+    abC === 0 && on(a, b, c) || abD === 0 && on(a, b, d) ||
+    cdA === 0 && on(c, d, a) || cdB === 0 && on(c, d, b);
+}

package/src/triangulation/isClockWise.js

@@ -0,0 +1,13 @@
+/**
+ * @returns {boolean} Whether the `{x, y}` points are in clockwise order.
+ */
+
+export function isClockWise(points) {
+  let area = 0;
+  let i, a, b;
+  for (i = 0; i < points.length; i++) {
+    a = points[i], b = points[(i + 1) % points.length];
+    area += a.x * b.y - b.x * a.y;
+  }
+  return area < 0;
+}

package/src/triangulation/minimumX.js

@@ -0,0 +1,6 @@
+export function minimumX(ring) {
+  const values = [];
+  let point;
+  for (point of ring) values.push(point.x);
+  return Math.min(...values);
+}

package/src/triangulation/on.js

@@ -0,0 +1,4 @@
+export function on(p, q, r) {
+  return Math.min(p.x, q.x) <= r.x && r.x <= Math.max(p.x, q.x) &&
+    Math.min(p.y, q.y) <= r.y && r.y <= Math.max(p.y, q.y);
+}

package/src/triangulation/sortHoles.js

@@ -0,0 +1,26 @@
+import { minimumX } from './minimumX.js';
+
+export function sortHoles(holes) {
+  const buffer = new Array(holes.length), entries = [];
+  let ring, width, start, middle, end, left, right, output, previous, i;
+  for (ring of holes) entries.push({ ring, x: minimumX(ring) });
+  let source = entries, target = buffer;
+  for (width = 1; width < entries.length; width *= 2) {
+    for (start = 0; start < entries.length; start += width * 2) {
+      middle = Math.min(start + width, entries.length), end = Math.min(start + width * 2, entries.length);
+      left = start, right = middle;
+      for (output = start; output < end; output++) {
+        if (left < middle && (right >= end || source[left].x <= source[right].x)) {
+          target[output] = source[left++];
+        } else {
+          target[output] = source[right++];
+        }
+      }
+    }
+    previous = source;
+    source = target;
+    target = previous;
+  }
+  for (i = 0; i < holes.length; i++) holes[i] = source[i].ring;
+  return holes;
+}

package/src/triangulation/triangulate.js

@@ -0,0 +1,86 @@
+import { isClockWise } from "./isClockWise.js";
+import { cross } from './cross.js';
+import { clean } from './clean.js';
+import { inside } from './inside.js';
+import { insideHole } from './insideHole.js';
+import { crossesBoundary } from './crossesBoundary.js';
+import { containsVertex } from './containsVertex.js';
+import { area } from './area.js';
+import { sortHoles } from './sortHoles.js';
+
+/**
+ * Triangulates a polygon given as `{x, y}` points.
+ * Rings omit the repeated closing point; winding is normalized internally.
+ * Vertex indices remain relative to the original inputs after duplicate/collinear
+ * cleanup. Hole bridges duplicate endpoints, not source vertices.
+ * @param {Object[]} contour Outer boundary.
+ * @param {Object[][]} [holes] Interior boundaries.
+ *
+ * @returns {number[][]} Triangles as indices in `[...contour, ...holes.flat()]`.
+ */
+
+export function triangulate(contour, holes = []) {
+  const points = [contour, ...holes].flat();
+  let p, index, path, ring, hole, bridge, distance, h, a, b, d, mid, h2, p2, clipped, i, c, triangle2;
+  for (p of points) {
+    if (!Number.isFinite(p.x) || !Number.isFinite(p.y)) throw new Error('Invalid polygon coordinates');
+  }
+  // Translate near the origin to avoid cancellation with geographic coordinates.
+  const vertices = [];
+  for (index = 0; index < points.length; index++) {
+    p = points[index];
+    vertices.push({ x: p.x - contour[0].x, y: p.y - contour[0].y, index });
+  }
+  // Remove zero-area corners before connecting holes; keep original vertex indices.
+  let offset = 0;
+  const rings = [], paths = [contour, ...holes];
+  for (index = 0; index < paths.length; index++) {
+    path = paths[index];
+    ring = clean(vertices.slice(offset, offset += path.length));
+    if (isClockWise(ring) !== Boolean(index)) ring.reverse();
+    rings.push(ring);
+  }
+  let polygon = rings[0].slice();
+  // A bridge must stay inside the outer boundary, outside every hole, and cross no edge.
+  // ponytail: quadratic ear clipping for building footprints; use spatial indexing for large rings.
+  const holesToConnect = sortHoles(rings.slice(1));
+  for (hole of holesToConnect) {
+    bridge = void 0, distance = Infinity;
+    for (h = 0; h < hole.length; h++) for (p = 0; p < polygon.length; p++) {
+      a = hole[h], b = polygon[p], d = (a.x - b.x) ** 2 + (a.y - b.y) ** 2;
+      if (d >= distance) continue;
+      mid = { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
+      if (!inside(mid, rings[0]) || insideHole(mid, rings)) continue;
+      if (crossesBoundary(a, b, polygon, rings)) continue;
+      bridge = [h, p]; distance = d;
+    }
+    if (!bridge) throw new Error('Unable to connect polygon hole');
+    [h2, p2] = bridge;
+    polygon = [...polygon.slice(0, p2 + 1), ...hole.slice(h2), ...hole.slice(0, h2 + 1),
+    polygon[p2], ...polygon.slice(p2 + 1)];
+  }
+  // Clip a convex corner only when no other vertex is inside/on its triangle.
+  const result = [];
+  while (polygon.length > 3) {
+    clipped = false;
+    for (i = 0; i < polygon.length; i++) {
+      a = polygon[(i + polygon.length - 1) % polygon.length], b = polygon[i], c = polygon[(i + 1) % polygon.length];
+      if (cross(a, b, c) <= 1e-10) continue;
+      if (containsVertex(polygon, a, b, c)) continue;
+      result.push([a.index, b.index, c.index]); polygon.splice(i, 1); clipped = true; break;
+    }
+    if (!clipped) throw new Error('Unable to triangulate polygon: invalid or self-intersecting rings');
+  }
+  if (cross(...polygon) > 1e-10) {
+    const triangle = [];
+    for (p of polygon) triangle.push(p.index);
+    result.push(triangle);
+  }
+  // Reject incomplete coverage instead of silently emitting a partial roof.
+  let holeArea = 0, actual = 0;
+  for (i = 1; i < rings.length; i++) holeArea += area(rings[i]);
+  const expected = area(rings[0]) - holeArea;
+  for (triangle2 of result) actual += cross(vertices[triangle2[0]], vertices[triangle2[1]], vertices[triangle2[2]]) / 2;
+  if (expected <= 0 || Math.abs(actual - expected) > Math.max(1e-7, expected * 1e-8)) throw new Error('Polygon triangulation area mismatch');
+  return result;
+}

package/src/utils/channel.js

@@ -1,4 +1,4 @@
-export const channel = (n, h, l, a) => {
+export function channel(n, h, l, a) {
   const k = (n + h * 12) % 12;
   return l - a * Math.max(-1, Math.min(k - 3, 9 - k, 1));
-};
+}

package/src/utils/compareDistance.js

@@ -0,0 +1,3 @@
+export function compareDistance(a, b) {
+  return a.distance - b.distance;
+}

package/src/utils/noOperation.js

@@ -0,0 +1 @@
+export function noOperation() {}

package/src/utils/toSRGB.js

@@ -1 +1,3 @@
-export const toSRGB = value => value <= 0.0031308 ? value * 12.92 : 1.055 * value ** (1 / 2.4) - 0.055;
+export function toSRGB(value) {
+  return value <= 0.0031308 ? value * 12.92 : 1.055 * value ** (1 / 2.4) - 0.055;
+}