leaflet-city-mapper 0.1.0 → 0.1.1

package/src/traffic/trafficStorage.js

@@ -1,13 +1,13 @@
-/**
- * Create and initialize a GPU storage buffer with at least 16 bytes.
- *
- * @param {GPUDevice} device Device creating the buffer.
- * @param {TypedArray} data Buffer contents.
- *
- * @returns {GPUBuffer} The initialized storage buffer.
- */
-export function trafficStorage(device, data) {
-  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;
-}
+/**
+ * Create and initialize a GPU storage buffer with at least 16 bytes.
+ *
+ * @param {GPUDevice} device Device creating the buffer.
+ * @param {TypedArray} data Buffer contents.
+ *
+ * @returns {GPUBuffer} The initialized storage buffer.
+ */
+export function trafficStorage(device, data) {
+  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/updateTraffic.js

@@ -1,15 +1,15 @@
-import { controlByLayer } from '../weakmaps/controlByLayer.js';
-import { loadTraffic } from './loadTraffic.js';
-
-/**
- * Reload lanes and tick the simulation when the clock changes or a relevant layer is removed.
- *
- * @param {Object} state Traffic layer state.
- * @param {Object} [event] Map event, optionally containing a removed layer.
- */
+import { controlByLayer } from '../weakmaps/controlByLayer.js';
+import { loadTraffic } from './loadTraffic.js';
+
+/**
+ * Reload lanes and tick the simulation when the clock changes or a relevant layer is removed.
+ *
+ * @param {Object} state Traffic layer state.
+ * @param {Object} [event] Map event, optionally containing a removed layer.
+ */
 export function updateTraffic(state, event) {
-  if (event?.layer && !controlByLayer.get(event.layer)?.time) return;
-  cancelAnimationFrame(state.frame);
-  loadTraffic(state);
-  state.tick();
+  if (event?.layer && !controlByLayer.get(event.layer)?.time) return;
+  cancelAnimationFrame(state.frame);
+  loadTraffic(state);
+  state.tick();
 }

package/src/traffic/updateTrafficLights.js

@@ -1,23 +1,23 @@
-import { locateTraffic } from './locateTraffic.js';
-
-/**
- * Rebuild the mesh's light snapshot by transforming each vehicle light to its current lane pose.
- *
- * @param {Object} state Traffic layer state.
- */
-export function updateTrafficLights(state) {
-  state.litAt = performance.now();
-  const lights = /* alloc */ [];
-  const target = state.position ||= /* 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, target));
-    for (light of state.lights) {
-      [lx, ly, lz] = light.position;
-      lights.push(/* alloc */ {
-        ...light, position: /* alloc */ [x - lx * dz - lz * dx, y + ly, z + lx * dx - lz * dz],
-      });
-    }
-  }
-  state.mesh.extras.lights = lights;
-}
+import { locateTraffic } from './locateTraffic.js';
+
+/**
+ * Rebuild the mesh's light snapshot by transforming each vehicle light to its current lane pose.
+ *
+ * @param {Object} state Traffic layer state.
+ */
+export function updateTrafficLights(state) {
+  state.litAt = performance.now();
+  const lights = /* alloc */ [];
+  const target = state.position ||= /* 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, target));
+    for (light of state.lights) {
+      [lx, ly, lz] = light.position;
+      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

@@ -1,15 +1,15 @@
-import { moveTraffic } from './moveTraffic.js';
-import { updateTrafficLights } from './updateTrafficLights.js';
-
-/**
- * Update GPU vehicle poses and refresh light positions, throttling live light updates.
- *
- * @param {Object} state Traffic layer state.
- * @param {number} ms Simulation timestamp in milliseconds.
- * @param {boolean} live Whether the simulation clock is live.
- */
-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);
-}
+import { moveTraffic } from './moveTraffic.js';
+import { updateTrafficLights } from './updateTrafficLights.js';
+
+/**
+ * Update GPU vehicle poses and refresh light positions, throttling live light updates.
+ *
+ * @param {Object} state Traffic layer state.
+ * @param {number} ms Simulation timestamp in milliseconds.
+ * @param {boolean} live Whether the simulation clock is live.
+ */
+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/updateTrafficTerrain.js

@@ -1,17 +1,17 @@
-import { disposeTrafficObject } from './disposeTrafficObject.js';
-import { groundTraffic } from './groundTraffic.js';
-import { trafficBounds } from './trafficBounds.js';
-
-/**
- * Reground traffic lanes after a terrain change and invalidate the route mesh and bounds.
- *
- * @param {Object} state Traffic layer state.
- */
+import { disposeTrafficObject } from './disposeTrafficObject.js';
+import { groundTraffic } from './groundTraffic.js';
+import { trafficBounds } from './trafficBounds.js';
+
+/**
+ * Reground traffic lanes after a terrain change and invalidate the route mesh and bounds.
+ *
+ * @param {Object} state Traffic layer state.
+ */
 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();
+  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/uploadTrafficLanes.js

@@ -1,27 +1,27 @@
-import { trafficStorage } from './trafficStorage.js';
-
-/**
- * Pack lane coordinates, elevations and cumulative distances into the GPU points buffer.
- *
- * @param {Object} state Traffic layer state.
- * @param {GPUDevice} device Device used to create the points buffer.
- */
-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;
-}
+import { trafficStorage } from './trafficStorage.js';
+
+/**
+ * Pack lane coordinates, elevations and cumulative distances into the GPU points buffer.
+ *
+ * @param {Object} state Traffic layer state.
+ * @param {GPUDevice} device Device used to create the points buffer.
+ */
+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/transforms/composeLocalTransform.js

@@ -1,23 +1,23 @@
-import { degrees } from '../globals/degrees.js';
-
-/**
- * Reuse the node's local matrix to compose translation, YXZ rotation and scale.
- *
- * @param {Object} node Scene node with position, rotation and scale.
- *
- * @returns {DOMMatrix} The composed local matrix.
- */
-export function composeLocalTransform(node) {
-  const matrix = node._localTransform ||= /* alloc */ new DOMMatrix();
-  matrix.m11 = 1, matrix.m12 = 0, matrix.m13 = 0, matrix.m14 = 0;
-  matrix.m21 = 0, matrix.m22 = 1, matrix.m23 = 0, matrix.m24 = 0;
-  matrix.m31 = 0, matrix.m32 = 0, matrix.m33 = 1, matrix.m34 = 0;
-  matrix.m41 = 0, matrix.m42 = 0, matrix.m43 = 0, matrix.m44 = 1;
-  matrix.translateSelf(node.position[0], node.position[1], node.position[2]);
-  // Node rotations use YXZ, as did the previous renderer.
-  matrix.rotateAxisAngleSelf(0, 1, 0, node.rotation[1] * degrees);
-  matrix.rotateAxisAngleSelf(1, 0, 0, node.rotation[0] * degrees);
-  matrix.rotateAxisAngleSelf(0, 0, 1, node.rotation[2] * degrees);
-  matrix.scaleSelf(node.scale[0], node.scale[1], node.scale[2]);
-  return matrix;
-}
+import { degrees } from '../globals/degrees.js';
+
+/**
+ * Reuse the node's local matrix to compose translation, YXZ rotation and scale.
+ *
+ * @param {Object} node Scene node with position, rotation and scale.
+ *
+ * @returns {DOMMatrix} The composed local matrix.
+ */
+export function composeLocalTransform(node) {
+  const matrix = node._localTransform ||= /* alloc */ new DOMMatrix();
+  matrix.m11 = 1, matrix.m12 = 0, matrix.m13 = 0, matrix.m14 = 0;
+  matrix.m21 = 0, matrix.m22 = 1, matrix.m23 = 0, matrix.m24 = 0;
+  matrix.m31 = 0, matrix.m32 = 0, matrix.m33 = 1, matrix.m34 = 0;
+  matrix.m41 = 0, matrix.m42 = 0, matrix.m43 = 0, matrix.m44 = 1;
+  matrix.translateSelf(node.position[0], node.position[1], node.position[2]);
+  // Node rotations use YXZ, as did the previous renderer.
+  matrix.rotateAxisAngleSelf(0, 1, 0, node.rotation[1] * degrees);
+  matrix.rotateAxisAngleSelf(1, 0, 0, node.rotation[0] * degrees);
+  matrix.rotateAxisAngleSelf(0, 0, 1, node.rotation[2] * degrees);
+  matrix.scaleSelf(node.scale[0], node.scale[1], node.scale[2]);
+  return matrix;
+}

package/src/transforms/transformNativePoint.js

@@ -1,19 +1,19 @@
-/**
- * Multiply a homogeneous point by a DOMMatrix and write its four components into target.
- *
- * @param {Object} target Reusable output point.
- * @param {DOMMatrix} matrix Transformation matrix.
- * @param {number} x Input x coordinate.
- * @param {number} y Input y coordinate.
- * @param {number} z Input z coordinate.
- * @param {number} w Input homogeneous coordinate.
- *
- * @returns {Object} The supplied target with x, y, z and w components.
- */
-export function transformNativePoint(target, matrix, x, y, z, w) {
-  target.x = matrix.m11 * x + matrix.m21 * y + matrix.m31 * z + matrix.m41 * w;
-  target.y = matrix.m12 * x + matrix.m22 * y + matrix.m32 * z + matrix.m42 * w;
-  target.z = matrix.m13 * x + matrix.m23 * y + matrix.m33 * z + matrix.m43 * w;
-  target.w = matrix.m14 * x + matrix.m24 * y + matrix.m34 * z + matrix.m44 * w;
-  return target;
-}
+/**
+ * Multiply a homogeneous point by a DOMMatrix and write its four components into target.
+ *
+ * @param {Object} target Reusable output point.
+ * @param {DOMMatrix} matrix Transformation matrix.
+ * @param {number} x Input x coordinate.
+ * @param {number} y Input y coordinate.
+ * @param {number} z Input z coordinate.
+ * @param {number} w Input homogeneous coordinate.
+ *
+ * @returns {Object} The supplied target with x, y, z and w components.
+ */
+export function transformNativePoint(target, matrix, x, y, z, w) {
+  target.x = matrix.m11 * x + matrix.m21 * y + matrix.m31 * z + matrix.m41 * w;
+  target.y = matrix.m12 * x + matrix.m22 * y + matrix.m32 * z + matrix.m42 * w;
+  target.z = matrix.m13 * x + matrix.m23 * y + matrix.m33 * z + matrix.m43 * w;
+  target.w = matrix.m14 * x + matrix.m24 * y + matrix.m34 * z + matrix.m44 * w;
+  return target;
+}

package/src/transforms/worldMatrixChanged.js

@@ -1,26 +1,26 @@
-/**
- * Compare and cache the node's explicit matrix or position, rotation and scale components.
- *
- * @param {Object} node Scene node with cached transform state.
- * @param {boolean} changed Whether another change was already detected.
- *
- * @returns {boolean} Whether the transform or another input changed.
- */
-export function worldMatrixChanged(node, changed) {
-  let i, value;
-  if (node.matrix) {
-    const state = node._matrixState ||= /* alloc */ new Float64Array(16);
-    for (i = 0; i < 16; i++) {
-      if (state[i] !== node.matrix[i]) changed = true;
-      state[i] = node.matrix[i];
-    }
-  } else {
-    const state = node._transformState ||= /* alloc */ new Float64Array(9);
-    for (i = 0; i < 9; i++) {
-      value = i < 3 ? node.position[i] : i < 6 ? node.rotation[i - 3] : node.scale[i - 6];
-      if (state[i] !== value) changed = true;
-      state[i] = value;
-    }
-  }
-  return changed;
-}
+/**
+ * Compare and cache the node's explicit matrix or position, rotation and scale components.
+ *
+ * @param {Object} node Scene node with cached transform state.
+ * @param {boolean} changed Whether another change was already detected.
+ *
+ * @returns {boolean} Whether the transform or another input changed.
+ */
+export function worldMatrixChanged(node, changed) {
+  let i, value;
+  if (node.matrix) {
+    const state = node._matrixState ||= /* alloc */ new Float64Array(16);
+    for (i = 0; i < 16; i++) {
+      if (state[i] !== node.matrix[i]) changed = true;
+      state[i] = node.matrix[i];
+    }
+  } else {
+    const state = node._transformState ||= /* alloc */ new Float64Array(9);
+    for (i = 0; i < 9; i++) {
+      value = i < 3 ? node.position[i] : i < 6 ? node.rotation[i - 3] : node.scale[i - 6];
+      if (state[i] !== value) changed = true;
+      state[i] = value;
+    }
+  }
+  return changed;
+}

package/src/triangulation/clipEars.js

@@ -1,32 +1,32 @@
-import { cross } from './cross.js';
-import { containsVertex } from './containsVertex.js';
-
-/**
- * Clip convex ears from a polygon in place to produce indexed triangles.
- *
- * @param {Object[]} polygon Counterclockwise vertices carrying original indices.
- *
- * @returns {number[][]} Triangles of original vertex indices.
- *
- * @throws {Error} If no further ear can be clipped.
- */
-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;
-}
+import { cross } from './cross.js';
+import { containsVertex } from './containsVertex.js';
+
+/**
+ * Clip convex ears from a polygon in place to produce indexed triangles.
+ *
+ * @param {Object[]} polygon Counterclockwise vertices carrying original indices.
+ *
+ * @returns {number[][]} Triangles of original vertex indices.
+ *
+ * @throws {Error} If no further ear can be clipped.
+ */
+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

@@ -1,30 +1,30 @@
-import { inside } from './inside.js';
-import { insideHole } from './insideHole.js';
-import { crossesBoundary } from './crossesBoundary.js';
-
-/**
- * Connect a hole to the polygon using the shortest valid vertex bridge.
- *
- * @param {Object[]} polygon Current polygon vertices.
- * @param {Object[]} hole Hole vertices to connect.
- * @param {Object[][]} rings Outer ring followed by hole rings.
- * @param {Object} mid Reusable midpoint with x and y fields.
- *
- * @returns {Object[]} Polygon vertices including the bridged hole.
- *
- * @throws {Error} If no valid bridge can be found.
- */
-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)];
-}
+import { inside } from './inside.js';
+import { insideHole } from './insideHole.js';
+import { crossesBoundary } from './crossesBoundary.js';
+
+/**
+ * Connect a hole to the polygon using the shortest valid vertex bridge.
+ *
+ * @param {Object[]} polygon Current polygon vertices.
+ * @param {Object[]} hole Hole vertices to connect.
+ * @param {Object[][]} rings Outer ring followed by hole rings.
+ * @param {Object} mid Reusable midpoint with x and y fields.
+ *
+ * @returns {Object[]} Polygon vertices including the bridged hole.
+ *
+ * @throws {Error} If no valid bridge can be found.
+ */
+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/cross.js

@@ -1,12 +1,12 @@
-/**
- * Compute the signed 2D cross product of the vectors from a to b and c.
- *
- * @param {Object} a Origin point with x and y coordinates.
- * @param {Object} b First endpoint.
- * @param {Object} c Second endpoint.
- *
- * @returns {number} Signed cross product.
- */
-export function cross(a, b, c) {
-  return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
-}
+/**
+ * Compute the signed 2D cross product of the vectors from a to b and c.
+ *
+ * @param {Object} a Origin point with x and y coordinates.
+ * @param {Object} b First endpoint.
+ * @param {Object} c Second endpoint.
+ *
+ * @returns {number} Signed cross product.
+ */
+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/equal.js

@@ -1,11 +1,11 @@
-/**
- * Compare two planar points by exact coordinates.
- *
- * @param {Object} a First point.
- * @param {Object} b Second point.
- *
- * @returns {boolean} Whether both coordinates match.
- */
-export function equal(a, b) {
-  return a.x === b.x && a.y === b.y;
-}
+/**
+ * Compare two planar points by exact coordinates.
+ *
+ * @param {Object} a First point.
+ * @param {Object} b Second point.
+ *
+ * @returns {boolean} Whether both coordinates match.
+ */
+export function equal(a, b) {
+  return a.x === b.x && a.y === b.y;
+}

package/src/triangulation/intersects.js

@@ -1,21 +1,21 @@
-import { equal } from './equal.js';
-import { cross } from './cross.js';
-import { on } from './on.js';
-
-/**
- * Test two segments for intersection, excluding shared endpoints.
- *
- * @param {Object} a First endpoint of the first segment.
- * @param {Object} b Second endpoint of the first segment.
- * @param {Object} c First endpoint of the second segment.
- * @param {Object} d Second endpoint of the second segment.
- *
- * @returns {boolean} Whether the segments intersect.
- */
-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);
-}
+import { equal } from './equal.js';
+import { cross } from './cross.js';
+import { on } from './on.js';
+
+/**
+ * Test two segments for intersection, excluding shared endpoints.
+ *
+ * @param {Object} a First endpoint of the first segment.
+ * @param {Object} b Second endpoint of the first segment.
+ * @param {Object} c First endpoint of the second segment.
+ * @param {Object} d Second endpoint of the second segment.
+ *
+ * @returns {boolean} Whether the segments intersect.
+ */
+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/mergeHoles.js

@@ -1,19 +1,19 @@
-/**
- * Merge two adjacent runs of hole entries by their minimum x coordinate.
- *
- * @param {Object[]} source Sorted runs of hole entries.
- * @param {Object[]} target Array receiving the merged entries.
- * @param {number} start First index of the runs.
- * @param {number} width Maximum length of each run.
- */
-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++];
-    }
-  }
-}
+/**
+ * Merge two adjacent runs of hole entries by their minimum x coordinate.
+ *
+ * @param {Object[]} source Sorted runs of hole entries.
+ * @param {Object[]} target Array receiving the merged entries.
+ * @param {number} start First index of the runs.
+ * @param {number} width Maximum length of each run.
+ */
+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++];
+    }
+  }
+}