@league-of-foundry-developers/foundry-vtt-types 12.331.3-beta → 12.331.5

package/src/foundry/common/utils/helpers.d.mts

@@ -1,4 +1,4 @@
-import type { AnyConstructor, AnyFunction, DeepPartial, InexactPartial } from "../../../types/utils.d.mts";
+import type { AnyConstructor, AnyFunction, DeepPartial, InexactPartial, NonNullish } from "#utils";
 import type Document from "../abstract/document.d.mts";
 
 /**
@@ -48,7 +48,7 @@ export interface DeepCloneOptions {
   strict?: boolean;
   /**
    * An internal depth tracker
-   * @defaultValue 0
+   * @defaultValue `0`
    */
   _d?: number;
 }
@@ -80,7 +80,7 @@ export type DiffObjectOptions = InexactPartial<{
 
   /**
    * An internal depth tracker
-   * @defaultValue 0
+   * @defaultValue `0`
    */
   _d?: number;
 }>;
@@ -113,7 +113,7 @@ export function objectsEqual<B extends object>(a: object, b: B): a is B;
 export function duplicate<T>(original: T): Duplicated<T>;
 
 /**
- * The resulting type when using {@link duplicate} on some data of type `T`.
+ * The resulting type when using {@link duplicate | `duplicate`} on some data of type `T`.
  *
  * @typeParam T - Original type.
  * @internal
@@ -273,8 +273,15 @@ export function getProperty(object: object, key: string): any;
  */
 export function setProperty(object: object, key: string, value: any): boolean;
 
-export type InvertableObject = Record<string | number | symbol, string | number | symbol>;
-export type InvertObject<in out T extends InvertableObject> = { [Key in keyof T as T[Key]]: Key };
+// Merging into this would be antithetical to its purpose.
+// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+export type InvertableObject = {
+  readonly [K: PropertyKey]: PropertyKey;
+};
+
+export type InvertObject<in out T extends InvertableObject> = {
+  [K in keyof T as T[K]]: K;
+};
 
 /**
  * Invert an object by assigning its values as keys and its keys as values.
@@ -297,7 +304,10 @@ export function isNewerVersion(v1: number | string, v0: number | string): boolea
  * @param value - The value to test
  * @returns Is the value empty-like?
  */
-export function isEmpty(value: undefined | null | unknown[] | object | Set<unknown> | Map<unknown, unknown>): boolean;
+
+export function isEmpty(
+  value: undefined | null | unknown[] | object | Set<unknown> | Map<unknown, unknown> | NonNullish,
+): boolean;
 
 export type MergeObject<T, U, M extends MergeObjectOptions> = UpdateInsert<
   DeleteByObjectKeys<T, U, M>,
@@ -406,7 +416,7 @@ export interface MergeObjectOptions {
    * Control whether to perform deletions on the original object if deletion keys are present in the other object.
    * @defaultValue `false`
    */
-  performDeletions?: boolean | undefined; //TODO: implement this in the mergeObject return type
+  performDeletions?: boolean | undefined; // TODO: implement this in the mergeObject return type
 }
 
 /**
@@ -415,7 +425,7 @@ export interface MergeObjectOptions {
  */
 declare function _mergeInsert(
   original: object,
-  k: string | number | symbol,
+  k: PropertyKey,
   v: any,
   options?: Pick<MergeObjectOptions, "insertKeys" | "insertValues" | "performDeletions">,
   _d?: number,
@@ -463,7 +473,7 @@ export function timeSince(timeStamp: Date | string): string;
  * @param options - Additional options. (default: `{}`)
  * @returns
  */
-export function formatFileSize(size: number, options: FormatFileSizeOptions): string;
+export function formatFileSize(size: number, options?: FormatFileSizeOptions): string;
 
 interface FormatFileSizeOptions {
   /**
@@ -488,7 +498,7 @@ interface ResolvedUUID {
   /**
    * The type of Document referenced. Legacy compendium UUIDs will not populate this field if the compendium is not active in the World.
    */
-  type?: Document.Type;
+  type?: Document.Type | undefined;
 
   /**
    * The ID of the Document referenced.
@@ -498,17 +508,17 @@ interface ResolvedUUID {
   /**
    * The primary Document type of this UUID. Only present if the Document is embedded.
    */
-  primaryType?: foundry.CONST.PRIMARY_DOCUMENT_TYPES;
+  primaryType?: foundry.CONST.PRIMARY_DOCUMENT_TYPES | undefined;
 
   /**
    * The primary Document ID of this UUID. Only present if the Document is embedded.
    */
-  primaryId?: string;
+  primaryId?: string | undefined;
 
   /**
    * The collection that the primary Document belongs to.
    */
-  collection?: DocumentCollection.Any;
+  collection?: DocumentCollection.Any | undefined;
 
   /**
    * Additional Embedded Document parts.
@@ -518,17 +528,17 @@ interface ResolvedUUID {
   /**
    * An already-resolved parent Document.
    */
-  doc?: Document.Any;
+  doc?: Document.Any | undefined;
 
   /**
    * Either the document type or the parent type. Retained for backwards compatibility.
    */
-  documentType?: DocumentType;
+  documentType?: Document.Type | undefined;
 
   /**
    * Either the document id or the parent id. Retained for backwards compatibility.
    */
-  documentId?: string;
+  documentId?: string | undefined;
 }
 
 interface ParseUUIDOptions {
@@ -570,7 +580,7 @@ declare function _resolveRelativeUuid(uuid: string, relative: Document.Any): Res
  * @param g - The green color value
  * @param b - The blue color value
  * @returns The HSV representation
- * @deprecated since v10 until v12, rgbToHsv is deprecated in favor of {@link foundry.utils.Color#hsv}
+ * @deprecated since v10 until v12, rgbToHsv is deprecated in favor of {@link foundry.utils.Color.hsv | `foundry.utils.Color#hsv`}
  */
 export function rgbToHsv(r: number, g: number, b: number): [h: number, s: number, v: number];
 
@@ -581,7 +591,7 @@ export function rgbToHsv(r: number, g: number, b: number): [h: number, s: number
  * @param s - The saturation
  * @param v - The value
  * @returns The RGB representation
- * @deprecated since v10 until v12, hsvToRgb is deprecated in favor of {@link foundry.utils.Color.fromHSV}
+ * @deprecated since v10 until v12, hsvToRgb is deprecated in favor of {@link foundry.utils.Color.fromHSV | `foundry.utils.Color.fromHSV`}
  */
 export function hsvToRgb(h: number, s: number, v: number): [r: number, g: number, b: number];
 
@@ -589,7 +599,7 @@ export function hsvToRgb(h: number, s: number, v: number): [r: number, g: number
  * Converts a color as an [R, G, B] array of normalized floats to a hexadecimal number.
  * @param rgb - Array of numbers where all values are normalized floats from 0.0 to 1.0.
  * @returns The numeric color as hexadecimal
- * @deprecated since v10 until v12, rgbToHex is deprecated in favor of {@link foundry.utils.Color.fromRGB}
+ * @deprecated since v10 until v12, rgbToHex is deprecated in favor of {@link foundry.utils.Color.fromRGB | `foundry.utils.Color.fromRGB`}
  */
 export function rgbToHex(rgb: [r: number, g: number, b: number]): number;
 
@@ -597,7 +607,7 @@ export function rgbToHex(rgb: [r: number, g: number, b: number]): number;
  * Convert a hex color code to an RGB array
  * @param hex - A hex color number
  * @returns An array of [r,g,b] colors normalized on the range of [0,1]
- * @deprecated since v10 until v12, hexToRGB is deprecated in favor of {@link foundry.utils.Color#rgb}
+ * @deprecated since v10 until v12, hexToRGB is deprecated in favor of {@link foundry.utils.Color.rgb | `foundry.utils.Color#rgb`}
  */
 export function hexToRGB(hex: number): [r: number, g: number, b: number];
 
@@ -607,7 +617,7 @@ export function hexToRGB(hex: number): [r: number, g: number, b: number];
  * @param alpha - An optional level of transparency
  *                (default: `1.0`)
  * @returns An rgba style string
- * @deprecated since v10 until v12, hexToRGBAString is deprecated in favor of {@link foundry.utils.Color#toRGBA}
+ * @deprecated since v10 until v12, hexToRGBAString is deprecated in favor of {@link foundry.utils.Color.toRGBA | `foundry.utils.Color#toRGBA`}
  */
 export function hexToRGBAString(hex: number, alpha?: number): `rgba(${number}, ${number}, ${number})`;
 
@@ -615,19 +625,19 @@ export function hexToRGBAString(hex: number, alpha?: number): `rgba(${number}, $
  * Convert a string color to a hex integer
  * @param color - The string color
  * @returns The hexadecimal color code
- * @deprecated since v10 until v12, colorStringToHex is deprecated in favor of {@link foundry.utils.Color.from}
+ * @deprecated since v10 until v12, colorStringToHex is deprecated in favor of {@link foundry.utils.Color.from | `foundry.utils.Color.from`}
  */
 export function colorStringToHex(color: string): number | null;
 
 /**
- * Internal Helper for {@link Duplicated}. A union type of all types that do not have a JSON representation.
+ * Internal Helper for {@link Duplicated | `Duplicated`}. A union type of all types that do not have a JSON representation.
  *
  * @internal
  */
 type NonStringifiable = undefined | AnyFunction | AnyConstructor | symbol;
 
 /**
- * Internal helper for {@link InnerDuplicated}. Maps the properties of `T` to their duplicated types.
+ * Internal helper for {@link InnerDuplicated | `InnerDuplicated`}. Maps the properties of `T` to their duplicated types.
  *
  * @typeParam T - The object type that should have its properties mapped.
  * @internal
@@ -644,7 +654,7 @@ type MapToInnerDuplicated<T extends object> = { [k in keyof T]: InnerDuplicated<
 type OmitOfType<T extends object, U> = { [k in keyof T as T[k] extends U ? never : k]: T[k] };
 
 /**
- * Internal helper type for {@link Duplicated}. It is the main part of the implementation, which does the recursion.
+ * Internal helper type for {@link Duplicated | `Duplicated`}. It is the main part of the implementation, which does the recursion.
  *
  * @typeParam T - Type currently being converted.
  * @internal

package/src/foundry/common/utils/http.d.mts

@@ -1,11 +1,11 @@
 /**
  * A wrapper method around `fetch` that attaches an AbortController signal to the `fetch` call for clean timeouts
- * @see https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal#aborting_a_fetch_with_timeout_or_explicit_abort
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal#aborting_a_fetch_with_timeout_or_explicit_abort}
  * @param url            - The URL to make the Request to
  * @param data           - The data of the Request
  *                         (defalt: `{}`)
  * @param timeoutOptions - (default: `{}`)
- * @throws {@link HttpError}
+ * @throws {@link HttpError | `HttpError`}
  */
 export declare function fetchWithTimeout(
   url: string,

package/src/foundry/common/utils/module.d.mts

@@ -1,7 +1,7 @@
 // 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/no-unresolved` from erroring `.mjs` is used.
-/* eslint-disable import/extensions */
+// While `.mts` could work, to avoid `import-x/no-unresolved` from erroring `.mjs` is used.
+/* eslint-disable import-x/extensions */
 
 export * from "./geometry.mjs";
 export * from "./helpers.mjs";

package/src/foundry/common/utils/string-tree.d.mts

@@ -1,9 +1,9 @@
-import type { InexactPartial } from "../../../types/utils.d.mts";
+import type { AnyObject } from "../../../utils/index.d.mts";
 
 /**
  * A data structure representing a tree of string nodes with arbitrary object leaves.
  */
-declare class StringTree<EntryType> {
+declare class StringTree<Leaf extends object = AnyObject, Key = string[]> {
   /**
    * The key symbol that stores the leaves of any given node.
    */
@@ -20,7 +20,7 @@ declare class StringTree<EntryType> {
    * @param entry    - The entry to store.
    * @returns   The node the entry was added to.
    */
-  addLeaf(strings: string[], entry: EntryType): StringTree.StringTreeNode;
+  addLeaf(strings: Key, entry: Leaf): StringTree.StringTreeNode<Leaf>;
 
   /**
    * Traverse the tree along the given string path and return any entries reachable from the node.
@@ -28,50 +28,32 @@ declare class StringTree<EntryType> {
    * @param options         - Additional options to configure behaviour.
    * @returns    The reachable entries
    */
-  lookup(
-    strings: string[],
-    options?: InexactPartial<{
-      /** The maximum number of items to retrieve. */
-      limit: number;
-      /** A filter function to apply to each candidate entry. */
-      filterEntries?: StringTree.StringTreeEntryFilter | undefined;
-    }>,
-  ): StringTree.StringTreeNode[];
+  lookup(strings: Key, options?: StringTree.LookupOptions): Leaf[];
 
   /**
    * Returns the node at the given path through the tree.
-   * @param strings                     - The string path to the desired node.
-   * @param options                     - Additional options to configure behaviour.
+   * @param strings - The string path to the desired node.
+   * @param options - Additional options to configure behaviour.
    * @returns The node at the path, if found
    */
-  nodeAtPrefix(
-    strings: string[],
-    options?: InexactPartial<{
-      /**
-       * Only return the most recently visited node that has
-       * leaves, otherwise return the exact node at the prefix,
-       * if it exists. Defaults to false.
-       */
-      hasLeaves: boolean;
-    }>,
-  ): StringTree.StringTreeNode | void;
+  nodeAtPrefix<Options extends StringTree.NodeAtPrefixOptions>(
+    strings: Key,
+    options?: Options,
+  ): StringTree.StringTreeNode<Leaf> | void;
 
   /**
    * Perform a breadth-first search starting from the given node and retrieving any entries reachable from that node,
    * until we reach the limit.
-   * @param node            - The starting node.
-   * @param entries         - The accumulated entries.
-   * @param queue           - The working queue of nodes to search.
-   * @param options         - Additional options to configure behaviour.
+   * @param node    - The starting node.
+   * @param entries - The accumulated entries.
+   * @param queue   - The working queue of nodes to search.
+   * @param options - Additional options to configure behaviour.
    */
   protected _breadthFirstSearch(
-    node: StringTree.StringTreeNode,
-    entries: EntryType[],
-    queue: StringTree.StringTreeNode[],
-    options?: InexactPartial<{
-      /** The maximum number of entries to retrieve before stopping. */
-      limit: number;
-    }>,
+    node: StringTree.StringTreeNode<Leaf>,
+    entries: Leaf[],
+    queue: StringTree.StringTreeNode<Leaf>[],
+    options?: StringTree.BreadthFirstSearchOptions,
   ): void;
 }
 
@@ -80,9 +62,9 @@ declare namespace StringTree {
    * A string tree node consists of zero-or-more string keys, and a leaves property that contains any objects that
    * terminate at the current node.
    */
-  interface StringTreeNode {
-    [StringTree.leaves]: Record<string, unknown>[];
-    [key: string]: StringTreeNode;
+  interface StringTreeNode<Leaf extends object> {
+    [StringTree.leaves]: Leaf[];
+    [key: string]: StringTreeNode<Leaf>;
   }
 
   /**
@@ -90,6 +72,30 @@ declare namespace StringTree {
    * @returns Whether the entry should be included in the result set.
    */
   type StringTreeEntryFilter = (entry: unknown) => boolean;
+
+  interface LookupOptions {
+    /** The maximum number of items to retrieve. */
+    limit?: number | undefined;
+
+    /** A filter function to apply to each candidate entry. */
+    filterEntries?: StringTree.StringTreeEntryFilter | undefined;
+  }
+
+  interface NodeAtPrefixOptions {
+    /**
+     * Only return the most recently visited node that has
+     * leaves, otherwise return the exact node at the prefix,
+     * if it exists. Defaults to false.
+     *
+     * @defaultValue `false`
+     */
+    hasLeaves?: boolean | undefined;
+  }
+
+  interface BreadthFirstSearchOptions {
+    /** The maximum number of entries to retrieve before stopping. */
+    limit?: number | undefined;
+  }
 }
 
 export default StringTree;

package/src/foundry/common/utils/word-tree.d.mts

@@ -1,4 +1,3 @@
-import type { InexactPartial } from "../../../types/utils.d.mts";
 import type StringTree from "./string-tree.d.mts";
 
 /**
@@ -6,15 +5,14 @@ import type StringTree from "./string-tree.d.mts";
  * Note that this works well for languages with alphabets (latin, cyrillic, korean, etc.), but may need more nuanced
  * handling for languages that compose characters and letters.
  */
-declare class WordTree extends StringTree<WordTree.WordTreeEntry> {
+declare class WordTree<Key = string> extends StringTree<WordTree.WordTreeEntry, Key> {
   /**
    * Insert an entry into the tree.
    * @param string    - The string key for the entry.
    * @param entry     - The entry to store.
    * @returns         The node the entry was added to.
    */
-  addLeaf(string: string, entry: WordTree.WordTreeEntry): StringTree.StringTreeNode;
-  addLeaf(strings: string[], entry: any): StringTree.StringTreeNode;
+  addLeaf(key: Key, entry: WordTree.WordTreeEntry): StringTree.StringTreeNode<WordTree.WordTreeEntry>;
 
   /**
    * Return entries that match the given string prefix.
@@ -22,29 +20,14 @@ declare class WordTree extends StringTree<WordTree.WordTreeEntry> {
    * @param options             - Additional options to configure behaviour.
    * @returns                   A number of entries that have the given prefix.
    */
-  lookup(
-    prefix: string,
-    options?: InexactPartial<{
-      /**
-       * The maximum number of items to retrieve. It is important
-       * to set this value as very short prefixes will naturally match large numbers
-       * of entries.
-       * (default: `10`)
-       */
-      limit: number;
-      /** A filter function to apply to each candidate entry. */
-      filterEntries?: StringTree.StringTreeEntryFilter | undefined;
-    }>,
-  ): WordTree.WordTreeEntry[];
-  lookup(strings: string[], options?: InexactPartial<{ limit: number }>): StringTree.StringTreeNode[];
+  lookup(prefix: Key, options?: StringTree.LookupOptions): WordTree.WordTreeEntry[];
 
   /**
    * Returns the node at the given prefix.
-   * @param prefix        - The prefix.
+   * @param prefix - The prefix.
    * @returns The node
    */
-  nodeAtPrefix(strings: string[], options?: InexactPartial<{ hasLeaves: boolean }>): StringTree.StringTreeNode | void;
-  nodeAtPrefix(prefix: string): WordTree.WordTreeEntry;
+  nodeAtPrefix(prefix: Key): StringTree.StringTreeNode<WordTree.WordTreeEntry> | void;
 }
 
 declare namespace WordTree {
@@ -52,14 +35,18 @@ declare namespace WordTree {
    * A leaf entry in the tree.
    */
   interface WordTreeEntry {
+    // TODO(LukeAbby): This appears to be possible to be a compendium index entry.
     /** An object that this entry represents. */
     entry: foundry.abstract.Document.Any;
+
     /** The document type. */
     documentName: string;
+
     /** The document's UUID. */
     uuid: string;
+
     /** The (optional) pack ID. */
-    pack?: string;
+    pack?: string | undefined;
   }
 }
 

package/src/foundry/index.d.mts

@@ -1,5 +1,4 @@
 import "./client/index.d.mts";
 import "./client-esm/client.d.mts";
-import "./clipper/index.d.mts";
 import "./common/prosemirror/index.d.mts";
 import "./public/index.d.mts";

package/src/foundry/{clipper → public/scripts/clipper}/clipper.d.mts

@@ -1,4 +1,4 @@
-import type { Brand } from "../../types/helperTypes.d.mts";
+import type { Brand } from "#utils";
 
 declare global {
   namespace ClipperLib {
@@ -110,10 +110,8 @@ declare global {
     let PI2: number;
 
     class IntPoint {
-      constructor(x: number, y: number, z: number);
-      constructor(x: number, y: number);
-      constructor(dp: DoublePoint);
-      constructor();
+      constructor(x: number, y: number, z?: number);
+      constructor(dp?: DoublePoint);
 
       X: number;
       Y: number;
@@ -164,25 +162,54 @@ declare global {
     }
 
     type ClipType = Brand<number, "ClipperLib.ClipType">;
-    const ClipType: Record<"ctIntersection" | "ctUnion" | "ctDifference" | "ctXor", ClipType>;
+    const ClipType: {
+      ctIntersection: 0 & ClipType;
+      ctUnion: 1 & ClipType;
+      ctDifference: 2 & ClipType;
+      ctXor: 3 & ClipType;
+    };
 
     type PolyType = Brand<number, "ClipperLib.PolyType">;
-    const PolyType: Record<"ptSubject" | "ptClip", PolyType>;
+    const PolyType: {
+      ptSubject: 0 & PolyType;
+      ptClip: 1 & PolyType;
+    };
 
     type PolyFillType = Brand<number, "ClipperLib.PolyFillType">;
-    const PolyFillType: Record<"pftEvenOdd" | "pftNonZero" | "pftPositive" | "pftNegative", PolyFillType>;
+    const PolyFillType: {
+      pftEvenOdd: 0 & PolyFillType;
+      pftNonZero: 1 & PolyFillType;
+      pftPositive: 2 & PolyFillType;
+      pftNegative: 3 & PolyFillType;
+    };
 
     type JoinType = Brand<number, "ClipperLib.JoinType">;
-    const JoinType: Record<"jtSquare" | "jtRound" | "jtMiter", JoinType>;
+    const JoinType: {
+      jtSquare: 0 & JoinType;
+      jtRound: 1 & JoinType;
+      jtMiter: 2 & JoinType;
+    };
 
     type EndType = Brand<number, "ClipperLib.EndType">;
-    const EndType: Record<"etOpenSquare" | "etOpenRound" | "etOpenButt" | "etClosedLine" | "etClosedPolygon", EndType>;
+    const EndType: {
+      etOpenSquare: 0 & EndType;
+      etOpenRound: 1 & EndType;
+      etOpenButt: 2 & EndType;
+      etClosedLine: 3 & EndType;
+      etClosedPolygon: 4 & EndType;
+    };
 
     type EdgeSide = Brand<number, "ClipperLib.EdgeSide">;
-    const EdgeSide: Record<"esLeft" | "esRight", EdgeSide>;
+    const EdgeSide: {
+      esLeft: 0 & EdgeSide;
+      esRight: 1 & EdgeSide;
+    };
 
     type Direction = Brand<number, "Direction">;
-    const Direction: Record<"dRightToLeft" | "dLeftToRight", Direction>;
+    const Direction: {
+      dRightToLeft: 0 & Direction;
+      dLeftToRight: 1 & Direction;
+    };
 
     class TEdge {
       Bot: IntPoint;
@@ -362,10 +389,10 @@ declare global {
       protected m_Scanbeam: Scanbeam | null;
 
       /** @defaultValue `null` */
-      protected m_PolyOuts: unknown | null;
+      protected m_PolyOuts: unknown;
 
       /** @defaultValue `null` */
-      protected m_ActiveEdges: unknown | null;
+      protected m_ActiveEdges: unknown;
 
       /**
        * -2^53
@@ -465,7 +492,16 @@ declare global {
     }
 
     class Clipper extends ClipperBase {
-      constructor(InitOptions?: number);
+      constructor(
+        /**
+         * @defaultValue `0`
+         * @remarks Bitmask options:
+         * - `ReverseSolution`:  `0b0000001`
+         * - `StrictlySimple`:   `0b0000010`
+         * - `PreserveColinear`: `0b0000100`
+         */
+        InitOptions?: number | null,
+      );
 
       /** @defaultValue `[]` */
       protected m_PolyOuts: OutRec[];
@@ -748,11 +784,17 @@ declare global {
 
       ClosedPathsFromPolyTree(polytree: PolyTree): Paths;
 
-      static NodeType: Record<"ntAny" | "ntOpen" | "ntClosed", Clipper.NodeType>;
+      static NodeType: Clipper.NodeTypes;
     }
 
     namespace Clipper {
       type NodeType = Brand<number, "ClipperLib.Clipper.NodeType">;
+
+      interface NodeTypes {
+        ntAny: 0 & NodeType;
+        ntOpen: 1 & NodeType;
+        ntClosed: 2 & NodeType;
+      }
     }
 
     class ClipperOffset {

package/src/foundry/public/scripts/index.d.mts

@@ -1 +1,2 @@
 import "./earcut-edges/index.d.mts";
+import "./clipper/index.d.mts";

package/src/foundry/public/scripts/workers/image-compressor.d.mts

@@ -0,0 +1,23 @@
+// eslint-disable-next-line import-x/extensions
+import * as worker from "../../../../types/workers/image-compressor.mjs";
+
+declare global {
+  export import FORMATS = worker.FORMATS;
+  export import Debug = worker.Debug;
+
+  export import ProcessBufferToBase64Options = worker.ProcessBufferToBase64Options;
+  export import ExpandOrReduceBufferOptions = worker.ExpandOrReduceBufferOptions;
+  export import ProcessBufferToBase64Return = worker.ProcessBufferToBase64Return;
+  export import ProcessBufferRedToBufferRGBAReturn = worker.ProcessBufferRedToBufferRGBAReturn;
+  export import ProcessBufferRGBAToBufferREDReturn = worker.ProcessBufferRGBAToBufferREDReturn;
+
+  export import processBufferToBase64 = worker.processBufferToBase64;
+  export import processBufferRedToBufferRGBA = worker.processBufferRedToBufferRGBA;
+  export import processBufferRGBAToBufferRED = worker.processBufferRGBAToBufferRED;
+  export import controlHashes = worker.controlHashes;
+  export import pixelsToOffscreenCanvas = worker.pixelsToOffscreenCanvas;
+  export import offscreenToBase64 = worker.offscreenToBase64;
+  export import blobToBase64 = worker.blobToBase64;
+  export import expandBuffer = worker.expandBuffer;
+  export import reduceBuffer = worker.reduceBuffer;
+}

package/src/foundry/public/scripts/workers/index.d.mts

@@ -0,0 +1 @@
+import "./image-compressor.d.mts";

package/{index-lenient.d.mts → src/index-lenient.d.mts}

@@ -1,3 +1,5 @@
+/* eslint-disable */
+
 import "./index.d.mts";
 
 declare global {

package/src/index.d.mts

@@ -1,2 +1,8 @@
+import "handlebars";
+import "jquery";
+import "pixi.js";
+import "showdown";
+
 import "./foundry/index.d.mts";
 import "./types/index.d.mts";
+import "./configuration/index.d.mts";

package/src/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig.json",
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "types": [],
+    "outDir": "../.typescript-build/src",
+    "composite": true,
+    "noEmit": false,
+    "emitDeclarationOnly": true
+  },
+  // Note: `**/*` is used to work around a bug with `eslint`. This will be removed once it's fixed.
+  "include": ["index.d.mts", "**/*"],
+  "exclude": ["index-lenient.d.mts"],
+  "references": []
+}