@woosh/meep-engine 2.163.11 → 2.165.0

package/src/core/geom/2d/convex-hull/fixed_convex_hull_relaxation.js

@@ -1,288 +1,7 @@
-import { array_copy } from "../../../collection/array/array_copy.js";
-import { Uint32Heap } from "../../../collection/heap/Uint32Heap.js";
-import { intersect_ray_2d } from "../intersect_ray_2d.js";
-import { triangle2d_compute_area } from "../triangle2d_compute_area.js";
-
-
-const v2_temp = new Float32Array(2);
-
-class Edge {
-    /**
-     * Unique index of this edge
-     * @type {number}
-     */
-    index;
-    /**
-     * Index into position buffer
-     * @type {number}
-     */
-    v0;
-    /**
-     * Index into position buffer
-     * @type {number}
-     */
-    v1;
-
-    /**
-     * @type {Edge}
-     */
-    next;
-    /**
-     * @type {Edge}
-     */
-    prev;
-}
-
-/**
- *
- * @param {number[]|Float32Array|Float64Array} output
- * @param {number} output_offset
- * @param {Edge} edge
- * @param {number[]} vertex_buffer
- * @returns {boolean}
- */
-function compute_collapse_target(output, output_offset, edge, vertex_buffer) {
-    const a0 = edge.prev.v0;
-    const a1 = edge.prev.v1;
-
-    const b0 = edge.next.v0;
-    const b1 = edge.next.v1;
-
-    const a0x = vertex_buffer[a0 * 2];
-    const a0y = vertex_buffer[a0 * 2 + 1];
-
-    const a1x = vertex_buffer[a1 * 2];
-    const a1y = vertex_buffer[a1 * 2 + 1];
-
-    const b0x = vertex_buffer[b0 * 2];
-    const b0y = vertex_buffer[b0 * 2 + 1];
-
-    const b1x = vertex_buffer[b1 * 2];
-    const b1y = vertex_buffer[b1 * 2 + 1];
-
-    const a_dir_x = a1x - a0x;
-    const a_dir_y = a1y - a0y;
-
-    const b_dir_x = b1x - b0x;
-    const b_dir_y = b1y - b0y;
-
-    return intersect_ray_2d(
-        output, output_offset,
-        a0x, a0y, a_dir_x, a_dir_y,
-        b0x, b0y, b_dir_x, b_dir_y
-    );
-}
-
-/**
- *
- * @param {number} point_offset
- * @param {number} point_count
- * @returns {Edge[]}
- */
-function build_edges(point_offset, point_count) {
-    /**
-     *
-     * @type {Edge[]}
-     */
-    const edges = [];
-
-    for (let i = 0; i < point_count; i++) {
-        const edge = new Edge();
-
-        edge.index = i;
-
-        edge.v0 = i + point_offset;
-        edge.v1 = (i + 1) % point_count + point_offset;
-
-        edges[i] = edge;
-    }
-
-    // connect edges
-    for (let i = 0; i < point_count; i++) {
-        const edge = edges[i];
-
-        edge.next = edges[(i + 1) % point_count];
-        edge.prev = edges[(point_count + i - 1) % point_count];
-    }
-
-    return edges;
-}
-
-/**
- *
- * @param {Edge} edge
- * @param {number[]|Float32Array|Float64Array} vertex_buffer
- * @param {number} new_vertex_index
- */
-function collapse_edge(edge, vertex_buffer, new_vertex_index) {
-    // this edge will be removed, previous and next edges will receive a new vertex where they connected to this edge
-    // adjacent edges will become neighbours
-
-    const valid = compute_collapse_target(v2_temp, 0, edge, vertex_buffer);
-
-    if (!valid) {
-        return false;
-    }
-
-    const next = edge.next;
-    const prev = edge.prev;
-
-    // connect edges together
-    next.prev = prev;
-    prev.next = next;
-
-    // inject new vertex
-
-    next.v0 = new_vertex_index;
-    prev.v1 = new_vertex_index;
-
-    //write out new vertex
-    array_copy(v2_temp, 0, vertex_buffer, new_vertex_index * 2, 2);
-
-    return true;
-}
-
-/**
- *
- * @param {Edge} edge
- * @param {number[]|Float64Array|Float32Array} vertex_buffer
- */
-function compute_collapse_cost(edge, vertex_buffer) {
-    if (!compute_collapse_target(v2_temp, 0, edge, vertex_buffer)) {
-        return Infinity;
-    }
-
-    const v0x = vertex_buffer[edge.v0 * 2];
-    const v0y = vertex_buffer[edge.v0 * 2 + 1];
-
-    const v1x = vertex_buffer[edge.v1 * 2];
-    const v1y = vertex_buffer[edge.v1 * 2 + 1];
-
-    const area = triangle2d_compute_area(
-        v0x, v0y, v2_temp[0], v2_temp[1], v1x, v1y
-    );
-
-    //
-    // if (area < 0 || Number.isNaN(area)) {
-    //     debugger;
-    // }
-
-    return area;
-}
-
-/**
- * Will throw an error after not being able to collapse an edge for this many cycles
- * @readonly
- * @type {number}
- */
-const RETRY_MAX_COUNT = 1000;
-
-/**
- * Relaxes existing convex hull by removing edges until desired cardinality of the hull is reached
- * The algorithm reaches the similar solution as the one proposed by humus, but arrives at a solution much faster as it doesn't need to consider every combination of edges
- * The algorithm is greedy, and thus it can lead to suboptimal cuts, especially on lower number of output vertices
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- *
- * @param {number[]|Float32Array} output result will be written here
- * @param {number} output_offset offset into output array where to write the result
- * @param {number} output_point_count number of points to comprise bounding polygon
- * @param {number[]} input_points Points to be bounded, must be an ordered loop
- * @param {number} input_point_count number of points in the input to consider
- * @returns {number} actual number of points, this can be lower because input polygon has too few points
- */
-export function fixed_convex_hull_relaxation(
-    output, output_offset, output_point_count,
-    input_points, input_point_count
-) {
-
-    if (output_point_count >= input_point_count) {
-        // special case, input polygon is smaller or equal to in cardinality to what's desired
-        array_copy(input_points, 0, output, output_offset, input_point_count * 2);
-        return input_point_count;
-    }
-
-
-    /**
-     * Point buffer will be twice as large as the input to have enough space for collapsing all the edges and recording
-     * new unique vertices produced
-     * @type {Float64Array}
-     */
-    const point_buffer = new Float32Array(input_point_count * 4);
-
-    array_copy(input_points, 0, point_buffer, 0, input_point_count * 2);
-
-    /**
-     * Offset into point buffer
-     * @type {number}
-     */
-    let point_buffer_cursor = input_point_count;
-
-    const edges = build_edges(0, input_point_count);
-    const live_edge_set = new Set(edges);
-
-    const edge_heap = new Uint32Heap(input_point_count);
-
-
-    // build costs for edges
-    for (let i = 0; i < input_point_count; i++) {
-        const cost = compute_collapse_cost(edges[i], point_buffer);
-        edge_heap.insert(i, cost);
-    }
-
-    let retry = 0;
-
-    while (live_edge_set.size > output_point_count) {
-        const victim = edge_heap.pop_min();
-
-        const edge = edges[victim];
-
-        if (!collapse_edge(edge, point_buffer, point_buffer_cursor)) {
-            // couldn't collapse, re-insert with very high score so other edges are tried first
-            edge_heap.insert(victim, Infinity);
-
-            retry++;
-
-            if (retry >= RETRY_MAX_COUNT) {
-                console.warn('Failed to collapse an edge after maximum number of retries has been reached');
-                break;
-            }
-
-            // skip the post-collapse bookkeeping: the edge was NOT collapsed, so it must not be consumed
-            // (deleted / cursor-advanced / neighbour-updated) as if it had been.
-            continue;
-        }
-
-        retry = 0;
-
-        point_buffer_cursor++;
-
-        live_edge_set.delete(edge);
-
-        // update costs for surviving neighbours
-        const next_index = edge.next.index;
-        const prev_index = edge.prev.index;
-        edge_heap.update_score(next_index, compute_collapse_cost(edges[next_index], point_buffer));
-        edge_heap.update_score(prev_index, compute_collapse_cost(edges[prev_index], point_buffer));
-    }
-
-    // pick first edge to start walking
-    const first_live_edge = live_edge_set.values().next().value;
-    let e = first_live_edge;
-
-    let output_cursor = output_offset;
-
-    do {
-        // walk the loop, recording first vertex of each edge we visit
-
-        array_copy(point_buffer, e.v0 * 2, output, output_cursor, 2);
-        e = e.next;
-
-        output_cursor += 2;
-
-    } while (e !== first_live_edge);
-
-    // number of output vertices is derived from how many we recorded
-    return (output_cursor - output_offset) / 2;
-}
+import { convex_hull_fixed_count_2d_relaxation } from "./convex_hull_fixed_count_2d_relaxation.js";
+
+/**
+ * @deprecated Renamed to {@link convex_hull_fixed_count_2d_relaxation}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const fixed_convex_hull_relaxation = convex_hull_fixed_count_2d_relaxation;

package/src/core/geom/2d/convex-hull/orient2d_indexed.d.ts

@@ -0,0 +1,10 @@
+/**
+ *
+ * @param {number[]} points
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @returns {number}
+ */
+export function orient2d_indexed(points: number[], a: number, b: number, c: number): number;
+//# sourceMappingURL=orient2d_indexed.d.ts.map

package/src/core/geom/2d/convex-hull/orient2d_indexed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orient2d_indexed.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/convex-hull/orient2d_indexed.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,yCANW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAalB"}

package/src/core/geom/2d/convex-hull/orient2d_indexed.js

@@ -0,0 +1,22 @@
+import { orient2d } from "robust-predicates";
+
+/**
+ *
+ * @param {number[]} points
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @returns {number}
+ */
+export function orient2d_indexed(points, a, b, c) {
+    const ax = points[a * 2];
+    const ay = points[a * 2 + 1];
+
+    const bx = points[b * 2];
+    const by = points[b * 2 + 1];
+
+    const cx = points[c * 2];
+    const cy = points[c * 2 + 1];
+
+    return orient2d(ax, ay, bx, by, cx, cy);
+}

package/src/core/geom/2d/convex-hull/orientation3_array.d.ts

@@ -1,10 +1,7 @@
 /**
- *
- * @param {number[]} points
- * @param {number} a
- * @param {number} b
- * @param {number} c
- * @returns {number}
+ * @deprecated Renamed to {@link orient2d_indexed}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function orientation3_array(points: number[], a: number, b: number, c: number): number;
+export const orientation3_array: typeof orient2d_indexed;
+import { orient2d_indexed } from "./orient2d_indexed.js";
 //# sourceMappingURL=orientation3_array.d.ts.map

package/src/core/geom/2d/convex-hull/orientation3_array.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"orientation3_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/convex-hull/orientation3_array.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,2CANW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAalB"}
+{"version":3,"file":"orientation3_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/convex-hull/orientation3_array.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,yDAAmD;iCANlB,uBAAuB"}

package/src/core/geom/2d/convex-hull/orientation3_array.js

@@ -1,22 +1,7 @@
-import { orient2d } from "robust-predicates";
-
-/**
- *
- * @param {number[]} points
- * @param {number} a
- * @param {number} b
- * @param {number} c
- * @returns {number}
- */
-export function orientation3_array(points, a, b, c) {
-    const ax = points[a * 2];
-    const ay = points[a * 2 + 1];
-
-    const bx = points[b * 2];
-    const by = points[b * 2 + 1];
-
-    const cx = points[c * 2];
-    const cy = points[c * 2 + 1];
-
-    return orient2d(ax, ay, bx, by, cx, cy);
-}
+import { orient2d_indexed } from "./orient2d_indexed.js";
+
+/**
+ * @deprecated Renamed to {@link orient2d_indexed}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const orientation3_array = orient2d_indexed;

package/src/core/geom/2d/hash-grid/shg_query_elements_line.js

@@ -1,6 +1,6 @@
 import { assert } from "../../../assert.js";
 import { aabb2_clip_line_cohen_sutherland } from "../aabb/aabb2_clip_line_cohen_sutherland.js";
-import { line2_distance_to_point_sqr } from "../line/line2_distance_to_point_sqr.js";
+import { line2_compute_segment_point_distance_sqr } from "../line/line2_compute_segment_point_distance_sqr.js";
 import {
     COLUMN_ELEMENT_X0,
     COLUMN_ELEMENT_X1,
@@ -106,12 +106,12 @@ export function shg_query_elements_line(
         }
 
         // check moves forward
-        const move_x_distance = line2_distance_to_point_sqr(
+        const move_x_distance = line2_compute_segment_point_distance_sqr(
             grid_x0, grid_y0, grid_x1, grid_y1,
             x + step_x + 0.5, y + 0.5
         );
 
-        const move_y_distance = line2_distance_to_point_sqr(
+        const move_y_distance = line2_compute_segment_point_distance_sqr(
             grid_x0, grid_y0, grid_x1, grid_y1,
             x + 0.5, y + step_y + 0.5
         );

package/src/core/geom/2d/intersect_ray_2d.d.ts

@@ -1,16 +1,7 @@
 /**
- * NOTE: that direction must not be normalized for correct results and instead derived from line length
- * @param {number[]|Float32Array|Float64Array} out
- * @param {number} out_offset
- * @param {number} origin_a_x
- * @param {number} origin_a_y
- * @param {number} direction_a_x
- * @param {number} direction_a_y
- * @param {number} origin_b_x
- * @param {number} origin_b_y
- * @param {number} direction_b_x
- * @param {number} direction_b_y
- * @returns {boolean} false if lines are coplanar or intersect on the wrong side
+ * @deprecated Renamed to {@link ray2_ray2_compute_intersection_array_2d}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function intersect_ray_2d(out: number[] | Float32Array | Float64Array, out_offset: number, origin_a_x: number, origin_a_y: number, direction_a_x: number, direction_a_y: number, origin_b_x: number, origin_b_y: number, direction_b_x: number, direction_b_y: number): boolean;
+export const intersect_ray_2d: typeof ray2_ray2_compute_intersection_array_2d;
+import { ray2_ray2_compute_intersection_array_2d } from "./line/ray2_ray2_compute_intersection_array_2d.js";
 //# sourceMappingURL=intersect_ray_2d.d.ts.map

package/src/core/geom/2d/intersect_ray_2d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intersect_ray_2d.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/2d/intersect_ray_2d.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,sCAZW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,cACN,MAAM,cACN,MAAM,iBACN,MAAM,iBACN,MAAM,cACN,MAAM,cACN,MAAM,iBACN,MAAM,iBACN,MAAM,GACJ,OAAO,CAoCnB"}
+{"version":3,"file":"intersect_ray_2d.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/2d/intersect_ray_2d.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,8EAAwE;wDANhB,mDAAmD"}

package/src/core/geom/2d/intersect_ray_2d.js

@@ -1,49 +1,7 @@
-/**
- * NOTE: that direction must not be normalized for correct results and instead derived from line length
- * @param {number[]|Float32Array|Float64Array} out
- * @param {number} out_offset
- * @param {number} origin_a_x
- * @param {number} origin_a_y
- * @param {number} direction_a_x
- * @param {number} direction_a_y
- * @param {number} origin_b_x
- * @param {number} origin_b_y
- * @param {number} direction_b_x
- * @param {number} direction_b_y
- * @returns {boolean} false if lines are coplanar or intersect on the wrong side
- */
-export function intersect_ray_2d(
-    out, out_offset,
-    origin_a_x, origin_a_y, direction_a_x, direction_a_y,
-    origin_b_x, origin_b_y, direction_b_x, direction_b_y
-) {
-
-    const denominator = (direction_a_x * direction_b_y - direction_a_y * direction_b_x);
-
-    if (Math.abs(denominator) < 1e-7){
-        // Parallel lines
-        return false;
-    }
-
-    const oab_y = origin_a_y - origin_b_y;
-    const oab_x = origin_a_x - origin_b_x;
-
-    const t = (direction_b_x * oab_y - direction_b_y * oab_x) / denominator;
-
-    if (t < 0.5) // Intersects on the wrong side
-        return false;
-
-    const point_x = origin_a_x + t * direction_a_x;
-    const point_y = origin_a_y + t * direction_a_y;
-
-
-    // if (Number.isNaN(point_x)) {
-    //     debugger;
-    // }
-
-
-    out[out_offset] = point_x;
-    out[out_offset + 1] = point_y;
-
-    return true;
-}
+import { ray2_ray2_compute_intersection_array_2d } from "./line/ray2_ray2_compute_intersection_array_2d.js";
+
+/**
+ * @deprecated Renamed to {@link ray2_ray2_compute_intersection_array_2d}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const intersect_ray_2d = ray2_ray2_compute_intersection_array_2d;

package/src/core/geom/2d/line/line2_compute_segment_point_distance_sqr.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Computes squared shortest distance between a line segment(defined by 2 points) and a point
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} px
+ * @param {number} py
+ */
+export function line2_compute_segment_point_distance_sqr(x0: number, y0: number, x1: number, y1: number, px: number, py: number): number;
+//# sourceMappingURL=line2_compute_segment_point_distance_sqr.d.ts.map

package/src/core/geom/2d/line/line2_compute_segment_point_distance_sqr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line2_compute_segment_point_distance_sqr.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/line/line2_compute_segment_point_distance_sqr.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,6DAPW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,UA4BhB"}

package/src/core/geom/2d/line/line2_compute_segment_point_distance_sqr.js

@@ -0,0 +1,39 @@
+import { clamp01 } from "../../../math/clamp01.js";
+import { v2_distance_sqr } from "../../vec2/v2_distance_sqr.js";
+
+/**
+ * Computes squared shortest distance between a line segment(defined by 2 points) and a point
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} px
+ * @param {number} py
+ */
+export function line2_compute_segment_point_distance_sqr(
+    x0, y0,
+    x1, y1,
+    px, py
+) {
+    // get line delta
+    const line_delta_x = x1 - x0;
+    const line_delta_y = y1 - y0;
+
+    // find closest point
+    const sp0_x = px - x0;
+    const sp0_y = py - y0;
+
+    //
+    const d2 = line_delta_x * line_delta_x + line_delta_y * line_delta_y;
+
+    const d3 = line_delta_x * sp0_x + line_delta_y * sp0_y;
+
+    const t = clamp01(d3 / d2);
+
+    // compute point on the line
+    const lp_x = line_delta_x * t + x0;
+    const lp_y = line_delta_y * t + y0;
+
+    // compute distance from the point in question to the point on the line
+    return v2_distance_sqr(px, py, lp_x, lp_y);
+}

package/src/core/geom/2d/line/line2_distance_to_point_sqr.d.ts

@@ -1,11 +1,7 @@
 /**
- * Computes squared shortest distance between a line segment(defined by 2 points) and a point
- * @param {number} x0
- * @param {number} y0
- * @param {number} x1
- * @param {number} y1
- * @param {number} px
- * @param {number} py
+ * @deprecated Renamed to {@link line2_compute_segment_point_distance_sqr}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function line2_distance_to_point_sqr(x0: number, y0: number, x1: number, y1: number, px: number, py: number): number;
+export const line2_distance_to_point_sqr: typeof line2_compute_segment_point_distance_sqr;
+import { line2_compute_segment_point_distance_sqr } from "./line2_compute_segment_point_distance_sqr.js";
 //# sourceMappingURL=line2_distance_to_point_sqr.d.ts.map

package/src/core/geom/2d/line/line2_distance_to_point_sqr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"line2_distance_to_point_sqr.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/line/line2_distance_to_point_sqr.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,gDAPW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,UA4BhB"}
+{"version":3,"file":"line2_distance_to_point_sqr.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/line/line2_distance_to_point_sqr.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,0FAAoF;yDAN3B,+CAA+C"}

package/src/core/geom/2d/line/line2_distance_to_point_sqr.js

@@ -1,39 +1,7 @@
-import { clamp01 } from "../../../math/clamp01.js";
-import { v2_distance_sqr } from "../../vec2/v2_distance_sqr.js";
-
-/**
- * Computes squared shortest distance between a line segment(defined by 2 points) and a point
- * @param {number} x0
- * @param {number} y0
- * @param {number} x1
- * @param {number} y1
- * @param {number} px
- * @param {number} py
- */
-export function line2_distance_to_point_sqr(
-    x0, y0,
-    x1, y1,
-    px, py
-) {
-    // get line delta
-    const line_delta_x = x1 - x0;
-    const line_delta_y = y1 - y0;
-
-    // find closest point
-    const sp0_x = px - x0;
-    const sp0_y = py - y0;
-
-    //
-    const d2 = line_delta_x * line_delta_x + line_delta_y * line_delta_y;
-
-    const d3 = line_delta_x * sp0_x + line_delta_y * sp0_y;
-
-    const t = clamp01(d3 / d2);
-
-    // compute point on the line
-    const lp_x = line_delta_x * t + x0;
-    const lp_y = line_delta_y * t + y0;
-
-    // compute distance from the point in question to the point on the line
-    return v2_distance_sqr(px, py, lp_x, lp_y);
-}
+import { line2_compute_segment_point_distance_sqr } from "./line2_compute_segment_point_distance_sqr.js";
+
+/**
+ * @deprecated Renamed to {@link line2_compute_segment_point_distance_sqr}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const line2_distance_to_point_sqr = line2_compute_segment_point_distance_sqr;

package/src/core/geom/2d/line/line2_segment_intersection_fraction_2d.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Fraction `t` in [0,1] along the segment (s0 -> s1) at which the infinite line through (l0, l1)
+ * crosses it. Returns -1 when the segment lies entirely on one side of the line (no crossing within
+ * the segment) or the two are parallel/collinear. -1 is a value the valid fraction can never take (a
+ * real crossing is always in [0,1]), and it is used instead of NaN so callers reject the no-crossing
+ * case with a trivial comparison (`t < 0` / `=== -1`) rather than the slower Number.isNaN.
+ *
+ * Unlike {@link line_segment_compute_line_segment_intersection_array_2d}, the first pair of points
+ * defines an unbounded line (not a segment) and the result is the parametric position on the segment
+ * rather than the intersection point.
+ *
+ * @param {number} l0_x line point A x
+ * @param {number} l0_y line point A y
+ * @param {number} l1_x line point B x
+ * @param {number} l1_y line point B y
+ * @param {number} s0_x segment start x
+ * @param {number} s0_y segment start y
+ * @param {number} s1_x segment end x
+ * @param {number} s1_y segment end y
+ * @returns {number}
+ */
+export function line2_segment_intersection_fraction_2d(l0_x: number, l0_y: number, l1_x: number, l1_y: number, s0_x: number, s0_y: number, s1_x: number, s1_y: number): number;
+//# sourceMappingURL=line2_segment_intersection_fraction_2d.d.ts.map

package/src/core/geom/2d/line/line2_segment_intersection_fraction_2d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line2_segment_intersection_fraction_2d.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/line/line2_segment_intersection_fraction_2d.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,6DAVW,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,GACJ,MAAM,CAsBlB"}