@excalidraw/excalidraw 0.18.0-a9e2d2348-preview → 0.18.0-b7aac689a

package/dist/types/excalidraw/workers.d.ts

@@ -1,36 +1,36 @@
-/**
- * Pool of idle short-lived workers.
- *
- * IMPORTANT: for simplicity it does not limit the number of newly created workers, leaving it up to the caller to manage the pool size.
- */
-export declare class WorkerPool<T, R> {
-    private idleWorkers;
-    private readonly workerUrl;
-    private readonly workerTTL;
-    private constructor();
-    /**
-     * Create a new worker pool.
-     *
-     * @param workerUrl - The URL of the worker file.
-     * @param options - The options for the worker pool.
-     * @throws If the worker is bundled into the main chunk.
-     * @returns A new worker pool instance.
-     */
-    static create<T, R>(workerUrl: URL | undefined, options?: {
-        ttl?: number;
-    }): WorkerPool<T, R>;
-    /**
-     * Take idle worker from the pool or create a new one and post a message to it.
-     */
-    postMessage(data: T, options: StructuredSerializeOptions): Promise<R>;
-    /**
-     * Terminate the idle workers in the pool.
-     */
-    clear(): Promise<void>;
-    /**
-     * Used to get a worker from the pool or create a new one if there is no idle available.
-     */
-    private createWorker;
-    private onMessageHandler;
-    private onErrorHandler;
-}
+/**
+ * Pool of idle short-lived workers.
+ *
+ * IMPORTANT: for simplicity it does not limit the number of newly created workers, leaving it up to the caller to manage the pool size.
+ */
+export declare class WorkerPool<T, R> {
+    private idleWorkers;
+    private readonly workerUrl;
+    private readonly workerTTL;
+    private constructor();
+    /**
+     * Create a new worker pool.
+     *
+     * @param workerUrl - The URL of the worker file.
+     * @param options - The options for the worker pool.
+     * @throws If the worker is bundled into the main chunk.
+     * @returns A new worker pool instance.
+     */
+    static create<T, R>(workerUrl: URL | undefined, options?: {
+        ttl?: number;
+    }): WorkerPool<T, R>;
+    /**
+     * Take idle worker from the pool or create a new one and post a message to it.
+     */
+    postMessage(data: T, options: StructuredSerializeOptions): Promise<R>;
+    /**
+     * Terminate the idle workers in the pool.
+     */
+    clear(): Promise<void>;
+    /**
+     * Used to get a worker from the pool or create a new one if there is no idle available.
+     */
+    private createWorker;
+    private onMessageHandler;
+    private onErrorHandler;
+}

package/dist/types/excalidraw/{element → wysiwyg}/textWysiwyg.d.ts

@@ -1,22 +1,24 @@
-import type { ExcalidrawElement, ExcalidrawTextElement } from "./types";
-import type App from "../components/App";
-export declare const textWysiwyg: ({ id, onChange, onSubmit, getViewportCoords, element, canvas, excalidrawContainer, app, autoSelect, }: {
-    id: ExcalidrawElement["id"];
-    /**
-     * textWysiwyg only deals with `originalText`
-     *
-     * Note: `text`, which can be wrapped and therefore different from `originalText`,
-     *       is derived from `originalText`
-     */
-    onChange?: ((nextOriginalText: string) => void) | undefined;
-    onSubmit: (data: {
-        viaKeyboard: boolean;
-        nextOriginalText: string;
-    }) => void;
-    getViewportCoords: (x: number, y: number) => [number, number];
-    element: ExcalidrawTextElement;
-    canvas: HTMLCanvasElement;
-    excalidrawContainer: HTMLDivElement | null;
-    app: App;
-    autoSelect?: boolean | undefined;
-}) => void;
+import type { ExcalidrawElement, ExcalidrawTextElement } from "@excalidraw/element/types";
+import type App from "../components/App";
+type SubmitHandler = () => void;
+export declare const textWysiwyg: ({ id, onChange, onSubmit, getViewportCoords, element, canvas, excalidrawContainer, app, autoSelect, }: {
+    id: ExcalidrawElement["id"];
+    /**
+     * textWysiwyg only deals with `originalText`
+     *
+     * Note: `text`, which can be wrapped and therefore different from `originalText`,
+     *       is derived from `originalText`
+     */
+    onChange?: ((nextOriginalText: string) => void) | undefined;
+    onSubmit: (data: {
+        viaKeyboard: boolean;
+        nextOriginalText: string;
+    }) => void;
+    getViewportCoords: (x: number, y: number) => [number, number];
+    element: ExcalidrawTextElement;
+    canvas: HTMLCanvasElement;
+    excalidrawContainer: HTMLDivElement | null;
+    app: App;
+    autoSelect?: boolean | undefined;
+}) => SubmitHandler;
+export {};

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

@@ -1,17 +1,19 @@
-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;
+export declare function radiansBetweenAngles(a: Radians, min: Radians, max: Radians): boolean;
+export declare function radiansDifference(a: Radians, b: Radians): Radians;

package/dist/types/math/src/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const PRECISION = 0.0001;
+export declare const LegendreGaussN24TValues: number[];
+export declare const LegendreGaussN24CValues: number[];

package/dist/types/math/src/curve.d.ts

@@ -0,0 +1,74 @@
+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>;
+export declare const bezierEquation: <Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, t: number) => 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>;
+export declare function curveTangent<Point extends GlobalPoint | LocalPoint>([p0, p1, p2, p3]: Curve<Point>, t: number): import("./types").Vector;
+export declare function curveCatmullRomQuadraticApproxPoints(points: GlobalPoint[], tension?: number): [GlobalPoint, GlobalPoint][] | undefined;
+export declare function curveCatmullRomCubicApproxPoints<Point extends GlobalPoint | LocalPoint>(points: Point[], tension?: number): Curve<Point>[] | undefined;
+export declare function curveOffsetPoints([p0, p1, p2, p3]: Curve<GlobalPoint>, offset: number, steps?: number): GlobalPoint[];
+export declare function offsetPointsForQuadraticBezier(p0: GlobalPoint, p1: GlobalPoint, p2: GlobalPoint, offsetDist: number, steps?: number): GlobalPoint[];
+/**
+ * Implementation based on Legendre-Gauss quadrature for more accurate arc
+ * length calculation.
+ *
+ * Reference: https://pomax.github.io/bezierinfo/#arclength
+ *
+ * @param c The curve to calculate the length of
+ * @returns The approximated length of the curve
+ */
+export declare function curveLength<P extends GlobalPoint | LocalPoint>(c: Curve<P>): number;
+/**
+ * Calculates the curve length from t=0 to t=parameter using the same
+ * Legendre-Gauss quadrature method used in curveLength
+ *
+ * @param c The curve to calculate the partial length for
+ * @param t The parameter value (0 to 1) to calculate length up to
+ * @returns The length of the curve from beginning to parameter t
+ */
+export declare function curveLengthAtParameter<P extends GlobalPoint | LocalPoint>(c: Curve<P>, t: number): number;
+/**
+ * Calculates the point at a specific percentage of a curve's total length
+ * using binary search for improved efficiency and accuracy.
+ *
+ * @param c The curve to calculate point on
+ * @param percent A value between 0 and 1 representing the percentage of the curve's length
+ * @returns The point at the specified percentage of curve length
+ */
+export declare function curvePointAtLength<P extends GlobalPoint | LocalPoint>(c: Curve<P>, percent: number): P;

package/dist/types/math/{ellipse.d.ts → src/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/dist/types/math/{index.d.ts → src/index.d.ts}

@@ -1,12 +1,13 @@
-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 "./ellipse";
+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/dist/types/math/{line.d.ts → src/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/dist/types/math/{point.d.ts → src/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, tolerance?: number): boolean;
+/**
+ * Rotate 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;
+/**
+ * Rotate 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/dist/types/math/{polygon.d.ts → src/polygon.d.ts}

@@ -1,5 +1,6 @@
-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 polygonIncludesPointNonZero: <Point extends [number, number]>(point: Point, polygon: Point[]) => boolean;
+export declare const pointOnPolygon: <Point extends GlobalPoint | LocalPoint>(p: Point, poly: Polygon<Point>, threshold?: number) => boolean;