@vpmedia/phaser 1.102.0 → 1.103.0

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"math.d.ts","sourceRoot":"","sources":["../../../src/phaser/util/math.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU,QAAgB,CAAC;AACxC,eAAO,MAAM,UAAU,QAAgB,CAAC;AACxC,eAAO,MAAM,IAAI,QAAc,CAAC;AAEhC;;;;GAIG;AACH,eAAO,MAAM,OAAO,GAAI,QAAG,aAE1B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,OAAO,GAAI,QAAG,WAE1B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,UAAK,QAUtC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GAAI,UAAK,EAAE,WAAM,YAEzC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,QAAQ,GAAI,YAAO,WAE/B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,QAAQ,GAAI,YAAO,WAE/B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,OAAO,GAAI,QAAG,EAAE,QAAG,WAE/B,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,GAAI,UAAK,EAAE,YAAO,EAAE,cAAS,QAOnD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,GAAI,UAAK,EAAE,QAAG,EAAE,QAAG,QAUnC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,GAAI,OAAE,EAAE,OAAE,EAAE,MAAC,QAE/B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,MAAC,EAAE,MAAC,WAE9B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAI,MAAC,EAAE,MAAC,QAWvC,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAE,EAAE,OAAE,EAAE,OAAE,EAAE,OAAE,WAItC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,GAAI,MAAC,EAAE,MAAC,EAAE,cAAS,YAErC,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,GAAI,MAAC,EAAE,MAAC,EAAE,MAAC,EAAE,MAAC,WAEpC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GAAI,MAAC,EAAE,MAAC,EAAE,MAAC,WAE/B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,UAAU,GAAI,UAAK,EAAE,QAAG,SASpC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,UAAU,GAAI,UAAK,EAAE,QAAG,SAQpC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,MAAM,GAAI,UAAK;;;;;;;;;CAwB3B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GAAI,UAAK,EAAE,QAAG,QAsBtC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vpmedia/phaser",
-  "version": "1.102.0",
+  "version": "1.103.0",
   "description": "@vpmedia/phaser is the modern ECMAScript port of the popular Phaser game engine v2.6.2",
   "author": "Andras Csizmadia <andras@vpmedia.hu> (www.vpmedia.hu)",
   "license": "MIT",
@@ -19,27 +19,41 @@
     "webgl",
     "canvas"
   ],
-  "main": "./src/index.js",
-  "types": "./types/index.d.ts",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "type": "module",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
   "dependencies": {
     "@vpmedia/simplify": "^1.74.0",
     "uuid": "^14.0.0"
   },
   "devDependencies": {
-    "@commitlint/cli": "^20.5.0",
-    "@commitlint/config-conventional": "^20.5.0",
-    "@types/node": "^25.6.0",
+    "@commitlint/cli": "^21.0.0",
+    "@commitlint/config-conventional": "^21.0.0",
+    "@commitlint/types": "^21.0.0",
+    "@types/node": "^25.6.2",
     "@vitest/coverage-v8": "^4.1.5",
-    "jsdom": "^29.0.2",
-    "oxfmt": "^0.46.0",
-    "oxlint": "^1.61.0",
-    "oxlint-tsgolint": "^0.21.1",
+    "jsdom": "^29.1.1",
+    "oxfmt": "^0.48.0",
+    "oxlint": "^1.63.0",
+    "oxlint-tsgolint": "^0.22.1",
+    "rolldown": "1.0.0",
     "typescript": "^6.0.3",
     "vitest": "^4.1.5"
   },
   "scripts": {
-    "build": "exit 0",
+    "build": "rolldown -c && tsc",
+    "clean": "rm -rf dist",
     "check": "pnpm lint && pnpm test && pnpm typecheck",
     "format": "oxfmt --write \"./**/*.{js,jsx,mjs,cjs,ts,tsx,json,css}\"",
     "lint": "oxlint src",

package/src/phaser/core/{animation.js → animation.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import { Signal } from './signal.js';
 
 export class Animation {
@@ -475,4 +476,4 @@ export class Animation {
       this.onUpdate = null;
     }
   }
-}
+}

package/src/phaser/core/{animation_manager.js → animation_manager.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import { Animation } from './animation.js';
 import { ENGINE_ERROR_CANNOT_SET_FRAME, ENGINE_ERROR_CANNOT_SET_FRAME_NAME } from './error_code.js';
 
@@ -345,4 +346,4 @@ export class AnimationManager {
       });
     }
   }
-}
+}

package/src/phaser/core/{array_set.js → array_set.ts}

@@ -1,9 +1,12 @@
 export class ArraySet {
+  position: number;
+  list: any[];
+
   /**
    * TBD.
    * @param {object[]} list - TBD.
    */
-  constructor(list = []) {
+  constructor(list: any[] = []) {
     this.position = 0;
     this.list = list;
   }

package/src/phaser/core/{cache.js → cache.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import { BaseTexture } from '../display/webgl/base_texture.js';
 import { Texture } from '../display/webgl/texture.js';
 import { JSONDataHash } from './animation_parser.js';
@@ -770,4 +771,4 @@ export class Cache {
     this._urlResolver = null;
     this._urlTemp = null;
   }
-}
+}

package/src/phaser/core/{device.js → device.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 export class Device {
   /**
    * Creates a new Device instance.
@@ -94,4 +95,4 @@ export class Device {
      */
     this.supportedImageFormats = {};
   }
-}
+}

package/src/phaser/core/{dom.js → dom.ts}

@@ -180,6 +180,13 @@ class DocumentBoundsRectangle {
 }
 
 export class DOM {
+  treatAsDesktop: boolean;
+  visualBounds: any;
+  layoutBounds: any;
+  documentBounds: any;
+  scrollXProvider: () => number;
+  scrollYProvider: () => number;
+
   /**
    * TBD.
    * @param {import('./device.js').Device} device - TBD.

package/src/phaser/core/{event_manager.js → event_manager.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import { Signal } from './signal.js';
 
 export class EventManager {
@@ -390,4 +391,4 @@ export class EventManager {
       this._onAnimationLoop.dispatch(...args);
     }
   }
-}
+}

package/src/phaser/core/{factory.js → factory.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import { BitmapText } from '../display/bitmap_text.js';
 import { Button } from '../display/button.js';
 import { Graphics } from '../display/graphics.js';

package/src/phaser/core/{frame.js → frame.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import { Rectangle } from '../geom/rectangle.js';
 import { distance } from '../util/math.js';
 import { cloneFrame } from './frame_util.js';
@@ -107,4 +108,4 @@ export class Frame {
     result.setTo(this.x, this.y, this.width, this.height);
     return result;
   }
-}
+}

package/src/phaser/core/{frame_data.js → frame_data.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import { cloneFrameData } from './frame_util.js';
 
 export class FrameData {
@@ -130,4 +131,4 @@ export class FrameData {
   get total() {
     return this._frames.length;
   }
-}
+}