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

package/src/foundry/client/canvas/extensions/polygon-extension.d.mts

@@ -0,0 +1,175 @@
+import type { InexactPartial } from "#utils";
+import type { Canvas } from "#client/canvas/_module.d.mts";
+import * as _PIXI from "pixi.js";
+
+export default function extendPIXIPolygon(): void;
+
+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".
+       * @remarks `defineProperty`'d with no explicit options
+       */
+      get isPositive(): boolean;
+
+      /**
+       * @defaultValue `undefined`
+       * @remarks `defineProperty`'d with explicit `{value: undefined, writable: true, enumerable: false}`
+       */
+      _isPositive: boolean | undefined;
+
+      /**
+       * 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. {@link 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 {@linkcode _PIXI.Polygon | PIXI.Polygon}.
+       * The bounding rectangle is normalized such that the width and height are non-negative.
+       * @returns The bounding {@linkcode _PIXI.Rectangle | PIXI.Rectangle}
+       */
+      getBounds(): PIXI.Rectangle;
+
+      /**
+       * Convert a {@linkcode _PIXI.Polygon | PIXI.Polygon} into an array of {@link PIXI.Polygon.ClipperPoint | 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 {@linkcode _PIXI.Polygon | PIXI.Polygon} is closed, defined by having the same starting and ending point.
+       * @remarks `defineProperty`'d with explicit `{enumerable: false}`
+       */
+      get isClosed(): boolean;
+
+      /**
+       * Intersect this {@linkcode _PIXI.Polygon | 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 {@linkcode _PIXI.Polygon | PIXI.Polygon} with an array of {@linkcode PIXI.Polygon.ClipperPoint | ClipperPoint}s.
+       * @param clipperPoints - Array of clipper points generated by {@linkcode PIXI.Polygon.toClipperPoints | PIXI.Polygon#toClipperPoints()}
+       * @param options       - Options which configure how the intersection is computed
+       * @returns The resulting `ClipperPoint`s
+       */
+      intersectClipper(
+        clipperPoints: PIXI.Polygon.ClipperPoint[],
+        options?: PIXI.Polygon.IntersectClipperOptions,
+      ): PIXI.Polygon.ClipperPoint[];
+
+      /**
+       * Intersect this {@linkcode _PIXI.Polygon | PIXI.Polygon} with a {@linkcode _PIXI.Circle | PIXI.Circle}.
+       * For now, convert the circle to a `Polygon` approximation and use {@linkcode 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
+       * @remarks Actually just calls {@linkcode PIXI.Circle.intersectPolygon | circle.intersectPolygon(this, options)}
+       */
+      intersectCircle(circle: PIXI.Circle, options?: PIXI.Circle.IntersectClipperOptions): PIXI.Polygon;
+
+      /**
+       * Intersect this {@linkcode _PIXI.Polygon | PIXI.Polygon} with a {@linkcode _PIXI.Rectangle | PIXI.Rectangle}.
+       * For now, convert the rectangle to a `Polygon` and use {@linkcode 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
+       * @remarks Actually just calls {@linkcode PIXI.Rectangle.intersectPolygon | rect.intersectPolygon(this, options)}
+       */
+      intersectRectangle(rect: PIXI.Rectangle, options?: PIXI.Rectangle.WACIntersectPolygonOptions): PIXI.Polygon;
+      intersectRectangle(
+        rect: PIXI.Rectangle,
+        options?: PIXI.Rectangle.ClipperLibIntersectPolygonOptions,
+      ): PIXI.Polygon;
+    }
+
+    namespace Polygon {
+      type PointsFlat = number[];
+      type Points = PointsFlat | PIXI.IPointData[];
+
+      /** @remarks Foundry uses this type instead of full {@linkcode ClipperLib.IntPoint} objects */
+      interface ClipperPoint {
+        X: number;
+        Y: number;
+      }
+
+      /** @internal */
+      type _IntersectCommonOptions = InexactPartial<{
+        /**
+         * The clipper clip type
+         * @defaultValue {@linkcode ClipperLib.ClipType.ctIntersection}
+         */
+        clipType: ClipperLib.ClipType;
+      }>;
+
+      interface IntersectPolygonOptions extends _IntersectCommonOptions {
+        /**
+         * A scaling factor passed to {@linkcode PIXI.Polygon.toClipperPoints | Polygon#toClipperPoints} to preserve precision
+         * @defaultValue {@linkcode CONST.CLIPPER_SCALING_FACTOR}
+         */
+        scalingFactor?: number | undefined;
+      }
+
+      interface IntersectClipperOptions extends _IntersectCommonOptions {
+        /**
+         * A scaling factor passed to {@linkcode PIXI.Polygon.toClipperPoints | Polygon#toClipperPoints} to preserve precision
+         * @defaultValue `1`
+         */
+        scalingFactor?: number | undefined;
+      }
+
+      interface ClipperPointsOptions {
+        /**
+         * A scaling factor used to preserve floating point precision
+         * @defaultValue `1`
+         */
+        scalingFactor?: number | undefined;
+      }
+    }
+
+    class Polygon extends _PIXI.Polygon {
+      /**
+       * Construct a {@linkcode _PIXI.Polygon | PIXI.Polygon} instance from an array of {@link PIXI.Polygon.ClipperPoint | clipper points} `[{X,Y}, ...]`.
+       * @param points  - An array of points returned by clipper
+       * @param options - Options which affect how canvas points are generated
+       * @returns The resulting `PIXI.Polygon`
+       */
+      static fromClipperPoints(
+        points: PIXI.Polygon.ClipperPoint[],
+        options?: PIXI.Polygon.ClipperPointsOptions,
+      ): PIXI.Polygon;
+    }
+  }
+}

package/src/foundry/client/canvas/extensions/rectangle-extension.d.mts

@@ -0,0 +1,287 @@
+import type { Brand, InexactPartial } from "#utils";
+import type { Canvas } from "#client/canvas/_module.d.mts";
+import type { WeilerAthertonClipper } from "#client/canvas/geometry/_module.d.mts";
+import * as _PIXI from "pixi.js";
+
+export default function extendPIXIRectangle(): void;
+
+declare global {
+  namespace PIXI {
+    interface Rectangle {
+      /**
+       * Calculate center of this rectangle.
+       * @remarks `defineProperty`'d with no explicit options
+       */
+      get center(): Canvas.Point;
+
+      /**
+       * Return the bounding box for a {@linkcode _PIXI.Rectangle | 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 {@link https://en.wikipedia.org/wiki/Cohen%E2%80%93Sutherland_algorithm}
+       * This differs from {@linkcode _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 {@linkcode PIXI.Rectangle.CS_ZONES}.)
+       *
+       * This is the rectangular version of {@linkcode PIXI.Circle.pointsBetween | PIXI.Circle#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 {@linkcode _PIXI.Rectangle | PIXI.Rectangle} into a {@linkcode _PIXI.Polygon | 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.
+       * @remarks `defineProperty`'d with no explicit options
+       */
+      get leftEdge(): PIXI.Rectangle.Edge;
+
+      /**
+       * Get the right edge of this rectangle.
+       * The returned edge endpoints are oriented clockwise around the rectangle.
+       * @remarks `defineProperty`'d with no explicit options
+       */
+      get rightEdge(): PIXI.Rectangle.Edge;
+
+      /**
+       * Get the top edge of this rectangle.
+       * The returned edge endpoints are oriented clockwise around the rectangle.
+       * @remarks `defineProperty`'d with no explicit options
+       */
+      get topEdge(): PIXI.Rectangle.Edge;
+
+      /**
+       * Get the bottom edge of this rectangle.
+       * The returned edge endpoints are oriented clockwise around the rectangle.
+       * @remarks `defineProperty`'d with no explicit options
+       */
+      get bottomEdge(): PIXI.Rectangle.Edge;
+
+      /**
+       * Calculate the rectangle Zone for a given point located around or in the rectangle.
+       * {@link 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 {@linkcode _PIXI.Rectangle | PIXI.Rectangle} with a {@linkcode _PIXI.Polygon | 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 {@linkcode _PIXI.Rectangle | PIXI.Rectangle} with an array of {@linkcode PIXI.Polygon.ClipperPoint | ClipperPoint}s.
+       * Currently, uses the {@linkcode ClipperLib | clipper} library. In the future we may replace this with more specialized logic which
+       * uses the line-line intersection formula.
+       * @param clipperPoints - Array of `ClipperPoint`s generated by {@linkcode PIXI.Polygon.toClipperPoints | PIXI.Polygon#toClipperPoints()}
+       * @param options       - Options which configure how the intersection is computed
+       * @returns The array of intersection points
+       */
+      intersectClipper(
+        clipperPoints: PIXI.Polygon.ClipperPoint[],
+        options?: PIXI.Polygon.IntersectClipperOptions,
+      ): PIXI.Polygon.ClipperPoint[];
+
+      /**
+       * Determine whether some other {@linkcode _PIXI.Rectangle | Rectangle} overlaps with this one.
+       * This check differs from the parent class {@linkcode _PIXI.Rectangle.intersects | 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`
+         */
+        inside: boolean;
+      }>;
+
+      /** Options affecting the intersect test. */
+      interface LineSegmentIntersectsOptions extends _LineSegmentIntersectsOptions {}
+
+      /**
+       * @remarks The options for {@linkcode PIXI.Rectangle.intersectPolygon | #intersectPolygon} when `weilerAtherton` is true (or not provided)
+       *
+       * This path does not use the `scalingFactor` property, and borrows `canMutate` from the WAC type
+       */
+      interface WACIntersectPolygonOptions extends WeilerAthertonClipper._CombineOptions {
+        /**
+         * One of {@linkcode WeilerAthertonClipper.ClipTypes | CLIP_TYPES}
+         * @defaultValue {@linkcode WeilerAthertonClipper.CLIP_TYPES.INTERSECT}
+         * @remarks The default is actually {@linkcode ClipperLib.ClipType.ctIntersection}, but that and {@linkcode ClipperLib.ClipType.ctUnion | ctUnion} are
+         * equivalent to `WeilerAthertonClipper.CLIP_TYPES.INTERSECT` and {@linkcode WeilerAthertonClipper.CLIP_TYPES.UNION | UNION} respectively at runtime
+         */
+        clipType?:
+          | WeilerAthertonClipper.CLIP_TYPES
+          | (typeof ClipperLib.ClipType)["ctIntersection" | "ctUnion"]
+          | undefined;
+
+        /**
+         * Use the Weiler-Atherton algorithm. Otherwise, use Clipper.
+         * @defaultValue `true`
+         */
+        weilerAtherton?: true | undefined;
+      }
+
+      /**
+       * @remarks The options for {@linkcode PIXI.Rectangle.intersectPolygon | #intersectPolygon} when `weilerAtherton` is false.
+       *
+       * This path does not use the `canMutate` property, but does include `scalingFactor` with a default of {@linkcode CONST.CLIPPER_SCALING_FACTOR},
+       * borrowed from the `Polygon` interface
+       */
+      interface ClipperLibIntersectPolygonOptions extends Pick<PIXI.Polygon.IntersectPolygonOptions, "scalingFactor"> {
+        /**
+         * One of {@linkcode ClipperLib.ClipTypes | CLIP_TYPES}
+         * @defaultValue {@linkcode ClipperLib.ClipType.ctIntersection}
+         * @remarks {@linkcode WeilerAthertonClipper.CLIP_TYPES.INTERSECT} and {@linkcode WeilerAthertonClipper.CLIP_TYPES.UNION | .UNION} are equivalent to
+         * {@linkcode ClipperLib.ClipType.ctIntersection} and {@linkcode ClipperLib.ClipType.ctUnion | ctUnion} respectively at runtime
+         */
+        clipType?: ClipperLib.ClipType | WeilerAthertonClipper.CLIP_TYPES | undefined;
+
+        /**
+         * Use the Weiler-Atherton algorithm. Otherwise, use Clipper.
+         * @defaultValue `true`
+         */
+        weilerAtherton: false;
+      }
+    }
+
+    class Rectangle extends _PIXI.Rectangle {
+      /**
+       * Bit code labels splitting a rectangle into zones, based on the Cohen-Sutherland algorithm.
+       * See {@link 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
+       */
+      static CS_ZONES: PIXI.Rectangle.CS_Zones;
+
+      /**
+       * 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;
+    }
+  }
+}

package/src/foundry/client/canvas/framebuffer-snapshot.d.mts

@@ -0,0 +1,33 @@
+import type { Identity } from "#utils";
+
+/**
+ * Provide the necessary methods to get a snapshot of the framebuffer into a render texture.
+ * Class meant to be used as a singleton.
+ * Created with the precious advices of dev7355608.
+ */
+declare class FramebufferSnapshot {
+  /**
+   * The RenderTexture that is the render destination for the framebuffer snapshot.
+   */
+  framebufferTexture: PIXI.RenderTexture;
+
+  /**
+   * Get the framebuffer texture snapshot.
+   * @param renderer - The renderer for this context.
+   * @returns The framebuffer snapshot.
+   */
+  getFramebufferTexture(renderer: PIXI.Renderer): PIXI.RenderTexture;
+
+  #FramebufferSnapshot: true;
+}
+
+declare namespace FramebufferSnapshot {
+  interface Any extends AnyFramebufferSnapshot {}
+  interface AnyConstructor extends Identity<typeof AnyFramebufferSnapshot> {}
+}
+
+export default FramebufferSnapshot;
+
+declare abstract class AnyFramebufferSnapshot extends FramebufferSnapshot {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/geometry/_module.d.mts

@@ -0,0 +1,17 @@
+// In Foundry itself this file contains re-exports of these other modules.
+// Therefore it has a runtime effect and uses `.mjs` instead of `.d.mts`.
+// While `.mts` could work, to avoid `import-x/no-unresolved` from erroring `.mjs` is used.
+/* eslint-disable import-x/extensions */
+
+export * as types from "./_types.mjs";
+export * as edges from "./edges/_module.mjs";
+
+export { default as Quadtree, CanvasQuadtree } from "./quad-tree.mjs";
+export { default as UnboundTransform } from "./unbound-transform.mjs";
+export { default as LimitedAnglePolygon } from "./shapes/limited-angle-polygon.mjs";
+export { default as PolygonMesher } from "./shapes/polygon-mesher.mjs";
+export { default as Ray } from "./shapes/ray.mjs";
+export { default as PointSourcePolygon } from "./shapes/source-polygon.mjs";
+export { default as ObservableTransform } from "./observable-transform.mjs";
+export { default as ClockwiseSweepPolygon } from "./clockwise-sweep.mjs";
+export { default as WeilerAthertonClipper } from "./weiler-atherton-clipping.mjs";

package/src/foundry/client/canvas/geometry/_types.d.mts

@@ -0,0 +1,34 @@
+import type { Edge, PolygonVertex } from "./edges/_module.d.mts";
+import type { ClockwiseSweepPolygon, PointSourcePolygon, Ray, Quadtree } from "./_module.mjs";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
+// After seeing that none of these types add anything or are even exported a
+// very reasonable question may be: Why on earth does this file exist?
+//
+// Well this is the file in which Foundry defines these types. We don't house
+// them here because it has poor discoverability. It's also just nice to
+// have as reference to keep us synced with the latest version of Foundry.
+
+export {};
+
+type ClipperPoint = PIXI.Polygon.ClipperPoint;
+
+type EdgeType = Edge.EdgeTypes;
+
+type EdgeOptions = ClockwiseSweepPolygon.EdgeOptions;
+
+type PointSourcePolygonType = PointSourcePolygon.PolygonType;
+
+type PointSourcePolygonConfig = PointSourcePolygon.Config;
+
+type ClockwiseSweepPolygonConfig = ClockwiseSweepPolygon.Config;
+
+type RayIntersection = Ray.Intersection;
+
+type QuadtreeObject<T> = Quadtree.Object<T>;
+
+type VertexMap = Map<number, PolygonVertex>;
+
+type EdgeSet = Set<Edge>;
+
+type PolygonRay = ClockwiseSweepPolygon.Ray;