@vpmedia/phaser 1.102.0 → 1.104.0

package/{types → dist}/phaser/geom/rounded_rectangle.d.ts

@@ -1,4 +1,10 @@
-export class RoundedRectangle {
+export declare class RoundedRectangle {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    radius: number;
+    type: number;
     /**
      * Creates a new RoundedRectangle instance.
      * @param {number} x - The x coordinate of the top-left corner of the rectangle (default: 0).
@@ -8,23 +14,17 @@ export class RoundedRectangle {
      * @param {number} radius - The corner radius (default: 20).
      */
     constructor(x?: number, y?: number, width?: number, height?: number, radius?: number);
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    radius: number;
-    type: number;
     /**
      * Checks if the specified point is contained within this rounded rectangle.
      * @param {number} x - The x coordinate of the point to check.
      * @param {number} y - The y coordinate of the point to check.
      * @returns {boolean} True if the point is contained within this rounded rectangle, false otherwise.
      */
-    contains(x: number, y: number): boolean;
+    contains(x: any, y: any): boolean;
     /**
      * Creates a clone of this rounded rectangle.
      * @returns {RoundedRectangle} A new rounded rectangle with the same values as this one.
      */
-    clone(): RoundedRectangle;
+    clone(): any;
 }
 //# sourceMappingURL=rounded_rectangle.d.ts.map

package/dist/phaser/geom/rounded_rectangle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rounded_rectangle.d.ts","sourceRoot":"","sources":["../../../src/phaser/geom/rounded_rectangle.ts"],"names":[],"mappings":"AAGA,qBAAa,gBAAgB;IAC3B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IAEb;;;;;;;OAOG;gBACS,CAAC,SAAI,EAAE,CAAC,SAAI,EAAE,KAAK,SAAI,EAAE,MAAM,SAAI,EAAE,MAAM,SAAK;IAS5D;;;;;OAKG;IACH,QAAQ,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA;IAYb;;;OAGG;IACH,KAAK;CAGN"}

package/dist/phaser/geom/util/circle.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Clones a circle.
+ * @param {Circle} input - The circle to clone.
+ * @param {Circle} output - Optional circle to store the result in.
+ * @returns {Circle} The cloned circle.
+ */
+export declare const clone: (input: any, output?: any) => any;
+/**
+ * Checks if a point is contained within the circle.
+ * @param {Circle} a - The circle to check.
+ * @param {number} x - The x coordinate of the point.
+ * @param {number} y - The y coordinate of the point.
+ * @returns {boolean} True if the point is contained within the circle, false otherwise.
+ */
+export declare const contains: (a: any, x: any, y: any) => boolean;
+/**
+ * Checks if two circles are equal.
+ * @param {Circle} a - The first circle to compare.
+ * @param {Circle} b - The second circle to compare.
+ * @returns {boolean} True if the circles are equal, false otherwise.
+ */
+export declare const equals: (a: any, b: any) => boolean;
+/**
+ * Checks if two circles intersect.
+ * @param {Circle} a - The first circle to check.
+ * @param {Circle} b - The second circle to check.
+ * @returns {boolean} True if the circles intersect, false otherwise.
+ */
+export declare const intersects: (a: any, b: any) => boolean;
+/**
+ * Gets a point on the circumference of the circle at the specified angle.
+ * @param {Circle} a - The circle to get the point from.
+ * @param {number} angle - The angle in radians or degrees (depending on asDegrees).
+ * @param {boolean} asDegrees - True if the angle is in degrees, false if in radians.
+ * @param {Point} output - Optional point to store the result in.
+ * @returns {Point} The point on the circumference of the circle.
+ */
+export declare const circumferencePoint: (a: any, angle: any, asDegrees?: boolean, output?: any) => any;
+/**
+ * Gets a point on the circumference of the circle at the specified angle.
+ * @param {Circle} a - The circle to get the point from.
+ * @param {number} angle - The angle in radians or degrees (depending on asDegrees).
+ * @param {boolean} asDegrees - True if the angle is in degrees, false if in radians.
+ * @param {Point} output - Optional point to store the result in.
+ * @returns {Point} The point on the circumference of the circle.
+ */
+export declare const intersectsPoint: (a: any, angle: any, asDegrees?: boolean, output?: any) => any;
+/**
+ * Checks if a circle intersects with a rectangle.
+ * @param {Circle} c - The circle to check.
+ * @param {object} r - The rectangle to check.
+ * @returns {boolean} True if the circle intersects with the rectangle, false otherwise.
+ */
+export declare const intersectsRectangle: (c: any, r: any) => boolean;
+//# sourceMappingURL=circle.d.ts.map

package/dist/phaser/geom/util/circle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circle.d.ts","sourceRoot":"","sources":["../../../../src/phaser/geom/util/circle.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAAI,UAAK,EAAE,YAAa,QAMzC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GAAI,MAAC,EAAE,MAAC,EAAE,MAAC,YAO/B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,MAAM,GAAI,MAAC,EAAE,MAAC,YAE1B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,MAAC,EAAE,MAAC,YAE9B,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,GAAI,MAAC,EAAE,UAAK,EAAE,mBAAiB,EAAE,YAAa,QAQ5E,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,GAAI,MAAC,EAAE,UAAK,EAAE,mBAAiB,EAAE,YAAa,QAQzE,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAI,MAAC,EAAE,MAAC,YAoBvC,CAAC"}

package/dist/phaser/geom/util/ellipse.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Checks if a point is contained within the ellipse.
+ * @param {import('../ellipse.js').Ellipse} a - The ellipse to check.
+ * @param {number} x - The x coordinate of the point.
+ * @param {number} y - The y coordinate of the point.
+ * @returns {boolean} True if the point is contained within the ellipse, false otherwise.
+ */
+export declare const contains: (a: any, x: any, y: any) => boolean;
+//# sourceMappingURL=ellipse.d.ts.map

package/dist/phaser/geom/util/ellipse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ellipse.d.ts","sourceRoot":"","sources":["../../../../src/phaser/geom/util/ellipse.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GAAI,MAAC,EAAE,MAAC,EAAE,MAAC,YAU/B,CAAC"}

package/dist/phaser/geom/util/line.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Clones a line.
+ * @param {Line} input - The line to clone.
+ * @param {Line} output - Optional line to store the result in.
+ * @returns {Line} The cloned line.
+ */
+export declare const clone: (input: any, output?: any) => any;
+/**
+ * Gets the intersection point of two lines.
+ * @param {object} a - The first line (with x1, y1, x2, y2 properties).
+ * @param {object} b - The second line (with x1, y1, x2, y2 properties).
+ * @param {object} e - The first endpoint of the first line (with x, y properties).
+ * @param {object} f - The second endpoint of the second line (with x, y properties).
+ * @param {boolean} asSegment - True if the lines are treated as segments, false if infinite lines.
+ * @param {Point} output - Optional point to store the result in.
+ * @returns {Point} The intersection point, or null if there is no intersection.
+ */
+export declare const intersectsPoints: (a: any, b: any, e: any, f: any, asSegment?: boolean, output?: any) => any;
+/**
+ * Gets the intersection point of two lines (alternative implementation).
+ * @param {object} a - The first line (with x1, y1, x2, y2 properties).
+ * @param {object} b - The second line (with x1, y1, x2, y2 properties).
+ * @param {boolean} asSegment - True if the lines are treated as segments, false if infinite lines.
+ * @param {Point} result - Optional point to store the result in.
+ * @returns {Point} The intersection point, or null if there is no intersection.
+ */
+export declare const intersects: (a: any, b: any, asSegment: any, result: any) => any;
+/**
+ * Checks if a line intersects with a rectangle.
+ * @param {object} line - The line to check (with x1, y1, x2, y2 properties).
+ * @param {object} rect - The rectangle to check (with x, y, width, height properties).
+ * @returns {boolean} True if the line intersects with the rectangle, false otherwise.
+ */
+export declare const intersectsRectangle: (line: any, rect: any) => boolean;
+/**
+ * Calculates the distance between two points (line length).
+ * @param {object} a - The first point (with x, y properties).
+ * @param {object} b - The second point (with x, y properties).
+ * @returns {number} The distance between the points.
+ */
+export declare const reflect: (a: any, b: any) => number;
+//# sourceMappingURL=line.d.ts.map

package/dist/phaser/geom/util/line.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../../../src/phaser/geom/util/line.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAAI,UAAK,EAAE,YAAa,QAOzC,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,GAAI,MAAC,EAAE,MAAC,EAAE,MAAC,EAAE,MAAC,EAAE,mBAAgB,EAAE,YAAa,QAwB3E,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,GAAI,MAAC,EAAE,MAAC,EAAE,cAAS,EAAE,WAAM,QAEjD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAI,SAAI,EAAE,SAAI,YA8C7C,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,OAAO,GAAI,MAAC,EAAE,MAAC,WAE3B,CAAC"}

package/dist/phaser/geom/util/matrix.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Clones a matrix.
+ * @param {Matrix} input - The matrix to clone.
+ * @param {Matrix} output - Optional matrix to store the result in.
+ * @returns {Matrix} The cloned matrix.
+ */
+export declare const clone: (input: any, output?: any) => any;
+/**
+ * Creates a new identity matrix.
+ * @returns {Matrix} A new identity matrix.
+ */
+export declare const getIdentityMatrix: () => any;
+/**
+ * Creates a new matrix with the specified values.
+ * @returns {Matrix} A new matrix.
+ */
+export declare const getTempMatrix: () => any;
+//# sourceMappingURL=matrix.d.ts.map

package/dist/phaser/geom/util/matrix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matrix.d.ts","sourceRoot":"","sources":["../../../../src/phaser/geom/util/matrix.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAAI,UAAK,EAAE,YAAa,QASzC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,iBAAiB,WAQ7B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,aAAa,WAQzB,CAAC"}

package/dist/phaser/geom/util/point.d.ts

@@ -0,0 +1,159 @@
+import { Point } from '../point.js';
+/**
+ * Adds two points together.
+ * @param {Point} a - The first point to add.
+ * @param {Point} b - The second point to add.
+ * @param {Point} output - The point to store the result in (optional).
+ * @returns {Point} A new point containing the sum of the two points.
+ */
+export declare const add: (a: any, b: any, output?: any) => any;
+/**
+ * Subtracts the second point from the first point.
+ * @param {Point} a - The first point to subtract from.
+ * @param {Point} b - The second point to subtract.
+ * @param {Point} output - The point to store the result in (optional).
+ * @returns {Point} A new point containing the difference of the two points.
+ */
+export declare const subtract: (a: any, b: any, output?: any) => any;
+/**
+ * Multiplies two points together.
+ * @param {Point} a - The first point to multiply.
+ * @param {Point} b - The second point to multiply.
+ * @param {Point} output - The point to store the result in (optional).
+ * @returns {Point} A new point containing the product of the two points.
+ */
+export declare const multiply: (a: any, b: any, output?: any) => any;
+/**
+ * Divides the first point by the second point.
+ * @param {Point} a - The first point to divide.
+ * @param {Point} b - The second point to divide by.
+ * @param {Point} output - The point to store the result in (optional).
+ * @returns {Point} A new point containing the quotient of the two points.
+ */
+export declare const divide: (a: any, b: any, output?: any) => any;
+/**
+ * Checks if two points are equal.
+ * @param {Point} a - The first point to compare.
+ * @param {Point} b - The second point to compare.
+ * @returns {boolean} True if the points are equal, false otherwise.
+ */
+export declare const equals: (a: any, b: any) => boolean;
+/**
+ * Calculates the angle between two points.
+ * @param {Point} a - The first point to calculate the angle from.
+ * @param {Point} b - The second point to calculate the angle to.
+ * @returns {number} The angle between the two points in radians.
+ */
+export declare const angle: (a: any, b: any) => number;
+/**
+ * Creates a new point with the same coordinates as the input point but with inverted signs.
+ * @param {Point} a - The point to negate.
+ * @param {Point} output - The point to store the result in (optional).
+ * @returns {Point} A new point with negated coordinates.
+ */
+export declare const negative: (a: any, output?: any) => any;
+/**
+ * Multiplies the second point by a scalar and adds it to the first point.
+ * @param {Point} a - The first point to add to.
+ * @param {Point} b - The second point to multiply by the scalar and add.
+ * @param {number} s - The scalar value to multiply the second point by.
+ * @param {Point} output - The point to store the result in (optional).
+ * @returns {Point} A new point with the result of the operation.
+ */
+export declare const multiplyAdd: (a: any, b: any, s: any, output?: any) => any;
+/**
+ * Interpolates between two points at a given factor.
+ * @param {Point} a - The first point to interpolate from.
+ * @param {Point} b - The second point to interpolate to.
+ * @param {number} f - The interpolation factor (0-1).
+ * @param {Point} output - The point to store the result in (optional).
+ * @returns {Point} A new point interpolated between the two points.
+ */
+export declare const interpolate: (a: any, b: any, f: any, output?: any) => any;
+/**
+ * Returns a perpendicular point (rotated 90 degrees counter-clockwise).
+ * @param {Point} a - The point to calculate the perpendicular for.
+ * @param {Point} output - The point to store the result in (optional).
+ * @returns {Point} A new point that is perpendicular to the input point.
+ */
+export declare const perp: (a: any, output?: any) => any;
+/**
+ * Returns a perpendicular point (rotated 90 degrees clockwise).
+ * @param {Point} a - The point to calculate the perpendicular for.
+ * @param {Point} output - The point to store the result in (optional).
+ * @returns {Point} A new point that is perpendicular to the input point (rotated clockwise).
+ */
+export declare const rperp: (a: any, output?: any) => any;
+/**
+ * Calculates the distance between two points.
+ * @param {Point} a - The first point to calculate the distance from.
+ * @param {Point} b - The second point to calculate the distance to.
+ * @param {boolean} round - Whether to round the result (default: false).
+ * @returns {number} The distance between the two points.
+ */
+export declare const distance: (a: any, b: any, round?: boolean) => number;
+/**
+ * Projects the first point onto the second point.
+ * @param {Point} a - The point to project.
+ * @param {Point} b - The point to project onto.
+ * @param {Point} output - The point to store the result in (optional).
+ * @returns {Point} A new point with the projected result.
+ */
+export declare const project: (a: any, b: any, output?: any) => any;
+/**
+ * Projects the first point onto the unit vector of the second point.
+ * @param {Point} a - The point to project.
+ * @param {Point} b - The point to project onto (unit vector).
+ * @param {Point} output - The point to store the result in (optional).
+ * @returns {Point} A new point with the projected result.
+ */
+export declare const projectUnit: (a: any, b: any, output?: any) => any;
+/**
+ * Returns a point with the same direction as the input point but with y coordinate negated.
+ * @param {Point} a - The point to calculate the normal for.
+ * @param {Point} output - The point to store the result in (optional).
+ * @returns {Point} A new point with the same x coordinate but negated y coordinate.
+ */
+export declare const normalRightHand: (a: any, output?: any) => any;
+/**
+ * Normalizes the input point to have a magnitude of 1 while preserving its direction.
+ * @param {Point} a - The point to normalize.
+ * @param {Point} output - The point to store the result in (optional).
+ * @returns {Point} A new normalized point.
+ */
+export declare const normalize: (a: any, output?: any) => any;
+/**
+ * Rotates a point around another point by a given angle.
+ * @param {Point} a - The point to rotate.
+ * @param {number} x - The x coordinate of the center point to rotate around.
+ * @param {number} y - The y coordinate of the center point to rotate around.
+ * @param {number} ang - The angle in radians to rotate by.
+ * @param {boolean} asDegrees - Whether the angle is provided in degrees (default: false).
+ * @param {number | null | undefined} dist - The distance to rotate from (default: null).
+ * @returns {Point} The rotated point instance for chaining.
+ */
+export declare const rotate: (a: any, x: any, y: any, ang: any, asDegrees: any, dist: any) => any;
+/**
+ * Calculates the centroid (average position) of a set of points.
+ * @param {Point[]} points - The array of points to calculate the centroid for.
+ * @param {Point} output - The point to store the result in (optional).
+ * @returns {Point} A new point representing the centroid of the input points.
+ * @throws {Error} If the points array is empty.
+ */
+export declare const centroid: (points: any, output?: any) => any;
+/**
+ * Parses an object with x and y properties into a Point.
+ * @param {object} obj - The object to parse (must have x and y properties).
+ * @param {string} xProp - The name of the property containing the x value (default: 'x').
+ * @param {string} yProp - The name of the property containing the y value (default: 'y').
+ * @returns {Point} A new point with parsed x and y values.
+ */
+export declare const parse: (obj: any, xProp?: string, yProp?: string) => Point;
+/**
+ * Creates a clone of the input point.
+ * @param {Point} input - The point to clone.
+ * @param {Point} output - The point to store the result in (optional).
+ * @returns {Point} A new point with the same coordinates as the input.
+ */
+export declare const clone: (input: any, output?: any) => any;
+//# sourceMappingURL=point.d.ts.map

package/dist/phaser/geom/util/point.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../../src/phaser/geom/util/point.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEpC;;;;;;GAMG;AACH,eAAO,MAAM,GAAG,GAAI,MAAC,EAAE,MAAC,EAAE,YAAa,QAKtC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GAAI,MAAC,EAAE,MAAC,EAAE,YAAa,QAK3C,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GAAI,MAAC,EAAE,MAAC,EAAE,YAAa,QAK3C,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,GAAI,MAAC,EAAE,MAAC,EAAE,YAAa,QAKzC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,MAAM,GAAI,MAAC,EAAE,MAAC,YAE1B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAAI,MAAC,EAAE,MAAC,WAEzB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,GAAI,MAAC,EAAE,YAAa,QAGxC,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,GAAI,MAAC,EAAE,MAAC,EAAE,MAAC,EAAE,YAAa,QAGjD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,GAAI,MAAC,EAAE,MAAC,EAAE,MAAC,EAAE,YAAa,QAGjD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,IAAI,GAAI,MAAC,EAAE,YAAa,QAGpC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAAI,MAAC,EAAE,YAAa,QAGrC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GAAI,MAAC,EAAE,MAAC,EAAE,eAAa,WAK3C,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,GAAI,MAAC,EAAE,MAAC,EAAE,YAAa,QAO1C,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GAAI,MAAC,EAAE,MAAC,EAAE,YAAa,QAO9C,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,eAAe,GAAI,MAAC,EAAE,YAAa,QAG/C,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,SAAS,GAAI,MAAC,EAAE,YAAa,QAOzC,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,GAAI,MAAC,EAAE,MAAC,EAAE,MAAC,EAAE,QAAG,EAAE,cAAS,EAAE,SAAI,QAkBnD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GAAI,WAAM,EAAE,YAAa,QAe7C,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,KAAK,GAAI,QAAG,EAAE,cAAW,EAAE,cAAW,UASlD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAAI,UAAK,EAAE,YAAa,QAIzC,CAAC"}

package/dist/phaser/geom/util/polygon.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Clones a polygon.
+ * @param {Polygon} input - The polygon to clone.
+ * @param {Polygon} output - Optional polygon to store the result in.
+ * @returns {Polygon} The cloned polygon.
+ */
+export declare const clone: (input: any, output?: any) => any;
+//# sourceMappingURL=polygon.d.ts.map

package/dist/phaser/geom/util/polygon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygon.d.ts","sourceRoot":"","sources":["../../../../src/phaser/geom/util/polygon.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAAI,UAAK,EAAE,YAAa,QAIzC,CAAC"}

package/dist/phaser/geom/util/rectangle.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Inflates the rectangle by the specified amounts on each axis.
+ * @param {Rectangle} a - The rectangle to inflate.
+ * @param {number} dx - The amount to inflate the rectangle horizontally.
+ * @param {number} dy - The amount to inflate the rectangle vertically.
+ * @returns {Rectangle} The inflated rectangle.
+ */
+export declare const inflate: (a: any, dx: any, dy: any) => any;
+/**
+ * Inflates the rectangle by the specified point values on each axis.
+ * @param {Rectangle} a - The rectangle to inflate.
+ * @param {object} point - The point containing x and y values to inflate the rectangle by.
+ * @returns {Rectangle} The inflated rectangle.
+ */
+export declare const inflatePoint: (a: any, point: any) => any;
+/**
+ * Gets the size of the rectangle as a point.
+ * @param {Rectangle} a - The rectangle to get the size of.
+ * @param {Point} output - Optional point to store the result in.
+ * @returns {Point} The size of the rectangle as a point (width, height).
+ */
+export declare const size: (a: any, output?: any) => any;
+/**
+ * Clones a rectangle.
+ * @param {Rectangle} input - The rectangle to clone.
+ * @param {Rectangle} output - Optional rectangle to store the result in.
+ * @returns {Rectangle} The cloned rectangle.
+ */
+export declare const clone: (input: any, output?: any) => any;
+/**
+ * Checks if a point is contained within the rectangle.
+ * @param {Rectangle} a - The rectangle to check.
+ * @param {number} x - The x coordinate of the point.
+ * @param {number} y - The y coordinate of the point.
+ * @returns {boolean} True if the point is contained within the rectangle, false otherwise.
+ */
+export declare const contains: (a: any, x: any, y: any) => boolean;
+/**
+ * Checks if a point is contained within the rectangle (raw version).
+ * @param {number} rx - The x coordinate of the rectangle.
+ * @param {number} ry - The y coordinate of the rectangle.
+ * @param {number} rw - The width of the rectangle.
+ * @param {number} rh - The height of the rectangle.
+ * @param {number} x - The x coordinate of the point.
+ * @param {number} y - The y coordinate of the point.
+ * @returns {boolean} True if the point is contained within the rectangle, false otherwise.
+ */
+export declare const containsRaw: (rx: any, ry: any, rw: any, rh: any, x: any, y: any) => boolean;
+/**
+ * Checks if a point is contained within the rectangle.
+ * @param {Rectangle} a - The rectangle to check.
+ * @param {Point} point - The point to check.
+ * @returns {boolean} True if the point is contained within the rectangle, false otherwise.
+ */
+export declare const containsPoint: (a: any, point: any) => boolean;
+/**
+ * Checks if rectangle a contains rectangle b.
+ * @param {Rectangle} a - The first rectangle to check.
+ * @param {Rectangle} b - The second rectangle to check.
+ * @returns {boolean} True if rectangle a contains rectangle b, false otherwise.
+ */
+export declare const containsRect: (a: any, b: any) => boolean;
+/**
+ * Checks if two rectangles are equal.
+ * @param {Rectangle} a - The first rectangle to compare.
+ * @param {Rectangle} b - The second rectangle to compare.
+ * @returns {boolean} True if the rectangles are equal, false otherwise.
+ */
+export declare const equals: (a: any, b: any) => boolean;
+/**
+ * Checks if two rectangles have the same dimensions.
+ * @param {Rectangle} a - The first rectangle to compare.
+ * @param {Rectangle} b - The second rectangle to compare.
+ * @returns {boolean} True if the rectangles have the same dimensions, false otherwise.
+ */
+export declare const sameDimensions: (a: any, b: any) => boolean;
+/**
+ * Checks if two rectangles intersect.
+ * @param {Rectangle} a - The first rectangle to check.
+ * @param {Rectangle} b - The second rectangle to check.
+ * @returns {boolean} True if the rectangles intersect, false otherwise.
+ */
+export declare const intersects: (a: any, b: any) => boolean;
+/**
+ * Gets the intersection of two rectangles.
+ * @param {Rectangle} a - The first rectangle.
+ * @param {Rectangle} b - The second rectangle.
+ * @param {Rectangle} output - Optional rectangle to store the result in.
+ * @returns {Rectangle} The intersection of the rectangles, or an empty rectangle if they don't intersect.
+ */
+export declare const intersection: (a: any, b: any, output?: any) => any;
+/**
+ * Checks if a rectangle intersects with a set of raw coordinates.
+ * @param {Rectangle} a - The rectangle to check.
+ * @param {number} left - The left coordinate of the area to check.
+ * @param {number} right - The right coordinate of the area to check.
+ * @param {number} top - The top coordinate of the area to check.
+ * @param {number} bottom - The bottom coordinate of the area to check.
+ * @param {number} tolerance - Optional tolerance value for intersection.
+ * @returns {boolean} True if the rectangle intersects with the area, false otherwise.
+ */
+export declare const intersectsRaw: (a: any, left: any, right: any, top: any, bottom: any, tolerance?: number) => boolean;
+/**
+ * Gets the union of two rectangles.
+ * @param {Rectangle} a - The first rectangle.
+ * @param {Rectangle} b - The second rectangle.
+ * @param {Rectangle} output - Optional rectangle to store the result in.
+ * @returns {Rectangle} The union of the rectangles.
+ */
+export declare const union: (a: any, b: any, output?: any) => any;
+/**
+ * Gets the axis-aligned bounding box (AABB) of a set of points.
+ * @param {Point[]} points - The array of points to calculate the AABB for.
+ * @param {Rectangle} output - Optional rectangle to store the result in.
+ * @returns {Rectangle} The AABB of the points.
+ */
+export declare const aabb: (points: any, output?: any) => any;
+/**
+ * Gets an empty rectangle instance.
+ * @returns {Rectangle} An empty rectangle.
+ */
+export declare const getEmptyRectangle: () => any;
+//# sourceMappingURL=rectangle.d.ts.map

package/dist/phaser/geom/util/rectangle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rectangle.d.ts","sourceRoot":"","sources":["../../../../src/phaser/geom/util/rectangle.ts"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,GAAI,MAAC,EAAE,OAAE,EAAE,OAAE,QAMhC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GAAI,MAAC,EAAE,UAAK,QAEpC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,IAAI,GAAI,MAAC,EAAE,YAAa,QAIpC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAAI,UAAK,EAAE,YAAa,QAIzC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GAAI,MAAC,EAAE,MAAC,EAAE,MAAC,YAK/B,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW,GAAI,OAAE,EAAE,OAAE,EAAE,OAAE,EAAE,OAAE,EAAE,MAAC,EAAE,MAAC,YAE/C,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,aAAa,GAAI,MAAC,EAAE,UAAK,YAErC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GAAI,MAAC,EAAE,MAAC,YAKhC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,MAAM,GAAI,MAAC,EAAE,MAAC,YAE1B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GAAI,MAAC,EAAE,MAAC,YAElC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,MAAC,EAAE,MAAC,YAK9B,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,GAAI,MAAC,EAAE,MAAC,EAAE,YAAa,QAS/C,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa,GAAI,MAAC,EAAE,SAAI,EAAE,UAAK,EAAE,QAAG,EAAE,WAAM,EAAE,kBAAa,YAOvE,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,KAAK,GAAI,MAAC,EAAE,MAAC,EAAE,YAAa,QAQxC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,IAAI,GAAI,WAAM,EAAE,YAAa,QAsBzC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,iBAAiB,WAQ7B,CAAC"}

package/dist/phaser/geom/util/rounded_rectangle.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Clones a rounded rectangle.
+ * @param {RoundedRectangle} input - The rounded rectangle to clone.
+ * @param {RoundedRectangle} output - Optional rounded rectangle to store the result in.
+ * @returns {RoundedRectangle} The cloned rounded rectangle.
+ */
+export declare const clone: (input: any, output?: any) => any;
+//# sourceMappingURL=rounded_rectangle.d.ts.map

package/dist/phaser/geom/util/rounded_rectangle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rounded_rectangle.d.ts","sourceRoot":"","sources":["../../../../src/phaser/geom/util/rounded_rectangle.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAAI,UAAK,EAAE,YAAa,QAQzC,CAAC"}

package/dist/phaser/util/math.d.ts

@@ -0,0 +1,154 @@
+export declare const DEG_TO_RAD: number;
+export declare const RAD_TO_DEG: number;
+export declare const PI_2: number;
+/**
+ * Converts a hexadecimal color value to RGB components.
+ * @param {number} hex - The hexadecimal color value.
+ * @returns {number[]} An array containing the RGB components [r, g, b].
+ */
+export declare const hex2rgb: (hex: any) => number[];
+/**
+ * Converts RGB components to a hexadecimal color value.
+ * @param {number} rgb - The RGB components array [r, g, b].
+ * @returns {number} The hexadecimal color value.
+ */
+export declare const rgb2hex: (rgb: any) => number;
+/**
+ * Gets the next power of two greater than or equal to a value.
+ * @param {number} value - The input value.
+ * @returns {number} The next power of two.
+ */
+export declare const getNextPowerOfTwo: (value: any) => any;
+/**
+ * Checks if both width and height are powers of two.
+ * @param {number} width - The width to check.
+ * @param {number} height - The height to check.
+ * @returns {boolean} True if both width and height are powers of two, false otherwise.
+ */
+export declare const isPowerOfTwo: (width: any, height: any) => boolean;
+/**
+ * Converts degrees to radians.
+ * @param {number} degrees - The angle in degrees.
+ * @returns {number} The angle in radians.
+ */
+export declare const degToRad: (degrees: any) => number;
+/**
+ * Converts radians to degrees.
+ * @param {number} radians - The angle in radians.
+ * @returns {number} The angle in degrees.
+ */
+export declare const radToDeg: (radians: any) => number;
+/**
+ * Gets a random integer between min and max (inclusive).
+ * @param {number} min - The minimum value.
+ * @param {number} max - The maximum value.
+ * @returns {number} A random integer between min and max.
+ */
+export declare const between: (min: any, max: any) => number;
+/**
+ * Snaps a value to the nearest multiple of gap, starting from start.
+ * @param {number} input - The value to snap.
+ * @param {number} gap - The gap size to snap to.
+ * @param {number} start - The starting offset for snapping.
+ * @returns {number} The snapped value.
+ */
+export declare const snapToCeil: (input: any, gap?: number, start?: number) => any;
+/**
+ * Wraps a value within a range.
+ * @param {number} value - The value to wrap.
+ * @param {number} min - The minimum value of the range.
+ * @param {number} max - The maximum value of the range.
+ * @returns {number} The wrapped value.
+ */
+export declare const wrap: (value: any, min: any, max: any) => any;
+/**
+ * Performs linear interpolation between two values.
+ * @param {number} p0 - The first point.
+ * @param {number} p1 - The second point.
+ * @param {number} t - The interpolation factor (0 to 1).
+ * @returns {number} The interpolated value.
+ */
+export declare const linear: (p0: any, p1: any, t: any) => any;
+/**
+ * Calculates the absolute difference between two numbers.
+ * @param {number} a - The first number.
+ * @param {number} b - The second number.
+ * @returns {number} The absolute difference between a and b.
+ */
+export declare const difference: (a: any, b: any) => number;
+/**
+ * Performs linear interpolation on an array of values.
+ * @param {number[]} v - The array of values.
+ * @param {number} k - The interpolation factor (0 to 1).
+ * @returns {number} The interpolated value.
+ */
+export declare const linearInterpolation: (v: any, k: any) => any;
+/**
+ * Calculates the distance between two points.
+ * @param {number} x1 - The x-coordinate of the first point.
+ * @param {number} y1 - The y-coordinate of the first point.
+ * @param {number} x2 - The x-coordinate of the second point.
+ * @param {number} y2 - The y-coordinate of the second point.
+ * @returns {number} The distance between the two points.
+ */
+export declare const distance: (x1: any, y1: any, x2: any, y2: any) => number;
+/**
+ * Checks if two numbers are within a tolerance of each other.
+ * @param {number} a - The first number.
+ * @param {number} b - The second number.
+ * @param {number} tolerance - The tolerance value.
+ * @returns {boolean} True if the numbers are within tolerance, false otherwise.
+ */
+export declare const within: (a: any, b: any, tolerance: any) => boolean;
+/**
+ * Creates a 32-bit color value from alpha, red, green, and blue components.
+ * @param {number} a - The alpha component (0-255).
+ * @param {number} r - The red component (0-255).
+ * @param {number} g - The green component (0-255).
+ * @param {number} b - The blue component (0-255).
+ * @returns {number} The 32-bit color value.
+ */
+export declare const getColor32: (a: any, r: any, g: any, b: any) => number;
+/**
+ * Creates a 24-bit color value from red, green, and blue components.
+ * @param {number} r - The red component (0-255).
+ * @param {number} g - The green component (0-255).
+ * @param {number} b - The blue component (0-255).
+ * @returns {number} The 24-bit color value.
+ */
+export declare const getColor: (r: any, g: any, b: any) => number;
+/**
+ * Converts a hex color string to RGB components.
+ * @param {string} value - The hex color string (e.g. "#FF0000").
+ * @param {{r?: number, g?: number, b?: number}} out - The object to store the result in.
+ */
+export declare const hexToColor: (value: any, out: any) => void;
+/**
+ * Converts a web color string (e.g. "rgb(255, 0, 0)") to RGB components with alpha.
+ * @param {string} value - The web color string (e.g. "rgba(255, 0, 0, 0.5)").
+ * @param {{r?: number, g?: number, b?: number, a?: number}} out - The object to store the result in.
+ */
+export declare const webToColor: (value: any, out: any) => void;
+/**
+ * Extracts RGB components from a 32-bit color value.
+ * @param {number} color - The 32-bit color value.
+ * @returns {{ alpha: number, red: number, green: number, blue: number, a: number, r: number, g: number, b: number}} An object containing the color components.
+ */
+export declare const getRGB: (color: any) => {
+    alpha: number;
+    red: number;
+    green: number;
+    blue: number;
+    a: number;
+    r: number;
+    g: number;
+    b: number;
+};
+/**
+ * Converts a color value (string or number) to an object with various color formats.
+ * @param {string|number} value - The color value (e.g. "#FF0000" or 0xFF0000).
+ * @param {{a?: number, r?: number, g?: number, b?: number, rgba?: string, color?: number, color32?: number}} out - The object to store the result in.
+ * @returns {{a?: number, r?: number, g?: number, b?: number, rgba?: string, color?: number, color32?: number}} The updated out object.
+ */
+export declare const valueToColor: (value: any, out: any) => any;
+//# sourceMappingURL=math.d.ts.map