leaflet-city-mapper 0.0.9 → 0.1.1

package/src/traffic/updateTrafficTerrain.js

@@ -2,11 +2,16 @@ 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();
+/**
+ * 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();
 }

package/src/traffic/uploadTrafficLanes.js

@@ -1,21 +1,27 @@
-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;
-}
+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/traffic/vehicleOffsets.js

@@ -1,8 +1,14 @@
 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. */
-
+/**
+ * Compute evenly spaced starting offsets for vehicles moving along a lane.
+ *
+ * @param {number} length Lane length in metres.
+ * @param {number} flow Vehicles per hour.
+ * @param {number} [velocity] Vehicle speed in metres per second.
+ *
+ * @returns {number[]} Starting offsets in metres.
+ */
 export function vehicleOffsets(length, flow, velocity = speed) {
   const count = Math.round(length * flow / 3600 / velocity);
   const offsets = Array.from(/* alloc */ { length: count });

package/src/transforms/README.md

@@ -0,0 +1,27 @@
+# Transforms
+
+[Source guide](../README.md) | [Project README](../../README.md)
+
+Composes model and scene transforms and updates world matrices when nodes or
+their parents change.
+
+## Local to world
+
+```mermaid
+flowchart LR
+  TRS["Node translation / YXZ rotation / scale"] --> Local["Local matrix"]
+  Explicit["Explicit node matrix"] --> Local
+  Parent["Parent world matrix"] --> World["World = parent × local"]
+  Local --> World
+  World --> Consumers["Rendering / picking / collision"]
+  GLTF["glTF translation / quaternion / scale"] --> Explicit
+```
+
+An explicit matrix overrides node components. Unchanged matrices are not
+recomputed, but children are still visited. Geographic projection is separate.
+
+- [composeLocalTransform.js](./composeLocalTransform.js): compose translation, rotation and scale.
+- [updateWorldMatrix.js](./updateWorldMatrix.js): update a scene subtree.
+- [modelNodeMatrix.js](./modelNodeMatrix.js): derive model node transforms.
+
+Related: [scene](../scene/README.md), [models](../models/README.md), [projections](../projections/README.md).

package/src/transforms/composeLocalTransform.js

@@ -1,16 +1,23 @@
-import { degrees } from '../globals/degrees.js';
-
-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/modelNodeMatrix.js

@@ -1,9 +1,14 @@
 import { geometryQuaternion } from '../globals/geometryQuaternion.js';
 import { geometryScale } from '../globals/geometryScale.js';
 import { geometryTranslation } from '../globals/geometryTranslation.js';
-/** glTF quaternion/translation/scale to a column-major matrix. */
-
 
+/**
+ * Convert glTF quaternion, translation and scale to a column-major matrix, or copy its explicit matrix.
+ *
+ * @param {Object} spec glTF node transform.
+ *
+ * @returns {number[]} Column-major 4x4 matrix.
+ */
 export function nodeMatrix(spec) {
   if (spec.matrix) return Array.from(spec.matrix);
   // glTF stores quaternions [x,y,z,w]; convert directly to a scaled column-major matrix.

package/src/transforms/transformNativePoint.js

@@ -1,7 +1,19 @@
-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/updateWorldMatrix.js

@@ -1,8 +1,11 @@
 import { worldMatrixChanged } from './worldMatrixChanged.js';
 import { composeLocalTransform } from './composeLocalTransform.js';
 
-/** Compose parent*local matrices; a node.matrix overrides its position/rotation/scale. */
-
+/**
+ * Compose parent*local matrices; a node.matrix overrides its position/rotation/scale.
+ *
+ * @param {Object} node Scene node whose subtree will be updated.
+ */
 export function updateWorldMatrix(node) {
   const parent = node.parent;
   const parentVersion = parent?._worldMatrixVersion || 0;

package/src/transforms/worldMatrixChanged.js

@@ -1,18 +1,26 @@
-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/README.md

@@ -0,0 +1,26 @@
+# Triangulation
+
+[Source guide](../README.md) | [Project README](../../README.md)
+
+Triangulates polygon contours and holes, cleaning rings and normalizing their
+winding while retaining indices into the original input vertices.
+
+## Polygon to triangles
+
+```mermaid
+flowchart LR
+  Rings["Outer contour + holes"] --> Clean["Clean + normalize winding"]
+  Clean --> Bridge["Connect holes"]
+  Bridge --> Clip["Clip ears"]
+  Clip --> Triangles["Triangles indexed into original inputs"]
+```
+
+Input rings omit the repeated closing vertex. Indices still refer to the
+original contour followed by holes after cleanup; preserve that contract.
+[MVT](../mvt/README.md) has a separate fallback for quantized rings.
+
+- [triangulate.js](./triangulate.js): triangulate a polygon.
+- [polygonRings.js](./polygonRings.js): clean and normalize rings.
+- [clipEars.js](./clipEars.js): generate triangles by ear clipping.
+
+Related: [geometry](../geometry/README.md), [mvt](../mvt/README.md).

package/src/triangulation/area.js

@@ -1,3 +1,10 @@
+/**
+ * Calculate the unsigned area enclosed by a planar ring.
+ *
+ * @param {Object[]} ring Points with x and y coordinates.
+ *
+ * @returns {number} Absolute ring area.
+ */
 export function area(ring) {
   let sum = 0;
   let i, p, q;

package/src/triangulation/clean.js

@@ -1,6 +1,15 @@
 import { cross } from './cross.js';
 import { equal } from './equal.js';
 
+/**
+ * Remove duplicate and collinear vertices in place while preserving at least three points.
+ *
+ * @param {Object[]} ring Planar vertices to clean.
+ *
+ * @returns {Object[]} The supplied ring.
+ *
+ * @throws {Error} If the ring has fewer than three vertices.
+ */
 export function clean(ring) {
   let changed = true;
   let i, a, b, c;

package/src/triangulation/clipEars.js

@@ -1,23 +1,32 @@
-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;
-}
+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,18 +1,30 @@
-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)];
-}
+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/containsVertex.js

@@ -1,6 +1,16 @@
 import { equal } from './equal.js';
 import { cross } from './cross.js';
 
+/**
+ * Check whether a polygon has another vertex inside or on a counterclockwise triangle.
+ *
+ * @param {Object[]} polygon Planar polygon vertices.
+ * @param {Object} a First triangle vertex.
+ * @param {Object} b Second triangle vertex.
+ * @param {Object} c Third triangle vertex.
+ *
+ * @returns {boolean} Whether a distinct polygon vertex is contained.
+ */
 export function containsVertex(polygon, a, b, c) {
   let p;
   for (p of polygon) {

package/src/triangulation/cross.js

@@ -1,3 +1,12 @@
-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/crossesBoundary.js

@@ -1,5 +1,15 @@
 import { crossesRing } from './crossesRing.js';
 
+/**
+ * Test a segment against the current polygon and each hole boundary.
+ *
+ * @param {Object} a First segment endpoint.
+ * @param {Object} b Second segment endpoint.
+ * @param {Object[]} polygon Current polygon vertices.
+ * @param {Object[][]} rings Outer ring followed by hole rings.
+ *
+ * @returns {boolean} Whether the segment intersects a boundary.
+ */
 export function crossesBoundary(a, b, polygon, rings) {
   if (crossesRing(a, b, polygon)) return true;
   let i;

package/src/triangulation/crossesRing.js

@@ -1,5 +1,14 @@
 import { intersects } from './intersects.js';
 
+/**
+ * Test a segment against all edges of a closed ring.
+ *
+ * @param {Object} a First segment endpoint.
+ * @param {Object} b Second segment endpoint.
+ * @param {Object[]} ring Planar ring vertices.
+ *
+ * @returns {boolean} Whether the segment intersects a ring edge away from shared endpoints.
+ */
 export function crossesRing(a, b, ring) {
   let i;
   for (i = 0; i < ring.length; i++) {

package/src/triangulation/equal.js

@@ -1,3 +1,11 @@
-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/inside.js

@@ -1,3 +1,11 @@
+/**
+ * Test a planar point against a ring using crossing parity.
+ *
+ * @param {Object} point Point with x and y coordinates.
+ * @param {Object[]} ring Planar ring vertices.
+ *
+ * @returns {boolean} Whether the crossing test places the point inside.
+ */
 export function inside(point, ring) {
   let result = false;
   let i, j, a, b;

package/src/triangulation/insideHole.js

@@ -1,5 +1,13 @@
 import { inside } from './inside.js';
 
+/**
+ * Test whether a point is inside any hole ring.
+ *
+ * @param {Object} point Point with x and y coordinates.
+ * @param {Object[][]} rings Outer ring followed by hole rings.
+ *
+ * @returns {boolean} Whether the point is inside a hole.
+ */
 export function insideHole(point, rings) {
   let i;
   for (i = 1; i < rings.length; i++) if (inside(point, rings[i])) return true;

package/src/triangulation/intersects.js

@@ -1,11 +1,21 @@
-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);
-}
+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/isClockWise.js

@@ -1,7 +1,10 @@
 /**
+ * Determine a planar ring's winding from its signed area.
+ *
+ * @param {Object[]} points Ring points with x and y coordinates.
+ *
  * @returns {boolean} Whether the `{x, y}` points are in clockwise order.
  */
-
 export function isClockWise(points) {
   let area = 0;
   let i, a, b;

package/src/triangulation/mergeHoles.js

@@ -1,11 +1,19 @@
-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++];
+    }
+  }
+}

package/src/triangulation/minimumX.js

@@ -1,3 +1,10 @@
+/**
+ * Find the smallest x coordinate in a ring.
+ *
+ * @param {Object[]} ring Points with x coordinates.
+ *
+ * @returns {number} Minimum x, or Infinity for an empty ring.
+ */
 export function minimumX(ring) {
   let minimum = Infinity;
   let point;