leaflet-city-mapper 0.0.3 → 0.0.4

package/src/traffic/removeTraffic.js

@@ -1,17 +1,20 @@
+import { trafficByLayer } from '../globals/trafficByLayer.js';
+
+
 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;
+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;
+  trafficByLayer.delete(state.layer);
+  destroyTrafficGpu(state);
+  state.lanes.length = 0;
+  state.trips.length = 0;
+  state.tripsKey = state.loaded = null;
 }

package/src/traffic/routeColor.js

@@ -1,6 +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];
+  if (!/^[\da-f]{6}$/i.test(color)) return /* alloc */ [0.1, 0.55, 0.65];
   const value = Number.parseInt(color, 16);
-  return [(value >> 16 & 255) / 255, (value >> 8 & 255) / 255, (value & 255) / 255];
-}
+  return /* alloc */ [(value >> 16 & 255) / 255, (value >> 8 & 255) / 255, (value & 255) / 255];
+}

package/src/traffic/routeGeometry.js

@@ -1,31 +1,21 @@
+import { appendRouteSegment } from './appendRouteSegment.js';
+
 /** 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;
+  const position = /* alloc */ [];
+  const normal = /* alloc */ [];
+  const color = /* alloc */ [];
+  let points, lengths, properties, raw, rgb, r, g, blue, i;
   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];
+    r = rgb === null ? 0.08 : (rgb >> 16 & 255) / 255;
+    g = rgb === null ? 0.7 : (rgb >> 8 & 255) / 255;
+    blue = rgb === null ? 0.85 : (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);
-        }
-      }
+      appendRouteSegment(position, normal, color, points, lengths, i, r, g, blue);
     }
   }
-  return { position, normal, color };
+  return /* alloc */ { position, normal, color };
 }

package/src/traffic/scheduledTrips.js

@@ -1,6 +1,8 @@
+import { trafficClocks } from '../globals/trafficClocks.js';
 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
@@ -9,28 +11,37 @@ import { compareDepartures } from './compareDepartures.js';
  */
 
 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 = {};
+  const time = date instanceof Date ? date
+    : /* alloc */ new Date(date);
+  if (!Number.isFinite(time.getTime())) throw /* alloc */ new Error('Invalid date');
+  let clock = trafficClocks.get(timeZone);
+  if (!clock) {
+    clock = /* alloc */ new Intl.DateTimeFormat('en-GB',
+      /* alloc */ {
+        timeZone, year: 'numeric', month: '2-digit', day: '2-digit',
+        hour: '2-digit', minute: '2-digit', second: '2-digit', hourCycle: 'h23',
+      });
+    if (trafficClocks.size >= 32) {
+      trafficClocks.delete(trafficClocks.keys().next().value);
+    }
+    trafficClocks.set(timeZone, clock);
+  }
+  const parts = /* alloc */ {};
   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 = [];
+  const weekday = ((Math.floor(Date.UTC(parts.year, parts.month - 1, parts.day) / 86400000) + 4) % 7 + 7) % 7;
+  const departures = /* alloc */ [];
   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 = [];
+  const trips = /* alloc */ [];
   for (departure of departures) {
-    if (minute >= departure && minute < departure + duration) trips.push({
+    if (minute >= departure && minute < departure + duration) trips.push(/* alloc */ {
       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,

package/src/traffic/tickTraffic.js

@@ -1,57 +1,26 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 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';
+import { refreshTrafficTrips } from './refreshTrafficTrips.js';
+import { updateTrafficPose } from './updateTrafficPose.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 (!sceneByLayer.get(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;
+    changed = refreshTrafficTrips(state, time, ms, valid);
+    if (changed === undefined) return;
   }
+  updateTrafficPose(state, ms, live);
   if (state.mesh || changed) updateScene(state.layer);
   if (live && valid) state.frame = requestAnimationFrame(state.tick);
 }

package/src/traffic/toLanes.js

@@ -1,15 +1,23 @@
+import { trafficEmptyList } from '../globals/trafficEmptyList.js';
 // 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;
+
+
+export function toLanes({ features = trafficEmptyList }) {
+  const lanes = /* alloc */ [];
+  let geometry, properties, lines, line, latlngs, lng, lat, i;
   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 });
+    if (geometry?.type !== 'LineString' && geometry?.type !== 'MultiLineString') continue;
+    lines = geometry.type === 'MultiLineString' ? geometry.coordinates : null;
+    for (i = 0; i < (lines ? lines.length : 1); i++) {
+      line = lines ? lines[i] : geometry.coordinates;
+      latlngs = /* alloc */ [];
+      for ([lng, lat] of line) latlngs.push(/* alloc */ [lat, lng]);
+      lanes.push(/* alloc */ {
+        latlngs, properties: properties ?? /* alloc */ {},
+        elevation: properties?.elevation,
+      });
     }
   }
   return lanes;

package/src/traffic/tooltip.js

@@ -1,11 +1,9 @@
 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');
+  let text = p.name ? String(p.name) : '';
+  if (p.departure) text += `${text ? '\n' : ''}Departure ${p.departure} ${p.timetable.timeZone}`;
+  if (p.description) text += `${text ? '\n' : ''}${p.description}`;
+  content.textContent = text;
   return content;
 }

package/src/traffic/trafficBounds.js

@@ -7,11 +7,15 @@ export function trafficBounds(state) {
     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 = [];
+  const data = /* alloc */ [];
   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 } } };
+  const extent = /* alloc */ {
+    attributes: /* alloc */ {
+      position: /* alloc */ { data },
+    },
+  };
   computeBounds(extent);
   state.mesh.geometry.bounds = extent.bounds;
 }

package/src/traffic/trafficNow.js

@@ -1,4 +1,10 @@
+import { cameraByMap } from '../globals/cameraByMap.js';
+
+
 export function trafficNow(state) {
-  const control = state.layer._map?._timeControl || { live: true };
-  return { live: control.live, time: control.live ? new Date() : control.time };
-}
+  const control = cameraByMap.get(state.layer._map)?._timeControl;
+  const live = control ? control.live : true;
+  return /* alloc */ {
+    live, time: live ? /* alloc */ new Date() : control.time,
+  };
+}

package/src/traffic/trafficStatusText.js

@@ -0,0 +1,5 @@
+export function trafficStatusText(state, valid) {
+  if (!valid) return `${state.vehicle}: select a valid simulation date`;
+  if (!state.loaded) return `${state.vehicle}: loading…`;
+  return `${state.trips.length} ${state.vehicle === 'boat' ? 'boats' : state.vehicle}`;
+}

package/src/traffic/trafficStorage.js

@@ -1,5 +1,5 @@
 export function trafficStorage(device, data) {
-  const buffer = device.createBuffer({ size: Math.max(16, data.byteLength), usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST });
+  const buffer = device.createBuffer(/* alloc */ { 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

@@ -4,21 +4,21 @@ 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 = [];
+  const trips = /* alloc */ [];
   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({
+      for (trip of scheduledTrips(time, timetable)) trips.push(/* alloc */ {
         id: `${l}-${trip.id}`, lane, distance: trip.progress * lane.length, speed: lane.length / (timetable.duration * 60),
-        properties: { ...lane.properties, departure: trip.departure },
+        properties: /* alloc */ { ...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({
+      for (k = 0; k < offsets.length; k++) trips.push(/* alloc */ {
         id: `${l}-${k}`, lane, distance: (offsets[k] + travelled) % lane.length, speed: velocity, properties: lane.properties,
       });
     }

package/src/traffic/updateTraffic.js

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

package/src/traffic/updateTrafficLights.js

@@ -0,0 +1,16 @@
+import { locateTraffic } from './locateTraffic.js';
+
+export function updateTrafficLights(state) {
+  state.litAt = performance.now();
+  const lights = /* alloc */ [];
+  let trip, x, y, z, dx, dz, lx, ly, lz, light;
+  for (trip of state.trips) {
+    ({ x, y, z, dx, dz } = locateTraffic(state, trip));
+    for ({ position: [lx, ly, lz], ...light } of state.lights) {
+      lights.push(/* alloc */ {
+        ...light, position: /* alloc */ [x - lx * dz - lz * dx, y + ly, z + lx * dx - lz * dz],
+      });
+    }
+  }
+  state.mesh.extras.lights = lights;
+}

package/src/traffic/updateTrafficPose.js

@@ -0,0 +1,8 @@
+import { moveTraffic } from './moveTraffic.js';
+import { updateTrafficLights } from './updateTrafficLights.js';
+
+export function updateTrafficPose(state, ms, live) {
+  if (!state.mesh) return;
+  moveTraffic(state, (ms - state.rebasedAt) / 1000);
+  if (state.lights && (!live || !(performance.now() - state.litAt < 100))) updateTrafficLights(state);
+}

package/src/traffic/uploadTrafficLanes.js

@@ -0,0 +1,21 @@
+import { trafficStorage } from './trafficStorage.js';
+
+export function uploadTrafficLanes(state, device) {
+  let lane, i, point, count = 0;
+  for (lane of state.lanes) count += lane.points.length;
+  const data = /* alloc */ 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;
+}

package/src/traffic/vehicleOffsets.js

@@ -1,10 +1,11 @@
-import { speed } from "../constants/speed.js";
+import { speed } from '../globals/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 });
+  const offsets = Array.from(/* alloc */ { length: count });
   let i;
   for (i = 0; i < offsets.length; i++) offsets[i] = (i + 0.5) * length / count;
   return offsets;

package/src/triangulation/clean.js

@@ -13,6 +13,6 @@ export function clean(ring) {
       }
     }
   }
-  if (ring.length < 3) throw new Error('Degenerate polygon ring');
+  if (ring.length < 3) throw /* alloc */ new Error('Degenerate polygon ring');
   return ring;
 }

package/src/triangulation/clipEars.js

@@ -0,0 +1,23 @@
+import { cross } from './cross.js';
+import { containsVertex } from './containsVertex.js';
+
+export function clipEars(polygon) {
+  const result = /* alloc */ [];
+  let clipped, i, a, b, c, p;
+  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(/* alloc */ [a.index, b.index, c.index]); polygon.splice(i, 1); clipped = true; break;
+    }
+    if (!clipped) throw /* alloc */ new Error('Unable to triangulate polygon: invalid or self-intersecting rings');
+  }
+  if (cross(...polygon) > 1e-10) {
+    const triangle = /* alloc */ [];
+    for (p of polygon) triangle.push(p.index);
+    result.push(triangle);
+  }
+  return result;
+}

package/src/triangulation/connectHole.js

@@ -0,0 +1,18 @@
+import { inside } from './inside.js';
+import { insideHole } from './insideHole.js';
+import { crossesBoundary } from './crossesBoundary.js';
+
+export function connectHole(polygon, hole, rings, mid) {
+  let h2 = -1, p2 = -1, distance = Infinity, h, p, a, b, d;
+  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; mid.y = (a.y + b.y) / 2;
+    if (!inside(mid, rings[0]) || insideHole(mid, rings)) continue;
+    if (crossesBoundary(a, b, polygon, rings)) continue;
+    h2 = h; p2 = p; distance = d;
+  }
+  if (h2 < 0) throw /* alloc */ new Error('Unable to connect polygon hole');
+  return /* alloc */ [...polygon.slice(0, p2 + 1), ...hole.slice(h2), ...hole.slice(0, h2 + 1),
+    polygon[p2], ...polygon.slice(p2 + 1)];
+}

package/src/triangulation/mergeHoles.js

@@ -0,0 +1,11 @@
+export function mergeHoles(source, target, start, width) {
+  const middle = Math.min(start + width, source.length), end = Math.min(start + width * 2, source.length);
+  let left = start, right = middle, output;
+  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++];
+    }
+  }
+}

package/src/triangulation/minimumX.js

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

package/src/triangulation/polygonRings.js

@@ -0,0 +1,14 @@
+import { clean } from './clean.js';
+import { isClockWise } from './isClockWise.js';
+
+export function polygonRings(paths, vertices) {
+  const rings = /* alloc */ [];
+  let offset = 0, index, path, ring;
+  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);
+  }
+  return rings;
+}

package/src/triangulation/sortHoles.js

@@ -1,21 +1,16 @@
 import { minimumX } from './minimumX.js';
+import { mergeHoles } from './mergeHoles.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) });
+  if (holes.length < 2) return holes;
+  const buffer = /* alloc */ new Array(holes.length);
+  const entries = /* alloc */ [];
+  let ring, width, start, previous, i;
+  for (ring of holes) entries.push(/* alloc */ { 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++];
-        }
-      }
+      mergeHoles(source, target, start, width);
     }
     previous = source;
     source = target;