@synnaxlabs/x 0.7.0

package/dist/spatial/bounds.d.ts

@@ -0,0 +1,31 @@
+import { type Bounds, bounds, type CrudeBounds } from '../spatial/base';
+export { type Bounds, bounds };
+export type Crude = CrudeBounds;
+export declare const construct: (lower: number | Crude, upper?: number) => Bounds;
+export declare const ZERO: {
+    lower: number;
+    upper: number;
+};
+export declare const INFINITE: {
+    lower: number;
+    upper: number;
+};
+export declare const DECIMAL: {
+    lower: number;
+    upper: number;
+};
+export declare const CLIP: {
+    lower: number;
+    upper: number;
+};
+export declare const equals: (a?: Bounds, b?: Bounds) => boolean;
+export declare const makeValid: (a: Bounds) => Bounds;
+export declare const clamp: (bounds: Bounds, target: number) => number;
+export declare const contains: (bounds: Bounds, target: number) => boolean;
+export declare const overlapsWith: (a: Bounds, b: Bounds) => boolean;
+export declare const span: (a: Bounds) => number;
+export declare const isZero: (a: Bounds) => boolean;
+export declare const spanIsZero: (a: Bounds) => boolean;
+export declare const isFinite: (a: Bounds) => boolean;
+export declare const max: (bounds: Crude[]) => Bounds;
+export declare const min: (bounds: Crude[]) => Bounds;

package/dist/spatial/bounds.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/spatial/box.d.ts

@@ -0,0 +1,265 @@
+import { z } from "zod";
+import type * as bounds from '../spatial/bounds';
+import type * as dimensions from '../spatial/dimensions';
+import * as direction from '../spatial/direction';
+import * as location from '../spatial/location';
+import * as xy from '../spatial/xy';
+declare const cssBox: z.ZodObject<{
+    top: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
+    left: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
+    width: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
+    height: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
+}, "strip", z.ZodTypeAny, {
+    width: string | number;
+    height: string | number;
+    top: string | number;
+    left: string | number;
+}, {
+    width: string | number;
+    height: string | number;
+    top: string | number;
+    left: string | number;
+}>;
+declare const domRect: z.ZodObject<{
+    left: z.ZodNumber;
+    top: z.ZodNumber;
+    right: z.ZodNumber;
+    bottom: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}, {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}>;
+export declare const box: z.ZodObject<{
+    one: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        x: number;
+        y: number;
+    }, {
+        x: number;
+        y: number;
+    }>;
+    two: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        x: number;
+        y: number;
+    }, {
+        x: number;
+        y: number;
+    }>;
+    root: z.ZodObject<{
+        x: z.ZodEnum<["left", "right"]>;
+        y: z.ZodEnum<["top", "bottom"]>;
+    }, "strip", z.ZodTypeAny, {
+        x: "right" | "left";
+        y: "top" | "bottom";
+    }, {
+        x: "right" | "left";
+        y: "top" | "bottom";
+    }>;
+}, "strip", z.ZodTypeAny, {
+    one: {
+        x: number;
+        y: number;
+    };
+    two: {
+        x: number;
+        y: number;
+    };
+    root: {
+        x: "right" | "left";
+        y: "top" | "bottom";
+    };
+}, {
+    one: {
+        x: number;
+        y: number;
+    };
+    two: {
+        x: number;
+        y: number;
+    };
+    root: {
+        x: "right" | "left";
+        y: "top" | "bottom";
+    };
+}>;
+export type Box = z.infer<typeof box>;
+export type CSS = z.infer<typeof cssBox>;
+export type DOMRect = z.infer<typeof domRect>;
+type Crude = DOMRect | Box | {
+    getBoundingClientRect: () => DOMRect;
+};
+/** A box centered at (0,0) with a width and height of 0. */
+export declare const ZERO: {
+    one: {
+        x: number; /**
+         * Box represents a general box in 2D space. It typically represents a bounding box
+         * for a DOM element, but can also represent a box in clip space or decimal space.
+         *
+         * It'simportant to note that the behavior of a Box varies depending on its coordinate
+         * system.Make sure you're aware of which coordinate system you're using.
+         *
+         * Many of the properties and methods on a Box access the same semantic value. The
+         * different accessors are there for ease of use and semantics.
+         */
+        y: number;
+    };
+    two: {
+        x: number; /**
+         * Box represents a general box in 2D space. It typically represents a bounding box
+         * for a DOM element, but can also represent a box in clip space or decimal space.
+         *
+         * It'simportant to note that the behavior of a Box varies depending on its coordinate
+         * system.Make sure you're aware of which coordinate system you're using.
+         *
+         * Many of the properties and methods on a Box access the same semantic value. The
+         * different accessors are there for ease of use and semantics.
+         */
+        y: number;
+    };
+    root: {
+        x: "right" | "left";
+        y: "top" | "bottom";
+    };
+};
+/**
+ * A box centered at (0,0) with a width and height of 1, and rooted in the
+ * bottom left. Note that pixel space is typically rooted in the top left.
+ */
+export declare const DECIMAL: {
+    one: {
+        x: number; /**
+         * Box represents a general box in 2D space. It typically represents a bounding box
+         * for a DOM element, but can also represent a box in clip space or decimal space.
+         *
+         * It'simportant to note that the behavior of a Box varies depending on its coordinate
+         * system.Make sure you're aware of which coordinate system you're using.
+         *
+         * Many of the properties and methods on a Box access the same semantic value. The
+         * different accessors are there for ease of use and semantics.
+         */
+        y: number;
+    };
+    two: {
+        x: number;
+        y: number;
+    };
+    root: {
+        x: "right" | "left";
+        y: "top" | "bottom";
+    };
+};
+export declare const copy: (b: Box, root?: location.CornerXY) => Box;
+/**
+ * Box represents a general box in 2D space. It typically represents a bounding box
+ * for a DOM element, but can also represent a box in clip space or decimal space.
+ *
+ * It'simportant to note that the behavior of a Box varies depending on its coordinate
+ * system.Make sure you're aware of which coordinate system you're using.
+ *
+ * Many of the properties and methods on a Box access the same semantic value. The
+ * different accessors are there for ease of use and semantics.
+ */
+export declare const construct: (first: number | DOMRect | xy.XY | Box | {
+    getBoundingClientRect: () => DOMRect;
+}, second?: number | xy.XY | dimensions.Dimensions | dimensions.Signed, width?: number, height?: number, coordinateRoot?: location.CornerXY) => Box;
+/**
+ * Checks if a box contains a point or another box.
+ *
+ * @param value - The point or box to check.
+ * @returns true if the box inclusively contains the point or box and false otherwise.
+ */
+export declare const contains: (b: Crude, value: Box | xy.XY) => boolean;
+/**
+ * @returns true if the given box is semantically equal to this box and false otherwise.
+ */
+export declare const equals: (a: Box, b: Box) => boolean;
+/**
+ * @returns the dimensions of the box. Note that these dimensions are guaranteed to
+ * be positive. To get the signed dimensions, use the `signedDims` property.
+ */
+export declare const dims: (b: Box) => dimensions.Dimensions;
+/**
+ * @returns the dimensions of the box. Note that these dimensions may be negative.
+ * To get the unsigned dimensions, use the `dims` property.
+ */
+export declare const signedDims: (b: Box) => dimensions.Signed;
+/**
+ * @returns the css representation of the box.
+ */
+export declare const css: (b: Box) => CSS;
+export declare const dim: (b: Crude, dir: direction.Crude, signed?: boolean) => number;
+/** @returns the pont corresponding to the given corner of the box. */
+export declare const xyLoc: (b: Crude, l: location.XY) => xy.XY;
+/**
+ * @returns a one dimensional coordinate corresponding to the location of the given
+ * side of the box i.e. the x coordinate of the left side, the y coordinate of the
+ * top side, etc.
+ */
+export declare const loc: (b: Crude, loc: location.Location) => number;
+export declare const locPoint: (b: Box, loc_: location.Location) => xy.XY;
+export declare const isZero: (b: Box) => boolean;
+export declare const width: (b: Crude) => number;
+export declare const height: (b: Crude) => number;
+export declare const signedWidth: (b: Crude) => number;
+export declare const signedHeight: (b: Crude) => number;
+export declare const topLeft: (b: Crude) => xy.XY;
+export declare const topRight: (b: Crude) => xy.XY;
+export declare const bottomLeft: (b: Crude) => xy.XY;
+export declare const bottomRight: (b: Crude) => xy.XY;
+export declare const right: (b: Crude) => number;
+export declare const bottom: (b: Crude) => number;
+export declare const left: (b: Crude) => number;
+export declare const top: (b: Crude) => number;
+export declare const center: (b: Crude) => xy.XY;
+export declare const x: (b: Crude) => number;
+export declare const y: (b: Crude) => number;
+export declare const root: (b: Crude) => xy.XY;
+export declare const xBounds: (b: Crude) => bounds.Bounds;
+export declare const yBounds: (b: Crude) => bounds.Bounds;
+export declare const reRoot: (b: Box, corner: location.CornerXY) => Box;
+/**
+ * Reposition a box so that it is visible within a given bound.
+ *
+ * @param target The box to reposition - Only works if the root is topLeft
+ * @param bound The box to reposition within - Only works if the root is topLeft
+ *
+ * @returns the repsoitioned box and a boolean indicating if the box was repositioned
+ * or not.
+ */
+export declare const positionSoVisible: (target_: Crude, bound_: Crude) => [Box, boolean];
+/**
+ * Reposition a box so that it is centered within a given bound.
+ *
+ * @param target The box to reposition - Only works if the root is topLeft
+ * @param bound The box to reposition within - Only works if the root is topLeft
+ * @returns the repsoitioned box
+ */
+export declare const positionInCenter: (target_: Crude, bound_: Crude) => Box;
+export declare const isBox: (value: unknown) => value is {
+    one: {
+        x: number;
+        y: number;
+    };
+    two: {
+        x: number;
+        y: number;
+    };
+    root: {
+        x: "right" | "left";
+        y: "top" | "bottom";
+    };
+};
+export declare const aspect: (b: Box) => number;
+export {};

package/dist/spatial/box.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/spatial/dimensions.d.ts

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import { dimensions, type Dimensions } from '../spatial/base';
+export { dimensions, type Dimensions };
+export declare const signed: z.ZodObject<{
+    signedWidth: z.ZodNumber;
+    signedHeight: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    signedWidth: number;
+    signedHeight: number;
+}, {
+    signedWidth: number;
+    signedHeight: number;
+}>;
+export declare const crude: z.ZodUnion<[z.ZodObject<{
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    width: number;
+    height: number;
+}, {
+    width: number;
+    height: number;
+}>, z.ZodObject<{
+    signedWidth: z.ZodNumber;
+    signedHeight: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    signedWidth: number;
+    signedHeight: number;
+}, {
+    signedWidth: number;
+    signedHeight: number;
+}>, z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    x: number;
+    y: number;
+}, {
+    x: number;
+    y: number;
+}>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
+export type Crude = z.infer<typeof crude>;
+export declare const ZERO: {
+    width: number;
+    height: number;
+};
+export declare const DECIMAL: {
+    width: number;
+    height: number;
+};
+export declare const construct: (width: number | Crude, height?: number) => Dimensions;
+export type Signed = z.infer<typeof signed>;
+export declare const equals: (ca: Crude, cb?: Crude | null) => boolean;
+export declare const swap: (ca: Crude) => Dimensions;
+export declare const svgViewBox: (ca: Crude) => string;
+export declare const couple: (ca: Crude) => [number, number];
+export declare const max: (crude: Crude[]) => Dimensions;
+export declare const min: (crude: Crude[]) => Dimensions;
+export declare const scale: (ca: Crude, factor: number) => Dimensions;

package/dist/spatial/dimensions.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/spatial/direction.d.ts

@@ -0,0 +1,10 @@
+import { type Dimension, type Direction, type Location, type direction, type SignedDimension, type CrudeDirection } from '../spatial/base';
+export type { Direction, direction };
+export declare const crude: import("zod").ZodUnion<[import("zod").ZodEnum<["x", "y"]>, import("zod").ZodEnum<["top", "right", "bottom", "left", "center"]>]>;
+export type Crude = CrudeDirection;
+export declare const construct: (c: Crude) => Direction;
+export declare const swap: (direction: CrudeDirection) => Direction;
+export declare const dimension: (direction: CrudeDirection) => Dimension;
+export declare const location: (direction: CrudeDirection) => Location;
+export declare const isDirection: (c: unknown) => c is "x" | "y";
+export declare const signedDimension: (direction: CrudeDirection) => SignedDimension;

package/dist/spatial/direction.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/spatial/external.d.ts

@@ -0,0 +1,8 @@
+export * as bounds from '../spatial/bounds';
+export * as box from '../spatial/box';
+export * as dimensions from '../spatial/dimensions';
+export * as direction from '../spatial/direction';
+export * as location from '../spatial/location';
+export * as xy from '../spatial/xy';
+export * as scale from '../spatial/scale';
+export * as spatial from '../spatial/spatial';

package/dist/spatial/index.d.ts

@@ -0,0 +1 @@
+export * from '../spatial/external';

package/dist/spatial/location.d.ts

@@ -0,0 +1,52 @@
+import { z } from "zod";
+import { location, type Location, X_LOCATIONS, Y_LOCATIONS, CENTER_LOCATIONS, type XLocation, type OuterLocation, type YLocation, outerLocation, type Direction, type CrudeLocation } from '../spatial/base';
+export { location, type Location, X_LOCATIONS, Y_LOCATIONS, CENTER_LOCATIONS, outerLocation as outer, };
+export declare const x: z.ZodEnum<["left", "right"]>;
+export declare const y: z.ZodEnum<["top", "bottom"]>;
+export type X = XLocation;
+export type Y = YLocation;
+export type Outer = OuterLocation;
+export declare const crude: z.ZodUnion<[z.ZodEnum<["x", "y"]>, z.ZodEnum<["top", "right", "bottom", "left", "center"]>, z.ZodType<String, z.ZodTypeDef, String>]>;
+export type Crude = CrudeLocation;
+export declare const construct: (cl: Crude) => Location;
+export declare const swap: (cl: Crude) => Location;
+export declare const rotate90: (cl: Crude) => Location;
+export declare const direction: (cl: Crude) => Direction;
+export declare const xy: z.ZodObject<{
+    x: z.ZodEnum<["top", "right", "bottom", "left", "center"]>;
+    y: z.ZodEnum<["top", "right", "bottom", "left", "center"]>;
+}, "strip", z.ZodTypeAny, {
+    x: "center" | "top" | "right" | "bottom" | "left";
+    y: "center" | "top" | "right" | "bottom" | "left";
+}, {
+    x: "center" | "top" | "right" | "bottom" | "left";
+    y: "center" | "top" | "right" | "bottom" | "left";
+}>;
+export declare const corner: z.ZodObject<{
+    x: z.ZodEnum<["left", "right"]>;
+    y: z.ZodEnum<["top", "bottom"]>;
+}, "strip", z.ZodTypeAny, {
+    x: "right" | "left";
+    y: "top" | "bottom";
+}, {
+    x: "right" | "left";
+    y: "top" | "bottom";
+}>;
+export type XY = z.infer<typeof xy>;
+export type CornerXY = z.infer<typeof corner>;
+export type CornerXYString = "topLeft" | "topRight" | "bottomLeft" | "bottomRight";
+export declare const TOP_LEFT: CornerXY;
+export declare const TOP_RIGHT: CornerXY;
+export declare const BOTTOM_LEFT: CornerXY;
+export declare const BOTTOM_RIGHT: CornerXY;
+export declare const CENTER: XY;
+export declare const TOP_CENTER: XY;
+export declare const BOTTOM_CENTER: XY;
+export declare const RIGHT_CENTER: XY;
+export declare const LEFT_CENTER: XY;
+export declare const xyEquals: (a: XY, b: XY) => boolean;
+export declare const xyCouple: (a: XY) => [Location, Location];
+export declare const isX: (a: Crude) => boolean;
+export declare const isY: (a: Crude) => boolean;
+export declare const xyToString: (a: XY) => string;
+export declare const constructXY: (x: Crude | XY, y?: Crude) => XY;

package/dist/spatial/location.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/spatial/position.d.ts

@@ -0,0 +1,2 @@
+import * as xy from '../spatial/xy';
+export declare const posititonSoVisible: (target: HTMLElement, p: xy.XY) => [xy.XY, boolean];

package/dist/spatial/scale.d.ts

@@ -0,0 +1,241 @@
+import { z } from "zod";
+import * as bounds from '../spatial/bounds';
+import { type Box } from '../spatial/box';
+import type * as dims from '../spatial/dimensions';
+import * as location from '../spatial/location';
+import * as xy from '../spatial/xy';
+export declare const crudeXYTransform: z.ZodObject<{
+    offset: z.ZodUnion<[z.ZodNumber, z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        x: number;
+        y: number;
+    }, {
+        x: number;
+        y: number;
+    }>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        width: number;
+        height: number;
+    }, {
+        width: number;
+        height: number;
+    }>, z.ZodObject<{
+        signedWidth: z.ZodNumber;
+        signedHeight: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        signedWidth: number;
+        signedHeight: number;
+    }, {
+        signedWidth: number;
+        signedHeight: number;
+    }>, z.ZodObject<{
+        clientX: z.ZodNumber;
+        clientY: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        clientX: number;
+        clientY: number;
+    }, {
+        clientX: number;
+        clientY: number;
+    }>]>;
+    scale: z.ZodUnion<[z.ZodNumber, z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        x: number;
+        y: number;
+    }, {
+        x: number;
+        y: number;
+    }>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        width: number;
+        height: number;
+    }, {
+        width: number;
+        height: number;
+    }>, z.ZodObject<{
+        signedWidth: z.ZodNumber;
+        signedHeight: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        signedWidth: number;
+        signedHeight: number;
+    }, {
+        signedWidth: number;
+        signedHeight: number;
+    }>, z.ZodObject<{
+        clientX: z.ZodNumber;
+        clientY: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        clientX: number;
+        clientY: number;
+    }, {
+        clientX: number;
+        clientY: number;
+    }>]>;
+}, "strip", z.ZodTypeAny, {
+    offset: (number | [number, number] | {
+        width: number;
+        height: number;
+    } | {
+        signedWidth: number;
+        signedHeight: number;
+    } | {
+        x: number;
+        y: number;
+    } | {
+        clientX: number;
+        clientY: number;
+    }) & (number | [number, number] | {
+        width: number;
+        height: number;
+    } | {
+        signedWidth: number;
+        signedHeight: number;
+    } | {
+        x: number;
+        y: number;
+    } | {
+        clientX: number;
+        clientY: number;
+    } | undefined);
+    scale: (number | [number, number] | {
+        width: number;
+        height: number;
+    } | {
+        signedWidth: number;
+        signedHeight: number;
+    } | {
+        x: number;
+        y: number;
+    } | {
+        clientX: number;
+        clientY: number;
+    }) & (number | [number, number] | {
+        width: number;
+        height: number;
+    } | {
+        signedWidth: number;
+        signedHeight: number;
+    } | {
+        x: number;
+        y: number;
+    } | {
+        clientX: number;
+        clientY: number;
+    } | undefined);
+}, {
+    offset: (number | [number, number] | {
+        width: number;
+        height: number;
+    } | {
+        signedWidth: number;
+        signedHeight: number;
+    } | {
+        x: number;
+        y: number;
+    } | {
+        clientX: number;
+        clientY: number;
+    }) & (number | [number, number] | {
+        width: number;
+        height: number;
+    } | {
+        signedWidth: number;
+        signedHeight: number;
+    } | {
+        x: number;
+        y: number;
+    } | {
+        clientX: number;
+        clientY: number;
+    } | undefined);
+    scale: (number | [number, number] | {
+        width: number;
+        height: number;
+    } | {
+        signedWidth: number;
+        signedHeight: number;
+    } | {
+        x: number;
+        y: number;
+    } | {
+        clientX: number;
+        clientY: number;
+    }) & (number | [number, number] | {
+        width: number;
+        height: number;
+    } | {
+        signedWidth: number;
+        signedHeight: number;
+    } | {
+        x: number;
+        y: number;
+    } | {
+        clientX: number;
+        clientY: number;
+    } | undefined);
+}>;
+export type XYTransformT = z.infer<typeof crudeXYTransform>;
+export type BoundVariant = "domain" | "range";
+type ValueType = "position" | "dimension";
+type Operation = (currScale: bounds.Bounds | null, type: ValueType, number: number, reverse: boolean) => OperationReturn;
+type OperationReturn = [bounds.Bounds | null, number];
+interface TypedOperation extends Operation {
+    type: "translate" | "magnify" | "scale" | "invert" | "clamp" | "re-bound";
+}
+export declare class Scale {
+    ops: TypedOperation[];
+    currBounds: bounds.Bounds | null;
+    currType: ValueType | null;
+    private reversed;
+    constructor();
+    static translate(value: number): Scale;
+    static magnify(value: number): Scale;
+    static scale(lowerOrBound: number | bounds.Bounds, upper?: number): Scale;
+    translate(value: number): Scale;
+    magnify(value: number): Scale;
+    scale(lowerOrBound: number | bounds.Bounds, upper?: number): Scale;
+    clamp(lowerOrBound: number | bounds.Bounds, upper?: number): Scale;
+    reBound(lowerOrBound: number | bounds.Bounds, upper?: number): Scale;
+    invert(): Scale;
+    pos(v: number): number;
+    dim(v: number): number;
+    private new;
+    private exec;
+    reverse(): Scale;
+    static readonly IDENTITY: Scale;
+}
+export declare const xyScaleToTransform: (scale: XY) => XYTransformT;
+export declare class XY {
+    x: Scale;
+    y: Scale;
+    currRoot: location.CornerXY | null;
+    constructor(x?: Scale, y?: Scale, root?: location.CornerXY | null);
+    static translate(xy: number | xy.XY, y?: number): XY;
+    static translateX(x: number): XY;
+    static translateY(y: number): XY;
+    static clamp(box: Box): XY;
+    static magnify(xy: xy.XY): XY;
+    static scale(box: dims.Dimensions | Box): XY;
+    static reBound(box: Box): XY;
+    translate(cp: number | xy.Crude, y?: number): XY;
+    translateX(x: number): XY;
+    translateY(y: number): XY;
+    magnify(xy: xy.XY): XY;
+    scale(b: Box | dims.Dimensions): XY;
+    reBound(b: Box): XY;
+    clamp(b: Box): XY;
+    copy(): XY;
+    reverse(): XY;
+    pos(xy: xy.XY): xy.XY;
+    box(b: Box): Box;
+    static readonly IDENTITY: XY;
+}
+export {};