@excalidraw/math 0.18.0-4e471c107 → 0.18.0-4e758db

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

@@ -0,0 +1,280 @@
+import type { SceneBounds } from "@excalidraw/element";
+import type { Bounds } from "@excalidraw/common";
+import type { ExcalidrawElement } from "@excalidraw/element/types";
+import type { AppState, NormalizedZoomValue, Offsets, PointerCoords, ScrollConstraints, ViewportOffsets, Zoom } from "./types";
+/** default rubberband overscroll give for scroll locks, in viewport px */
+export declare const DEFAULT_OVERSCROLL = 150;
+type ZoomOptions = {
+    viewportX: number;
+    viewportY: number;
+    nextZoom: NormalizedZoomValue;
+};
+export type AnimationOptions = {
+    duration?: number;
+};
+export type SetViewportRect = {
+    x: number;
+    y: number;
+    width?: number;
+    height?: number;
+};
+export type SetViewportOptions = {
+    /**
+     * what to show in the viewport: an explicit scene-coordinate box/rect,
+     * element(s), or an element id / element-link URL.
+     *
+     * IMPORTANT: if supplying ExcalidrawElement(s), only non-deleted elements
+     * that actually exist on the canvas are considered. If you want to navigate
+     * to elements that's not on canvas yet, supply their bounds by using
+     * `getCommonBounds` (see {@link getCommonBounds}).
+     */
+    target: Bounds | SetViewportRect | ExcalidrawElement | readonly ExcalidrawElement[] | string;
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/Properties/object-fit
+     *
+     * - `scale-down` - zoom out so the target fits the viewport, never zooming past 100%
+     * - `contain` - zoom the target so it fills the viewport (may exceed 100%)
+     * - `none` - keep the current zoom, only center the target in the viewport
+     */
+    fit?: "scale-down" | "contain" | "none";
+    lock?: {
+        /** constraints panning to the target box */
+        scroll?: ScrollConstraints["lockScroll"];
+        /** makes the resolved zoom the minimum zoom */
+        zoom?: ScrollConstraints["lockZoom"];
+        /**
+         * Rubberband give past the lock, in viewport px (zoom-independent): how
+         * far the user can pan beyond the constraint before snapping back.
+         * `true` (default) uses {@link DEFAULT_OVERSCROLL}, `false` disables
+         * (rigid lock), a number sets the give explicitly.
+         */
+        overscroll?: boolean | number;
+    };
+    animation?: AnimationOptions | boolean;
+    /**
+     * CSS-style per-side viewport insets, in viewport pixels
+     * (zoom-independent) — static values, editor-UI-derived (`ui`), or a
+     * combination. See {@link ViewportOffsets}.
+     */
+    offsets?: ViewportOffsets;
+};
+type Viewport = Pick<AppState, "scrollX" | "scrollY" | "zoom">;
+/**
+ * Clamps a proposed scroll/zoom against the active lock (`scrollConstraints`).
+ * Returns the input scroll/zoom unchanged when there is no lock.
+ * `overscroll` (screen px, zoom-independent) is rubberband give past the
+ * resting clamp — pass 0 for a hard clamp.
+ */
+export declare const constrainScrollState: (state: Pick<AppState, "scrollX" | "scrollY" | "zoom" | "width" | "height" | "scrollConstraints">, overscroll?: number) => Viewport;
+/**
+ * Resolves a focal-point zoom against the active scroll constraints while
+ * preserving the current rubberband displacement in screen pixels. This lets
+ * zoom and scroll-constraint snap-back compose without either visually
+ * cancelling the other.
+ */
+export declare const getViewportForZoomWithScrollConstraints: (opts: ZoomOptions, state: AppState) => Viewport;
+export declare const zoomToFitBounds: ({ bounds, appState, canvasOffsets, fit, minZoom, maxZoom, steppedZoom, }: {
+    bounds: SceneBounds;
+    canvasOffsets?: Offsets;
+    appState: Readonly<AppState>;
+    fit?: SetViewportOptions["fit"];
+    minZoom?: number;
+    maxZoom?: number;
+    steppedZoom?: boolean;
+}) => {
+    appState: {
+        scrollX: number;
+        scrollY: number;
+        zoom: {
+            value: NormalizedZoomValue;
+        };
+        contextMenu: {
+            items: import("./components/ContextMenu").ContextMenuItems;
+            top: number;
+            left: number;
+        } | null;
+        showWelcomeScreen: boolean;
+        isLoading: boolean;
+        errorMessage: React.ReactNode;
+        activeEmbeddable: {
+            element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
+            state: "hover" | "active";
+        } | null;
+        newElement: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawNonSelectionElement> | null;
+        resizingElement: import("@excalidraw/element/types").NonDeletedExcalidrawElement | null;
+        multiElement: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawLinearElement> | null;
+        selectionElement: import("@excalidraw/element/types").NonDeletedExcalidrawElement | null;
+        isBindingEnabled: boolean;
+        boxSelectionMode: import("./types").BoxSelectionMode;
+        bindingPreference: "enabled" | "disabled";
+        isMidpointSnappingEnabled: boolean;
+        inputDevice: import("./types").InputDevice;
+        suggestedBinding: {
+            element: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawBindableElement>;
+            midPoint?: import("@excalidraw/math").GlobalPoint;
+        } | null;
+        hoveredArrowTextAnchor: {
+            elementId: import("@excalidraw/element/types").ExcalidrawArrowElement["id"];
+            anchor: "start" | "end" | "label";
+        } | null;
+        frameToHighlight: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawFrameLikeElement> | null;
+        frameRendering: {
+            enabled: boolean;
+            name: boolean;
+            outline: boolean;
+            clip: boolean;
+        };
+        editingFrame: import("@excalidraw/element/types").ExcalidrawFrameLikeElement["id"] | null;
+        elementsToHighlight: readonly import("@excalidraw/element/types").NonDeletedExcalidrawElement[] | null;
+        editingTextElement: import("@excalidraw/element/types").ExcalidrawTextElement | null;
+        activeTool: {
+            lastActiveTool: import("./types").ActiveTool | null;
+            locked: boolean;
+            fromSelection: boolean;
+        } & import("./types").ActiveTool;
+        preferredSelectionTool: {
+            type: "selection" | "lasso";
+            initialized: boolean;
+        };
+        penMode: boolean;
+        penDetected: boolean;
+        exportBackground: boolean;
+        exportEmbedScene: boolean;
+        exportWithDarkMode: boolean;
+        exportScale: number;
+        currentItemStrokeColor: string;
+        currentItemStickynoteStrokeColor: string;
+        currentItemStickynoteBackgroundColor: string;
+        currentItemBackgroundColor: string;
+        currentItemFillStyle: ExcalidrawElement["fillStyle"];
+        currentItemStrokeWidthKey: import("@excalidraw/common").StrokeWidthKey;
+        currentItemStrokeStyle: ExcalidrawElement["strokeStyle"];
+        currentItemRoughness: number;
+        currentItemStrokeVariability: import("@excalidraw/element/types").StrokeVariability;
+        currentItemOpacity: number;
+        currentItemFontFamily: import("@excalidraw/element/types").FontFamilyValues;
+        currentItemFontSize: number;
+        currentItemTextAlign: import("@excalidraw/element/types").TextAlign;
+        currentItemStartArrowhead: import("@excalidraw/element/types").Arrowhead | null;
+        currentItemEndArrowhead: import("@excalidraw/element/types").Arrowhead | null;
+        currentHoveredFontFamily: import("@excalidraw/element/types").FontFamilyValues | null;
+        currentItemRoundness: import("@excalidraw/element/types").StrokeRoundness;
+        currentItemArrowType: "sharp" | "round" | "elbow";
+        viewBackgroundColor: string;
+        scrollConstraints: ScrollConstraints | null;
+        cursorButton: "up" | "down";
+        scrolledOutside: boolean;
+        name: string | null;
+        isResizing: boolean;
+        isRotating: boolean;
+        openMenu: "canvas" | null;
+        openPopup: "canvasBackground" | "elementBackground" | "elementStroke" | "fontFamily" | "compactTextProperties" | "compactStrokeStyles" | "compactOtherProperties" | "compactArrowProperties" | null;
+        openSidebar: {
+            name: import("./types").SidebarName;
+            tab?: import("./types").SidebarTabName;
+        } | null;
+        openDialog: null | {
+            name: "imageExport" | "help" | "jsonExport";
+        } | {
+            name: "ttd";
+            tab: "text-to-diagram" | "mermaid";
+        } | {
+            name: "commandPalette";
+        } | {
+            name: "settings";
+        } | {
+            name: "elementLinkSelector";
+            sourceElementId: ExcalidrawElement["id"];
+        } | {
+            name: "charts";
+            data: import("./charts").Spreadsheet;
+            rawText: string;
+        };
+        defaultSidebarDockedPreference: boolean;
+        lastPointerDownWith: import("@excalidraw/element/types").PointerType;
+        selectedElementIds: Readonly<{
+            [id: string]: true;
+        }>;
+        hoveredElementIds: Readonly<{
+            [id: string]: true;
+        }>;
+        previousSelectedElementIds: {
+            [id: string]: true;
+        };
+        selectedElementsAreBeingDragged: boolean;
+        shouldCacheIgnoreZoom: boolean;
+        toast: {
+            message: React.ReactNode;
+            closable?: boolean;
+            duration?: number;
+        } | null;
+        zenModeEnabled: boolean;
+        theme: import("@excalidraw/element/types").Theme;
+        gridSize: number;
+        gridStep: number;
+        gridModeEnabled: boolean;
+        viewModeEnabled: boolean;
+        selectedGroupIds: {
+            [groupId: string]: boolean;
+        };
+        editingGroupId: import("@excalidraw/element/types").GroupId | null;
+        width: number;
+        height: number;
+        offsetTop: number;
+        offsetLeft: number;
+        fileHandle: FileSystemFileHandle | null;
+        collaborators: Map<import("./types").SocketId, import("./types").Collaborator>;
+        stats: {
+            open: boolean;
+            panels: number;
+        };
+        showHyperlinkPopup: false | "info" | "editor";
+        selectedLinearElement: import("@excalidraw/element").LinearElementEditor | null;
+        snapLines: readonly import("./snapping").SnapLine[];
+        originSnapOffset: {
+            x: number;
+            y: number;
+        } | null;
+        objectsSnapModeEnabled: boolean;
+        isCropping: boolean;
+        croppingElementId: ExcalidrawElement["id"] | null;
+        searchMatches: Readonly<{
+            focusedId: ExcalidrawElement["id"] | null;
+            matches: readonly import("./types").SearchMatch[];
+        }> | null;
+        activeLockedId: string | null;
+        lockedMultiSelections: {
+            [groupId: string]: true;
+        };
+        bindMode: import("@excalidraw/element/types").BindMode;
+        colorTopPicks: {
+            elementStroke: readonly string[] | null;
+            elementBackground: readonly string[] | null;
+            bucketFill: readonly string[] | null;
+            stickyNoteStroke: readonly string[] | null;
+            stickyNoteBackground: readonly string[] | null;
+        };
+    };
+    captureUpdate: "EVENTUALLY";
+};
+export declare const getClosestElementBounds: (elements: readonly ExcalidrawElement[], from: {
+    x: number;
+    y: number;
+}) => Bounds;
+export declare const centerScrollOn: ({ scenePoint, viewportDimensions, zoom, offsets, }: {
+    scenePoint: PointerCoords;
+    viewportDimensions: {
+        height: number;
+        width: number;
+    };
+    zoom: Zoom;
+    offsets?: Offsets;
+}) => {
+    scrollX: number;
+    scrollY: number;
+};
+export declare const getScrollToContentState: (elements: readonly ExcalidrawElement[], appState: AppState) => {
+    scrollX: number;
+    scrollY: number;
+};
+export {};

package/dist/types/excalidraw/wysiwyg/textWysiwyg.d.ts

@@ -1,15 +1,14 @@
-import type { ExcalidrawElement, ExcalidrawTextElement } from "@excalidraw/element/types";
+import type { 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"];
+export declare const textWysiwyg: ({ onChange, onSubmit, getViewportCoords, element, canvas, excalidrawContainer, app, autoSelect, initialCaretSceneCoords, }: {
     /**
      * 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;
+    onChange?: (nextOriginalText: string) => void;
     onSubmit: (data: {
         viaKeyboard: boolean;
         nextOriginalText: string;
@@ -19,6 +18,10 @@ export declare const textWysiwyg: ({ id, onChange, onSubmit, getViewportCoords,
     canvas: HTMLCanvasElement;
     excalidrawContainer: HTMLDivElement | null;
     app: App;
-    autoSelect?: boolean | undefined;
+    autoSelect?: boolean;
+    initialCaretSceneCoords?: {
+        x: number;
+        y: number;
+    } | null;
 }) => SubmitHandler;
 export {};

package/dist/types/fractional-indexing/src/index.d.ts

@@ -0,0 +1,29 @@
+export declare const BASE_62_DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+/**
+ * @param {string} key
+ * @param {string} digits
+ * @return {void}
+ */
+export declare function validateOrderKey(key: string, digits?: string): void;
+/**
+ * @param {string | null | undefined} a
+ * @param {string | null | undefined} b
+ * @param {string=} digits
+ * @return {string}
+ */
+export declare function generateKeyBetween(a: string | null | undefined, b: string | null | undefined, digits?: string): string;
+/**
+ * same preconditions as generateKeysBetween.
+ * n >= 0.
+ * Returns an array of n distinct keys in sorted order.
+ * If a and b are both null, returns [a0, a1, ...]
+ * If one or the other is null, returns consecutive "integer"
+ * keys.  Otherwise, returns relatively short keys between
+ * a and b.
+ * @param {string | null | undefined} a
+ * @param {string | null | undefined} b
+ * @param {number} n
+ * @param {string} digits
+ * @return {string[]}
+ */
+export declare function generateNKeysBetween(a: string | null | undefined, b: string | null | undefined, n: number, digits?: string): string[];

package/dist/types/laser-pointer/src/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./state";
+export type { Point } from "./math";

package/dist/types/laser-pointer/src/math.d.ts

@@ -0,0 +1,16 @@
+export type Point = [x: number, y: number, r: number];
+export declare function add([ax, ay, ar]: Point, [bx, by, br]: Point): Point;
+export declare function sub([ax, ay, ar]: Point, [bx, by, br]: Point): Point;
+export declare function smul([x, y, r]: Point, s: number): Point;
+export declare function norm([x, y, r]: Point): Point;
+export declare function rot([x, y, r]: Point, rad: number): Point;
+export declare function plerp(a: Point, b: Point, t: number): Point;
+export declare function lerp(a: number, b: number, t: number): number;
+export declare function angle(p: Point, p1: Point, p2: Point): number;
+export declare function normAngle(a: number): number;
+export declare function mag([x, y]: Point): number;
+export declare function dist([ax, ay]: Point, [bx, by]: Point): number;
+export declare function getCircleAndPerpendicularLineIntersectionsAtPoint(point: Point, direction: Point, radius: number): [Point, Point];
+export declare function runLength(ps: Point[]): number;
+export declare const clamp: (v: number, min: number, max: number) => number;
+export declare function distancePointToSegment(p3: Point, p1: Point, p2: Point): number;

package/dist/types/laser-pointer/src/simplify.d.ts

@@ -0,0 +1,2 @@
+import { type Point } from "./math";
+export declare function douglasPeucker(points: Point[], epsilon: number): Point[];

package/dist/types/laser-pointer/src/state.d.ts

@@ -0,0 +1,36 @@
+import type { Point } from "./math";
+export type SizeMappingDetails = {
+    pressure: number;
+    runningLength: number;
+    currentIndex: number;
+    totalLength: number;
+};
+export type LaserPointerOptions = {
+    /** @default 2 */
+    size: number;
+    streamline: number;
+    simplify: number;
+    simplifyPhase: "tail" | "output" | "input";
+    keepHead: boolean;
+    sizeMapping: (details: SizeMappingDetails) => number;
+};
+export declare class LaserPointer {
+    static defaults: LaserPointerOptions;
+    static constants: {
+        cornerDetectionMaxAngle: number;
+        cornerDetectionVariance: (s: number) => 1 | 0.5;
+        maxTailLength: number;
+    };
+    options: LaserPointerOptions;
+    constructor(options: Partial<LaserPointerOptions>);
+    originalPoints: Point[];
+    private stablePoints;
+    private tailPoints;
+    private isFresh;
+    private get lastPoint();
+    addPoint(point: Point): void;
+    close(): void;
+    stabilizeTail(): void;
+    private getSize;
+    getStrokeOutline(sizeOverride?: number | undefined): Point[];
+}

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

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

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

@@ -12,21 +12,29 @@ export declare const bezierEquation: <Point extends GlobalPoint | LocalPoint>(c:
 /**
  * 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[];
+export declare function curveIntersectLineSegment<Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, l: LineSegment<Point>, opts?: {
+    tolerance?: number;
+    iterLimit?: number;
+}): Point[];
+/**
+ * Finds the parameter on the Bezier curve whose point is closest to another
+ * point
+ *
+ * @param c The curve to test
+ * @param p The point to measure from
+ * @param tolerance The width of the search window under which the bisection
+ *   stops refining the parameter
+ */
+export declare function curveClosestParameter<Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, p: Point, tolerance?: number): number;
 /**
  * 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
+ * @param c The curve to test
+ * @param p The point to measure from
+ * @param tolerance The width of the search window under which the bisection
+ *   stops refining the parameter
  */
-export declare function curveClosestPoint<Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, p: Point, tolerance?: number): Point | null;
+export declare function curveClosestPoint<Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, p: Point, tolerance?: number): Point;
 /**
  * Determines the distance between a point and the closest point on the
  * Bezier curve.
@@ -34,7 +42,7 @@ export declare function curveClosestPoint<Point extends GlobalPoint | LocalPoint
  * @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;
+export declare function curvePointDistance<Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, p: Point, tolerance?: number): number;
 /**
  * Determines if the parameter is a Curve
  */
@@ -71,4 +79,6 @@ export declare function curveLengthAtParameter<P extends GlobalPoint | LocalPoin
  * @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;
+export declare function curvePointAtLength<P extends GlobalPoint | LocalPoint>(c: Curve<P>, percent: number, 
+/** pass the curve's total length when already known to skip recomputing it */
+totalLength?: number): P;

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

@@ -2,6 +2,7 @@ export * from "./angle";
 export * from "./curve";
 export * from "./ellipse";
 export * from "./line";
+export * from "./pca";
 export * from "./point";
 export * from "./polygon";
 export * from "./range";

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

@@ -0,0 +1,79 @@
+import type { GlobalPoint, LocalPoint, Vector } from "./types";
+/**
+ * The principal axes of a point set, i.e. the eigen decomposition of its
+ * 2x2 covariance matrix.
+ *
+ * The axes are orthonormal and ordered by variance, so `major` is the
+ * direction along which the points spread the most. Together with `centroid`
+ * they define a canonical frame: expressing the points in it removes
+ * translation and rotation, and dividing by `sqrt(majorVariance)` removes
+ * scale.
+ */
+export type PrincipalAxes<Point extends GlobalPoint | LocalPoint> = {
+    centroid: Point;
+    /** Unit vector along the direction of largest variance. */
+    major: Vector;
+    /** Unit vector along the direction of smallest variance, normal to major. */
+    minor: Vector;
+    /** Variance along `major` (the larger eigenvalue, λ₁). */
+    majorVariance: number;
+    /** Variance along `minor` (the smaller eigenvalue, λ₂). */
+    minorVariance: number;
+};
+/**
+ * A point expressed in a principal axes frame: `u` along the major axis,
+ * `v` along the minor axis, both relative to the centroid.
+ */
+export type PrincipalCoords = [u: number, v: number];
+/**
+ * Compute the centroid of a point set.
+ */
+export declare function centroid<Point extends GlobalPoint | LocalPoint>(points: readonly Point[]): Point;
+/**
+ * Principal component analysis of a 2D point set.
+ *
+ * Computes the centroid and the eigen decomposition of the covariance matrix
+ * [[μ20, μ11], [μ11, μ02]].
+ *
+ * @param points At least two points; fewer leaves the axes degenerate.
+ * @returns The centroid, the orthonormal axes and their variances.
+ */
+export declare function principalAxes<Point extends GlobalPoint | LocalPoint>(points: readonly Point[]): PrincipalAxes<Point>;
+/**
+ * Express points in the frame of the given principal axes, making the point
+ * cloud rotation, scale and translation invariant.
+ */
+export declare function principalCoords<Point extends GlobalPoint | LocalPoint>(points: readonly Point[], axes: PrincipalAxes<Point>, scale?: number): PrincipalCoords[];
+/**
+ * Flip the major axis so that it points toward the denser end of the point
+ * cloud, resolving the 180° sign ambiguity of the eigenvector.
+ *
+ * @returns The axes with `major`/`minor` flipped if needed. Variances are
+ * unchanged, as they are invariant to axis sign.
+ */
+export declare function orientPrincipalAxes<Point extends GlobalPoint | LocalPoint>(points: readonly Point[], axes: PrincipalAxes<Point>): PrincipalAxes<Point>;
+/**
+ * Ratio of the minor to the major variance in [0, 1]
+ *
+ * @returns 0 is a perfectly straight stroke, 1 is a stroke with no preferred
+ * direction.
+ */
+export declare function elongation<Point extends GlobalPoint | LocalPoint>(axes: PrincipalAxes<Point>): number;
+/**
+ * The `order`-th standardized moment of a sample in a rotation and scale
+ * invariant way (sandardizing by sigma).
+ *
+ * @returns 0 for a degenerate (zero variance) sample.
+ */
+export declare function standardizedMoment(values: readonly number[], order: number): number;
+/**
+ * Third standardized moment: how lopsided a sample is.
+ *
+ */
+export declare function skewness(values: readonly number[]): number;
+/**
+ * Fourth standardized moment: how the mass is split between the tails and the
+ * middle of a sample. Not excess kurtosis, a normal sample gives 3.
+ *
+ */
+export declare function kurtosis(values: readonly number[]): number;

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

@@ -1,4 +1,4 @@
-import type { LocalPoint, GlobalPoint, Radians, Degrees, Vector } from "./types";
+import type { LocalPoint, GlobalPoint, Radians, Degrees, Vector, GlobalCoord, LocalCoord } from "./types";
 /**
  * Create a properly typed Point instance from the X and Y coordinates.
  *
@@ -7,6 +7,11 @@ import type { LocalPoint, GlobalPoint, Radians, Degrees, Vector } from "./types"
  * @returns The branded and created point
  */
 export declare function pointFrom<Point extends GlobalPoint | LocalPoint>(x: number, y: number): Point;
+export declare function pointFrom<Coord extends GlobalCoord | LocalCoord>(coords: Coord): Coord extends GlobalCoord ? GlobalPoint : LocalPoint;
+export declare function pointFrom<Point extends GlobalPoint | LocalPoint>(coords: {
+    x: number;
+    y: number;
+}): Point;
 /**
  * Converts and remaps an array containing a pair of numbers to Point.
  *
@@ -52,7 +57,7 @@ export declare function pointsEqual<Point extends GlobalPoint | LocalPoint>(a: P
  * @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;
+export declare function pointRotateRads<Point extends GlobalPoint | LocalPoint>(point: Point, center: Point, angle: Radians): Point;
 /**
  * Rotate a point by [angle] degree.
  *
@@ -120,3 +125,4 @@ export declare const pointScaleFromOrigin: <P extends GlobalPoint | LocalPoint>(
  * @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;
+export declare const isValidPoint: (point: unknown) => point is LocalPoint;

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

@@ -1,6 +1,30 @@
 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 polygonIncludesPoint: <Point extends LocalPoint | GlobalPoint>(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;
+export declare function polygonIsClosed<Point extends LocalPoint | GlobalPoint>(polygon: readonly Point[], tolerance?: number): boolean;
+/**
+ * The signed area of a polygon via the shoelace formula. Positive when the
+ * vertices wind counter-clockwise in a y-down coordinate system.
+ *
+ * The polygon may be given open or closed; a closing vertex
+ */
+export declare function polygonSignedArea<Point extends LocalPoint | GlobalPoint>(polygon: readonly Point[], tolerance?: number): number;
+export declare function polygonArea<Point extends LocalPoint | GlobalPoint>(polygon: readonly Point[], tolerance?: number): number;
+/**
+ * The convex hull of a point set via Andrew's monotone chain.
+ *
+ * @returns The hull vertices in counter-clockwise order (y-down), without a
+ * repeated closing vertex.
+ */
+export declare function convexHull<Point extends LocalPoint | GlobalPoint>(points: readonly Point[]): Point[];
+/**
+ * Drop the points of a convex polygon that only contribute a shallow turn,
+ * merging each run of near-collinear points into one.
+ *
+ * @param polygon A convex polygon, as returned by `convexHull`.
+ * @param angleThreshold Minimum accumulated turn (radians) for a vertex to be
+ * kept.
+ */
+export declare function simplifyConvexPolygon<Point extends LocalPoint | GlobalPoint>(polygon: readonly Point[], angleThreshold: number): Point[];

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

@@ -13,9 +13,7 @@ export declare function rangeInclusive(start: number, end: number): InclusiveRan
  * @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";
-};
+export declare function rangeInclusiveFromPair(pair: [start: number, end: number]): InclusiveRange;
 /**
  * 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].

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

@@ -21,14 +21,19 @@ export declare const isLineSegment: <Point extends GlobalPoint | LocalPoint>(seg
  * @param origin
  * @returns
  */
-export declare const lineSegmentRotate: <Point extends GlobalPoint | LocalPoint>(l: LineSegment<Point>, angle: Radians, origin?: Point | undefined) => LineSegment<Point>;
+export declare const lineSegmentRotate: <Point extends LocalPoint | GlobalPoint>(l: LineSegment<Point>, angle: Radians, origin?: Point) => 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;
+export declare const pointOnLineSegment: <Point extends LocalPoint | GlobalPoint>(point: Point, line: LineSegment<Point>, threshold?: number) => boolean;
+export declare const distanceToLineSegment: <Point extends LocalPoint | GlobalPoint>(point: Point, line: LineSegment<Point>) => number;
+/**
+ * Returns the point at parameter `t` along the segment, where `t = 0` is the
+ * segment's start and `t = 1` its end. Not clamped.
+ */
+export declare function lineSegmentPointAt<Point extends GlobalPoint | LocalPoint>(line: LineSegment<Point>, t: number): Point;
 /**
  * Returns the intersection point of a segment and a line
  *
@@ -37,3 +42,5 @@ export declare const distanceToLineSegment: <Point extends GlobalPoint | LocalPo
  * @returns
  */
 export declare function lineSegmentIntersectionPoints<Point extends GlobalPoint | LocalPoint>(l: LineSegment<Point>, s: LineSegment<Point>, threshold?: number): Point | null;
+export declare function lineSegmentsDistance<Point extends GlobalPoint | LocalPoint>(s1: LineSegment<Point>, s2: LineSegment<Point>): number;
+export declare function lineSegmentClosestParameter<Point extends GlobalPoint | LocalPoint>(point: Point, line: LineSegment<Point>): number;