@design-core/core 0.0.1 → 0.0.3

package/test/lib/intersect.test.js

@@ -1,287 +1,140 @@
-import {Point} from '../../core/entities/point.js';
-import {Intersection} from '../../core/lib/intersect';
+import { Point } from '../../core/entities/point.js';
+import { Intersection } from '../../core/lib/intersect';
 
 test('Test Intersection.intersectCircleEllipse()', () => {
   expect(true).toBeTruthy();
   // TODO: intersectCircleEllipse
 });
 
-test('Test Intersection.intersectCircleLine()', () => {
-  // Intersection
-  const circle = {centre: new Point(10, 10), radius: 5};
-  const line = {start: new Point(), end: new Point(10, 10)};
-  const result = Intersection.intersectCircleLine(circle, line, false);
-  expect(result.status).toBe('Intersection');
-  expect(result.points.length).toBe(1);
-  expect(result.points[0].x).toBeCloseTo(6.46);
-  expect(result.points[0].y).toBeCloseTo(6.46);
-
-  // No Intersection - Outside
-  const circle1 = {centre: new Point(10, 10), radius: 2};
-  const line1 = {start: new Point(), end: new Point(0, 10)};
-  const result1 = Intersection.intersectCircleLine(circle1, line1, false);
-  expect(result1.status).toBe('Outside');
-  expect(result1.points.length).toBe(0);
-
-  // No Intersection - Inside
-  const circle2 = {centre: new Point(), radius: 20};
-  const line2 = {start: new Point(), end: new Point(0, 10)};
-  const result2 = Intersection.intersectCircleLine(circle2, line2, false);
-  expect(result2.status).toBe('Inside');
-  expect(result2.points.length).toBe(0);
-});
-
-test('Test Intersection.intersectLineCircle()', () => {
-  // Intersection
-  const circle = {centre: new Point(10, 10), radius: 5};
-  const line = {start: new Point(), end: new Point(10, 10)};
-  const result = Intersection.intersectLineCircle(line, circle, false);
-  expect(result.status).toBe('Intersection');
-  expect(result.points.length).toBe(1);
-  expect(result.points[0].x).toBeCloseTo(6.46);
-  expect(result.points[0].y).toBeCloseTo(6.46);
-
-  // No Intersection - Outside
-  const circle1 = {centre: new Point(10, 10), radius: 2};
-  const line1 = {start: new Point(), end: new Point(0, 10)};
-  const result1 = Intersection.intersectLineCircle(line1, circle1, false);
-  expect(result1.status).toBe('Outside');
-  expect(result1.points.length).toBe(0);
-
-  // No Intersection - Inside
-  const circle2 = {centre: new Point(), radius: 20};
-  const line2 = {start: new Point(), end: new Point(0, 10)};
-  const result2 = Intersection.intersectLineCircle(line2, circle2, false);
-  expect(result2.status).toBe('Inside');
-  expect(result2.points.length).toBe(0);
-});
-
-test('Test Intersection.intersectCircleCircle()', () => {
-  // Intersection
-  const circle1 = {centre: new Point(10, 10), radius: 5};
-  const circle2 = {centre: new Point(15, 10), radius: 5};
-  const result = Intersection.intersectCircleCircle(circle1, circle2, false);
-  expect(result.status).toBe('Intersection');
-  expect(result.points.length).toBe(2);
-  expect(result.points[0].x).toBeCloseTo(12.5);
-  expect(result.points[0].y).toBeCloseTo(14.33);
-
-  // No Intersection - Inside
-  const circle3 = {centre: new Point(10, 10), radius: 5};
-  const circle4 = {centre: new Point(10, 10), radius: 2};
-  const result1 = Intersection.intersectCircleCircle(circle3, circle4, false);
-  expect(result1.status).toBe('Inside');
-  expect(result1.points.length).toBe(0);
-
-  // No Intersection - Outside
-  const circle5 = {centre: new Point(10, 10), radius: 5};
-  const circle6 = {centre: new Point(-10, 10), radius: 2};
-  const result2 = Intersection.intersectCircleCircle(circle5, circle6, false);
-  expect(result2.status).toBe('Outside');
-  expect(result2.points.length).toBe(0);
-});
-
-test('Test Intersection.intersectCirclePolygon()', () => {
-  // Intersection.intersectCirclePolygon(c,r,points);
-  expect(true).toBeTruthy();
-  // TODO: intersectCirclePolygon
-});
-
-test('Test Intersection.intersectArcRectangle()', () => {
-  // Intersection
-  const arc = {centre: new Point(), radius: 14.14, startPoint: new Point(10, 10), endPoint: new Point(-10, 10)};
-  const rectangle = {start: new Point(), end: new Point(25, 25)};
-  const result = Intersection.intersectArcRectangle(arc, rectangle, false);
+test('Test intersectSegmentSegment - circle line', () => {
+  // CCW semicircular arc from (10,0) to (-10,0) with bulge=1
+  // centre (0,0), radius 10, passes through (0,10)
+  // Vertical line from (0,-15) to (0,15) crosses the arc at (0,10)
+  const result = Intersection.intersectSegmentSegment(
+      new Point(10, 0, 1), new Point(-10, 0),
+      new Point(0, -15), new Point(0, 15),
+      false,
+  );
   expect(result.status).toBe('Intersection');
   expect(result.points.length).toBe(1);
   expect(result.points[0].x).toBeCloseTo(0);
-  expect(result.points[0].y).toBeCloseTo(14.14);
-
-  // No Intersection
-  const arc1 = {centre: new Point(), radius: 14.14, startPoint: new Point(-10, 0), endPoint: new Point(0, -10)};
-  const rectangle1 = {start: new Point(), end: new Point(25, 25)};
-  const result1 = Intersection.intersectArcRectangle(arc1, rectangle1, false);
-  expect(result1.status).toBe('No Intersection');
-  expect(result1.points.length).toBe(0);
-});
-
-test('Test Intersection.intersectArcLine()', () => {
-  // Intersection
-  const arc = {centre: new Point(), radius: 14.14, startPoint: new Point(10, 10), endPoint: new Point(-10, 10)};
-  const line = {start: new Point(), end: new Point(0, 25)};
-  const result = Intersection.intersectArcLine(arc, line, false);
-  expect(result.status).toBe('Intersection');
-  expect(result.points.length).toBe(1);
-  expect(result.points[0].x).toBeCloseTo(0);
-  expect(result.points[0].y).toBeCloseTo(14.14);
-
-  // Intersection - Arc straddles 0 with startAngle > endAngle
-  const arc1 = {centre: new Point(), radius: 14.14, startPoint: new Point(10, -10), endPoint: new Point(-10, 10)};
-  const line1 = {start: new Point(), end: new Point(0, 25)};
-  const result1 = Intersection.intersectArcLine(arc1, line1, false);
-  expect(result1.status).toBe('Intersection');
-  expect(result1.points.length).toBe(1);
-  expect(result1.points[0].x).toBeCloseTo(0);
-  expect(result1.points[0].y).toBeCloseTo(14.14);
-
-  // No Intersection
-  const arc2 = {centre: new Point(), radius: 14.14, startPoint: new Point(-10, 0), endPoint: new Point(0, -10)};
-  const line2 = {start: new Point(), end: new Point(0, 25)};
-  const result2 = Intersection.intersectArcLine(arc2, line2, false);
-  expect(result2.status).toBe('No Intersection');
-  expect(result2.points.length).toBe(0);
+  expect(result.points[0].y).toBeCloseTo(10);
 });
 
-test('Test Intersection.intersectLineArc()', () => {
-  // Intersection
-  const arc = {centre: new Point(), radius: 14.14, startPoint: new Point(10, 10), endPoint: new Point(-10, 10)};
-  const line = {start: new Point(), end: new Point(0, 25)};
-  const result = Intersection.intersectLineArc(line, arc, false);
-  expect(result.status).toBe('Intersection');
+test('Test intersectSegmentSegment - tangent arc line', () => {
+  // CCW semicircular arc from (10,0) to (-10,0), centre (0,0), radius 10
+  // Horizontal line y=10 is tangent to the top of the arc at (0,10)
+  const result = Intersection.intersectSegmentSegment(
+      new Point(10, 0, 1), new Point(-10, 0),
+      new Point(-15, 10), new Point(15, 10),
+      false,
+  );
+  expect(result.status).toBe('Tangent');
   expect(result.points.length).toBe(1);
   expect(result.points[0].x).toBeCloseTo(0);
-  expect(result.points[0].y).toBeCloseTo(14.14);
-
-  // No Intersection
-  const arc1 = {centre: new Point(), radius: 14.14, startPoint: new Point(-10, 0), endPoint: new Point(0, -10)};
-  const line1 = {start: new Point(), end: new Point(0, 25)};
-  const result1 = Intersection.intersectLineArc(line1, arc1, false);
-  expect(result1.status).toBe('No Intersection');
-  expect(result1.points.length).toBe(0);
-});
-
-test('Test Intersection.intersectCircleArc()', () => {
-  // Intersection
-  const arc = {centre: new Point(), radius: 14.14, startPoint: new Point(10, 10), endPoint: new Point(-10, 10)};
-  const circle = {centre: new Point(10, 10), radius: 5};
-  const result = Intersection.intersectCircleArc(circle, arc, false);
-  expect(result.status).toBe('Intersection');
-  expect(result.points.length).toBe(1);
-  expect(result.points[0].x).toBeCloseTo(5.894);
-  expect(result.points[0].y).toBeCloseTo(12.853);
-
-  // No Intersection
-  const arc1 = {centre: new Point(), radius: 14.14, startPoint: new Point(-10, 0), endPoint: new Point(0, -10)};
-  const circle1 = {centre: new Point(10, 10), radius: 5};
-  const result1 = Intersection.intersectCircleArc(circle1, arc1, false);
-  expect(result1.status).toBe('No Intersection');
-  expect(result1.points.length).toBe(0);
-});
-
-test('Test Intersection.intersectArcCircle()', () => {
-  // Intersection
-  const arc = {centre: new Point(), radius: 14.14, startPoint: new Point(10, 10), endPoint: new Point(-10, 10)};
-  const circle = {centre: new Point(10, 10), radius: 5};
-  const result = Intersection.intersectArcCircle(arc, circle, false);
-  expect(result.status).toBe('Intersection');
-  expect(result.points.length).toBe(1);
-  expect(result.points[0].x).toBeCloseTo(5.894);
-  expect(result.points[0].y).toBeCloseTo(12.853);
-
-  // Clockwise Arc Intersection
-  const cwArc = {centre: new Point(), radius: 14.14, startPoint: new Point(10, 10), endPoint: new Point(-10, 10), direction: -1};
-  const cwResult = Intersection.intersectArcCircle(cwArc, circle, false);
-  expect(cwResult.status).toBe('Intersection');
-  expect(cwResult.points.length).toBe(1);
-  expect(cwResult.points[0].x).toBeCloseTo(12.853);
-  expect(cwResult.points[0].y).toBeCloseTo(5.894);
-
-  // No Intersection
-  const arc1 = {centre: new Point(), radius: 14.14, startPoint: new Point(-10, 0), endPoint: new Point(0, -10)};
-  const circle1 = {centre: new Point(10, 10), radius: 5};
-  const result1 = Intersection.intersectArcCircle(arc1, circle1, false);
-  expect(result1.status).toBe('No Intersection');
-  expect(result1.points.length).toBe(0);
-});
-
-test('Test Intersection.intersectCircleRectangle()', () => {
-  // Intersection
-  const circle = {centre: new Point(), radius: 14.14};
-  const rectangle = {start: new Point(), end: new Point(25, 25)};
-  const result = Intersection.intersectCircleRectangle(circle, rectangle, false);
-  expect(result.status).toBe('Intersection');
-  expect(result.points.length).toBe(2);
-  expect(result.points[0].x).toBeCloseTo(14.14);
-  expect(result.points[0].y).toBeCloseTo(0);
-
-  // No Intersection - Outside
-  const circle1 = {centre: new Point(12.5, 12.5), radius: 10};
-  const rectangle1 = {start: new Point(), end: new Point(25, 25)};
-  const result1 = Intersection.intersectCircleRectangle(circle1, rectangle1, false);
-  expect(result1.status).toBe('Outside');
-  expect(result1.points.length).toBe(0);
-
-  // No Intersection - Inside
-  const circle2 = {centre: new Point(12.5, 12.5), radius: 100};
-  const rectangle2 = {start: new Point(), end: new Point(25, 25)};
-  const result2 = Intersection.intersectCircleRectangle(circle2, rectangle2, false);
-  expect(result2.status).toBe('Inside');
-  expect(result2.points.length).toBe(0);
-});
-
-test('Test Intersection.intersectEllipseEllipse()', () => {
-  // Intersection.intersectEllipseEllipse(c1,rx1,ry1,c2,rx2,ry2);
-  expect(true).toBeTruthy();
-  // TODO: intersectEllipseEllipse
-});
-
-test('Test Intersection.intersectEllipseLine()', () => {
-  // Intersection.intersectEllipseLine(ellipse,line,extend);
-  expect(true).toBeTruthy();
-  // TODO: intersectEllipseLine
+  expect(result.points[0].y).toBeCloseTo(10);
 });
 
-test('Test Intersection.intersectEllipsePolygon()', () => {
-  // Intersection.intersectEllipsePolygon(c,rx,ry,points);
-  expect(true).toBeTruthy();
-  // TODO: intersectEllipsePolygon
+test('Test intersectSegmentSegment - concentric arcs same radius', () => {
+  // Two semicircular arcs with the same centre and radius
+  const result = Intersection.intersectSegmentSegment(
+      new Point(10, 0, 1), new Point(-10, 0),
+      new Point(0, 10, 1), new Point(0, -10),
+      false,
+  );
+  expect(result.status).toBe('Coincident');
+  expect(result.points.length).toBe(0);
 });
 
-test('Test Intersection.intersectEllipseRectangle()', () => {
-  // Intersection.intersectEllipseRectangle(ellipse,rectangle,extend);
-  expect(true).toBeTruthy();
-  // TODO: intersectEllipseRectangle
+test('Test intersectSegmentSegment - concentric arcs different radius', () => {
+  // Two semicircular arcs with the same centre but different radii
+  const result = Intersection.intersectSegmentSegment(
+      new Point(10, 0, 1), new Point(-10, 0),
+      new Point(5, 0, 1), new Point(-5, 0),
+      false,
+  );
+  expect(result.status).toBe('Inside');
+  expect(result.points.length).toBe(0);
 });
 
-test('Test Intersection.intersectLineLine()', () => {
-  // Intersection
-  const line1 = {start: new Point(), end: new Point(0, 10)};
-  const line2 = {start: new Point(-5, 5), end: new Point(5, 5)};
-  const result = Intersection.intersectLineLine(line1, line2, false);
-  expect(result.status).toBe('Intersection');
+test('Test intersectSegmentSegment - line line', () => {
+  // Crossing - segments cross in their interiors
+  const result = Intersection.intersectSegmentSegment(
+      new Point(), new Point(0, 10),
+      new Point(-5, 5), new Point(5, 5),
+      false,
+  );
+  expect(result.status).toBe('Perpendicular');
   expect(result.points.length).toBe(1);
   expect(result.points[0].x).toBeCloseTo(0);
   expect(result.points[0].y).toBeCloseTo(5);
 
-  // Intersection - Extend
-  const line3 = {start: new Point(1, 5), end: new Point(5, 5)};
-  const result1 = Intersection.intersectLineLine(line1, line3, true);
-  expect(result1.status).toBe('Intersection');
+  // Crossing - non-perpendicular crossing
+  const resultCross = Intersection.intersectSegmentSegment(
+      new Point(0, 0), new Point(10, 5),
+      new Point(0, 5), new Point(10, 0),
+      false,
+  );
+  expect(resultCross.status).toBe('Crossing');
+
+  // Crossing - Extend (perpendicular - vertical boundary, horizontal selected extended)
+  const result1 = Intersection.intersectSegmentSegment(
+      new Point(), new Point(0, 10),
+      new Point(1, 5), new Point(5, 5),
+      false, true,
+  );
+  expect(result1.status).toBe('Perpendicular');
   expect(result1.points.length).toBe(1);
   expect(result1.points[0].x).toBeCloseTo(0);
   expect(result1.points[0].y).toBeCloseTo(5);
 
   // No Intersection - Parallel
-  const line4 = {start: new Point(1, 0), end: new Point(1, 10)};
-  const result2 = Intersection.intersectLineLine(line1, line4, false);
+  const result2 = Intersection.intersectSegmentSegment(
+      new Point(), new Point(0, 10),
+      new Point(1, 0), new Point(1, 10),
+      false,
+  );
   expect(result2.status).toBe('Parallel');
   expect(result2.points.length).toBe(0);
 
-  // No Intersection - Coincident
-  const line5 = {start: new Point(0, 1), end: new Point(0, 8)};
-  const result3 = Intersection.intersectLineLine(line1, line5, false);
-  expect(result3.status).toBe('Coincident');
-  expect(result3.points.length).toBe(0);
+  // Touching - endpoint of one segment lies on interior of the other
+  const result3 = Intersection.intersectSegmentSegment(
+      new Point(), new Point(0, 10),
+      new Point(0, 1), new Point(0, 8),
+      false,
+  );
+  expect(result3.status).toBe('Touching');
+  expect(result3.points.length).toBe(1);
+
+  // No Intersection - Collinear but disjoint (no overlap)
+  const result4 = Intersection.intersectSegmentSegment(
+      new Point(0, 0), new Point(0, 5),
+      new Point(0, 7), new Point(0, 10),
+      false,
+  );
+  expect(result4.status).toBe('None');
+  expect(result4.points.length).toBe(0);
+
+  // Endpoint - segments share an endpoint
+  const result5 = Intersection.intersectSegmentSegment(
+      new Point(0, 0), new Point(0, 10),
+      new Point(0, 10), new Point(10, 10),
+      false,
+  );
+  expect(result5.status).toBe('Endpoint');
+  expect(result5.points.length).toBe(1);
+  expect(result5.points[0].x).toBeCloseTo(0);
+  expect(result5.points[0].y).toBeCloseTo(10);
 });
 
-test('Test Intersection.intersectPolylineLine()', () => {
+test('Test intersectPolylinePolyline - polyline line', () => {
   // Intersection
-  const points = [new Point(), new Point(0, 10)];
-  const polyline = {points: points};
-  const line = {start: new Point(-5, 5), end: new Point(5, 5)};
+  let points = [new Point(), new Point(0, 10)];
+  let polyline = points;
+  let line = [new Point(-10, 5), new Point(10, 5)];
 
   // Test polyline with single segment
-  const result = Intersection.intersectPolylineLine(polyline, line, false);
+  let result = Intersection.intersectPolylinePolyline(polyline, line, false);
   expect(result.status).toBe('Intersection');
   expect(result.points.length).toBe(1);
   expect(result.points[0].x).toBeCloseTo(0);
@@ -289,26 +142,93 @@ test('Test Intersection.intersectPolylineLine()', () => {
 
   // Test polyline with multiple segments
   points.push(new Point(2, 10), new Point(2, 0));
-  const result2 = Intersection.intersectPolylineLine(polyline, line, false);
-  expect(result2.status).toBe('Intersection');
-  expect(result2.points.length).toBe(2);
-  expect(result2.points[1].x).toBeCloseTo(2);
-  expect(result2.points[1].y).toBeCloseTo(5);
+  result = Intersection.intersectPolylinePolyline(polyline, line, false);
+  expect(result.status).toBe('Intersection');
+  expect(result.points.length).toBe(2);
+  expect(result.points[1].x).toBeCloseTo(2);
+  expect(result.points[1].y).toBeCloseTo(5);
 
   // No Intersection
-  const line2 = {start: new Point(5, 0), end: new Point(5, 10)};
-  const result3 = Intersection.intersectPolylineLine(polyline, line2, false);
-  expect(result3.status).toBe('No Intersection');
-  expect(result3.points.length).toBe(0);
+  const line2 = [new Point(5, 0), new Point(5, 10)];
+  result = Intersection.intersectPolylinePolyline(polyline, line2, false);
+  expect(result.status).toBe('None');
+  expect(result.points.length).toBe(0);
+
+  // Test polyline with 180 degree arc segment - 270 - 90 - negative bulge
+  // counter clockwise bulge = +ve, clockwise bulge = -ve,
+  points = [new Point(0, 0, -1), new Point(0, 10)];
+  polyline = points;
+  result = Intersection.intersectPolylinePolyline(polyline, line, false);
+  expect(result.status).toBe('Intersection');
+  expect(result.points.length).toBe(1);
+  expect(result.points[0].x).toBeCloseTo(-5);
+  expect(result.points[0].y).toBeCloseTo(5);
+
+  // Test polyline with 180 degree arc segment - 270 - 90 - positive bulge
+  // counter clockwise bulge = +ve, clockwise bulge = -ve,
+  points = [new Point(0, 0, 1), new Point(0, 10)];
+  polyline = points;
+  result = Intersection.intersectPolylinePolyline(polyline, line, false);
+  expect(result.status).toBe('Intersection');
+  expect(result.points.length).toBe(1);
+  expect(result.points[0].x).toBeCloseTo(5);
+  expect(result.points[0].y).toBeCloseTo(5);
+
+  // Test polyline with 180 degree arc segment 180 - 0 - negative bulge
+  // counter clockwise bulge = +ve, clockwise bulge = -ve,
+  points = [new Point(-5, 5, -1), new Point(5, 5)];
+  polyline = points;
+  line = [new Point(-10, 5), new Point(10, 5)];
+  result = Intersection.intersectPolylinePolyline(polyline, line, false);
+  expect(result.status).toBe('Intersection');
+  expect(result.points.length).toBe(2);
+  expect(result.points[0].x).toBeCloseTo(5);
+  expect(result.points[0].y).toBeCloseTo(5);
+  expect(result.points[1].x).toBeCloseTo(-5);
+  expect(result.points[1].y).toBeCloseTo(5);
+
+  // Test polyline with 180 degree arc segment 180 - 0 - positive bulge
+  // counter clockwise bulge = +ve, clockwise bulge = -ve,
+  points = [new Point(-5, 5, 1), new Point(5, 5)];
+  polyline = points;
+  line = [new Point(-10, 5), new Point(10, 5)];
+  result = Intersection.intersectPolylinePolyline(polyline, line, false);
+  expect(result.status).toBe('Intersection');
+  expect(result.points.length).toBe(2);
+  expect(result.points[0].x).toBeCloseTo(5);
+  expect(result.points[0].y).toBeCloseTo(5);
+  expect(result.points[1].x).toBeCloseTo(-5);
+  expect(result.points[1].y).toBeCloseTo(5);
+
+  // Test polyline with 180 degree arc segment 180 - 0 - negative bulge - offset line
+  // counter clockwise bulge = +ve, clockwise bulge = -ve
+  // direction: - ccw > 0, cw <= 0
+  points = [new Point(-5, 5, -1), new Point(5, 5)];
+  polyline = points;
+  line = [new Point(0, 7), new Point(10, 7)];
+  result = Intersection.intersectPolylinePolyline(polyline, line, false);
+  expect(result.status).toBe('Intersection');
+  expect(result.points.length).toBe(1);
+  expect(result.points[0].x).toBeCloseTo(4.5826);
+  expect(result.points[0].y).toBeCloseTo(7);
+
+  // Test polyline with 180 degree arc segment 180 - 0 - positive bulge - offset line
+  // counter clockwise bulge = +ve, clockwise bulge = -ve,
+  points = [new Point(-5, 5, 1), new Point(5, 5)];
+  polyline = points;
+  line = [new Point(0, 7), new Point(10, 7)];
+  result = Intersection.intersectPolylinePolyline(polyline, line, false);
+  expect(result.status).toBe('None');
+  expect(result.points.length).toBe(0);
 });
 
-test('Test Intersection.intersectPolylineRectangle()', () => {
+test('Test intersectPolylinePolyline with rectangle polyline', () => {
   const points = [new Point(-5, 5), new Point(5, 5)];
-  const polyline = {points: points};
-  const rectangle = {start: new Point(), end: new Point(25, 25)};
+  const polyline = points;
+  const rectangle = [new Point(), new Point(25, 0), new Point(25, 25), new Point(0, 25), new Point()];
 
   // Test polyline with single segment
-  const result = Intersection.intersectPolylineRectangle(polyline, rectangle, false);
+  const result = Intersection.intersectPolylinePolyline(polyline, rectangle, false);
   expect(result.status).toBe('Intersection');
   expect(result.points.length).toBe(1);
   expect(result.points[0].x).toBeCloseTo(0);
@@ -316,103 +236,306 @@ test('Test Intersection.intersectPolylineRectangle()', () => {
 
   // Test polyline with multiple segments
   points.push(new Point(5, 20), new Point(30, 20));
-  const result2 = Intersection.intersectPolylineRectangle(polyline, rectangle, false);
+  const result2 = Intersection.intersectPolylinePolyline(polyline, rectangle, false);
   expect(result2.status).toBe('Intersection');
   expect(result2.points.length).toBe(2);
-  expect(result2.points[0].x).toBeCloseTo(25);
-  expect(result2.points[0].y).toBeCloseTo(20);
+  expect(result2.points[0].x).toBeCloseTo(0);
+  expect(result2.points[0].y).toBeCloseTo(5);
+  expect(result2.points[1].x).toBeCloseTo(25);
+  expect(result2.points[1].y).toBeCloseTo(20);
 
-  // No Intersection
+  // Overlapping collinear segments
   const points2 = [new Point(5, 5), new Point(20, 20)];
-  const polyline2 = {points: points2};
-  const result3 = Intersection.intersectPolylineLine(polyline2, rectangle, false);
-  expect(result3.status).toBe('No Intersection');
-  expect(result3.points.length).toBe(0);
+  const polyline2 = points2;
+  const result3 = Intersection.intersectPolylinePolyline(polyline2, [new Point(), new Point(25, 25)], false);
+  expect(result3.status).toBe('Intersection');
+  expect(result3.points.length).toBe(1);
+});
+
+test('Test intersectPolylinePolyline - polyline arc', () => {
+  // Intersection - polyline(boundary) vs arc segment(selected)
+  const polyline = [new Point(), new Point(0, 25)];
+  // Arc segment from (10,10) to (-10,10) with bulge=1
+  // This creates a CCW semicircular arc with centre (0,10), radius 10
+  const arcPolyline = [new Point(10, 10, 1), new Point(-10, 10)];
+  const result = Intersection.intersectPolylinePolyline(polyline, arcPolyline, false);
+  expect(result.status).toBe('Intersection');
+  expect(result.points.length).toBe(1);
+  expect(result.points[0].x).toBeCloseTo(0);
+  expect(result.points[0].y).toBeCloseTo(20);
 });
 
-test('Test Intersection.intersectLineRectangle()', () => {
-  const line1 = {start: new Point(-5, 5), end: new Point(5, 5)};
-  const rectangle = {start: new Point(), end: new Point(25, 25)};
+test('Test Intersection.intersectPolylinePolyline()', () => {
+  // Two crossing polylines with line segments
+  const polyline1 = [new Point(-10, 0), new Point(10, 0)];
+  const polyline2 = [new Point(0, -10), new Point(0, 10)];
 
-  // Test rectangle with single intersection
-  const result = Intersection.intersectLineRectangle(line1, rectangle, false);
+  const result = Intersection.intersectPolylinePolyline(polyline1, polyline2, false);
   expect(result.status).toBe('Intersection');
   expect(result.points.length).toBe(1);
   expect(result.points[0].x).toBeCloseTo(0);
-  expect(result.points[0].y).toBeCloseTo(5);
+  expect(result.points[0].y).toBeCloseTo(0);
 
-  // Test rectangle with multiple intersections
-  const line2 = {start: new Point(-5, 5), end: new Point(30, 20)};
-  const result2 = Intersection.intersectLineRectangle(line2, rectangle, false);
-  expect(result2.status).toBe('Intersection');
-  expect(result2.points.length).toBe(2);
-  expect(result2.points[0].x).toBeCloseTo(25);
-  expect(result2.points[0].y).toBeCloseTo(17.857);
-  expect(result2.points[1].x).toBeCloseTo(0);
-  expect(result2.points[1].y).toBeCloseTo(7.14);
+  // No intersection
+  const polyline3 = [new Point(20, 0), new Point(30, 0)];
+  const result2 = Intersection.intersectPolylinePolyline(polyline1, polyline3, false);
+  expect(result2.status).toBe('None');
+  expect(result2.points.length).toBe(0);
 
-  // No Intersection
-  const line3 = {start: new Point(5, 5), end: new Point(20, 20)};
-  const result3 = Intersection.intersectLineRectangle(line3, rectangle, false);
-  expect(result3.status).toBe('No Intersection');
-  expect(result3.points.length).toBe(0);
+  // Polyline with arc segment intersecting a line-segment polyline
+  // CCW arc from (-5,0) to (5,0) with bulge=1 goes through (0,-5)
+  const polyline4 = [new Point(-5, 0, 1), new Point(5, 0)];
+  const polyline5 = [new Point(0, -10), new Point(0, -3)];
+
+  const result3 = Intersection.intersectPolylinePolyline(polyline4, polyline5, false);
+  expect(result3.status).toBe('Intersection');
+  expect(result3.points.length).toBe(1);
+  expect(result3.points[0].x).toBeCloseTo(0);
+  expect(result3.points[0].y).toBeCloseTo(-5);
+});
+
+test('Test intersectPolylinePolyline - polyline arc with extend', () => {
+  // Arc: quarter circle from (10,0) to (0,10) centred at origin, radius 10, CCW
+  // Represent as polyline with arc segment
+  const arcPolyline = [new Point(10, 0, 1), new Point(0, 10)];
+
+  // Polyline crossing the arc
+  const polyline = [new Point(0, 0), new Point(15, 15)];
+
+  // Without extend - intersection should be on the arc
+  const result1 = Intersection.intersectPolylinePolyline(polyline, arcPolyline, false);
+  expect(result1.status).toBe('Intersection');
+  expect(result1.points.length).toBe(1);
+
+  // With extend - all circle intersections returned (not filtered by arc bounds)
+  const result2 = Intersection.intersectPolylinePolyline(polyline, arcPolyline, true);
+  expect(result2.status).toBe('Intersection');
+  expect(result2.points.length).toBeGreaterThanOrEqual(1);
 });
 
-test('Test Intersection.intersectRectangleLine()', () => {
-  const line1 = {start: new Point(-5, 5), end: new Point(5, 5)};
-  const rectangle = {start: new Point(), end: new Point(25, 25)};
+test('Test intersectSegmentSegment - both segments extended (ray-ray equivalent)', () => {
+  // Perpendicular lines meeting at origin
+  const r1 = Intersection.intersectSegmentSegment(
+      new Point(-5, 0), new Point(5, 0),
+      new Point(0, -5), new Point(0, 5),
+      true, true,
+  );
+  expect(r1.points.length).toBe(1);
+  expect(r1.points[0].x).toBeCloseTo(0);
+  expect(r1.points[0].y).toBeCloseTo(0);
+
+  // Non-perpendicular: lines y=1 and x=1 meeting at (1, 1)
+  const r2 = Intersection.intersectSegmentSegment(
+      new Point(0, 1), new Point(10, 1),
+      new Point(1, 0), new Point(1, 10),
+      true, true,
+  );
+  expect(r2.points.length).toBe(1);
+  expect(r2.points[0].x).toBeCloseTo(1);
+  expect(r2.points[0].y).toBeCloseTo(1);
+
+  // 45-degree lines crossing at (5, 5)
+  const r3 = Intersection.intersectSegmentSegment(
+      new Point(0, 0), new Point(10, 10),
+      new Point(10, 0), new Point(0, 10),
+      true, true,
+  );
+  expect(r3.points.length).toBe(1);
+  expect(r3.points[0].x).toBeCloseTo(5);
+  expect(r3.points[0].y).toBeCloseTo(5);
+
+  // Parallel lines — should return no points
+  const r4 = Intersection.intersectSegmentSegment(
+      new Point(0, 0), new Point(10, 0),
+      new Point(0, 1), new Point(10, 1),
+      true, true,
+  );
+  expect(r4.points.length).toBe(0);
+
+  // Disjoint segments that only intersect when both extended
+  const r5 = Intersection.intersectSegmentSegment(
+      new Point(0, 0), new Point(2, 0),
+      new Point(5, -2), new Point(5, -1),
+      true, true,
+  );
+  expect(r5.points.length).toBe(1);
+  expect(r5.points[0].x).toBeCloseTo(5);
+  expect(r5.points[0].y).toBeCloseTo(0);
+});
 
-  // Test rectangle with single intersection
-  const result = Intersection.intersectRectangleLine(rectangle, line1, false);
+// ------------------------------------------------------------
+// intersectSegmentSegment — circle/arc vs line, non-origin centre
+// These tests specifically exercise the numerical stability fix:
+// computing centreToStart = a1 - c before squaring avoids
+// floating-point cancellation that occurs when the expanded form
+// a1² + c² - 2·a1·c is used with an off-origin circle centre.
+// ------------------------------------------------------------
+
+test('intersectSegmentSegment - arc vs line, non-origin centre, two circle intersections but one on arc', () => {
+  // Circle centred at (1000, 1000), radius 50.
+  // Top point: (1000, 1050), bottom: (1000, 950).
+  // Left semicircle arc: top → bottom with bulge=1 (CCW).
+  // Horizontal line through centre: (950, 1000) → (1050, 1000).
+  // The full circle intersects the line at (950,1000) and (1050,1000),
+  // but only (950,1000) lies on the left semicircle arc — the arc filter
+  // removes the right-side point, leaving one result.
+  const leftArcStart = new Point(1000, 1050, 1);
+  const leftArcEnd = new Point(1000, 950);
+
+  const lineStart = new Point(950, 1000);
+  const lineEnd = new Point(1050, 1000);
+
+  // arc(boundary) vs line(selected)
+  const result = Intersection.intersectSegmentSegment(
+      leftArcStart, leftArcEnd,
+      lineStart, lineEnd,
+      false,
+  );
+  // Only the point on the left semicircle passes the arc filter
   expect(result.status).toBe('Intersection');
   expect(result.points.length).toBe(1);
-  expect(result.points[0].x).toBeCloseTo(0);
-  expect(result.points[0].y).toBeCloseTo(5);
+  expect(result.points[0].x).toBeCloseTo(950);
+  expect(result.points[0].y).toBeCloseTo(1000);
+});
 
-  // Test rectangle with multiple intersections
-  const line2 = {start: new Point(-5, 5), end: new Point(30, 20)};
-  const result2 = Intersection.intersectRectangleLine(rectangle, line2, false);
-  expect(result2.status).toBe('Intersection');
-  expect(result2.points.length).toBe(2);
-  expect(result2.points[0].x).toBeCloseTo(25);
-  expect(result2.points[0].y).toBeCloseTo(17.857);
-  expect(result2.points[1].x).toBeCloseTo(0);
-  expect(result2.points[1].y).toBeCloseTo(7.14);
+test('intersectSegmentSegment - arc vs line, non-origin centre, line outside arc', () => {
+  // Same circle at (1000, 1000) radius 50.
+  // Line entirely to the right of centre: (1060, 900) → (1060, 1100).
+  // This line is outside the circle entirely.
+  const arcStart = new Point(1000, 1050, 1);
+  const arcEnd = new Point(1000, 950);
+
+  const result = Intersection.intersectSegmentSegment(
+      arcStart, arcEnd,
+      new Point(1060, 900), new Point(1060, 1100),
+      false,
+  );
+  expect(result.status).toBe('Outside');
+  expect(result.points.length).toBe(0);
+});
 
-  // No Intersection
-  const line3 = {start: new Point(5, 5), end: new Point(20, 20)};
-  const result3 = Intersection.intersectRectangleLine(rectangle, line3, false);
-  expect(result3.status).toBe('No Intersection');
-  expect(result3.points.length).toBe(0);
+test('intersectSegmentSegment - arc vs line, non-origin centre, line inside circle', () => {
+  // Same circle at (1000, 1000) radius 50.
+  // Short line fully inside the circle: (1000, 990) → (1000, 1010).
+  // The circle-line quadratic yields two roots outside [0,1];
+  // one u<0 and one u>1 → INSIDE status, no points without extend.
+  const arcStart = new Point(1000, 1050, 1);
+  const arcEnd = new Point(1000, 950);
+
+  const result = Intersection.intersectSegmentSegment(
+      arcStart, arcEnd,
+      new Point(1000, 990), new Point(1000, 1010),
+      false,
+  );
+  expect(result.status).toBe('Inside');
+  expect(result.points.length).toBe(0);
 });
 
-test('Test Intersection.intersectPolygonPolygon()', () => {
-  // Intersection.intersectPolygonPolygon(points1,points2);
-  expect(true).toBeTruthy();
-  // TODO: intersectPolygonPolygon
+test('intersectPolylinePolyline - full circle vs diameter line, non-origin centre', () => {
+  // Reproduces the real-world trim failure:
+  // Circle centred at (588.75, 354.25), radius 78.136.
+  // The line connecting the two points where it intersects the
+  // circle is a near-diameter, with large absolute coordinates.
+  // Prior to the fix the discriminant underflowed to 0 or negative
+  // due to floating-point cancellation, returning no intersections.
+  const cx = 588.7494381894326;
+  const cy = 354.25057706935644;
+  const r = 78.13609384123743;
+
+  // Circle represented as two CCW semicircular arc segments (matching
+  // Circle.toPolylinePoints() output):
+  //   top = centre.project(0,  r)  →  (cx, cy + r)
+  //   bot = centre.project(0, -r)  →  (cx, cy - r)
+  const top = new Point(cx, cy + r, 1); // left semicircle start
+  const bot = new Point(cx, cy - r, 1); // right semicircle start
+  const topClose = new Point(cx, cy + r); // closure point
+
+  const circlePolyline = [top, bot, topClose];
+
+  // The failing line from the DXF file — a near-diameter of the circle.
+  const linePolyline = [
+    new Point(644, 299.00001525878906),
+    new Point(533.4988763788651, 409.5011388799238),
+  ];
+
+  const result = Intersection.intersectPolylinePolyline(linePolyline, circlePolyline, false);
+  expect(result.status).toBe('Intersection');
+  // The line passes through both halves of the circle, yielding two points.
+  expect(result.points.length).toBe(2);
+  // Each intersection point must lie approximately on the circle.
+  for (const pt of result.points) {
+    const dist = Math.sqrt((pt.x - cx) ** 2 + (pt.y - cy) ** 2);
+    expect(dist).toBeCloseTo(r, 3);
+  }
 });
 
-test('Test Intersection.intersectPolygonRectangle()', () => {
-  // Intersection.intersectPolygonRectangle(points,r1,r2);
-  expect(true).toBeTruthy();
-  // TODO: intersectPolygonRectangle
+// ------------------------------------------------------------
+// intersectCircleCircle — covering the INTERSECTION and OUTSIDE
+// branches of #intersectCircleCircle, including the refactored
+// axialDist / halfChordLength / chordMidpoint / perpOffset logic.
+// ------------------------------------------------------------
+
+test('intersectSegmentSegment - arc vs arc, two intersecting circles, single shared point per arc pair', () => {
+  // Circle 1: centre (0,0), radius 5 — top CCW semicircle: (5,0) → (-5,0)
+  // Circle 2: centre (6,0), radius 5 — top CCW semicircle: (11,0) → (1,0)
+  // The two circles intersect at (3,4) and (3,-4).
+  // Both top arcs contain (3,4); neither contains (3,-4).
+  const result = Intersection.intersectSegmentSegment(
+      new Point(5, 0, 1), new Point(-5, 0),
+      new Point(11, 0, 1), new Point(1, 0),
+      false,
+  );
+  expect(result.status).toBe('Intersection');
+  expect(result.points.length).toBe(1);
+  expect(result.points[0].x).toBeCloseTo(3);
+  expect(result.points[0].y).toBeCloseTo(4);
 });
 
-test('Test Intersection.intersectRectangleRectangle()', () => {
-  const rectangle1 = {start: new Point(), end: new Point(25, 25)};
-  const rectangle2 = {start: new Point(10, 10), end: new Point(35, 35)};
+test('intersectSegmentSegment - arc vs arc, circles outside each other', () => {
+  // Circle 1: centre (0,0), radius 5  — top arc: (5,0) → (-5,0)
+  // Circle 2: centre (20,0), radius 5 — top arc: (25,0) → (15,0)
+  // cDist (20) > rMax (10): OUTSIDE, no intersection points.
+  const result = Intersection.intersectSegmentSegment(
+      new Point(5, 0, 1), new Point(-5, 0),
+      new Point(25, 0, 1), new Point(15, 0),
+      false,
+  );
+  expect(result.status).toBe('Outside');
+  expect(result.points.length).toBe(0);
+});
+
+test('intersectPolylinePolyline - two full circles (two arcs each) intersecting at two points', () => {
+  // Circle 1: centre (0,0), radius 5.
+  // Circle 2: centre (6,0), radius 5.
+  // Intersection points: (3,4) and (3,-4).
+  // Each circle is represented as two CCW semicircular arc segments.
+  const circle1 = [new Point(5, 0, 1), new Point(-5, 0, 1), new Point(5, 0)];
+  const circle2 = [new Point(11, 0, 1), new Point(1, 0, 1), new Point(11, 0)];
 
-  const result = Intersection.intersectRectangleRectangle(rectangle1, rectangle2, false);
+  const result = Intersection.intersectPolylinePolyline(circle1, circle2, false);
   expect(result.status).toBe('Intersection');
   expect(result.points.length).toBe(2);
-  expect(result.points[0].x).toBeCloseTo(25);
-  expect(result.points[0].y).toBeCloseTo(10);
-  expect(result.points[1].x).toBeCloseTo(10);
-  expect(result.points[1].y).toBeCloseTo(25);
 
-  // No Intersection
-  const rectangle3 = {start: new Point(10, 10), end: new Point(20, 20)};
-  const result2 = Intersection.intersectRectangleRectangle(rectangle1, rectangle3, false);
-  expect(result2.status).toBe('No Intersection');
-  expect(result2.points.length).toBe(0);
+  // Both points must lie on both circles (radius 5 from each centre).
+  for (const pt of result.points) {
+    expect(Math.sqrt(pt.x ** 2 + pt.y ** 2)).toBeCloseTo(5);
+    expect(Math.sqrt((pt.x - 6) ** 2 + pt.y ** 2)).toBeCloseTo(5);
+  }
+
+  // Verify the specific coordinate values.
+  const ys = result.points.map((p) => p.y).sort((a, b) => a - b);
+  expect(ys[0]).toBeCloseTo(-4);
+  expect(ys[1]).toBeCloseTo(4);
+  result.points.forEach((p) => expect(p.x).toBeCloseTo(3));
+});
+
+test('intersectPolylinePolyline - two full circles outside each other, no intersection', () => {
+  // Circle 1: centre (0,0), radius 5.
+  // Circle 2: centre (20,0), radius 5. cDist=20 > rMax=10.
+  const circle1 = [new Point(5, 0, 1), new Point(-5, 0, 1), new Point(5, 0)];
+  const circle2 = [new Point(25, 0, 1), new Point(15, 0, 1), new Point(25, 0)];
+
+  const result = Intersection.intersectPolylinePolyline(circle1, circle2, false);
+  expect(result.status).toBe('None');
+  expect(result.points.length).toBe(0);
 });