@league-of-foundry-developers/foundry-vtt-types 13.340.0 → 13.345.1-beta.20250704.94554

package/src/foundry/client/pixi/extensions/circle.d.mts

@@ -1,143 +0,0 @@
-import type { NullishProps } from "fvtt-types/utils";
-import type { LineCircleIntersection } from "../../../common/utils/geometry.d.mts";
-import * as _PIXI from "pixi.js";
-
-declare global {
-  namespace PIXI {
-    interface Circle {
-      /**
-       * Determine the center of the circle.
-       * Trivial, but used to match center method for other shapes.
-       */
-      get center(): PIXI.Point;
-
-      /**
-       * Determine if a point is on or nearly on this circle.
-       * @param point   - Point to test
-       * @param epsilon - Tolerated margin of error
-       *                  (default: `1e-08`)
-       * @returns Is the point on the circle within the allowed tolerance?
-       */
-      pointIsOn(point: Canvas.Point, epsilon?: number): boolean;
-
-      /**
-       * Get all intersection points on this circle for a segment A|B
-       * Intersections are sorted from A to B.
-       * @param a - The first endpoint on segment A|B
-       * @param b - The second endpoint on segment A|B
-       * @returns Points where the segment A|B intersects the circle
-       */
-      segmentIntersections(a: Canvas.Point, b: Canvas.Point): LineCircleIntersection["intersections"];
-
-      /**
-       * Calculate an x,y point on this circle's circumference given an angle
-       * 0: due east
-       * π / 2: due south
-       * π or -π: due west
-       * -π/2: due north
-       * @param angle - Angle of the point, in radians
-       * @returns The point on the circle at the given angle
-       */
-      pointAtAngle(angle: number): Canvas.Point;
-
-      /**
-       * Get all the points for a polygon approximation of this circle between two points.
-       * The two points can be anywhere in 2d space. The intersection of this circle with the line from this circle center
-       * to the point will be used as the start or end point, respectively.
-       * This is used to draw the portion of the circle (the arc) between two intersection points on this circle.
-       * @param a       - Point in 2d space representing the start point
-       * @param b       - Point in 2d space representing the end point
-       * @param options - Options passed on to the pointsForArc method
-       * @returns An array of points arranged clockwise from start to end
-       */
-      pointsBetween(a: Canvas.Point, b: Canvas.Point, options?: Circle.PointsForArcOptions): Canvas.Point[];
-
-      /**
-       * Get the points that would approximate a circular arc along this circle, given a starting and ending angle.
-       * Points returned are clockwise. If from and to are the same, a full circle will be returned.
-       * @param fromAngle - Starting angle, in radians. π is due north, π/2 is due east
-       * @param toAngle   - Ending angle, in radians
-       * @param options   - Options which affect how the circle is converted
-       * @returns An array of points along the requested arc
-       */
-      pointsForArc(fromAngle: number, toAngle: number, options?: Circle.PointsForArcOptions): Canvas.Point[];
-
-      /**
-       * Approximate this PIXI.Circle as a PIXI.Polygon
-       * @param options - Options forwarded on to the pointsForArc method
-       * @returns The Circle expressed as a PIXI.Polygon
-       */
-      toPolygon(options?: Circle.PointsForArcOptions): PIXI.Polygon;
-
-      /**
-       * Intersect this PIXI.Circle with a PIXI.Polygon.
-       * @param polygon - A PIXI.Polygon
-       * @param options - Options which configure how the intersection is computed
-       * @returns The intersected polygon
-       * @remarks Slightly bugged in v12; if `options.weilerAtherton` is falsey, it will not pass on `options.clipType` to `PIXI.Polygon#intersectPolygon`,
-       * forcing the default of `ClipperLib.ClipTypes.ctIntersection`
-       */
-      intersectPolygon(polygon: PIXI.Polygon, options?: PIXI.Circle.WACIntersectPolygonOptions): PIXI.Polygon;
-      intersectPolygon(polygon: PIXI.Polygon, options?: PIXI.Circle.ClipperLibIntersectPolygonOptions): PIXI.Polygon;
-
-      /**
-       * Intersect this PIXI.Circle with an array of ClipperPoints.
-       * Convert the circle to a Polygon approximation and use intersectPolygon.
-       * In the future we may replace this with more specialized logic which uses the line-circle intersection formula.
-       * @param clipperPoints - Array of ClipperPoints generated by PIXI.Polygon.toClipperPoints()
-       * @param options       - Options which configure how the intersection is computed
-       * @returns The intersected polygon
-       */
-      intersectClipper(
-        clipperPoints: PIXI.Polygon.ClipperPoint[],
-        options?: PIXI.Circle.IntersectClipperOptions,
-      ): PIXI.Polygon;
-    }
-
-    namespace Circle {
-      /** @remarks The options for `intersectPolygon` when `weilerAtherton` is true (or not provided) */
-      interface WACIntersectPolygonOptions extends PIXI.Rectangle.WACIntersectPolygonOptions {}
-
-      /** @remarks The options for `intersectPolygon` when `weilerAtherton` is false. */
-      interface ClipperLibIntersectPolygonOptions
-        extends PIXI.Rectangle.ClipperLibIntersectPolygonOptions,
-          Pick<PIXI.Circle.PointsForArcOptions, "density"> {}
-
-      /** @internal Helper type to simplify use of optionality- and nullish-permissiveness-modifying helpers */
-      type _PointsForArcOptions = NullishProps<{
-        /**
-         * The number of points which defines the density of approximation
-         * @defaultValue `PIXI.Circle.approximateVertexDensity(this.radius)`
-         * @remarks Default provided by `??=` in `pointsForArc` function body
-         */
-        density: number;
-
-        /**
-         * Whether to include points at the circle where the arc starts and ends
-         * @defaultValue `true`
-         */
-        includeEndpoints: boolean;
-      }>;
-
-      interface PointsForArcOptions extends _PointsForArcOptions {}
-
-      interface IntersectClipperOptions
-        extends PIXI.Polygon.IntersectClipperOptions,
-          Pick<PIXI.Circle.PointsForArcOptions, "density"> {}
-    }
-
-    class Circle extends _PIXI.Circle {
-      /**
-       * The recommended vertex density for the regular polygon approximation of a circle of a given radius.
-       * Small radius circles have fewer vertices. The returned value will be rounded up to the nearest integer.
-       * See the formula described at:
-       * https://math.stackexchange.com/questions/4132060/compute-number-of-regular-polgy-sides-to-approximate-circle-to-defined-precision
-       * @param radius  - Circle radius
-       * @param epsilon - The maximum tolerable distance between an approximated line segment and the true radius.
-       *                  A larger epsilon results in fewer points for a given radius. (default: `1`)
-       * @returns The number of points for the approximated polygon
-       */
-      static approximateVertexDensity(radius: number, epsilon?: number): number;
-    }
-  }
-}

package/src/foundry/client/pixi/extensions/graphics.d.mts

@@ -1,45 +0,0 @@
-export {};
-
-declare global {
-  namespace PIXI {
-    namespace Graphics {
-      type Path =
-        | [points: number[] | PIXI.IPointData[] | PIXI.Polygon, smoothingFactor?: number]
-        | Array<number | PIXI.IPointData>;
-    }
-  }
-}
-
-/**
- * @remarks Internal helper to accommodate for the reuse of functions across the various Graphics classes
- */
-interface GraphicsHelper {
-  /**
-   * Draws a path.
-   * @param path - The polygon or points.
-   * @returns This Graphics instance.
-   */
-  drawPath(...path: PIXI.Graphics.Path): this;
-
-  /**
-   * Draws a smoothed polygon.
-   * @param path - The polygon or points.
-   * @returns This Graphics instance.
-   */
-  drawSmoothedPolygon(...path: PIXI.Graphics.Path): this;
-
-  /**
-   * Draws a smoothed path.
-   * @param path - The polygon or points.
-   * @returns This Graphics instance.
-   */
-  drawSmoothedPath(...path: PIXI.Graphics.Path): this;
-}
-
-declare module "pixi.js" {
-  interface Graphics extends GraphicsHelper {}
-}
-
-declare module "@pixi/graphics-smooth" {
-  interface SmoothGraphics extends GraphicsHelper {}
-}

package/src/foundry/client/pixi/extensions/index.d.mts

@@ -1,5 +0,0 @@
-import "./circle.d.mts";
-import "./graphics.d.mts";
-import "./observable-transform.d.mts";
-import "./polygon.d.mts";
-import "./rectangle.d.mts";

package/src/foundry/client/pixi/extensions/observable-transform.d.mts

@@ -1,38 +0,0 @@
-export {};
-
-declare global {
-  /**
-   * A custom Transform class allowing to observe changes with a callback.
-   * @privateRemarks Scope extends object is intentional; `"The scope bound to an ObservableTransform class must be a valid object/class."`
-   */
-  class ObservableTransform<CB extends (this: Scope) => unknown, Scope extends object> extends PIXI.Transform {
-    /**
-     *
-     * @param callback - The callback called to observe changes.
-     * @param scope    - The scope of the callback.
-     */
-    constructor(callback: CB, scope: Scope);
-
-    /**
-     * The callback which is observing the changes.
-     */
-    cb: CB;
-
-    /**
-     * The scope of the callback.
-     */
-    scope: Scope;
-
-    protected override onChange(): void;
-
-    protected override updateSkew(): void;
-  }
-  namespace ObservableTransform {
-    interface Any extends AnyObservableTransform {}
-    type AnyConstructor = typeof AnyObservableTransform;
-  }
-}
-
-declare abstract class AnyObservableTransform extends ObservableTransform<any, any> {
-  constructor(arg0: never, ...args: never[]);
-}

package/src/foundry/client/pixi/extensions/polygon.d.mts

@@ -1,163 +0,0 @@
-import type { InexactPartial, NullishProps } from "fvtt-types/utils";
-import * as _PIXI from "pixi.js";
-
-declare global {
-  namespace PIXI {
-    interface Polygon {
-      /**
-       * Test whether the polygon is has a positive signed area.
-       * Using a y-down axis orientation, this means that the polygon is "clockwise".
-       */
-      get isPositive(): boolean;
-
-      /**
-       * @remarks Non enumerable
-       */
-      _isPositive?: boolean;
-
-      /**
-       * Clear the cached signed orientation.
-       */
-      clearCache(): void;
-
-      /**
-       * Compute the signed area of polygon using an approach similar to ClipperLib.Clipper.Area.
-       * The math behind this is based on the Shoelace formula. https://en.wikipedia.org/wiki/Shoelace_formula.
-       * The area is positive if the orientation of the polygon is positive.
-       * @returns The signed area of the polygon
-       */
-      signedArea(): number;
-
-      /**
-       * Reverse the order of the polygon points in-place, replacing the points array into the polygon.
-       * Note: references to the old points array will not be affected.
-       * @returns This polygon with its orientation reversed
-       */
-      reverseOrientation(): this;
-
-      /**
-       * Add a de-duplicated point to the Polygon.
-       * @param point - The point to add to the Polygon
-       * @returns A reference to the polygon for method chaining
-       */
-      addPoint(point: Canvas.Point): this;
-
-      /**
-       * Return the bounding box for a PIXI.Polygon.
-       * The bounding rectangle is normalized such that the width and height are non-negative.
-       * @returns The bounding PIXI.Rectangle
-       */
-      getBounds(): PIXI.Rectangle;
-
-      /**
-       * Convert a PIXI.Polygon into an array of clipper points [\{X,Y\}, ...].
-       * Note that clipper points must be rounded to integers.
-       * In order to preserve some amount of floating point precision, an optional scaling factor may be provided.
-       * @param options - Options which affect how clipper points are generated
-       * @returns An array of points to be used by clipper
-       */
-      toClipperPoints(options?: PIXI.Polygon.ClipperPointsOptions): PIXI.Polygon.ClipperPoint[];
-
-      /**
-       * Determine whether the PIXI.Polygon is closed, defined by having the same starting and ending point.
-       * @remarks Non-enumerable
-       */
-      get isClosed(): boolean;
-
-      /**
-       * Intersect this PIXI.Polygon with another PIXI.Polygon using the clipper library.
-       * @param other   - Another PIXI.Polygon
-       * @param options - Options which configure how the intersection is computed
-       * @returns The intersected polygon
-       */
-      intersectPolygon(other: PIXI.Polygon, options?: PIXI.Polygon.IntersectPolygonOptions): PIXI.Polygon;
-
-      /**
-       * Intersect this PIXI.Polygon with an array of ClipperPoints.
-       * @param clipperPoints - Array of clipper points generated by PIXI.Polygon.toClipperPoints()
-       * @param options       - Options which configure how the intersection is computed
-       */
-      intersectClipper(
-        clipperPoints: PIXI.Polygon.ClipperPoint[],
-        options?: PIXI.Polygon.IntersectClipperOptions,
-      ): PIXI.Polygon.ClipperPoint[];
-
-      /**
-       * Intersect this PIXI.Polygon with a PIXI.Circle.
-       * For now, convert the circle to a Polygon approximation and use intersectPolygon.
-       * In the future we may replace this with more specialized logic which uses the line-circle intersection formula.
-       * @param circle  - A PIXI.Circle
-       * @param options - Options which configure how the intersection is computed
-       * @returns The intersected polygon
-       */
-      intersectCircle(circle: PIXI.Circle, options?: PIXI.Circle.IntersectClipperOptions): PIXI.Polygon;
-
-      /**
-       * Intersect this PIXI.Polygon with a PIXI.Rectangle.
-       * For now, convert the rectangle to a Polygon and use intersectPolygon.
-       * In the future we may replace this with more specialized logic which uses the line-line intersection formula.
-       * @param rect    - A PIXI.Rectangle
-       * @param options - Options which configure how the intersection is computed
-       * @returns The intersected polygon
-       */
-      intersectRectangle(rect: PIXI.Rectangle, options?: PIXI.Rectangle.WACIntersectPolygonOptions): PIXI.Polygon;
-      intersectRectangle(
-        rect: PIXI.Rectangle,
-        options?: PIXI.Rectangle.ClipperLibIntersectPolygonOptions,
-      ): PIXI.Polygon;
-    }
-
-    namespace Polygon {
-      type OrPointsFlat = number[] | PIXI.Polygon;
-      type OrPoints = OrPointsFlat | PIXI.IPointData[];
-
-      /** @privateRemarks Foundry uses this type instead of full `ClipperLib.IntPoint` objects */
-      interface ClipperPoint {
-        X: number;
-        Y: number;
-      }
-
-      /** @internal  */
-      type _IntersectClipperOptions = InexactPartial<{
-        /**
-         * A scaling factor passed to Polygon#toClipperPoints to preserve precision
-         * @remarks Can't be `null` as, where it has any, it only has parameter defaults
-         * @defaultValue `1`
-         */
-        scalingFactor: number;
-      }> &
-        NullishProps<{
-          /**
-           * The clipper clip type
-           * @defaultValue `ClipperLib.ClipType.ctIntersection`
-           * @remarks ClipperLib functions require a non-nullish `ClipperLib.ClipType` value, but the Foundry functions have `??=` guards for this.
-           */
-          clipType: ClipperLib.ClipType;
-        }>;
-
-      interface IntersectClipperOptions extends _IntersectClipperOptions {}
-
-      /**
-       * @privateRemarks Separate interface despite identical keys for purposes of declaration merging
-       * and just having an expected name for external reference
-       */
-      interface IntersectPolygonOptions extends _IntersectClipperOptions {}
-
-      interface ClipperPointsOptions extends Pick<PIXI.Polygon.IntersectClipperOptions, "scalingFactor"> {}
-    }
-
-    class Polygon extends _PIXI.Polygon {
-      /**
-       * Construct a PIXI.Polygon instance from an array of clipper points [\{X,Y\}, ...].
-       * @param points  - An array of points returned by clipper
-       * @param options - Options which affect how canvas points are generated
-       * @param scalingFactor -
-       * @returns The resulting PIXI.Polygon
-       */
-      static fromClipperPoints(
-        points: PIXI.Polygon.ClipperPoint[],
-        options?: PIXI.Polygon.ClipperPointsOptions,
-      ): PIXI.Polygon;
-    }
-  }
-}

package/src/foundry/client/pixi/extensions/rectangle.d.mts

@@ -1,274 +0,0 @@
-import type { Brand, InexactPartial } from "fvtt-types/utils";
-import * as _PIXI from "pixi.js";
-
-declare global {
-  namespace PIXI {
-    interface Rectangle {
-      /**
-       * Bit code labels splitting a rectangle into zones, based on the Cohen-Sutherland algorithm.
-       * See https://en.wikipedia.org/wiki/Cohen%E2%80%93Sutherland_algorithm
-       *          left    central   right
-       * top      1001    1000      1010
-       * central  0001    0000      0010
-       * bottom   0101    0100      0110
-       */
-      CS_ZONES: PIXI.Rectangle.CS_Zones;
-
-      /**
-       * Calculate center of this rectangle.
-       */
-      get center(): Canvas.Point;
-
-      /**
-       * Return the bounding box for a PIXI.Rectangle.
-       * The bounding rectangle is normalized such that the width and height are non-negative.
-       */
-      getBounds(): PIXI.Rectangle;
-
-      /**
-       * Determine if a point is on or nearly on this rectangle.
-       * @param p - Point to test
-       * @returns Is the point on the rectangle boundary?
-       */
-      pointIsOn(p: Canvas.Point): boolean;
-
-      /**
-       * Calculate the rectangle Zone for a given point located around, on, or in the rectangle.
-       * See https://en.wikipedia.org/wiki/Cohen%E2%80%93Sutherland_algorithm
-       * This differs from _getZone in how points on the edge are treated: they are not considered inside.
-       * @param point - A point to test for location relative to the rectangle
-       * @returns Which edge zone does the point belong to?
-       */
-      _getEdgeZone(point: Canvas.Point): PIXI.Rectangle.CS_ZONES;
-
-      /**
-       * Get all the points (corners) for a polygon approximation of a rectangle between two points on the rectangle.
-       * The two points can be anywhere in 2d space on or outside the rectangle.
-       * The starting and ending side are based on the zone of the corresponding a and b points.
-       * (See PIXI.Rectangle.CS_ZONES.)
-       * This is the rectangular version of PIXI.Circle.prototype.pointsBetween, and is similarly used
-       * to draw the portion of the shape between two intersection points on that shape.
-       * @param a - A point on or outside the rectangle, representing the starting position.
-       * @param b - A point on or outside the rectangle, representing the starting position.
-       * @returns Points returned are clockwise from start to end.
-       */
-      pointsBetween(a: Canvas.Point, b: Canvas.Point): Canvas.Point[];
-
-      /**
-       * Get all intersection points for a segment A|B
-       * Intersections are sorted from A to B.
-       * @param a - Endpoint A of the segment
-       * @param b - Endpoint B of the segment
-       * @returns Array of intersections or empty if no intersection.
-       *  If A|B is parallel to an edge of this rectangle, returns the two furthest points on
-       *  the segment A|B that are on the edge.
-       *  The return object's t0 property signifies the location of the intersection on segment A|B.
-       *  This will be NaN if the segment is a point.
-       *  The return object's t1 property signifies the location of the intersection on the rectangle edge.
-       *  The t1 value is measured relative to the intersecting edge of the rectangle.
-       */
-      segmentIntersections(a: Canvas.Point, b: Canvas.Point): Canvas.Point[];
-
-      /**
-       * Compute the intersection of this Rectangle with some other Rectangle.
-       * @param other - Some other rectangle which intersects this one
-       * @returns The intersected rectangle
-       */
-      intersection(other: PIXI.Rectangle): PIXI.Rectangle;
-
-      /**
-       * Convert this PIXI.Rectangle into a PIXI.Polygon
-       * @returns The Rectangle expressed as a PIXI.Polygon
-       */
-      toPolygon(): PIXI.Polygon;
-
-      /**
-       * Get the left edge of this rectangle.
-       * The returned edge endpoints are oriented clockwise around the rectangle.
-       */
-      get leftEdge(): PIXI.Rectangle.Edge;
-
-      /**
-       * Get the right edge of this rectangle.
-       * The returned edge endpoints are oriented clockwise around the rectangle.
-       */
-      get rightEdge(): PIXI.Rectangle.Edge;
-
-      /**
-       * Get the top edge of this rectangle.
-       * The returned edge endpoints are oriented clockwise around the rectangle.
-       */
-      get topEdge(): PIXI.Rectangle.Edge;
-
-      /**
-       * Get the bottom edge of this rectangle.
-       * The returned edge endpoints are oriented clockwise around the rectangle.
-       */
-      get bottomEdge(): PIXI.Rectangle.Edge;
-
-      /**
-       * Calculate the rectangle Zone for a given point located around or in the rectangle.
-       * https://en.wikipedia.org/wiki/Cohen%E2%80%93Sutherland_algorithm
-       *
-       * @param p - Point to test for location relative to the rectangle
-       */
-      _getZone(p: Canvas.Point): PIXI.Rectangle.CS_ZONES;
-
-      /**
-       * Test whether a line segment AB intersects this rectangle.
-       * @param a       - The first endpoint of segment AB
-       * @param b       - The second endpoint of segment AB
-       * @param options - Options affecting the intersect test.
-       * @returns True if intersects.
-       */
-      lineSegmentIntersects(
-        a: Canvas.Point,
-        b: Canvas.Point,
-        options?: PIXI.Rectangle.LineSegmentIntersectsOptions,
-      ): boolean;
-
-      /**
-       * Intersect this PIXI.Rectangle with a PIXI.Polygon.
-       * @param polygon - A PIXI.Polygon
-       * @param options - Options which configure how the intersection is computed
-       * @returns The intersected polygon
-       */
-      intersectPolygon(polygon: PIXI.Polygon, options?: PIXI.Rectangle.WACIntersectPolygonOptions): PIXI.Polygon;
-      intersectPolygon(polygon: PIXI.Polygon, options?: PIXI.Rectangle.ClipperLibIntersectPolygonOptions): PIXI.Polygon;
-
-      /**
-       * Intersect this PIXI.Rectangle with an array of ClipperPoints. Currently, uses the clipper library.
-       * In the future we may replace this with more specialized logic which uses the line-line intersection formula.
-       * @param clipperPoints - Array of ClipperPoints generated by PIXI.Polygon.toClipperPoints()
-       * @param options       - Options which configure how the intersection is computed
-       * @returns The intersected polygon
-       * @remarks Foundry has this typed as returning `PIXI.Polygon | null`, but this method will actually
-       * return an empty array if this rectangle's width or height are 0. This is almost certainly a bug.
-       */
-      intersectClipper(
-        clipperPoints: PIXI.Polygon.ClipperPoint[],
-        options?: PIXI.Polygon.IntersectClipperOptions,
-      ): PIXI.Polygon | [];
-
-      /**
-       * Determine whether some other Rectangle overlaps with this one.
-       * This check differs from the parent class Rectangle#intersects test because it is true for adjacency (zero area).
-       * @param other - Some other rectangle against which to compare
-       * @returns Do the rectangles overlap?
-       */
-      overlaps(other: PIXI.Rectangle): boolean;
-
-      /**
-       * Normalize the width and height of the rectangle in-place, enforcing that those dimensions be positive.
-       */
-      normalize(): PIXI.Rectangle;
-
-      /**
-       * Fits this rectangle around this rectangle rotated around the given pivot counterclockwise by the given angle in radians.
-       * @param radians - The angle of rotation.
-       * @param pivot   - An optional pivot point (normalized).
-       * @returns A new rotated rectangle
-       */
-      rotate(radians: number, pivot?: PIXI.Point): PIXI.Rectangle;
-    }
-
-    namespace Rectangle {
-      type CS_ZONES = Brand<number, "PIXI.Rectangle.CS_ZONES">;
-
-      interface CS_Zones {
-        INSIDE: 0x0000 & CS_ZONES;
-        LEFT: 0x0001 & CS_ZONES;
-        RIGHT: 0x0010 & CS_ZONES;
-        TOP: 0x1000 & CS_ZONES;
-        BOTTOM: 0x0100 & CS_ZONES;
-        TOPLEFT: 0x1001 & CS_ZONES;
-        TOPRIGHT: 0x1010 & CS_ZONES;
-        BOTTOMRIGHT: 0x0110 & CS_ZONES;
-        BOTTOMLEFT: 0x0101 & CS_ZONES;
-      }
-
-      interface Edge {
-        A: Canvas.Point;
-        B: Canvas.Point;
-      }
-
-      /** @internal */
-      type _LineSegmentIntersectsOptions = InexactPartial<{
-        /**
-         * If true, a line contained within the rectangle will return true
-         * @defaultValue `false`
-         * @remarks Can't be `null` as it only has a parameter default
-         */
-        inside: boolean;
-      }>;
-
-      /** Options affecting the intersect test. */
-      interface LineSegmentIntersectsOptions extends _LineSegmentIntersectsOptions {}
-
-      /** @remarks The options for `intersectPolygon` when `weilerAtherton` is true (or not provided) */
-      interface WACIntersectPolygonOptions extends WeilerAthertonClipper._CombineOptions {
-        /**
-         * One of CLIP_TYPES
-         * @defaultValue `WeilerAthertonClipper.CLIP_TYPES.INTERSECT`
-         * @remarks Default provided by `??=` in function body
-         *
-         * The default is actually `ClipperLib.ClipType.ctIntersection`, but that and `.ctUnion` are
-         * equivalent to  `WeilerAthertonClipper.CLIP_TYPES.INTERSECT` and `.UNION` respectively at runtime
-         */
-        clipType?:
-          | WeilerAthertonClipper.CLIP_TYPES
-          | (typeof ClipperLib.ClipType)["ctIntersection" | "ctUnion"]
-          | undefined
-          | null;
-
-        /**
-         * Use the Weiler-Atherton algorithm. Otherwise, use Clipper.
-         * @defaultValue `true`
-         */
-        weilerAtherton?: true;
-      }
-
-      /** @remarks The options for `intersectPolygon` when `weilerAtherton` is false. */
-      interface ClipperLibIntersectPolygonOptions extends PIXI.Polygon.ClipperPointsOptions {
-        /**
-         * One of CLIP_TYPES
-         * @defaultValue `ClipperLib.ClipType.ctIntersection`
-         * @remarks Default provided by `??=` in function body
-         *
-         * `WeilerAthertonClipper.CLIP_TYPES.INTERSECT` and `.UNION` are equivalent to
-         * `ClipperLib.ClipType.ctIntersection` and `.ctUnion` respectively at runtime
-         */
-        clipType?: ClipperLib.ClipType | WeilerAthertonClipper.CLIP_TYPES | null | undefined;
-
-        /**
-         * Use the Weiler-Atherton algorithm. Otherwise, use Clipper.
-         * @defaultValue `true`
-         */
-        weilerAtherton: false;
-      }
-    }
-
-    class Rectangle extends _PIXI.Rectangle {
-      /**
-       * Create normalized rectangular bounds given a rectangle shape and an angle of central rotation.
-       * @param x       - The top-left x-coordinate of the un-rotated rectangle
-       * @param y       - The top-left y-coordinate of the un-rotated rectangle
-       * @param width   - The width of the un-rotated rectangle
-       * @param height  - The height of the un-rotated rectangle
-       * @param radians - The angle of rotation about the center
-       * @param pivot   - An optional pivot point (if not provided, the pivot is the centroid)
-       * @param _outRect - (Internal)
-       * @returns The constructed rotated rectangle bounds
-       */
-      static fromRotation(
-        x: number,
-        y: number,
-        width: number,
-        height: number,
-        radians: number,
-        pivot?: PIXI.Point,
-        _outRect?: PIXI.Rectangle,
-      ): PIXI.Rectangle;
-    }
-  }
-}