leaflet-city-mapper 0.0.8 → 0.1.0

package/src/traffic/readyTraffic.js

@@ -1,5 +1,10 @@
-import { startTraffic } from './startTraffic.js';
-
+import { startTraffic } from './startTraffic.js';
+
+/**
+ * Mark a traffic layer ready and start it if already attached to a map.
+ *
+ * @param {Object} state Traffic layer state.
+ */
 export function readyTraffic(state) {
   state.ready = true;
   if (state.layer._map) startTraffic(state);

package/src/traffic/rebaseTraffic.js

@@ -1,11 +1,13 @@
 import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
-
-
-
 import { destroyTrafficGpu } from './destroyTrafficGpu.js';
 import { trafficStorage } from './trafficStorage.js';
 import { uploadTrafficLanes } from './uploadTrafficLanes.js';
 
+/**
+ * Upload current lanes and trips, recreating device resources as needed and binding the traffic compute pipeline.
+ *
+ * @param {Object} state Traffic layer state.
+ */
 export function rebaseTraffic(state) {
   const { device } = rendererByLayer.get(state.layer);
   if (state.gpu?.device !== device) {

package/src/traffic/rebuildTrafficMesh.js

@@ -4,7 +4,11 @@ import { createTrafficMesh } from './createTrafficMesh.js';
 import { disposeTrafficObject } from './disposeTrafficObject.js';
 import { trafficBounds } from './trafficBounds.js';
 
-
+/**
+ * Replace the batched vehicle mesh and feature ranges when the active trip set changes.
+ *
+ * @param {Object} state Traffic layer state.
+ */
 export function rebuildTrafficMesh(state) {
   const { trips, model, vertices } = state;
   disposeTrafficObject(state, state.mesh);

package/src/traffic/refreshTrafficTrips.js

@@ -5,6 +5,16 @@ import { rebuildTrafficMesh } from './rebuildTrafficMesh.js';
 import { rebaseTraffic } from './rebaseTraffic.js';
 import { trafficStatusText } from './trafficStatusText.js';
 
+/**
+ * Recompute scheduled trips and status, rebuilding changed geometry and rebasing GPU data.
+ *
+ * @param {Object} state Traffic layer state.
+ * @param {Date|undefined} time Simulation time, if available.
+ * @param {number|undefined} ms Simulation timestamp in milliseconds, if available.
+ * @param {boolean} valid Whether the simulation timestamp is valid.
+ *
+ * @returns {boolean|undefined} Whether geometry changed, or undefined if updating trips failed.
+ */
 export function refreshTrafficTrips(state, time, ms, valid) {
   let text;
   try {

package/src/traffic/removeTraffic.js

@@ -1,9 +1,12 @@
 import { trafficByLayer } from '../weakmaps/trafficByLayer.js';
-
-
 import { disposeTrafficObject } from './disposeTrafficObject.js';
 import { destroyTrafficGpu } from './destroyTrafficGpu.js';
 
+/**
+ * Abort loading, unregister listeners and release traffic meshes, GPU resources and lane state.
+ *
+ * @param {Object} state Traffic layer state.
+ */
 export function removeTraffic(state) {
   state.request?.abort();
   cancelAnimationFrame(state.frame);

package/src/traffic/routeColor.js

@@ -1,3 +1,10 @@
+/**
+ * Decode a six-digit route color to normalized RGB, falling back to the default route color.
+ *
+ * @param {Object|null|undefined} properties Route properties containing an optional route_color.
+ *
+ * @returns {number[]} Normalized RGB components.
+ */
 export function routeColor(properties) {
   const color = properties?.route_color;
   if (!/^[\da-f]{6}$/i.test(color)) return /* alloc */ [0.1, 0.55, 0.65];

package/src/traffic/scheduledTrips.js

@@ -2,14 +2,17 @@ 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 {Date|string|number} date Simulation date.
  * @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.
+ *
+ * @throws {Error} If the date is invalid.
  */
-
 export function scheduledTrips(date, { timeZone, duration, services }) {
   const time = date instanceof Date ? date
     : /* alloc */ new Date(date);

package/src/traffic/startTraffic.js

@@ -1,5 +1,10 @@
-import { underEntry } from '../layer-controls/underEntry.js';
-
+import { underEntry } from '../layer-controls/underEntry.js';
+
+/**
+ * Register time and terrain listeners, show the layer status and start traffic updates.
+ *
+ * @param {Object} state Traffic layer state.
+ */
 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);

package/src/traffic/tickTraffic.js

@@ -1,12 +1,14 @@
 import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
-
-
-
 import { update as updateScene } from '../scene/scheduleSceneUpdate.js';
 import { trafficNow } from './trafficNow.js';
 import { refreshTrafficTrips } from './refreshTrafficTrips.js';
 import { updateTrafficPose } from './updateTrafficPose.js';
 
+/**
+ * Update trips and GPU poses for the simulation clock, scheduling another frame in live mode.
+ *
+ * @param {Object} state Traffic layer state.
+ */
 export function tickTraffic(state) {
   state.frame = undefined;
   if (!state.ready || !state.layer._map) return;

package/src/traffic/trafficBounds.js

@@ -1,5 +1,10 @@
 import { computeBounds } from '../geometry/computeBounds.js';
 
+/**
+ * Compute conservative traffic mesh bounds from lane points, vehicle dimensions and lateral offset.
+ *
+ * @param {Object} state Traffic layer state.
+ */
 export function trafficBounds(state) {
   let radius = 20, height = 5;
   let i, lane, x, z, y;

package/src/traffic/trafficNow.js

@@ -1,8 +1,13 @@
-import { timeControlByMap } from '../weakmaps/timeControlByMap.js';
-
-
+import { timeControlByMap } from '../weakmaps/timeControlByMap.js';
 
-export function trafficNow(state) {
+/**
+ * Return the selected simulation time, or the current time when the map clock is live.
+ *
+ * @param {Object} state Traffic layer state.
+ *
+ * @returns {Object} Live-mode flag and selected time.
+ */
+export function trafficNow(state) {
   const control = timeControlByMap.get(state.layer._map);
   const live = control ? control.live : true;
   return /* alloc */ {

package/src/traffic/trafficStatusText.js

@@ -1,3 +1,11 @@
+/**
+ * Format the traffic layer status for an invalid clock, loading state or active trip count.
+ *
+ * @param {Object} state Traffic layer state.
+ * @param {boolean} valid Whether the simulation time is valid.
+ *
+ * @returns {string} Status text.
+ */
 export function trafficStatusText(state, valid) {
   if (!valid) return `${state.vehicle}: select a valid simulation date`;
   if (!state.loaded) return `${state.vehicle}: loading…`;

package/src/traffic/trafficStorage.js

@@ -1,3 +1,11 @@
+/**
+ * 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);

package/src/traffic/trafficTooltip.js

@@ -1,3 +1,10 @@
+/**
+ * Build a text-only traffic tooltip from the route name, departure and description.
+ *
+ * @param {Object} feature Feature containing traffic properties.
+ *
+ * @returns {HTMLElement} Tooltip content.
+ */
 export function tooltip({ properties: p }) {
   const content = document.createElement('div');
   content.style.whiteSpace = 'pre-line';

package/src/traffic/tripsAt.js

@@ -1,8 +1,15 @@
 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.
-
+/**
+ * Generate active timetable trips and evenly spaced looping vehicles for flow-based lanes at the given time.
+ *
+ * @param {Date} time Simulation time.
+ * @param {Array} lanes Prepared traffic lanes.
+ * @param {number} velocity Flow-vehicle speed in metres per second.
+ *
+ * @returns {Array} Active trips and their lane positions.
+ */
 export function tripsAt(time, lanes, velocity) {
   const trips = /* alloc */ [];
   let l, lane, timetable, flow, trip, travelled, offsets, k;

package/src/traffic/updateTraffic.js

@@ -1,10 +1,13 @@
-import { controlByLayer } from '../weakmaps/controlByLayer.js';
-
-
-
-import { loadTraffic } from './loadTraffic.js';
-
-export function updateTraffic(state, event) {
+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);

package/src/traffic/updateTrafficLights.js

@@ -1,5 +1,10 @@
 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 */ [];

package/src/traffic/updateTrafficPose.js

@@ -1,6 +1,13 @@
 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);

package/src/traffic/updateTrafficTerrain.js

@@ -1,8 +1,13 @@
-import { disposeTrafficObject } from './disposeTrafficObject.js';
-import { groundTraffic } from './groundTraffic.js';
-import { trafficBounds } from './trafficBounds.js';
-
-export function updateTrafficTerrain(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);

package/src/traffic/uploadTrafficLanes.js

@@ -1,5 +1,11 @@
 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;

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,5 +1,12 @@
 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;

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,3 +1,15 @@
+/**
+ * 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;

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,3 +1,11 @@
+/**
+ * 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) {

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,6 +1,15 @@
 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;

package/src/triangulation/connectHole.js

@@ -2,6 +2,18 @@ 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++) {

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 @@
+/**
+ * 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 @@
+/**
+ * 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

@@ -2,6 +2,16 @@ 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);