@excalidraw/excalidraw 0.18.0-d92384b77-3 → 0.18.0-de715913e

package/dist/types/math/{range.d.ts → src/range.d.ts}

@@ -1,44 +1,44 @@
-import type { InclusiveRange } from "./types";
-/**
- * Create an inclusive range from the two numbers provided.
- *
- * @param start Start of the range
- * @param end End of the range
- * @returns
- */
-export declare function rangeInclusive(start: number, end: number): InclusiveRange;
-/**
- * Turn a number pair into an inclusive range.
- *
- * @param pair The number pair to convert to an inclusive range
- * @returns The new inclusive range
- */
-export declare function rangeInclusiveFromPair(pair: [start: number, end: number]): [number, number] & {
-    _brand: "excalimath_degree";
-};
-/**
- * Given two ranges, return if the two ranges overlap with each other e.g.
- * [1, 3] overlaps with [2, 4] while [1, 3] does not overlap with [4, 5].
- *
- * @param param0 One of the ranges to compare
- * @param param1 The other range to compare against
- * @returns TRUE if the ranges overlap
- */
-export declare const rangesOverlap: ([a0, a1]: InclusiveRange, [b0, b1]: InclusiveRange) => boolean;
-/**
- * Given two ranges,return ther intersection of the two ranges if any e.g. the
- * intersection of [1, 3] and [2, 4] is [2, 3].
- *
- * @param param0 The first range to compare
- * @param param1 The second range to compare
- * @returns The inclusive range intersection or NULL if no intersection
- */
-export declare const rangeIntersection: ([a0, a1]: InclusiveRange, [b0, b1]: InclusiveRange) => InclusiveRange | null;
-/**
- * Determine if a value is inside a range.
- *
- * @param value The value to check
- * @param range The range
- * @returns
- */
-export declare const rangeIncludesValue: (value: number, [min, max]: InclusiveRange) => boolean;
+import type { InclusiveRange } from "./types";
+/**
+ * Create an inclusive range from the two numbers provided.
+ *
+ * @param start Start of the range
+ * @param end End of the range
+ * @returns
+ */
+export declare function rangeInclusive(start: number, end: number): InclusiveRange;
+/**
+ * Turn a number pair into an inclusive range.
+ *
+ * @param pair The number pair to convert to an inclusive range
+ * @returns The new inclusive range
+ */
+export declare function rangeInclusiveFromPair(pair: [start: number, end: number]): [number, number] & {
+    _brand: "excalimath_degree";
+};
+/**
+ * Given two ranges, return if the two ranges overlap with each other e.g.
+ * [1, 3] overlaps with [2, 4] while [1, 3] does not overlap with [4, 5].
+ *
+ * @param param0 One of the ranges to compare
+ * @param param1 The other range to compare against
+ * @returns TRUE if the ranges overlap
+ */
+export declare const rangesOverlap: ([a0, a1]: InclusiveRange, [b0, b1]: InclusiveRange) => boolean;
+/**
+ * Given two ranges,return ther intersection of the two ranges if any e.g. the
+ * intersection of [1, 3] and [2, 4] is [2, 3].
+ *
+ * @param param0 The first range to compare
+ * @param param1 The second range to compare
+ * @returns The inclusive range intersection or NULL if no intersection
+ */
+export declare const rangeIntersection: ([a0, a1]: InclusiveRange, [b0, b1]: InclusiveRange) => InclusiveRange | null;
+/**
+ * Determine if a value is inside a range.
+ *
+ * @param value The value to check
+ * @param range The range
+ * @returns
+ */
+export declare const rangeIncludesValue: (value: number, [min, max]: InclusiveRange) => boolean;

package/dist/types/math/{rectangle.d.ts → src/rectangle.d.ts}

@@ -1,3 +1,5 @@
-import type { GlobalPoint, LineSegment, LocalPoint, Rectangle } from "./types";
-export declare function rectangle<P extends GlobalPoint | LocalPoint>(topLeft: P, bottomRight: P): Rectangle<P>;
-export declare function rectangleIntersectLineSegment<Point extends LocalPoint | GlobalPoint>(r: Rectangle<Point>, l: LineSegment<Point>): Point[];
+import type { GlobalPoint, LineSegment, LocalPoint, Rectangle } from "./types";
+export declare function rectangle<P extends GlobalPoint | LocalPoint>(topLeft: P, bottomRight: P): Rectangle<P>;
+export declare function rectangleFromNumberSequence<Point extends LocalPoint | GlobalPoint>(minX: number, minY: number, maxX: number, maxY: number): Rectangle<Point>;
+export declare function rectangleIntersectLineSegment<Point extends LocalPoint | GlobalPoint>(r: Rectangle<Point>, l: LineSegment<Point>): Point[];
+export declare function rectangleIntersectRectangle<Point extends LocalPoint | GlobalPoint>(rectangle1: Rectangle<Point>, rectangle2: Rectangle<Point>): boolean;

package/dist/types/math/{segment.d.ts → src/segment.d.ts}

@@ -1,39 +1,39 @@
-import type { GlobalPoint, LineSegment, LocalPoint, Radians } from "./types";
-/**
- * Create a line segment from two points.
- *
- * @param points The two points delimiting the line segment on each end
- * @returns The line segment delineated by the points
- */
-export declare function lineSegment<P extends GlobalPoint | LocalPoint>(a: P, b: P): LineSegment<P>;
-/**
- *
- * @param segment
- * @returns
- */
-export declare const isLineSegment: <Point extends GlobalPoint | LocalPoint>(segment: unknown) => segment is LineSegment<Point>;
-/**
- * Return the coordinates resulting from rotating the given line about an origin by an angle in radians
- * note that when the origin is not given, the midpoint of the given line is used as the origin.
- *
- * @param l
- * @param angle
- * @param origin
- * @returns
- */
-export declare const lineSegmentRotate: <Point extends GlobalPoint | LocalPoint>(l: LineSegment<Point>, angle: Radians, origin?: Point | undefined) => LineSegment<Point>;
-/**
- * Calculates the point two line segments with a definite start and end point
- * intersect at.
- */
-export declare const segmentsIntersectAt: <Point extends GlobalPoint | LocalPoint>(a: Readonly<LineSegment<Point>>, b: Readonly<LineSegment<Point>>) => Point | null;
-export declare const pointOnLineSegment: <Point extends GlobalPoint | LocalPoint>(point: Point, line: LineSegment<Point>, threshold?: number) => boolean;
-export declare const distanceToLineSegment: <Point extends GlobalPoint | LocalPoint>(point: Point, line: LineSegment<Point>) => number;
-/**
- * Returns the intersection point of a segment and a line
- *
- * @param l
- * @param s
- * @returns
- */
-export declare function lineSegmentIntersectionPoints<Point extends GlobalPoint | LocalPoint>(l: LineSegment<Point>, s: LineSegment<Point>): Point | null;
+import type { GlobalPoint, LineSegment, LocalPoint, Radians } from "./types";
+/**
+ * Create a line segment from two points.
+ *
+ * @param points The two points delimiting the line segment on each end
+ * @returns The line segment delineated by the points
+ */
+export declare function lineSegment<P extends GlobalPoint | LocalPoint>(a: P, b: P): LineSegment<P>;
+/**
+ *
+ * @param segment
+ * @returns
+ */
+export declare const isLineSegment: <Point extends GlobalPoint | LocalPoint>(segment: unknown) => segment is LineSegment<Point>;
+/**
+ * Return the coordinates resulting from rotating the given line about an origin by an angle in radians
+ * note that when the origin is not given, the midpoint of the given line is used as the origin.
+ *
+ * @param l
+ * @param angle
+ * @param origin
+ * @returns
+ */
+export declare const lineSegmentRotate: <Point extends GlobalPoint | LocalPoint>(l: LineSegment<Point>, angle: Radians, origin?: Point | undefined) => LineSegment<Point>;
+/**
+ * Calculates the point two line segments with a definite start and end point
+ * intersect at.
+ */
+export declare const segmentsIntersectAt: <Point extends GlobalPoint | LocalPoint>(a: Readonly<LineSegment<Point>>, b: Readonly<LineSegment<Point>>) => Point | null;
+export declare const pointOnLineSegment: <Point extends GlobalPoint | LocalPoint>(point: Point, line: LineSegment<Point>, threshold?: number) => boolean;
+export declare const distanceToLineSegment: <Point extends GlobalPoint | LocalPoint>(point: Point, line: LineSegment<Point>) => number;
+/**
+ * Returns the intersection point of a segment and a line
+ *
+ * @param l
+ * @param s
+ * @returns
+ */
+export declare function lineSegmentIntersectionPoints<Point extends GlobalPoint | LocalPoint>(l: LineSegment<Point>, s: LineSegment<Point>, threshold?: number): Point | null;

package/dist/types/math/{triangle.d.ts → src/triangle.d.ts}

@@ -1,11 +1,11 @@
-import type { GlobalPoint, LocalPoint, Triangle } from "./types";
-/**
- * Tests if a point lies inside a triangle. This function
- * will return FALSE if the point lies exactly on the sides
- * of the triangle.
- *
- * @param triangle The triangle to test the point for
- * @param p The point to test whether is in the triangle
- * @returns TRUE if the point is inside of the triangle
- */
-export declare function triangleIncludesPoint<P extends GlobalPoint | LocalPoint>([a, b, c]: Triangle<P>, p: P): boolean;
+import type { GlobalPoint, LocalPoint, Triangle } from "./types";
+/**
+ * Tests if a point lies inside a triangle. This function
+ * will return FALSE if the point lies exactly on the sides
+ * of the triangle.
+ *
+ * @param triangle The triangle to test the point for
+ * @param p The point to test whether is in the triangle
+ * @returns TRUE if the point is inside of the triangle
+ */
+export declare function triangleIncludesPoint<P extends GlobalPoint | LocalPoint>([a, b, c]: Triangle<P>, p: P): boolean;

package/dist/types/math/{types.d.ts → src/types.d.ts}

@@ -1,105 +1,106 @@
-/**
- * By definition one radian is the angle subtended at the centre
- * of a circle by an arc that is equal in length to the radius.
- */
-export type Radians = number & {
-    _brand: "excalimath__radian";
-};
-/**
- * An angle measurement of a plane angle in which one full
- * rotation is 360 degrees.
- */
-export type Degrees = number & {
-    _brand: "excalimath_degree";
-};
-/**
- * A number range which includes the start and end numbers in the range.
- */
-export type InclusiveRange = [number, number] & {
-    _brand: "excalimath_degree";
-};
-/**
- * Represents a 2D position in world or canvas space. A
- * global coordinate.
- */
-export type GlobalPoint = [x: number, y: number] & {
-    _brand: "excalimath__globalpoint";
-};
-/**
- * Represents a 2D position in whatever local space it's
- * needed. A local coordinate.
- */
-export type LocalPoint = [x: number, y: number] & {
-    _brand: "excalimath__localpoint";
-};
-/**
- * A line is an infinitely long object with no width, depth, or curvature.
- */
-export type Line<P extends GlobalPoint | LocalPoint> = [p: P, q: P] & {
-    _brand: "excalimath_line";
-};
-/**
- * In geometry, a line segment is a part of a straight
- * line that is bounded by two distinct end points, and
- * contains every point on the line that is between its endpoints.
- */
-export type LineSegment<P extends GlobalPoint | LocalPoint> = [a: P, b: P] & {
-    _brand: "excalimath_linesegment";
-};
-/**
- * Represents a 2D vector
- */
-export type Vector = [u: number, v: number] & {
-    _brand: "excalimath__vector";
-};
-/**
- * A triangle represented by 3 points
- */
-export type Triangle<P extends GlobalPoint | LocalPoint> = [
-    a: P,
-    b: P,
-    c: P
-] & {
-    _brand: "excalimath__triangle";
-};
-/**
- * A rectangular shape represented by 4 points at its corners
- */
-export type Rectangle<P extends GlobalPoint | LocalPoint> = [a: P, b: P] & {
-    _brand: "excalimath__rectangle";
-};
-/**
- * A polygon is a closed shape by connecting the given points
- * rectangles and diamonds are modelled by polygons
- */
-export type Polygon<Point extends GlobalPoint | LocalPoint> = Point[] & {
-    _brand: "excalimath_polygon";
-};
-/**
- * Cubic bezier curve with four control points
- */
-export type Curve<Point extends GlobalPoint | LocalPoint> = [
-    Point,
-    Point,
-    Point,
-    Point
-] & {
-    _brand: "excalimath_curve";
-};
-export type PolarCoords = [
-    radius: number,
-    /** angle in radians */
-    angle: number
-];
-/**
-  An ellipse is specified by its center, angle, and its major and minor axes
-  but for the sake of simplicity, we've used halfWidth and halfHeight instead
-  in replace of semi major and semi minor axes
- */
-export type Ellipse<Point extends GlobalPoint | LocalPoint> = {
-    center: Point;
-    halfWidth: number;
-    halfHeight: number;
-} & {
-    _brand: "excalimath_ellipse";
-};
+/**
+ * By definition one radian is the angle subtended at the centre
+ * of a circle by an arc that is equal in length to the radius.
+ */
+export type Radians = number & {
+    _brand: "excalimath__radian";
+};
+/**
+ * An angle measurement of a plane angle in which one full
+ * rotation is 360 degrees.
+ */
+export type Degrees = number & {
+    _brand: "excalimath_degree";
+};
+/**
+ * A number range which includes the start and end numbers in the range.
+ */
+export type InclusiveRange = [number, number] & {
+    _brand: "excalimath_degree";
+};
+/**
+ * Represents a 2D position in world or canvas space. A
+ * global coordinate.
+ */
+export type GlobalPoint = [x: number, y: number] & {
+    _brand: "excalimath__globalpoint";
+};
+/**
+ * Represents a 2D position in whatever local space it's
+ * needed. A local coordinate.
+ */
+export type LocalPoint = [x: number, y: number] & {
+    _brand: "excalimath__localpoint";
+};
+/**
+ * A line is an infinitely long object with no width, depth, or curvature.
+ */
+export type Line<P extends GlobalPoint | LocalPoint> = [p: P, q: P] & {
+    _brand: "excalimath_line";
+};
+/**
+ * In geometry, a line segment is a part of a straight
+ * line that is bounded by two distinct end points, and
+ * contains every point on the line that is between its endpoints.
+ */
+export type LineSegment<P extends GlobalPoint | LocalPoint> = [a: P, b: P] & {
+    _brand: "excalimath_linesegment";
+};
+/**
+ * Represents a 2D vector
+ */
+export type Vector = [u: number, v: number] & {
+    _brand: "excalimath__vector";
+};
+/**
+ * A triangle represented by 3 points
+ */
+export type Triangle<P extends GlobalPoint | LocalPoint> = [
+    a: P,
+    b: P,
+    c: P
+] & {
+    _brand: "excalimath__triangle";
+};
+/**
+ * A rectangular shape represented by 4 points at its corners
+ */
+export type Rectangle<P extends GlobalPoint | LocalPoint> = [a: P, b: P] & {
+    _brand: "excalimath__rectangle";
+};
+/**
+ * A polygon is a closed shape by connecting the given points
+ * rectangles and diamonds are modelled by polygons
+ */
+export type Polygon<Point extends GlobalPoint | LocalPoint> = Point[] & {
+    _brand: "excalimath_polygon";
+};
+/**
+ * Cubic bezier curve with four control points
+ */
+export type Curve<Point extends GlobalPoint | LocalPoint> = [
+    Point,
+    Point,
+    Point,
+    Point
+] & {
+    _brand: "excalimath_curve";
+};
+export type PolarCoords = [
+    radius: number,
+    /** angle in radians */
+    angle: number
+];
+/**
+  An ellipse is specified by its center, angle, and its major and minor axes
+  but for the sake of simplicity, we've used halfWidth and halfHeight instead
+  in replace of semi major and semi minor axes
+ */
+export type Ellipse<Point extends GlobalPoint | LocalPoint> = {
+    center: Point;
+    halfWidth: number;
+    halfHeight: number;
+} & {
+    _brand: "excalimath_ellipse";
+};
+export type ElementsSegmentsMap = Map<string, LineSegment<GlobalPoint>[]>;

package/dist/types/math/{utils.d.ts → src/utils.d.ts}

@@ -1,7 +1,7 @@
-export declare const PRECISION = 0.0001;
-export declare const clamp: (value: number, min: number, max: number) => number;
-export declare const round: (value: number, precision: number, func?: "round" | "floor" | "ceil") => number;
-export declare const roundToStep: (value: number, step: number, func?: "round" | "floor" | "ceil") => number;
-export declare const average: (a: number, b: number) => number;
-export declare const isFiniteNumber: (value: any) => value is number;
-export declare const isCloseTo: (a: number, b: number, precision?: number) => boolean;
+export declare const PRECISION = 0.0001;
+export declare const clamp: (value: number, min: number, max: number) => number;
+export declare const round: (value: number, precision: number, func?: "round" | "floor" | "ceil") => number;
+export declare const roundToStep: (value: number, step: number, func?: "round" | "floor" | "ceil") => number;
+export declare const average: (a: number, b: number) => number;
+export declare const isFiniteNumber: (value: any) => value is number;
+export declare const isCloseTo: (a: number, b: number, precision?: number) => boolean;

package/dist/types/math/{vector.d.ts → src/vector.d.ts}

@@ -1,88 +1,94 @@
-import type { GlobalPoint, LocalPoint, Vector } from "./types";
-/**
- * Create a vector from the x and y coordiante elements.
- *
- * @param x The X aspect of the vector
- * @param y T Y aspect of the vector
- * @returns The constructed vector with X and Y as the coordinates
- */
-export declare function vector(x: number, y: number, originX?: number, originY?: number): Vector;
-/**
- * Turn a point into a vector with the origin point.
- *
- * @param p The point to turn into a vector
- * @param origin The origin point in a given coordiante system
- * @returns The created vector from the point and the origin
- */
-export declare function vectorFromPoint<Point extends GlobalPoint | LocalPoint>(p: Point, origin?: Point): Vector;
-/**
- * Cross product is a binary operation on two vectors in 2D space.
- * It results in a vector that is perpendicular to both vectors.
- *
- * @param a One of the vectors to use for the directed area calculation
- * @param b The other vector to use for the directed area calculation
- * @returns The directed area value for the two vectos
- */
-export declare function vectorCross(a: Vector, b: Vector): number;
-/**
- * Dot product is defined as the sum of the products of the
- * two vectors.
- *
- * @param a One of the vectors for which the sum of products is calculated
- * @param b The other vector for which the sum of products is calculated
- * @returns The sum of products of the two vectors
- */
-export declare function vectorDot(a: Vector, b: Vector): number;
-/**
- * Determines if the value has the shape of a Vector.
- *
- * @param v The value to test
- * @returns TRUE if the value has the shape and components of a Vectors
- */
-export declare function isVector(v: unknown): v is Vector;
-/**
- * Add two vectors by adding their coordinates.
- *
- * @param a One of the vectors to add
- * @param b The other vector to add
- * @returns The sum vector of the two provided vectors
- */
-export declare function vectorAdd(a: Readonly<Vector>, b: Readonly<Vector>): Vector;
-/**
- * Add two vectors by adding their coordinates.
- *
- * @param start One of the vectors to add
- * @param end The other vector to add
- * @returns The sum vector of the two provided vectors
- */
-export declare function vectorSubtract(start: Readonly<Vector>, end: Readonly<Vector>): Vector;
-/**
- * Scale vector by a scalar.
- *
- * @param v The vector to scale
- * @param scalar The scalar to multiply the vector components with
- * @returns The new scaled vector
- */
-export declare function vectorScale(v: Vector, scalar: number): Vector;
-/**
- * Calculates the sqare magnitude of a vector. Use this if you compare
- * magnitudes as it saves you an SQRT.
- *
- * @param v The vector to measure
- * @returns The scalar squared magnitude of the vector
- */
-export declare function vectorMagnitudeSq(v: Vector): number;
-/**
- * Calculates the magnitude of a vector.
- *
- * @param v The vector to measure
- * @returns The scalar magnitude of the vector
- */
-export declare function vectorMagnitude(v: Vector): number;
-/**
- * Normalize the vector (i.e. make the vector magnitue equal 1).
- *
- * @param v The vector to normalize
- * @returns The new normalized vector
- */
-export declare const vectorNormalize: (v: Vector) => Vector;
+import type { GlobalPoint, LocalPoint, Vector } from "./types";
+/**
+ * Create a vector from the x and y coordiante elements.
+ *
+ * @param x The X aspect of the vector
+ * @param y T Y aspect of the vector
+ * @returns The constructed vector with X and Y as the coordinates
+ */
+export declare function vector(x: number, y: number, originX?: number, originY?: number): Vector;
+/**
+ * Turn a point into a vector with the origin point.
+ *
+ * @param p The point to turn into a vector
+ * @param origin The origin point in a given coordiante system
+ * @param threshold The threshold to consider the vector as 'undefined'
+ * @param defaultValue The default value to return if the vector is 'undefined'
+ * @returns The created vector from the point and the origin or default
+ */
+export declare function vectorFromPoint<Point extends GlobalPoint | LocalPoint>(p: Point, origin?: Point, threshold?: number, defaultValue?: Vector): Vector;
+/**
+ * Cross product is a binary operation on two vectors in 2D space.
+ * It results in a vector that is perpendicular to both vectors.
+ *
+ * @param a One of the vectors to use for the directed area calculation
+ * @param b The other vector to use for the directed area calculation
+ * @returns The directed area value for the two vectos
+ */
+export declare function vectorCross(a: Vector, b: Vector): number;
+/**
+ * Dot product is defined as the sum of the products of the
+ * two vectors.
+ *
+ * @param a One of the vectors for which the sum of products is calculated
+ * @param b The other vector for which the sum of products is calculated
+ * @returns The sum of products of the two vectors
+ */
+export declare function vectorDot(a: Vector, b: Vector): number;
+/**
+ * Determines if the value has the shape of a Vector.
+ *
+ * @param v The value to test
+ * @returns TRUE if the value has the shape and components of a Vectors
+ */
+export declare function isVector(v: unknown): v is Vector;
+/**
+ * Add two vectors by adding their coordinates.
+ *
+ * @param a One of the vectors to add
+ * @param b The other vector to add
+ * @returns The sum vector of the two provided vectors
+ */
+export declare function vectorAdd(a: Readonly<Vector>, b: Readonly<Vector>): Vector;
+/**
+ * Add two vectors by adding their coordinates.
+ *
+ * @param start One of the vectors to add
+ * @param end The other vector to add
+ * @returns The sum vector of the two provided vectors
+ */
+export declare function vectorSubtract(start: Readonly<Vector>, end: Readonly<Vector>): Vector;
+/**
+ * Scale vector by a scalar.
+ *
+ * @param v The vector to scale
+ * @param scalar The scalar to multiply the vector components with
+ * @returns The new scaled vector
+ */
+export declare function vectorScale(v: Vector, scalar: number): Vector;
+/**
+ * Calculates the sqare magnitude of a vector. Use this if you compare
+ * magnitudes as it saves you an SQRT.
+ *
+ * @param v The vector to measure
+ * @returns The scalar squared magnitude of the vector
+ */
+export declare function vectorMagnitudeSq(v: Vector): number;
+/**
+ * Calculates the magnitude of a vector.
+ *
+ * @param v The vector to measure
+ * @returns The scalar magnitude of the vector
+ */
+export declare function vectorMagnitude(v: Vector): number;
+/**
+ * Normalize the vector (i.e. make the vector magnitue equal 1).
+ *
+ * @param v The vector to normalize
+ * @returns The new normalized vector
+ */
+export declare const vectorNormalize: (v: Vector) => Vector;
+/**
+ * Calculate the right-hand normal of the vector.
+ */
+export declare const vectorNormal: (v: Vector) => Vector;

package/dist/types/utils/{bbox.d.ts → src/bbox.d.ts}

@@ -1,9 +1,9 @@
-import { type GlobalPoint, type LocalPoint } from "@excalidraw/math";
-import type { Bounds } from "@excalidraw/excalidraw/element/bounds";
-export type LineSegment<P extends LocalPoint | GlobalPoint> = [P, P];
-export declare function getBBox<P extends LocalPoint | GlobalPoint>(line: LineSegment<P>): Bounds;
-export declare function doBBoxesIntersect(a: Bounds, b: Bounds): boolean;
-export declare function isPointOnLine<P extends GlobalPoint | LocalPoint>(l: LineSegment<P>, p: P): boolean;
-export declare function isPointRightOfLine<P extends GlobalPoint | LocalPoint>(l: LineSegment<P>, p: P): boolean;
-export declare function isLineSegmentTouchingOrCrossingLine<P extends GlobalPoint | LocalPoint>(a: LineSegment<P>, b: LineSegment<P>): boolean;
-export declare function doLineSegmentsIntersect<P extends GlobalPoint | LocalPoint>(a: LineSegment<P>, b: LineSegment<P>): boolean;
+import { type GlobalPoint, type LocalPoint } from "@excalidraw/math";
+import type { Bounds } from "@excalidraw/element";
+export type LineSegment<P extends LocalPoint | GlobalPoint> = [P, P];
+export declare function getBBox<P extends LocalPoint | GlobalPoint>(line: LineSegment<P>): Bounds;
+export declare function doBBoxesIntersect(a: Bounds, b: Bounds): boolean;
+export declare function isPointOnLine<P extends GlobalPoint | LocalPoint>(l: LineSegment<P>, p: P): boolean;
+export declare function isPointRightOfLine<P extends GlobalPoint | LocalPoint>(l: LineSegment<P>, p: P): boolean;
+export declare function isLineSegmentTouchingOrCrossingLine<P extends GlobalPoint | LocalPoint>(a: LineSegment<P>, b: LineSegment<P>): boolean;
+export declare function doLineSegmentsIntersect<P extends GlobalPoint | LocalPoint>(a: LineSegment<P>, b: LineSegment<P>): boolean;