dacha 0.18.0-alpha.0 → 0.18.0-alpha.1

package/build/contrib/components/collider/index.d.ts

@@ -1,12 +1,18 @@
 import { Component } from '../../../engine/component';
+import type { Point } from '../../../engine/math-lib';
 export interface ColliderConfig {
-    type: 'box' | 'circle';
+    type: 'box' | 'circle' | 'segment';
     centerX: number;
     centerY: number;
     sizeX?: number;
     sizeY?: number;
+    point1X?: number;
+    point1Y?: number;
+    point2X?: number;
+    point2Y?: number;
     radius?: number;
     layer: string;
+    debugColor?: string;
 }
 /**
  * Collider component for defining collision boundaries.
@@ -42,13 +48,16 @@ export interface ColliderConfig {
  * @category Components
  */
 export declare class Collider extends Component {
-    type: 'box' | 'circle';
+    type: 'box' | 'circle' | 'segment';
     centerX: number;
     centerY: number;
     sizeX?: number;
     sizeY?: number;
     radius?: number;
+    point1?: Point;
+    point2?: Point;
     layer: string;
+    debugColor?: string;
     constructor(config: ColliderConfig);
     clone(): Collider;
 }

package/build/contrib/components/collider/index.js

@@ -39,7 +39,10 @@ export class Collider extends Component {
     sizeX;
     sizeY;
     radius;
+    point1;
+    point2;
     layer;
+    debugColor;
     constructor(config) {
         super();
         this.type = config.type;
@@ -48,7 +51,22 @@ export class Collider extends Component {
         this.sizeX = config.sizeX;
         this.sizeY = config.sizeY;
         this.radius = config.radius;
+        this.point1 =
+            config.point1X !== undefined || config.point1Y !== undefined
+                ? {
+                    x: config.point1X ?? 0,
+                    y: config.point1Y ?? 0,
+                }
+                : undefined;
+        this.point2 =
+            config.point2X !== undefined || config.point2Y !== undefined
+                ? {
+                    x: config.point2X ?? 0,
+                    y: config.point2Y ?? 0,
+                }
+                : undefined;
         this.layer = config.layer;
+        this.debugColor = config.debugColor;
     }
     clone() {
         return new Collider({
@@ -58,7 +76,12 @@ export class Collider extends Component {
             sizeX: this.sizeX,
             sizeY: this.sizeY,
             radius: this.radius,
+            point1X: this.point1?.x,
+            point1Y: this.point1?.y,
+            point2X: this.point2?.x,
+            point2Y: this.point2?.y,
             layer: this.layer,
+            debugColor: this.debugColor,
         });
     }
 }

package/build/contrib/components/shape/index.d.ts

@@ -5,7 +5,7 @@ interface RenderData {
     view: Graphics;
     graphicsContextKey?: string;
 }
-export type ShapeType = 'rectangle' | 'roundRectangle' | 'circle' | 'ellipse';
+export type ShapeType = 'rectangle' | 'roundRectangle' | 'circle' | 'ellipse' | 'line';
 export interface BaseShape {
     type: ShapeType;
     strokeColor?: string;
@@ -39,7 +39,14 @@ export interface Ellipse extends BaseShape {
     radiusX: number;
     radiusY: number;
 }
-export type ShapeConfig = BaseShape & Partial<Rectangle | RoundRectangle | Circle | Ellipse>;
+export interface Line extends BaseShape {
+    type: 'line';
+    point1X: number;
+    point1Y: number;
+    point2X: number;
+    point2Y: number;
+}
+export type ShapeConfig = BaseShape & Partial<Rectangle | RoundRectangle | Circle | Ellipse | Line>;
 /**
  * Shape component for rendering 2D geometry.
  *
@@ -112,6 +119,14 @@ export declare class Shape extends Component {
     radiusX?: number;
     /** Radius Y of the shape */
     radiusY?: number;
+    /** Start point X coordinate for line shape */
+    point1X?: number;
+    /** Start point Y coordinate for line shape */
+    point1Y?: number;
+    /** End point X coordinate for line shape */
+    point2X?: number;
+    /** End point Y coordinate for line shape */
+    point2Y?: number;
     /** Internal rendering data */
     renderData?: RenderData;
     /**

package/build/contrib/components/shape/index.js

@@ -71,6 +71,14 @@ export class Shape extends Component {
     radiusX;
     /** Radius Y of the shape */
     radiusY;
+    /** Start point X coordinate for line shape */
+    point1X;
+    /** Start point Y coordinate for line shape */
+    point1Y;
+    /** End point X coordinate for line shape */
+    point2X;
+    /** End point Y coordinate for line shape */
+    point2Y;
     /** Internal rendering data */
     renderData;
     /**
@@ -96,6 +104,10 @@ export class Shape extends Component {
         this.radius = config.radius;
         this.radiusX = config.radiusX;
         this.radiusY = config.radiusY;
+        this.point1X = config.point1X;
+        this.point1Y = config.point1Y;
+        this.point2X = config.point2X;
+        this.point2Y = config.point2Y;
     }
     clone() {
         return new Shape({
@@ -114,6 +126,10 @@ export class Shape extends Component {
             radius: this.radius,
             radiusX: this.radiusX,
             radiusY: this.radiusY,
+            point1X: this.point1X,
+            point1Y: this.point1Y,
+            point2X: this.point2X,
+            point2Y: this.point2Y,
             fill: this.fill,
         });
     }

package/build/contrib/systems/camera-system/{service.d.ts → api.d.ts}

@@ -1,19 +1,19 @@
 import type { Actor } from '../../../engine/actor';
-interface CameraServiceOptions {
+interface CameraAPIOptions {
     onCameraUpdate: (actor: Actor) => void;
     findCurrentCamera: () => Actor | undefined;
 }
 /**
- * Service that manages camera control and current camera tracking
+ * API that manages camera control and current camera tracking
  *
  * Provides methods to set and get the current camera actor
  *
  * @category Systems
  */
-export declare class CameraService {
+export declare class CameraAPI {
     private onCameraUpdate;
     private findCurrentCamera;
-    constructor({ onCameraUpdate, findCurrentCamera }: CameraServiceOptions);
+    constructor({ onCameraUpdate, findCurrentCamera }: CameraAPIOptions);
     setCurrentCamera(actor: Actor): void;
     getCurrentCamera(): Actor | undefined;
 }

package/build/contrib/systems/camera-system/{service.js → api.js}

@@ -1,12 +1,12 @@
 import { Camera } from '../../components';
 /**
- * Service that manages camera control and current camera tracking
+ * API that manages camera control and current camera tracking
  *
  * Provides methods to set and get the current camera actor
  *
  * @category Systems
  */
-export class CameraService {
+export class CameraAPI {
     onCameraUpdate;
     findCurrentCamera;
     constructor({ onCameraUpdate, findCurrentCamera }) {

package/build/contrib/systems/camera-system/index.d.ts

@@ -1,2 +1,2 @@
 export { CameraSystem } from './system';
-export { CameraService } from './service';
+export { CameraAPI } from './api';

package/build/contrib/systems/camera-system/index.js

@@ -1,2 +1,2 @@
 export { CameraSystem } from './system';
-export { CameraService } from './service';
+export { CameraAPI } from './api';

package/build/contrib/systems/camera-system/system.d.ts

@@ -11,7 +11,7 @@ import type { WorldSystemOptions } from '../../../engine/system';
 export declare class CameraSystem extends WorldSystem {
     private actorQuery?;
     private window;
-    private cameraService;
+    private cameraApi;
     constructor(options: WorldSystemOptions);
     onSceneEnter(scene: Scene): void;
     onSceneExit(): void;

package/build/contrib/systems/camera-system/system.js

@@ -2,7 +2,7 @@ import { WorldSystem } from '../../../engine/system';
 import { ActorQuery } from '../../../engine/actor';
 import { Camera } from '../../components/camera';
 import { getWindowNode } from '../../utils/get-window-node';
-import { CameraService } from './service';
+import { CameraAPI } from './api';
 /**
  * Camera system that manages camera control and current camera tracking
  *
@@ -13,17 +13,17 @@ import { CameraService } from './service';
 export class CameraSystem extends WorldSystem {
     actorQuery;
     window;
-    cameraService;
+    cameraApi;
     constructor(options) {
         super();
         const { windowNodeId, world } = options;
         const windowNode = getWindowNode(windowNodeId);
         this.window = windowNode;
-        this.cameraService = new CameraService({
+        this.cameraApi = new CameraAPI({
             onCameraUpdate: this.handleCameraUpdate,
             findCurrentCamera: this.findCurrentCamera,
         });
-        world.addService(this.cameraService);
+        world.systemApi.register(this.cameraApi);
         window.addEventListener('resize', this.handleWindowResize);
     }
     onSceneEnter(scene) {
@@ -34,6 +34,7 @@ export class CameraSystem extends WorldSystem {
         this.handleWindowResize();
     }
     onSceneExit() {
+        this.actorQuery?.destroy();
         this.actorQuery = undefined;
     }
     onWorldDestroy() {

package/build/contrib/systems/index.d.ts

@@ -1,14 +1,14 @@
 export { Animator } from './animator';
-export { CameraSystem, CameraService } from './camera-system';
+export { CameraSystem, CameraAPI } from './camera-system';
 export { GameStatsMeter } from './game-stats-meter';
 export { KeyboardInputSystem } from './keyboard-input-system';
 export { KeyboardControlSystem } from './keyboard-control-system';
 export { MouseControlSystem } from './mouse-control-system';
 export { MouseInputSystem } from './mouse-input-system';
-export { PhysicsSystem } from './physics-system';
+export { PhysicsSystem, PhysicsAPI } from './physics-system';
 export { BehaviorSystem, Behavior } from './behavior-system';
 export type { BehaviorOptions } from './behavior-system';
 export { UIBridge } from './ui-bridge';
 export type { UIOptions, UIInitFn, UIDestroyFn, LoadUIFn } from './ui-bridge';
 export { AudioSystem } from './audio-system';
-export { Renderer, RendererService, FilterEffect, Shader } from './renderer';
+export { Renderer, RendererAPI, FilterEffect, Shader } from './renderer';

package/build/contrib/systems/index.js

@@ -1,12 +1,12 @@
 export { Animator } from './animator';
-export { CameraSystem, CameraService } from './camera-system';
+export { CameraSystem, CameraAPI } from './camera-system';
 export { GameStatsMeter } from './game-stats-meter';
 export { KeyboardInputSystem } from './keyboard-input-system';
 export { KeyboardControlSystem } from './keyboard-control-system';
 export { MouseControlSystem } from './mouse-control-system';
 export { MouseInputSystem } from './mouse-input-system';
-export { PhysicsSystem } from './physics-system';
+export { PhysicsSystem, PhysicsAPI } from './physics-system';
 export { BehaviorSystem, Behavior } from './behavior-system';
 export { UIBridge } from './ui-bridge';
 export { AudioSystem } from './audio-system';
-export { Renderer, RendererService, FilterEffect, Shader } from './renderer';
+export { Renderer, RendererAPI, FilterEffect, Shader } from './renderer';

package/build/contrib/systems/mouse-input-system/subsystems/coordinates-projector/index.d.ts

@@ -1,7 +1,6 @@
 import type { WorldSystemOptions } from '../../../../../engine/system';
 export declare class CoordinatesProjector {
     private world;
-    private cameraService;
     constructor(options: WorldSystemOptions);
     destroy(): void;
     private handleMouseInput;

package/build/contrib/systems/mouse-input-system/subsystems/coordinates-projector/index.js

@@ -1,20 +1,19 @@
 import { MouseInput } from '../../../../events';
-import { CameraService } from '../../../camera-system';
-import { getProjectedX, getProjectedY } from '../../../../utils/coordinates-projection';
+import { CameraAPI } from '../../../camera-system';
+import { getProjectedX, getProjectedY, } from '../../../../utils/coordinates-projection';
 export class CoordinatesProjector {
     world;
-    cameraService;
     constructor(options) {
         const { world } = options;
         this.world = world;
-        this.cameraService = world.getService(CameraService);
         this.world.addEventListener(MouseInput, this.handleMouseInput);
     }
     destroy() {
         this.world.removeEventListener(MouseInput, this.handleMouseInput);
     }
     handleMouseInput = (event) => {
-        const currentCamera = this.cameraService.getCurrentCamera();
+        const cameraApi = this.world.systemApi.get(CameraAPI);
+        const currentCamera = cameraApi.getCurrentCamera();
         event.x = currentCamera ? getProjectedX(event.x, currentCamera) : event.x;
         event.y = currentCamera ? getProjectedY(event.y, currentCamera) : event.y;
     };

package/build/contrib/systems/physics-system/api.d.ts

@@ -0,0 +1,58 @@
+import type { Actor } from '../../../engine/actor';
+import type { CollisionDetectionSubsystem } from './subsystems';
+import type { RaycastHit, RaycastParams, OverlapBoxParams, OverlapCircleParams, OverlapPointParams } from './types';
+/**
+ * API that provides methods for performing physics queries such as raycasting and overlap tests.
+ *
+ * Query results are based on the latest prepared physics state.
+ * That state is updated during the physics system fixed update step,
+ * so direct transform or collider changes made outside physics update
+ * are not guaranteed to be reflected immediately in query results.
+ *
+ * @category Systems
+ */
+export declare class PhysicsAPI {
+    private collisionDetectionSubsystem;
+    constructor(collisionDetectionSubsystem: CollisionDetectionSubsystem);
+    /**
+     * Casts a ray and returns the nearest hit, if any.
+     *
+     * The ray starts at `params.origin`, travels in `params.direction`,
+     * and is limited by `params.maxDistance`.
+     *
+     * @param params - Raycast parameters
+     * @returns The nearest hit or `null` when nothing is hit
+     */
+    raycast(params: RaycastParams): RaycastHit | null;
+    /**
+     * Casts a ray and returns all hits sorted by distance.
+     *
+     * The ray starts at `params.origin`, travels in `params.direction`,
+     * and is limited by `params.maxDistance`.
+     *
+     * @param params - Raycast parameters
+     * @returns All hits sorted from nearest to farthest
+     */
+    raycastAll(params: RaycastParams): RaycastHit[];
+    /**
+     * Returns all actors whose colliders contain the given point.
+     *
+     * @param params - Point overlap parameters
+     * @returns Actors whose colliders overlap the point
+     */
+    overlapPoint(params: OverlapPointParams): Actor[];
+    /**
+     * Returns all actors whose colliders overlap the given circle.
+     *
+     * @param params - Circle overlap parameters
+     * @returns Actors whose colliders overlap the circle
+     */
+    overlapCircle(params: OverlapCircleParams): Actor[];
+    /**
+     * Returns all actors whose colliders overlap the given box.
+     *
+     * @param params - Box overlap parameters
+     * @returns Actors whose colliders overlap the box
+     */
+    overlapBox(params: OverlapBoxParams): Actor[];
+}

package/build/contrib/systems/physics-system/api.js

@@ -0,0 +1,67 @@
+/**
+ * API that provides methods for performing physics queries such as raycasting and overlap tests.
+ *
+ * Query results are based on the latest prepared physics state.
+ * That state is updated during the physics system fixed update step,
+ * so direct transform or collider changes made outside physics update
+ * are not guaranteed to be reflected immediately in query results.
+ *
+ * @category Systems
+ */
+export class PhysicsAPI {
+    collisionDetectionSubsystem;
+    constructor(collisionDetectionSubsystem) {
+        this.collisionDetectionSubsystem = collisionDetectionSubsystem;
+    }
+    /**
+     * Casts a ray and returns the nearest hit, if any.
+     *
+     * The ray starts at `params.origin`, travels in `params.direction`,
+     * and is limited by `params.maxDistance`.
+     *
+     * @param params - Raycast parameters
+     * @returns The nearest hit or `null` when nothing is hit
+     */
+    raycast(params) {
+        return this.collisionDetectionSubsystem.raycast(params);
+    }
+    /**
+     * Casts a ray and returns all hits sorted by distance.
+     *
+     * The ray starts at `params.origin`, travels in `params.direction`,
+     * and is limited by `params.maxDistance`.
+     *
+     * @param params - Raycast parameters
+     * @returns All hits sorted from nearest to farthest
+     */
+    raycastAll(params) {
+        return this.collisionDetectionSubsystem.raycastAll(params);
+    }
+    /**
+     * Returns all actors whose colliders contain the given point.
+     *
+     * @param params - Point overlap parameters
+     * @returns Actors whose colliders overlap the point
+     */
+    overlapPoint(params) {
+        return this.collisionDetectionSubsystem.overlapPoint(params);
+    }
+    /**
+     * Returns all actors whose colliders overlap the given circle.
+     *
+     * @param params - Circle overlap parameters
+     * @returns Actors whose colliders overlap the circle
+     */
+    overlapCircle(params) {
+        return this.collisionDetectionSubsystem.overlapCircle(params);
+    }
+    /**
+     * Returns all actors whose colliders overlap the given box.
+     *
+     * @param params - Box overlap parameters
+     * @returns Actors whose colliders overlap the box
+     */
+    overlapBox(params) {
+        return this.collisionDetectionSubsystem.overlapBox(params);
+    }
+}

package/build/contrib/systems/physics-system/index.d.ts

@@ -1,20 +1,2 @@
-import { SceneSystem } from '../../../engine/system';
-import type { SceneSystemOptions, UpdateOptions } from '../../../engine/system';
-/**
- * Physics system that handles 2D physics simulation and collision detection
- *
- * Manages rigid body physics and collision detection and resolution.
- *
- * @extends SceneSystem
- *
- * @category Systems
- */
-export declare class PhysicsSystem extends SceneSystem {
-    private physicsSubsystem;
-    private collisionDetectionSubsystem;
-    private collisionBroadcastSubsystem;
-    private constraintSolver;
-    constructor(options: SceneSystemOptions);
-    onSceneDestroy(): void;
-    fixedUpdate(options: UpdateOptions): void;
-}
+export { PhysicsSystem } from './physics-system';
+export { PhysicsAPI } from './api';

package/build/contrib/systems/physics-system/index.js

@@ -1,35 +1,2 @@
-import { SceneSystem } from '../../../engine/system';
-import { PhysicsSubsystem, CollisionDetectionSubsystem, CollisionBroadcastSubsystem, ConstraintSolver, } from './subsystems';
-/**
- * Physics system that handles 2D physics simulation and collision detection
- *
- * Manages rigid body physics and collision detection and resolution.
- *
- * @extends SceneSystem
- *
- * @category Systems
- */
-export class PhysicsSystem extends SceneSystem {
-    physicsSubsystem;
-    collisionDetectionSubsystem;
-    collisionBroadcastSubsystem;
-    constraintSolver;
-    constructor(options) {
-        super();
-        this.physicsSubsystem = new PhysicsSubsystem(options);
-        this.collisionDetectionSubsystem = new CollisionDetectionSubsystem(options);
-        this.collisionBroadcastSubsystem = new CollisionBroadcastSubsystem();
-        this.constraintSolver = new ConstraintSolver();
-    }
-    onSceneDestroy() {
-        this.physicsSubsystem.destroy();
-        this.collisionDetectionSubsystem.destroy();
-    }
-    fixedUpdate(options) {
-        this.physicsSubsystem.update(options);
-        const contacts = this.collisionDetectionSubsystem.update();
-        this.constraintSolver.update(contacts);
-        this.collisionBroadcastSubsystem.update(contacts);
-    }
-}
-PhysicsSystem.systemName = 'PhysicsSystem';
+export { PhysicsSystem } from './physics-system';
+export { PhysicsAPI } from './api';

package/build/contrib/systems/physics-system/physics-system.d.ts

@@ -0,0 +1,24 @@
+import { SceneSystem } from '../../../engine/system';
+import type { SceneSystemOptions, UpdateOptions } from '../../../engine/system';
+/**
+ * Physics system that handles 2D physics simulation and collision detection
+ *
+ * Manages rigid body physics and collision detection and resolution.
+ *
+ * @extends SceneSystem
+ *
+ * @category Systems
+ */
+export declare class PhysicsSystem extends SceneSystem {
+    private world;
+    private physicsSubsystem;
+    private collisionDetectionSubsystem;
+    private collisionBroadcastSubsystem;
+    private constraintSolver;
+    private physicsApi;
+    constructor(options: SceneSystemOptions);
+    onSceneEnter(): void;
+    onSceneExit(): void;
+    onSceneDestroy(): void;
+    fixedUpdate(options: UpdateOptions): void;
+}

package/build/contrib/systems/physics-system/physics-system.js

@@ -0,0 +1,47 @@
+import { SceneSystem } from '../../../engine/system';
+import { PhysicsSubsystem, CollisionDetectionSubsystem, CollisionBroadcastSubsystem, ConstraintSolver, } from './subsystems';
+import { PhysicsAPI } from './api';
+/**
+ * Physics system that handles 2D physics simulation and collision detection
+ *
+ * Manages rigid body physics and collision detection and resolution.
+ *
+ * @extends SceneSystem
+ *
+ * @category Systems
+ */
+export class PhysicsSystem extends SceneSystem {
+    world;
+    physicsSubsystem;
+    collisionDetectionSubsystem;
+    collisionBroadcastSubsystem;
+    constraintSolver;
+    physicsApi;
+    constructor(options) {
+        super();
+        this.world = options.world;
+        this.physicsSubsystem = new PhysicsSubsystem(options);
+        this.collisionDetectionSubsystem = new CollisionDetectionSubsystem(options);
+        this.collisionBroadcastSubsystem = new CollisionBroadcastSubsystem();
+        this.constraintSolver = new ConstraintSolver();
+        this.physicsApi = new PhysicsAPI(this.collisionDetectionSubsystem);
+    }
+    onSceneEnter() {
+        this.world.systemApi.register(this.physicsApi);
+    }
+    onSceneExit() {
+        this.world.systemApi.unregister(PhysicsAPI);
+    }
+    onSceneDestroy() {
+        this.world.systemApi.unregister(PhysicsAPI);
+        this.physicsSubsystem.destroy();
+        this.collisionDetectionSubsystem.destroy();
+    }
+    fixedUpdate(options) {
+        this.physicsSubsystem.update(options);
+        const contacts = this.collisionDetectionSubsystem.update();
+        this.constraintSolver.update(contacts);
+        this.collisionBroadcastSubsystem.update(contacts);
+    }
+}
+PhysicsSystem.systemName = 'PhysicsSystem';

package/build/contrib/systems/physics-system/subsystems/collision-detection/aabb-builders/build-circle-aabb.js

@@ -1,6 +1,5 @@
 export const buildCircleAABB = (geometry) => {
-    const { radius } = geometry;
-    const { x: centerX, y: centerY } = geometry.center;
+    const { radius, center: { x: centerX, y: centerY }, } = geometry;
     return {
         min: { x: centerX - radius, y: centerY - radius },
         max: { x: centerX + radius, y: centerY + radius },

package/build/contrib/systems/physics-system/subsystems/collision-detection/aabb-builders/build-point-aabb.d.ts

@@ -0,0 +1,2 @@
+import type { AABB, Geometry } from '../types';
+export declare const buildPointAABB: (geometry: Geometry) => AABB;

package/build/contrib/systems/physics-system/subsystems/collision-detection/aabb-builders/build-point-aabb.js

@@ -0,0 +1,7 @@
+export const buildPointAABB = (geometry) => {
+    const { center } = geometry;
+    return {
+        min: { ...center },
+        max: { ...center },
+    };
+};

package/build/contrib/systems/physics-system/subsystems/collision-detection/aabb-builders/build-ray-aabb.d.ts

@@ -0,0 +1,2 @@
+import type { AABB, Geometry } from '../types';
+export declare const buildRayAABB: (geometry: Geometry) => AABB;

package/build/contrib/systems/physics-system/subsystems/collision-detection/aabb-builders/build-ray-aabb.js

@@ -0,0 +1,9 @@
+export const buildRayAABB = (geometry) => {
+    const { origin, direction, maxDistance } = geometry;
+    const endX = origin.x + direction.x * maxDistance;
+    const endY = origin.y + direction.y * maxDistance;
+    return {
+        min: { x: Math.min(origin.x, endX), y: Math.min(origin.y, endY) },
+        max: { x: Math.max(origin.x, endX), y: Math.max(origin.y, endY) },
+    };
+};

package/build/contrib/systems/physics-system/subsystems/collision-detection/aabb-builders/build-segment-aabb.d.ts

@@ -0,0 +1,2 @@
+import type { AABB, Geometry } from '../types';
+export declare const buildSegmentAABB: (geometry: Geometry) => AABB;

package/build/contrib/systems/physics-system/subsystems/collision-detection/aabb-builders/build-segment-aabb.js

@@ -0,0 +1,14 @@
+import { INTERSECTION_EPSILON } from '../intersection-checkers/utils';
+export const buildSegmentAABB = (geometry) => {
+    const { point1, point2 } = geometry;
+    return {
+        min: {
+            x: Math.min(point1.x, point2.x) - INTERSECTION_EPSILON,
+            y: Math.min(point1.y, point2.y) - INTERSECTION_EPSILON,
+        },
+        max: {
+            x: Math.max(point1.x, point2.x) + INTERSECTION_EPSILON,
+            y: Math.max(point1.y, point2.y) + INTERSECTION_EPSILON,
+        },
+    };
+};