@league-of-foundry-developers/foundry-vtt-types 13.340.0 → 13.340.1

package/src/foundry/client-esm/canvas/edges/vertex.d.mts

@@ -1,13 +1,12 @@
-import type { NullishProps } from "../../../../utils/index.d.mts";
+import type { Identity, NullishProps } from "fvtt-types/utils";
 import type Edge from "./edge.d.mts";
 
 /**
  * A specialized point data structure used to represent vertices in the context of the ClockwiseSweepPolygon.
  * This class is not designed or intended for use outside of that context.
- * @internal
  */
 declare class PolygonVertex {
-  constructor(x: number, y: number, options?: PolygonVertex.ConstructorOptions);
+  constructor(x: number, y: number, { distance, index }?: PolygonVertex.ConstructorOptions);
 
   x: number;
 
@@ -18,7 +17,7 @@ declare class PolygonVertex {
 
   /**
    * @defaultValue `undefined`
-   * @remarks Accessed externally in {@link ClockwiseSweepPolygon#_testCollision}
+   * @remarks Accessed externally in {@link ClockwiseSweepPolygon._testCollision | `ClockwiseSweepPolygon#_testCollision`}
    */
   _distance: number | undefined | null;
 
@@ -108,10 +107,9 @@ declare class PolygonVertex {
   /**
    * Record whether this PolygonVertex has been visited in the sweep
    * @defaultValue `false`
-   * @remarks Set externally during `ClockwiseSweeepPolygon` initialization
-   * @privateRemarks Foundry marked `@internal`
+   * @remarks Foundry marked `@internal`, set externally during `ClockwiseSweepPolygon` initialization
    */
-  _visited: boolean;
+  protected _visited: boolean;
 
   /**
    * Is this vertex limited in type?
@@ -131,7 +129,10 @@ declare class PolygonVertex {
    */
   get isTerminal(): boolean;
 
-  /**declareme point?
+  /**
+   * Is this vertex the same point as some other vertex?
+   * @param other - Some other vertex
+   * @returns Are they the same point?
    */
   equals(other: PolygonVertex): boolean;
 
@@ -141,12 +142,13 @@ declare class PolygonVertex {
    * @param options - Additional options that apply to this vertex
    * @returns The constructed vertex
    */
+  // options: not null (destructured when passed to `new this()`)
   static fromPoint(point: Canvas.Point, options?: PolygonVertex.ConstructorOptions): PolygonVertex;
 }
 
 declare namespace PolygonVertex {
   interface Any extends AnyPolygonVertex {}
-  type AnyConstructor = typeof AnyPolygonVertex;
+  interface AnyConstructor extends Identity<typeof AnyPolygonVertex> {}
 
   /** @internal */
   type _ConstructorOptions = NullishProps<{
@@ -158,7 +160,7 @@ declare namespace PolygonVertex {
 }
 
 declare abstract class AnyPolygonVertex extends PolygonVertex {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }
 
 export default PolygonVertex;

package/src/foundry/client-esm/canvas/regions/geometry.d.mts

@@ -1,31 +1,38 @@
 /**
- * The geometry of a {@link Region}.
+ * The geometry of a {@link Region | `Region`}.
  * - Vertex Attribute: `aVertexPosition` (`vec2`)
  * - Draw Mode: `PIXI.DRAW_MODES.TRIANGLES`
  */
 declare class RegionGeometry extends PIXI.Geometry {
   /**
    * Create a RegionGeometry
-   * @internal
+   * @remarks Foundry marked `@internal`
    */
-  constructor(region: Region.ConfiguredInstance);
+  constructor(region: Region.Implementation);
 
   /** The Region this geometry belongs to */
-  get region(): Region.ConfiguredInstance;
+  get region(): Region.Implementation;
 
   /**
    * Update the buffers
-   * @internal
+   * @remarks Foundry marked `@internal`, is exclusively called externally in `Region##updateShapes`
    */
   protected _clearBuffers(): void;
 
   /**
    * Update the buffers
-   * @internal
+   * @remarks Foundry marked `@internal`, is exclusively called externally in `Region##updateShapes`
    */
   protected _updateBuffers(): void;
+}
+
+declare namespace RegionGeometry {
+  interface Any extends AnyRegionGeometry {}
+  type AnyConstructor = typeof AnyRegionGeometry;
+}
 
-  #regionGeometry: true;
+declare abstract class AnyRegionGeometry extends RegionGeometry {
+  constructor(...args: never);
 }
 
 export default RegionGeometry;

package/src/foundry/client-esm/canvas/regions/mesh.d.mts

@@ -1,50 +1,49 @@
-/** A mesh of a {@link Region} */
+/** A mesh of a {@link Region | `Region`} */
 declare class RegionMesh extends PIXI.Container {
-  #regionMesh: true;
-
   /**
    * Create a RegionMesh
    * @param region        - The Region to create the RegionMesh from.
-   * @param shaderClass   - The shader class to use. @defaultValue `RegionShader`
+   * @param shaderClass   - The shader class to use. (default: `RegionShader`)
    */
-  constructor(region: Region.ConfiguredInstance, shaderClass?: AbstractBaseShader);
+  // shaderClass: not null (parameter default only)
+  constructor(region: Region.Implementation, shaderClass?: AbstractBaseShader.AnyConstructor);
 
   /** The Region of this RegionMesh */
-  get region(): Region.ConfiguredInstance;
+  get region(): Region.Implementation;
 
   /** The shader bound to this RegionMesh */
   get shader(): AbstractBaseShader;
 
   /** The blend mode assigned tot his RegionMesh */
   get blendMode(): PIXI.BLEND_MODES;
-  set blendMode(value: PIXI.BLEND_MODES);
+  set blendMode(value);
 
   /**
    * The tint applied to the mesh. This is a hex value.
    *
    * A value of 0xFFFFFF will remove any tint effect.
-   * @defaultValue 0xFFFFFF
+   * @defaultValue `0xFFFFFF`
    */
   get tint(): number;
-  set tint(value: number);
+  set tint(value);
 
   /** The tint applied to the mesh. This is a hex value. A value of 0xFFFFFF will remove any tint effect. */
   protected _tintColor: PIXI.Color;
 
   /**
    * Cached tint value for the shader uniforms
-   * @internal
+   * @remarks Foundry marked `@internal`
    */
-  protected _cachedTint: [red: number, green: number, blue: number, alpha: number];
+  protected _cachedTint: Color.RGBAColorVector;
 
   /** Used to track a tint or alpha change to execute a recomputation of _cachedTint. */
   protected _tintAlphaDirty: boolean;
 
   /**
    * Initialize shader based on the shader class type.
-   * @param shaderClass   - The shader class, which must inherit from {@link AbstractBaseShader}.
+   * @param shaderClass - The shader class, which must inherit from {@link AbstractBaseShader | `AbstractBaseShader`}.
    */
-  setShaderClass(shaderClass: typeof AbstractBaseShader): void;
+  setShaderClass(shaderClass: AbstractBaseShader.AnyConstructor): void;
 
   override updateTransform(): void;
 
@@ -52,10 +51,22 @@ declare class RegionMesh extends PIXI.Container {
 
   protected override _calculateBounds(): void;
 
-  /** Tests if a point is indie this RegionMesh */
+  /**
+   * Tests if a point is inside this RegionMesh.
+   * @privateRemarks The rare instance of Foundry using the PIXI interface in *their* types
+   */
   containsPoint(point: PIXI.IPointData): boolean;
 
   override destroy(options?: PIXI.IDestroyOptions | boolean): void;
 }
 
+declare namespace RegionMesh {
+  interface Any extends AnyRegionMesh {}
+  type AnyConstructor = typeof AnyRegionMesh;
+}
+
+declare abstract class AnyRegionMesh extends RegionMesh {
+  constructor(...args: never);
+}
+
 export default RegionMesh;

package/src/foundry/client-esm/canvas/regions/polygon-tree.d.mts

@@ -1,13 +1,11 @@
-import type { Point } from "@common/_types.d.mts";
+import type { Point } from "#common/_types.d.mts";
 
-/** The node of a {@link RegionPolygonTree}.*/
+/** The node of a {@link RegionPolygonTree | `RegionPolygonTree`}.*/
 declare class RegionPolygonTreeNode {
-  #regionPolygonTreeNode: true;
-
   /**
    * Create a RegionPolygonTreeNode.
    * @param parent    - The parent node.
-   * @internal
+   * @remarks Foundry marked `@internal`
    */
   constructor(parent: RegionPolygonTreeNode | null);
 
@@ -15,62 +13,77 @@ declare class RegionPolygonTreeNode {
    * Create a node from the Clipper path and add it to the children of the parent.
    * @param clipperPath   - The clipper path of this node.
    * @param parent        - The parent node or `null` if root.
-   * @internal
+   * @remarks Foundry marked `@internal`, called exclusively  {@link RegionPolygonTree._fromClipperPolyTree | `RegionPolygonTree._fromClipperPolyTree`}
    */
-  static _fromClipperPath(
-    clipperPath: ClipperLib.IntPoint[],
+  protected static _fromClipperPath(
+    clipperPath: ClipperLib.Path,
     parent: RegionPolygonTreeNode | null,
   ): RegionPolygonTreeNode;
 
   /** The parent of this node or `null` if this is the root node. */
   get parent(): RegionPolygonTreeNode | null;
 
-  /** The children of this node. */
-  get children(): ReadonlyArray<RegionPolygonTreeNode>;
+  /**
+   * The children of this node.
+   * @remarks Foundry types this as `ReadonlyArray<>`, but does nothing to prevent writes
+   * at runtime, just returning a reference to `this.#children`
+   */
+  get children(): RegionPolygonTreeNode[];
 
   /**
    * The depth of this node.
+   *
    * The depth of the root node is 0.
    */
   get depth(): number;
 
   /**
    * Is this a hole?
+   *
    * The root node is a hole.
    */
   get isHole(): boolean;
 
   /**
    * The Clipper path of this node.
+   *
    * It is empty in case of the root node.
+   * @remarks Foundry types this as `ReadonlyArray<>`, but does nothing to prevent writes
+   * at runtime, just returning a reference to `this.#clipperPath`
    */
-  get clipperPath(): ReadonlyArray<ClipperLib.IntPoint> | null;
+  get clipperPath(): ClipperLib.Path | null;
 
   /**
    * The polygon of this node.
+   *
    * It is `null` in case of the root node.
    */
   get polygon(): PIXI.Polygon | null;
 
   /**
    * The points of the polygon ([x0, y0, x1, y1, ...]).
+   *
    * They are `null` in case of the root node.
+   * @remarks Foundry types this as `ReadonlyArray<>`, but does nothing to prevent writes
+   * at runtime, just returning a reference to `this.polygon.points`
    */
-  get points(): ReadonlyArray<number> | null;
+  get points(): number[] | null;
 
   /**
    * The bounds of the polygon.
+   *
    * They are `null` in case of the root node.
    */
   get bounds(): PIXI.Rectangle | null;
 
+  /** @privateRemarks Recursively iterates all child nodes */
   [Symbol.iterator](): Generator<RegionPolygonTreeNode>;
 
   /**
    * Test whether given point is contained within this node.
-   * @param point     - The point.
+   * @param point - The point.
    */
-  testPoint(point: Point): boolean;
+  testPoint(point: Canvas.Point): boolean;
 
   /**
    * Test circle containment/intersection with this node.
@@ -80,22 +93,40 @@ declare class RegionPolygonTreeNode {
    *                  - 0: the circle is intersects the boundary.
    *                  - 1: the circle is in the interior and does not intersect the boundary.
    */
-  testCircle(center: Point, radius: number): -1 | 0 | 1;
+  testCircle(center: Canvas.Point, radius: number): -1 | 0 | 1;
 }
 
-/** The polygon tree of a {@link Region}. */
+declare namespace RegionPolygonTreeNode {
+  interface Any extends AnyRegionPolygonTreeNode {}
+  type AnyConstructor = typeof AnyRegionPolygonTreeNode;
+}
+
+/** The polygon tree of a {@link Region | `Region`}. */
 declare class RegionPolygonTree extends RegionPolygonTreeNode {
   /**
    * Create a RegionPolygonTree
-   * @internal
+   * @remarks Foundry marked `@internal`
    */
   constructor();
 
   /**
    * Create the tree from a Clipper polygon tree.
-   * @internal
+   * @remarks Foundry marked `@internal`, called exclusively from {@link Region#polygonTree | `Region#polygonTree`}
    */
-  static _fromClipperPolyTree(clipperPolyTree: ClipperLib.PolyTree): RegionPolygonTree;
+  protected static _fromClipperPolyTree(clipperPolyTree: ClipperLib.PolyTree): RegionPolygonTree;
+}
+
+declare namespace RegionPolygonTree {
+  interface Any extends AnyRegionPolygonTree {}
+  type AnyConstructor = typeof AnyRegionPolygonTree;
+}
+
+declare abstract class AnyRegionPolygonTreeNode extends RegionPolygonTreeNode {
+  constructor(...args: never);
+}
+
+declare abstract class AnyRegionPolygonTree extends RegionPolygonTree {
+  constructor(...args: never);
 }
 
 export default RegionPolygonTree;

package/src/foundry/client-esm/canvas/regions/shape.d.mts

@@ -1,39 +1,22 @@
 import type { CircleShapeData, EllipseShapeData, PolygonShapeData, RectangleShapeData } from "../../data/_module.d.mts";
 
-declare namespace RegionShape {
-  type Any = RegionShape<any>;
-
-  type ShapeData = CircleShapeData | EllipseShapeData | PolygonShapeData | RectangleShapeData;
-  type ShapeType = ShapeData["type"];
-
-  type CreatedRegionShape<ShapeData extends RegionShape.ShapeData> = _CreateReturnType<ShapeData, ShapeData["type"]>;
-
-  /** @internal */
-  type _CreateReturnType<ShapeData extends RegionShape.ShapeData, ShapeType extends RegionShape.ShapeType> =
-    | (ShapeType extends "circle" ? RegionCircle<ShapeData> : never)
-    | (ShapeType extends "ellipse" ? RegionEllipse<ShapeData> : never)
-    | (ShapeType extends "polygon" ? RegionPolygon<ShapeData> : never)
-    | (ShapeType extends "rectangle" ? RegionRectangle<ShapeData> : never);
-}
-
-/** A shape of a {@link Region} */
+/** A shape of a {@link Region | `Region`} */
 declare abstract class RegionShape<ShapeData extends RegionShape.ShapeData> {
-  #regionShape: true;
-
   /**
    * Create the RegionShape from the shape data.
-   * @param data    - The shape data.
+   * @param data - The shape data.
    */
   constructor(data: ShapeData);
 
   /**
    * Create the RegionShape from the shape data.
-   * @param data    - The shape data.
+   * @param data - The shape data.
    */
   static create<ShapeData extends RegionShape.ShapeData>(data: ShapeData): RegionShape.CreatedRegionShape<ShapeData>;
 
   /**
    * The data of this shape.
+   *
    * It is owned by the shape and must not be modified.
    */
   get data(): ShapeData;
@@ -43,31 +26,51 @@ declare abstract class RegionShape<ShapeData extends RegionShape.ShapeData> {
 
   /**
    * The Clipper paths of this shape.
+   *
    * The winding numbers are 1 or 0.
+   * @remarks Foundry types this as `ReadonlyArray<>`, but does nothing to prevent writes
+   * at runtime, just returning a reference to `this.#clipperPaths`
    */
-  get clipperPaths(): ReadonlyArray<ReadonlyArray<ClipperLib.IntPoint>>;
+  get clipperPaths(): ClipperLib.Paths;
 
   /** The Clipper polygon tree of this shape */
   get clipperPolyTree(): ClipperLib.PolyTree;
 
   /**
    * Create the Clipper polygon tree of this shape.
-   * This function may return a single positively-orientated and non-selfintersecting Clipper path instead of a tree,
+   *
+   * This function may return a single positively-orientated and non-self-intersecting Clipper path instead of a tree,
    * which is automatically converted to a Clipper polygon tree.
+   *
    * This function is called only once. It is not called if the shape is empty.
+   * @remarks Despite Foundry typing this as possibly returning a `PolyTree`, all four core subclasses return `Path`s,
+   * relying on the {@link RegionShape.clipperPolyTree | `#clipperPolyTree`} getter to convert and cache it.
    */
-  protected abstract _createClipperPolyTree(): ClipperLib.PolyTree | ClipperLib.IntPoint[];
+  protected abstract _createClipperPolyTree(): ClipperLib.PolyTree | ClipperLib.Path;
 
   /**
    * Draw shape into the graphics.
-   * @param graphics      - The graphics to draw the shape into.
-   * @internal
+   * @param graphics  - The graphics to draw the shape into.
+   * @remarks Foundry marked `@internal` but not `@abstract`, despite it throwing if not overridden
    */
   protected abstract _drawShape(graphics: PIXI.Graphics): void;
 }
 
+declare namespace RegionShape {
+  interface Any extends AnyRegionShape {}
+  type AnyConstructor = typeof AnyRegionShape;
+
+  type ShapeData = CircleShapeData | EllipseShapeData | PolygonShapeData | RectangleShapeData;
+
+  type CreatedRegionShape<ShapeData extends RegionShape.ShapeData> =
+    | (ShapeData extends CircleShapeData ? RegionCircle<ShapeData> : never)
+    | (ShapeData extends EllipseShapeData ? RegionEllipse<ShapeData> : never)
+    | (ShapeData extends PolygonShapeData ? RegionPolygon<ShapeData> : never)
+    | (ShapeData extends RectangleShapeData ? RegionRectangle<ShapeData> : never);
+}
+
 /**
- * A circle of a {@link Region}
+ * A circle of a {@link Region | `Region`}
  * @privateRemarks Technically `ShapeData` should extend `CircleShapeData`, but it's easier to instantiate if it's `RegionShape.ShapeData`.
  */
 declare class RegionCircle<ShapeData extends RegionShape.ShapeData> extends RegionShape<ShapeData> {
@@ -75,12 +78,13 @@ declare class RegionCircle<ShapeData extends RegionShape.ShapeData> extends Regi
 
   constructor(data: ShapeData);
 
-  protected override _createClipperPolyTree(): ClipperLib.PolyTree | ClipperLib.IntPoint[];
+  protected override _createClipperPolyTree(): ClipperLib.Path;
 
   protected override _drawShape(graphics: PIXI.Graphics): void;
 }
+
 /**
- * An ellipse of a {@link Region}
+ * An ellipse of a {@link Region | `Region`}
  * @privateRemarks Technically `ShapeData` should extend `EllipseShapeData`, but it's easier to instantiate if it's `RegionShape.ShapeData`.
  */
 declare class RegionEllipse<ShapeData extends RegionShape.ShapeData> extends RegionShape<ShapeData> {
@@ -88,31 +92,38 @@ declare class RegionEllipse<ShapeData extends RegionShape.ShapeData> extends Reg
 
   constructor(data: ShapeData);
 
-  protected override _createClipperPolyTree(): ClipperLib.PolyTree | ClipperLib.IntPoint[];
+  protected override _createClipperPolyTree(): ClipperLib.Path;
 
   protected override _drawShape(graphics: PIXI.Graphics): void;
 }
+
 /**
- * A polygon of a {@link Region}
+ * A polygon of a {@link Region | `Region`}
  * @privateRemarks Technically `ShapeData` should extend `PolygonShapeData`, but it's easier to instantiate if it's `RegionShape.ShapeData`.
  */
 declare class RegionPolygon<ShapeData extends RegionShape.ShapeData> extends RegionShape<ShapeData> {
   constructor(params: ShapeData);
 
-  protected override _createClipperPolyTree(): ClipperLib.PolyTree | ClipperLib.IntPoint[];
+  protected override _createClipperPolyTree(): ClipperLib.Path;
 
   protected override _drawShape(graphics: PIXI.Graphics): void;
 }
+
 /**
- * A rectangle of a {@link Region}
+ * A rectangle of a {@link Region | `Region`}
  * @privateRemarks Technically `ShapeData` should extend `RectangleShapeData`, but it's easier to instantiate if it's `RegionShape.ShapeData`.
  */
 declare class RegionRectangle<ShapeData extends RegionShape.ShapeData> extends RegionShape<ShapeData> {
   constructor(params: ShapeData);
 
-  protected override _createClipperPolyTree(): ClipperLib.PolyTree | ClipperLib.IntPoint[];
+  protected override _createClipperPolyTree(): ClipperLib.Path;
 
   protected override _drawShape(graphics: PIXI.Graphics): void;
 }
 
+// Only RegionShape is exported, so `Any_` classes and types for the subclasses have been omitted
+declare abstract class AnyRegionShape extends RegionShape<RegionShape.ShapeData> {
+  constructor(...args: never);
+}
+
 export default RegionShape;

package/src/foundry/client-esm/canvas/scene-manager.d.mts

@@ -1,3 +1,4 @@
+import type { AnyFunction, Identity } from "fvtt-types/utils";
 /**
  * A framework for imbuing special scripted behaviors into a single specific Scene.
  * Managed scenes are registered in CONFIG.Canvas.managedScenes.
@@ -46,12 +47,12 @@ declare class SceneManager {
   /**
    * The SceneManager is constructed by passing a reference to the active Scene document.
    */
-  constructor(scene: Scene);
+  constructor(scene: Scene.Implementation);
 
   /**
    * The managed Scene
    */
-  get scene(): Scene.ConfiguredInstance;
+  get scene(): Scene.Implementation;
 
   /**
    * Additional behaviors to perform when the Canvas is first initialized for the Scene.
@@ -82,7 +83,7 @@ declare class SceneManager {
   /**
    * Register additional hook functions are only used while this Scene is active and is automatically deactivated.
    */
-  registerHooks(hookName: string, handler: (...args: unknown[]) => unknown): void;
+  registerHooks(hookName: string, handler: AnyFunction): void;
 
   /**
    * Deactivate Hook functions that were added specifically for this Scene.
@@ -91,12 +92,12 @@ declare class SceneManager {
 }
 
 declare namespace SceneManager {
-  type Any = AnySceneManager;
-  type AnyConstructor = typeof AnySceneManager;
+  interface Any extends AnySceneManager {}
+  interface AnyConstructor extends Identity<typeof AnySceneManager> {}
 }
 
 declare abstract class AnySceneManager extends SceneManager {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }
 
 export default SceneManager;

package/src/foundry/client-esm/canvas/smaa/blend.d.mts

@@ -1,6 +1,17 @@
 /**
- * The blending weight calculation filter for {@link foundry.canvas.SMAAFilter}.
+ * The neighborhood blending filter for {@link foundry.canvas.SMAAFilter | `foundry.canvas.SMAAFilter`}.
  */
-export default class SMAABWeightCalculationFilter extends PIXI.Filter {
-  constructor(config: foundry.canvas.SMAAFilter.SMAAFilterConfig);
+declare class SMAANeighborhoodBlendingFilter extends PIXI.Filter {
+  constructor();
 }
+
+declare namespace SMAANeighborhoodBlendingFilter {
+  interface Any extends AnySMAANeighborhoodBlendingFilter {}
+  type AnyConstructor = typeof AnySMAANeighborhoodBlendingFilter;
+}
+
+declare abstract class AnySMAANeighborhoodBlendingFilter extends SMAANeighborhoodBlendingFilter {
+  constructor(...args: never);
+}
+
+export default SMAANeighborhoodBlendingFilter;

package/src/foundry/client-esm/canvas/smaa/edges.d.mts

@@ -1,6 +1,28 @@
+import type { IntentionalPartial, RequiredProps } from "fvtt-types/utils";
+
 /**
- * The edge detection filter for {@link foundry.canvas.SMAAFilter}.
+ * The edge detection filter for {@link foundry.canvas.SMAAFilter | `foundry.canvas.SMAAFilter`}.
  */
-export default class SMAAEdgeDetectionFilter extends PIXI.Filter {
-  constructor(config: foundry.canvas.SMAAFilter.SMAAFilterConfig);
+declare class SMAAEdgeDetectionFilter extends PIXI.Filter {
+  constructor(config: SMAAEdgeDetectionFilter.Config);
 }
+
+declare namespace SMAAEdgeDetectionFilter {
+  interface Any extends AnySMAAEdgeDetectionFilter {}
+  type AnyConstructor = typeof AnySMAAEdgeDetectionFilter;
+
+  /**
+   * @privateRemarks The SMAAEdgeDetectionFilter constructor passes `config` to an unexported local
+   * function that only uses two properties of the interface
+   */
+  type Config = RequiredProps<
+    IntentionalPartial<foundry.canvas.SMAAFilter.Config>,
+    "threshold" | "localContrastAdaptionFactor"
+  >;
+}
+
+declare abstract class AnySMAAEdgeDetectionFilter extends SMAAEdgeDetectionFilter {
+  constructor(...args: never);
+}
+
+export default SMAAEdgeDetectionFilter;