@zsviczian/excalidraw 0.18.0-2 → 0.18.0-4

package/types/math/angle.d.ts

@@ -1,17 +1,17 @@
-import type { Degrees, GlobalPoint, LocalPoint, PolarCoords, Radians } from "./types";
-export declare const normalizeRadians: (angle: Radians) => Radians;
-/**
- * Return the polar coordinates for the given cartesian point represented by
- * (x, y) for the center point 0,0 where the first number returned is the radius,
- * the second is the angle in radians.
- */
-export declare const cartesian2Polar: <P extends GlobalPoint | LocalPoint>([x, y,]: P) => PolarCoords;
-export declare function degreesToRadians(degrees: Degrees): Radians;
-export declare function radiansToDegrees(degrees: Radians): Degrees;
-/**
- * Determines if the provided angle is a right angle.
- *
- * @param rads The angle to measure
- * @returns TRUE if the provided angle is a right angle
- */
-export declare function isRightAngleRads(rads: Radians): boolean;
+import type { Degrees, GlobalPoint, LocalPoint, PolarCoords, Radians } from "./types";
+export declare const normalizeRadians: (angle: Radians) => Radians;
+/**
+ * Return the polar coordinates for the given cartesian point represented by
+ * (x, y) for the center point 0,0 where the first number returned is the radius,
+ * the second is the angle in radians.
+ */
+export declare const cartesian2Polar: <P extends GlobalPoint | LocalPoint>([x, y,]: P) => PolarCoords;
+export declare function degreesToRadians(degrees: Degrees): Radians;
+export declare function radiansToDegrees(degrees: Radians): Degrees;
+/**
+ * Determines if the provided angle is a right angle.
+ *
+ * @param rads The angle to measure
+ * @returns TRUE if the provided angle is a right angle
+ */
+export declare function isRightAngleRads(rads: Radians): boolean;

package/types/math/curve.d.ts

@@ -1,40 +1,40 @@
-import type { Curve, GlobalPoint, LineSegment, LocalPoint } from "./types";
-/**
- *
- * @param a
- * @param b
- * @param c
- * @param d
- * @returns
- */
-export declare function curve<Point extends GlobalPoint | LocalPoint>(a: Point, b: Point, c: Point, d: Point): Curve<Point>;
-/**
- * Computes the intersection between a cubic spline and a line segment.
- */
-export declare function curveIntersectLineSegment<Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, l: LineSegment<Point>): Point[];
-/**
- * Finds the closest point on the Bezier curve from another point
- *
- * @param x
- * @param y
- * @param P0
- * @param P1
- * @param P2
- * @param P3
- * @param tolerance
- * @param maxLevel
- * @returns
- */
-export declare function curveClosestPoint<Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, p: Point, tolerance?: number): Point | null;
-/**
- * Determines the distance between a point and the closest point on the
- * Bezier curve.
- *
- * @param c The curve to test
- * @param p The point to measure from
- */
-export declare function curvePointDistance<Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, p: Point): number;
-/**
- * Determines if the parameter is a Curve
- */
-export declare function isCurve<P extends GlobalPoint | LocalPoint>(v: unknown): v is Curve<P>;
+import type { Curve, GlobalPoint, LineSegment, LocalPoint } from "./types";
+/**
+ *
+ * @param a
+ * @param b
+ * @param c
+ * @param d
+ * @returns
+ */
+export declare function curve<Point extends GlobalPoint | LocalPoint>(a: Point, b: Point, c: Point, d: Point): Curve<Point>;
+/**
+ * Computes the intersection between a cubic spline and a line segment.
+ */
+export declare function curveIntersectLineSegment<Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, l: LineSegment<Point>): Point[];
+/**
+ * Finds the closest point on the Bezier curve from another point
+ *
+ * @param x
+ * @param y
+ * @param P0
+ * @param P1
+ * @param P2
+ * @param P3
+ * @param tolerance
+ * @param maxLevel
+ * @returns
+ */
+export declare function curveClosestPoint<Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, p: Point, tolerance?: number): Point | null;
+/**
+ * Determines the distance between a point and the closest point on the
+ * Bezier curve.
+ *
+ * @param c The curve to test
+ * @param p The point to measure from
+ */
+export declare function curvePointDistance<Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, p: Point): number;
+/**
+ * Determines if the parameter is a Curve
+ */
+export declare function isCurve<P extends GlobalPoint | LocalPoint>(v: unknown): v is Curve<P>;

package/types/math/ellipse.d.ts

@@ -1,44 +1,44 @@
-import type { Ellipse, GlobalPoint, Line, LineSegment, LocalPoint } from "./types";
-/**
- * Construct an Ellipse object from the parameters
- *
- * @param center The center of the ellipse
- * @param angle The slanting of the ellipse in radians
- * @param halfWidth Half of the width of a non-slanted version of the ellipse
- * @param halfHeight Half of the height of a non-slanted version of the ellipse
- * @returns The constructed Ellipse object
- */
-export declare function ellipse<Point extends GlobalPoint | LocalPoint>(center: Point, halfWidth: number, halfHeight: number): Ellipse<Point>;
-/**
- * Determines if a point is inside or on the ellipse outline
- *
- * @param p The point to test
- * @param ellipse The ellipse to compare against
- * @returns TRUE if the point is inside or on the outline of the ellipse
- */
-export declare const ellipseIncludesPoint: <Point extends GlobalPoint | LocalPoint>(p: Point, ellipse: Ellipse<Point>) => boolean;
-/**
- * Tests whether a point lies on the outline of the ellipse within a given
- * tolerance
- *
- * @param point The point to test
- * @param ellipse The ellipse to compare against
- * @param threshold The distance to consider a point close enough to be "on" the outline
- * @returns TRUE if the point is on the ellise outline
- */
-export declare const ellipseTouchesPoint: <Point extends GlobalPoint | LocalPoint>(point: Point, ellipse: Ellipse<Point>, threshold?: number) => boolean;
-/**
- * Determine the shortest euclidean distance from a point to the
- * outline of the ellipse
- *
- * @param p The point to consider
- * @param ellipse The ellipse to calculate the distance to
- * @returns The eucledian distance
- */
-export declare const ellipseDistanceFromPoint: <Point extends GlobalPoint | LocalPoint>(p: Point, ellipse: Ellipse<Point>) => number;
-/**
- * Calculate a maximum of two intercept points for a line going throug an
- * ellipse.
- */
-export declare function ellipseSegmentInterceptPoints<Point extends GlobalPoint | LocalPoint>(e: Readonly<Ellipse<Point>>, s: Readonly<LineSegment<Point>>): Point[];
-export declare function ellipseLineIntersectionPoints<Point extends GlobalPoint | LocalPoint>({ center, halfWidth, halfHeight }: Ellipse<Point>, [g, h]: Line<Point>): Point[];
+import type { Ellipse, GlobalPoint, Line, LineSegment, LocalPoint } from "./types";
+/**
+ * Construct an Ellipse object from the parameters
+ *
+ * @param center The center of the ellipse
+ * @param angle The slanting of the ellipse in radians
+ * @param halfWidth Half of the width of a non-slanted version of the ellipse
+ * @param halfHeight Half of the height of a non-slanted version of the ellipse
+ * @returns The constructed Ellipse object
+ */
+export declare function ellipse<Point extends GlobalPoint | LocalPoint>(center: Point, halfWidth: number, halfHeight: number): Ellipse<Point>;
+/**
+ * Determines if a point is inside or on the ellipse outline
+ *
+ * @param p The point to test
+ * @param ellipse The ellipse to compare against
+ * @returns TRUE if the point is inside or on the outline of the ellipse
+ */
+export declare const ellipseIncludesPoint: <Point extends GlobalPoint | LocalPoint>(p: Point, ellipse: Ellipse<Point>) => boolean;
+/**
+ * Tests whether a point lies on the outline of the ellipse within a given
+ * tolerance
+ *
+ * @param point The point to test
+ * @param ellipse The ellipse to compare against
+ * @param threshold The distance to consider a point close enough to be "on" the outline
+ * @returns TRUE if the point is on the ellise outline
+ */
+export declare const ellipseTouchesPoint: <Point extends GlobalPoint | LocalPoint>(point: Point, ellipse: Ellipse<Point>, threshold?: number) => boolean;
+/**
+ * Determine the shortest euclidean distance from a point to the
+ * outline of the ellipse
+ *
+ * @param p The point to consider
+ * @param ellipse The ellipse to calculate the distance to
+ * @returns The eucledian distance
+ */
+export declare const ellipseDistanceFromPoint: <Point extends GlobalPoint | LocalPoint>(p: Point, ellipse: Ellipse<Point>) => number;
+/**
+ * Calculate a maximum of two intercept points for a line going throug an
+ * ellipse.
+ */
+export declare function ellipseSegmentInterceptPoints<Point extends GlobalPoint | LocalPoint>(e: Readonly<Ellipse<Point>>, s: Readonly<LineSegment<Point>>): Point[];
+export declare function ellipseLineIntersectionPoints<Point extends GlobalPoint | LocalPoint>({ center, halfWidth, halfHeight }: Ellipse<Point>, [g, h]: Line<Point>): Point[];

package/types/math/index.d.ts

@@ -1,12 +1,12 @@
-export * from "./angle";
-export * from "./curve";
-export * from "./line";
-export * from "./point";
-export * from "./polygon";
-export * from "./range";
-export * from "./rectangle";
-export * from "./segment";
-export * from "./triangle";
-export * from "./types";
-export * from "./vector";
-export * from "./utils";
+export * from "./angle";
+export * from "./curve";
+export * from "./line";
+export * from "./point";
+export * from "./polygon";
+export * from "./range";
+export * from "./rectangle";
+export * from "./segment";
+export * from "./triangle";
+export * from "./types";
+export * from "./vector";
+export * from "./utils";

package/types/math/line.d.ts

@@ -1,17 +1,17 @@
-import type { GlobalPoint, Line, LocalPoint } from "./types";
-/**
- * Create a line from two points.
- *
- * @param points The two points lying on the line
- * @returns The line on which the points lie
- */
-export declare function line<P extends GlobalPoint | LocalPoint>(a: P, b: P): Line<P>;
-/**
- * Determines the intersection point (unless the lines are parallel) of two
- * lines
- *
- * @param a
- * @param b
- * @returns
- */
-export declare function linesIntersectAt<Point extends GlobalPoint | LocalPoint>(a: Line<Point>, b: Line<Point>): Point | null;
+import type { GlobalPoint, Line, LocalPoint } from "./types";
+/**
+ * Create a line from two points.
+ *
+ * @param points The two points lying on the line
+ * @returns The line on which the points lie
+ */
+export declare function line<P extends GlobalPoint | LocalPoint>(a: P, b: P): Line<P>;
+/**
+ * Determines the intersection point (unless the lines are parallel) of two
+ * lines
+ *
+ * @param a
+ * @param b
+ * @returns
+ */
+export declare function linesIntersectAt<Point extends GlobalPoint | LocalPoint>(a: Line<Point>, b: Line<Point>): Point | null;

package/types/math/point.d.ts

@@ -1,122 +1,122 @@
-import type { LocalPoint, GlobalPoint, Radians, Degrees, Vector } from "./types";
-/**
- * Create a properly typed Point instance from the X and Y coordinates.
- *
- * @param x The X coordinate
- * @param y The Y coordinate
- * @returns The branded and created point
- */
-export declare function pointFrom<Point extends GlobalPoint | LocalPoint>(x: number, y: number): Point;
-/**
- * Converts and remaps an array containing a pair of numbers to Point.
- *
- * @param numberArray The number array to check and to convert to Point
- * @returns The point instance
- */
-export declare function pointFromArray<Point extends GlobalPoint | LocalPoint>(numberArray: number[]): Point | undefined;
-/**
- * Converts and remaps a pair of numbers to Point.
- *
- * @param pair A number pair to convert to Point
- * @returns The point instance
- */
-export declare function pointFromPair<Point extends GlobalPoint | LocalPoint>(pair: [number, number]): Point;
-/**
- * Convert a vector to a point.
- *
- * @param v The vector to convert
- * @returns The point the vector points at with origin 0,0
- */
-export declare function pointFromVector<P extends GlobalPoint | LocalPoint>(v: Vector, offset?: P): P;
-/**
- * Checks if the provided value has the shape of a Point.
- *
- * @param p The value to attempt verification on
- * @returns TRUE if the provided value has the shape of a local or global point
- */
-export declare function isPoint(p: unknown): p is LocalPoint | GlobalPoint;
-/**
- * Compare two points coordinate-by-coordinate and if
- * they are closer than INVERSE_PRECISION it returns TRUE.
- *
- * @param a Point The first point to compare
- * @param b Point The second point to compare
- * @returns TRUE if the points are sufficiently close to each other
- */
-export declare function pointsEqual<Point extends GlobalPoint | LocalPoint>(a: Point, b: Point): boolean;
-/**
- * Roate a point by [angle] radians.
- *
- * @param point The point to rotate
- * @param center The point to rotate around, the center point
- * @param angle The radians to rotate the point by
- * @returns The rotated point
- */
-export declare function pointRotateRads<Point extends GlobalPoint | LocalPoint>([x, y]: Point, [cx, cy]: Point, angle: Radians): Point;
-/**
- * Roate a point by [angle] degree.
- *
- * @param point The point to rotate
- * @param center The point to rotate around, the center point
- * @param angle The degree to rotate the point by
- * @returns The rotated point
- */
-export declare function pointRotateDegs<Point extends GlobalPoint | LocalPoint>(point: Point, center: Point, angle: Degrees): Point;
-/**
- * Translate a point by a vector.
- *
- * WARNING: This is not for translating Excalidraw element points!
- *          You need to account for rotation on base coordinates
- *          on your own.
- *          CONSIDER USING AN APPROPRIATE ELEMENT-AWARE TRANSLATE!
- *
- * @param p The point to apply the translation on
- * @param v The vector to translate by
- * @returns
- */
-export declare function pointTranslate<From extends GlobalPoint | LocalPoint, To extends GlobalPoint | LocalPoint>(p: From, v?: Vector): To;
-/**
- * Find the center point at equal distance from both points.
- *
- * @param a One of the points to create the middle point for
- * @param b The other point to create the middle point for
- * @returns The middle point
- */
-export declare function pointCenter<P extends LocalPoint | GlobalPoint>(a: P, b: P): P;
-/**
- * Calculate the distance between two points.
- *
- * @param a First point
- * @param b Second point
- * @returns The euclidean distance between the two points.
- */
-export declare function pointDistance<P extends LocalPoint | GlobalPoint>(a: P, b: P): number;
-/**
- * Calculate the squared distance between two points.
- *
- * Note: Use this if you only compare distances, it saves a square root.
- *
- * @param a First point
- * @param b Second point
- * @returns The euclidean distance between the two points.
- */
-export declare function pointDistanceSq<P extends LocalPoint | GlobalPoint>(a: P, b: P): number;
-/**
- * Scale a point from a given origin by the multiplier.
- *
- * @param p The point to scale
- * @param mid The origin to scale from
- * @param multiplier The scaling factor
- * @returns
- */
-export declare const pointScaleFromOrigin: <P extends GlobalPoint | LocalPoint>(p: P, mid: P, multiplier: number) => GlobalPoint | LocalPoint;
-/**
- * Returns whether `q` lies inside the segment/rectangle defined by `p` and `r`.
- * This is an approximation to "does `q` lie on a segment `pr`" check.
- *
- * @param p The first point to compare against
- * @param q The actual point this function checks whether is in between
- * @param r The other point to compare against
- * @returns TRUE if q is indeed between p and r
- */
-export declare const isPointWithinBounds: <P extends GlobalPoint | LocalPoint>(p: P, q: P, r: P) => boolean;
+import type { LocalPoint, GlobalPoint, Radians, Degrees, Vector } from "./types";
+/**
+ * Create a properly typed Point instance from the X and Y coordinates.
+ *
+ * @param x The X coordinate
+ * @param y The Y coordinate
+ * @returns The branded and created point
+ */
+export declare function pointFrom<Point extends GlobalPoint | LocalPoint>(x: number, y: number): Point;
+/**
+ * Converts and remaps an array containing a pair of numbers to Point.
+ *
+ * @param numberArray The number array to check and to convert to Point
+ * @returns The point instance
+ */
+export declare function pointFromArray<Point extends GlobalPoint | LocalPoint>(numberArray: number[]): Point | undefined;
+/**
+ * Converts and remaps a pair of numbers to Point.
+ *
+ * @param pair A number pair to convert to Point
+ * @returns The point instance
+ */
+export declare function pointFromPair<Point extends GlobalPoint | LocalPoint>(pair: [number, number]): Point;
+/**
+ * Convert a vector to a point.
+ *
+ * @param v The vector to convert
+ * @returns The point the vector points at with origin 0,0
+ */
+export declare function pointFromVector<P extends GlobalPoint | LocalPoint>(v: Vector, offset?: P): P;
+/**
+ * Checks if the provided value has the shape of a Point.
+ *
+ * @param p The value to attempt verification on
+ * @returns TRUE if the provided value has the shape of a local or global point
+ */
+export declare function isPoint(p: unknown): p is LocalPoint | GlobalPoint;
+/**
+ * Compare two points coordinate-by-coordinate and if
+ * they are closer than INVERSE_PRECISION it returns TRUE.
+ *
+ * @param a Point The first point to compare
+ * @param b Point The second point to compare
+ * @returns TRUE if the points are sufficiently close to each other
+ */
+export declare function pointsEqual<Point extends GlobalPoint | LocalPoint>(a: Point, b: Point): boolean;
+/**
+ * Roate a point by [angle] radians.
+ *
+ * @param point The point to rotate
+ * @param center The point to rotate around, the center point
+ * @param angle The radians to rotate the point by
+ * @returns The rotated point
+ */
+export declare function pointRotateRads<Point extends GlobalPoint | LocalPoint>([x, y]: Point, [cx, cy]: Point, angle: Radians): Point;
+/**
+ * Roate a point by [angle] degree.
+ *
+ * @param point The point to rotate
+ * @param center The point to rotate around, the center point
+ * @param angle The degree to rotate the point by
+ * @returns The rotated point
+ */
+export declare function pointRotateDegs<Point extends GlobalPoint | LocalPoint>(point: Point, center: Point, angle: Degrees): Point;
+/**
+ * Translate a point by a vector.
+ *
+ * WARNING: This is not for translating Excalidraw element points!
+ *          You need to account for rotation on base coordinates
+ *          on your own.
+ *          CONSIDER USING AN APPROPRIATE ELEMENT-AWARE TRANSLATE!
+ *
+ * @param p The point to apply the translation on
+ * @param v The vector to translate by
+ * @returns
+ */
+export declare function pointTranslate<From extends GlobalPoint | LocalPoint, To extends GlobalPoint | LocalPoint>(p: From, v?: Vector): To;
+/**
+ * Find the center point at equal distance from both points.
+ *
+ * @param a One of the points to create the middle point for
+ * @param b The other point to create the middle point for
+ * @returns The middle point
+ */
+export declare function pointCenter<P extends LocalPoint | GlobalPoint>(a: P, b: P): P;
+/**
+ * Calculate the distance between two points.
+ *
+ * @param a First point
+ * @param b Second point
+ * @returns The euclidean distance between the two points.
+ */
+export declare function pointDistance<P extends LocalPoint | GlobalPoint>(a: P, b: P): number;
+/**
+ * Calculate the squared distance between two points.
+ *
+ * Note: Use this if you only compare distances, it saves a square root.
+ *
+ * @param a First point
+ * @param b Second point
+ * @returns The euclidean distance between the two points.
+ */
+export declare function pointDistanceSq<P extends LocalPoint | GlobalPoint>(a: P, b: P): number;
+/**
+ * Scale a point from a given origin by the multiplier.
+ *
+ * @param p The point to scale
+ * @param mid The origin to scale from
+ * @param multiplier The scaling factor
+ * @returns
+ */
+export declare const pointScaleFromOrigin: <P extends GlobalPoint | LocalPoint>(p: P, mid: P, multiplier: number) => GlobalPoint | LocalPoint;
+/**
+ * Returns whether `q` lies inside the segment/rectangle defined by `p` and `r`.
+ * This is an approximation to "does `q` lie on a segment `pr`" check.
+ *
+ * @param p The first point to compare against
+ * @param q The actual point this function checks whether is in between
+ * @param r The other point to compare against
+ * @returns TRUE if q is indeed between p and r
+ */
+export declare const isPointWithinBounds: <P extends GlobalPoint | LocalPoint>(p: P, q: P, r: P) => boolean;

package/types/math/polygon.d.ts

@@ -1,5 +1,5 @@
-import type { GlobalPoint, LocalPoint, Polygon } from "./types";
-export declare function polygon<Point extends GlobalPoint | LocalPoint>(...points: Point[]): Polygon<Point>;
-export declare function polygonFromPoints<Point extends GlobalPoint | LocalPoint>(points: Point[]): Polygon<Point>;
-export declare const polygonIncludesPoint: <Point extends GlobalPoint | LocalPoint>(point: Point, polygon: Polygon<Point>) => boolean;
-export declare const pointOnPolygon: <Point extends GlobalPoint | LocalPoint>(p: Point, poly: Polygon<Point>, threshold?: number) => boolean;
+import type { GlobalPoint, LocalPoint, Polygon } from "./types";
+export declare function polygon<Point extends GlobalPoint | LocalPoint>(...points: Point[]): Polygon<Point>;
+export declare function polygonFromPoints<Point extends GlobalPoint | LocalPoint>(points: Point[]): Polygon<Point>;
+export declare const polygonIncludesPoint: <Point extends GlobalPoint | LocalPoint>(point: Point, polygon: Polygon<Point>) => boolean;
+export declare const pointOnPolygon: <Point extends GlobalPoint | LocalPoint>(p: Point, poly: Polygon<Point>, threshold?: number) => boolean;

package/types/math/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/types/math/rectangle.d.ts

@@ -1,3 +1,3 @@
-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 rectangleIntersectLineSegment<Point extends LocalPoint | GlobalPoint>(r: Rectangle<Point>, l: LineSegment<Point>): Point[];