@league-of-foundry-developers/foundry-vtt-types 0.8.9-8 → 9.242.0

package/src/foundry/common/packages.mjs/worldData.d.ts

@@ -3,13 +3,13 @@ import * as fields from '../data/fields.mjs';
 import { PackageData, PackageDataConstructorData, PackageDataProperties, PackageDataSchema } from './packageData';
 
 interface WorldDataSchema extends Omit<PackageDataSchema, 'system'> {
-  system: typeof fields.REQUIRED_STRING;
-  background: typeof fields.STRING_FIELD;
-  coreVersion: typeof fields.REQUIRED_STRING;
-  nextSession: typeof fields.STRING_FIELD;
-  resetKeys: typeof fields.BOOLEAN_FIELD;
-  safeMode: typeof fields.BOOLEAN_FIELD;
-  systemVersion: FieldReturnType<typeof fields.REQUIRED_STRING, { default: () => string }>;
+  system: fields.RequiredString;
+  background: fields.StringField;
+  coreVersion: fields.RequiredString;
+  nextSession: fields.StringField;
+  resetKeys: fields.BooleanField;
+  safeMode: fields.BooleanField;
+  systemVersion: FieldReturnType<fields.RequiredString, { default: () => string }>;
 }
 
 interface WorldDataProperties extends Omit<PackageDataProperties, 'system'> {
@@ -17,19 +17,24 @@ interface WorldDataProperties extends Omit<PackageDataProperties, 'system'> {
   system: string;
 
   /** A web URL or local file path which provides a background banner image */
-  background?: string;
+  background: string | undefined;
 
   /** The version of the core software for which this world has been migrated */
   coreVersion: string;
 
   /** An ISO datetime string when the next game session is scheduled to occur */
-  nextSession?: string;
+  nextSession: string | undefined;
 
+  /** @defaultValue `false` */
   resetKeys: boolean;
 
+  /** @defaultValue `false` */
   safeMode: boolean;
 
-  /** The version of the game system for which this world has been migrated */
+  /**
+   * The version of the game system for which this world has been migrated
+   * @defaultValue `"0"`
+   */
   systemVersion: string;
 }
 
@@ -38,29 +43,35 @@ interface WorldDataConstructorData extends Omit<PackageDataConstructorData, 'sys
   system: string;
 
   /** A web URL or local file path which provides a background banner image */
-  background?: string | null;
+  background?: string | null | undefined;
 
   /** The version of the core software for which this world has been migrated */
   coreVersion: string;
 
   /** An ISO datetime string when the next game session is scheduled to occur */
-  nextSession?: string | null;
+  nextSession?: string | null | undefined;
 
-  resetKeys?: boolean | null;
+  /** @defaultValue `false` */
+  resetKeys?: boolean | null | undefined;
 
-  safeMode?: boolean | null;
+  /** @defaultValue `false` */
+  safeMode?: boolean | null | undefined;
 
-  /** The version of the game system for which this world has been migrated */
-  systemVersion?: string | null;
+  /**
+   * The version of the game system for which this world has been migrated
+   * @defaultValue `"0"`
+   */
+  systemVersion?: string | null | undefined;
 }
 
 /**
  * The data schema used to define World manifest files.
  * Extends the basic PackageData schema with some additional world-specific fields.
  */
-export declare class WorldData extends PackageData<WorldDataSchema, WorldDataProperties, WorldDataConstructorData> {
+export class WorldData extends PackageData<WorldDataSchema, WorldDataProperties, WorldDataConstructorData> {
+  /** @override */
   static defineSchema(): WorldDataSchema;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
-export declare interface WorldData extends WorldDataProperties {}
+export interface WorldData extends WorldDataProperties {}

package/src/foundry/common/types.mjs.d.ts

@@ -20,6 +20,101 @@ declare type Rectangle =
       height: number;
     };
 
+/** A Client Keybinding Action Configuration */
+declare interface KeybindingActionConfig {
+  /** The namespace within which the action was registered */
+  namespace?: string;
+
+  /** The human readable name */
+  name: string;
+
+  /** An additional human readable hint */
+  hint?: string;
+
+  /** The default bindings that can never be changed nor removed. */
+  uneditable?: KeybindingActionBinding[];
+
+  /** The default bindings that can be changed by the user. */
+  editable?: KeybindingActionBinding[];
+
+  /** A function to execute when a key down event occurs. If True is returned, the event is consumed and no further keybinds execute. */
+  onDown?: () => boolean | void;
+
+  /** A function to execute when a key up event occurs. If True is returned, the event is consumed and no further keybinds execute. */
+  onUp?: () => boolean | void;
+
+  /** If True, allows Repeat events to execute the Action's onDown. Defaults to false. */
+  repeat?: boolean;
+
+  /** If true, only a GM can edit and execute this Action */
+  restricted?: boolean;
+
+  /** Modifiers such as [ "CONTROL" ] that can be also pressed when executing this Action. Prevents using one of these modifiers as a Binding. */
+  reservedModifiers?: string[];
+
+  /** The preferred precedence of running this Keybinding Action */
+  precedence?: number; // TODO: KEYBINDING_PRECEDENCE?
+
+  /** The recorded registration order of the action */
+  order?: number;
+}
+
+/** A Client Keybinding Action Binding */
+declare interface KeybindingActionBinding {
+  /** The KeyboardEvent#code value from https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/code/code_values */
+  key: string;
+
+  /** An array of modifiers keys from KeyboardManager.MODIFIER_KEYS which are required for this binding to be activated */
+  modifiers?: string[];
+}
+
+declare interface KeybindingAction {
+  action: string;
+  key: string;
+  name: string;
+  requiredModifiers: string[];
+  optionalModifiers: string[];
+  onDown: Function;
+  onUp: Function;
+  repeat: boolean;
+  restricted: boolean;
+  precedence: number;
+  order: number;
+}
+
+/** Keyboard event context */
+declare interface KeyboardEventContext {
+  /** The normalized string key, such as "A" */
+  key: string;
+
+  /** The originating keypress event */
+  event: KeyboardEvent;
+
+  /** Is the Shift modifier being pressed */
+  isShift: boolean;
+
+  /** Is the Control or Meta modifier being processed */
+  isControl: boolean;
+
+  /** Is the Alt modifier being pressed */
+  isAlt: boolean;
+
+  /** Are any of the modifiers being pressed */
+  hasModifier: boolean;
+
+  /** A list of string modifiers applied to this context, such as [ "CONTROL" ] */
+  modifiers: string[];
+
+  /** True if the Key is Up, else False if down */
+  up: boolean;
+
+  /** True if the given key is being held down such that it is automatically repeating. */
+  repeat: boolean;
+
+  /** The executing Keybinding Action. May be undefined until the action is known. */
+  action: string | undefined;
+}
+
 type RequestData = object | object[] | string | string[];
 
 interface SocketRequest {

package/src/foundry/common/utils/geometry.mjs.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Determine the relative orientation of three points in two-dimensional space.
+ * The result is also an approximation of twice the signed area of the triangle defined by the three points.
+ * This method is fast - but not robust against issues of floating point precision. Best used with integer coordinates.
+ * Adapted from https://github.com/mourner/robust-predicates
+ *
+ * @param a - An endpoint of segment AB, relative to which point C is tested
+ * @param b - An endpoint of segment AB, relative to which point C is tested
+ * @param c - A point that is tested relative to segment AB
+ *
+ * @returns The relative orientation of points A, B, and C
+ *          A positive value if the points are in counter-clockwise order (C lies to the left of AB)
+ *          A negative value if the points are in clockwise order (C lies to the right of AB)
+ *          Zero if the points A, B, and C are collinear.
+ */
+export function orient2dFast(a: Point, b: Point, c: Point): number;
+
+/**
+ * Quickly test whether the line segment AB intersects with the line segment CD.
+ * This method does not determine the point of intersection, for that use lineLineIntersection
+ *
+ * @param a - The first endpoint of segment AB
+ * @param b - The second endpoint of segment AB
+ * @param c - The first endpoint of segment CD
+ * @param d - The second endpoint of segment CD
+ *
+ * @returns Do the line segments intersect?
+ */
+export function lineSegmentIntersects(a: Point, b: Point, c: Point, d: Point): boolean;
+
+interface LineIntersection {
+  /** The x-coordinate of intersection */
+  x: number;
+
+  /** The y-coordinate of intersection */
+  y: number;
+
+  /** The vector distance from A to B on segment AB */
+  t0: number;
+
+  /** The vector distance from C to D on segment CD */
+  t1?: number;
+}
+
+/**
+ * An internal helper method for computing the intersection between two infinite-length lines.
+ * Adapted from http://paulbourke.net/geometry/pointlineplane/
+ *
+ * @param a - The first endpoint of segment AB
+ * @param b - The second endpoint of segment AB
+ * @param c - The first endpoint of segment CD
+ * @param d - The second endpoint of segment CD
+ *
+ * @returns An intersection point, or null if no intersection occurred
+ */
+export function lineLineIntersection(a: Point, b: Point, c: Point, d: Point): LineIntersection | null;
+
+/**
+ * An internal helper method for computing the intersection between two finite line segments.
+ * Adapted from http://paulbourke.net/geometry/pointlineplane/
+ *
+ * @param a       - The first endpoint of segment AB
+ * @param b       - The second endpoint of segment AB
+ * @param c       - The first endpoint of segment CD
+ * @param d       - The second endpoint of segment CD
+ * @param epsilon - A small epsilon which defines a tolerance for near-equality
+ *                  (default: `1e-8`)
+ *
+ * @returns An intersection point, or null if no intersection occurred
+ */
+export function lineSegmentIntersection(
+  a: Point,
+  b: Point,
+  c: Point,
+  d: Point,
+  epsilon?: number
+): LineIntersection | null;
+
+interface LineCircleIntersection {
+  /** Is point A inside the circle? */
+  aInside: boolean;
+
+  /** Is point B inside the circle? */
+  bInside: boolean;
+
+  /** Is the segment AB contained within the circle? */
+  contained: boolean;
+
+  /** Is the segment AB fully outside the circle? */
+  outside: boolean;
+
+  /** Is the segment AB tangent to the circle? */
+  tangent: boolean;
+
+  /** Intersection points: zero, one, or two */
+  intersections: [number] | [number, number] | [number, number, number];
+}
+
+/**
+ * Determine the intersection between a candidate wall and the circular radius of the polygon.
+ *
+ * @param a       - The initial vertex of the candidate edge
+ * @param b       - The second vertex of the candidate edge
+ * @param center  - The center of the bounding circle
+ * @param radius  - The radius of the bounding circle
+ * @param epsilon - A small tolerance for floating point precision
+ *                  (default: `1e-8`)
+ *
+ * @returns The intersection of the segment AB with the circle
+ */
+export function lineCircleIntersection(
+  a: Point,
+  b: Point,
+  center: Point,
+  radius: number,
+  epsilon?: number
+): LineCircleIntersection;
+
+/**
+ * Identify the point closest to C on segment AB
+ *
+ * @param c - The reference point C
+ * @param a - Point A on segment AB
+ * @param b - Point B on segment AB
+ *
+ * @returns The closest point to C on segment AB
+ */
+export function closestPointToSegment(c: Point, a: Point, b: Point): Point;
+
+/**
+ * Determine the points of intersection between a line segment (p0,p1) and a circle.
+ * There will be zero, one, or two intersections
+ * See https://math.stackexchange.com/a/311956
+ *
+ * @param p0      - The initial point of the line segment
+ * @param p1      - The terminal point of the line segment
+ * @param center  - The center of the circle
+ * @param radius  - The radius of the circle
+ * @param epsilon - A small tolerance for floating point precision
+ *                  (default: `0`)
+ */
+export function quadraticIntersection(
+  p0: Point,
+  p1: Point,
+  center: Point,
+  radius: number,
+  epsilon?: number
+): { x: number; y: number }[];

package/src/foundry/common/utils/helpers.mjs.d.ts

@@ -2,8 +2,13 @@
  * Benchmark the performance of a function, calling it a requested number of iterations.
  * @param func       - The function to benchmark
  * @param iterations - The number of iterations to test
+ * @param args       - Additional arguments passed to the benchmarked function
  */
-export declare function benchmark(func: () => unknown, iterations: number): void;
+export declare function benchmark<F extends (...args: any[]) => unknown>(
+  func: F,
+  iterations: number,
+  ...args: Parameters<F>
+): Promise<void>;
 
 /**
  * Wrap a callback in a debounced timeout.
@@ -22,9 +27,18 @@ export declare function debounce<T extends (...args: any[]) => unknown>(
  * This method DOES support recursive data structures containing inner objects or arrays.
  * This method DOES NOT support advanced object types like Set, Map, or other specialized classes.
  * @param original - Some sort of data
+ * @param options  - Options to configure the behaviour of deepClone
  * @returns The clone of that data
  */
-export declare function deepClone<T>(original: T): T;
+export declare function deepClone<T>(original: T, options?: DeepCloneOptions): T;
+
+interface DeepCloneOptions {
+  /**
+   * Throw an Error if deepClone is unable to clone something instead of returning the original
+   * @defaultValue `false`
+   */
+  strict?: boolean;
+}
 
 /**
  * Deeply difference an object against some other, returning the update keys and values
@@ -101,6 +115,17 @@ type InnerDuplicated<T> = T extends { toJSON(): infer U }
  */
 export type Duplicated<T> = T extends NonStringifiable ? never : InnerDuplicated<T>;
 
+/**
+ * Test whether some class is a subclass of a parent.
+ * @param cls    - The class to test
+ * @param parent - Some other class which may be a parent
+ * @returns Is the class a subclass of the parent?
+ */
+export declare function isSubclass(
+  cls: new (...args: any[]) => unknown,
+  parent: new (...args: any[]) => unknown
+): boolean;
+
 /**
  * Encode a url-like string by replacing any characters which need encoding
  * @param path - A fully-qualified URL or url component (like a relative path)
@@ -233,43 +258,6 @@ export declare function isNewerVersion(v1: number | string, v0: number | string)
  */
 export declare function isObjectEmpty(obj: object): boolean;
 
-/**
- * Update a source object by replacing its keys and values with those from a target object.
- *
- * @param original - The initial object which should be updated with values from the target
- * @param other    - A new object whose values should replace those in the source
- *                   (default: `{}`)
- * @param options  - Additional options which configure the merge
- *                   (default: `{}`)
- * @param _d       - A privately used parameter to track recursion depth.
- *                   (default: `0`)
- * @returns The original source object including updated, inserted, or overwritten records.
- *
- * @example <caption>Control how new keys and values are added</caption>
- * ```typescript
- * mergeObject({k1: "v1"}, {k2: "v2"}, {insertKeys: false}); // {k1: "v1"}
- * mergeObject({k1: "v1"}, {k2: "v2"}, {insertKeys: true});  // {k1: "v1", k2: "v2"}
- * mergeObject({k1: {i1: "v1"}}, {k1: {i2: "v2"}}, {insertValues: false}); // {k1: {i1: "v1"}}
- * mergeObject({k1: {i1: "v1"}}, {k1: {i2: "v2"}}, {insertValues: true}); // {k1: {i1: "v1", i2: "v2"}}
- * ```
- *
- * @example <caption>Control how existing data is overwritten</caption>
- * ```typescript
- * mergeObject({k1: "v1"}, {k1: "v2"}, {overwrite: true}); // {k1: "v2"}
- * mergeObject({k1: "v1"}, {k1: "v2"}, {overwrite: false}); // {k1: "v1"}
- * ```
- *
- * @example <caption>Control whether merges are performed recursively</caption>
- * ```typescript
- * mergeObject({k1: {i1: "v1"}}, {k1: {i2: "v2"}}, {recursive: false}); // {k1: {i1: "v2"}}
- * mergeObject({k1: {i1: "v1"}}, {k1: {i2: "v2"}}, {recursive: true}); // {k1: {i1: "v1", i2: "v2"}}
- * ```
- *
- * @example <caption>Deleting an existing object key</caption>
- * ```typescript
- * mergeObject({k1: "v1", k2: "v2"}, {"-=k1": null});   // {k2: "v2"}
- * ```
- */
 type OmitByValue<T, ValueType> = { [Key in keyof T as T[Key] extends ValueType ? never : Key]: T[Key] };
 type RemoveNever<T> = OmitByValue<T, never>;
 type PropWithMinus<K> = K extends string ? `-=${K}` : never;
@@ -308,6 +296,43 @@ type WithWidenedArrayTypes<T> = T extends Array<any>
   ? { [K in keyof T]: WithWidenedArrayTypes<T[K]> }
   : T;
 
+/**
+ * Update a source object by replacing its keys and values with those from a target object.
+ *
+ * @param original - The initial object which should be updated with values from the target
+ * @param other    - A new object whose values should replace those in the source
+ *                   (default: `{}`)
+ * @param options  - Additional options which configure the merge
+ *                   (default: `{}`)
+ * @param _d       - A privately used parameter to track recursion depth.
+ *                   (default: `0`)
+ * @returns The original source object including updated, inserted, or overwritten records.
+ *
+ * @example <caption>Control how new keys and values are added</caption>
+ * ```typescript
+ * mergeObject({k1: "v1"}, {k2: "v2"}, {insertKeys: false}); // {k1: "v1"}
+ * mergeObject({k1: "v1"}, {k2: "v2"}, {insertKeys: true});  // {k1: "v1", k2: "v2"}
+ * mergeObject({k1: {i1: "v1"}}, {k1: {i2: "v2"}}, {insertValues: false}); // {k1: {i1: "v1"}}
+ * mergeObject({k1: {i1: "v1"}}, {k1: {i2: "v2"}}, {insertValues: true}); // {k1: {i1: "v1", i2: "v2"}}
+ * ```
+ *
+ * @example <caption>Control how existing data is overwritten</caption>
+ * ```typescript
+ * mergeObject({k1: "v1"}, {k1: "v2"}, {overwrite: true}); // {k1: "v2"}
+ * mergeObject({k1: "v1"}, {k1: "v2"}, {overwrite: false}); // {k1: "v1"}
+ * ```
+ *
+ * @example <caption>Control whether merges are performed recursively</caption>
+ * ```typescript
+ * mergeObject({k1: {i1: "v1"}}, {k1: {i2: "v2"}}, {recursive: false}); // {k1: {i1: "v2"}}
+ * mergeObject({k1: {i1: "v1"}}, {k1: {i2: "v2"}}, {recursive: true}); // {k1: {i1: "v1", i2: "v2"}}
+ * ```
+ *
+ * @example <caption>Deleting an existing object key</caption>
+ * ```typescript
+ * mergeObject({k1: "v1", k2: "v2"}, {"-=k1": null});   // {k2: "v2"}
+ * ```
+ */
 export declare function mergeObject<
   T extends object,
   U extends DeepPartial<WithWidenedArrayTypes<T>>,

package/src/foundry/common/utils/module.mjs.d.ts

@@ -1,3 +1,4 @@
+export * from './geometry.mjs';
 export * from './helpers.mjs';
 export { default as Collection } from './collection.mjs';
 export { default as Semaphore } from './semaphore.mjs';

package/src/foundry/common/utils/primitives.mjs.d.ts

@@ -1,4 +1,4 @@
-declare interface Math {
+interface Math {
   /**
    * Bound a number between some minimum and maximum value, inclusively
    * @param num - The current value
@@ -44,7 +44,7 @@ declare interface Math {
   toRadians(angle: number): number;
 }
 
-declare interface Set<T> {
+interface Set<T> {
   /**
    * Test whether this set is equal to some other set.
    * Sets are equal if they share the same members, independent of order
@@ -53,6 +53,26 @@ declare interface Set<T> {
    */
   equals(other: Set<T>): boolean;
 
+  /**
+   * Return the first value from the set.
+   * @returns The first element in the set, or undefined
+   */
+  first(): T | undefined;
+
+  /**
+   * Return the intersection of two sets.
+   * @param other - Some other set to compare against
+   * @returns The intersection of both sets
+   */
+  intersection(other: Set<T>): Set<T>;
+
+  /**
+   * Test whether this set has an intersection with another set.
+   * @param other - Another set to compare against
+   * @returns Do the sets intersect?
+   */
+  intersects(other: Set<T>): boolean;
+
   /**
    * Test whether this set is a subset of some other set.
    * A set is a subset if all its members are also present in the other set.
@@ -62,9 +82,15 @@ declare interface Set<T> {
   isSubset(other: Set<T>): boolean;
 }
 
-declare interface String {
+interface String {
+  /**
+   * Capitalize a string, transforming it's first character to a capital letter
+   */
   capitalize<S extends string>(this: S): Capitalize<S>;
 
+  /**
+   * Convert a string to Title Case where the first letter of each word is capitalized
+   */
   titleCase<S extends string>(this: S): Titlecase<S>;
 
   /**
@@ -74,20 +100,59 @@ declare interface String {
 
   /**
    * Transform any string into a url-viable slug string
-   * @param replacement - The replacement character to separate terms
-   *                      (default: `'-'`)
-   * @param strict      - Replace all non-alphanumeric characters, or allow them?
-   *                      (default: `false`)
+   * @param options - Optional arguments which customize how the slugify operation is performed
    * @returns The cleaned slug string
    */
-  slugify({ replacement, strict }?: { replacement?: string; strict?: boolean }): string;
+  slugify(options?: String.SlugifyOptions): string;
+}
+
+declare namespace String {
+  interface SlugifyOptions {
+    /**
+     * The replacement character to separate terms
+     * @defaultValue `'-'`
+     */
+    replacement?: string;
+
+    /**
+     * Replace all non-alphanumeric characters, or allow them?
+     * @defaultValue `false`
+     */
+    strict?: boolean;
+  }
 }
 
-declare interface Number {
+interface Number {
+  /**
+   * Test for near-equivalence of two numbers within some permitted epsilon
+   * @param n - Some other number
+   * @param e - Some permitted epsilon, by default 1e-8
+                (default: `1e-8`)
+   * @returns Are the numbers almost equal?
+   */
+  almostEqual(n: number, e?: number): boolean;
+
+  /**
+   * Transform a number to an ordinal string representation. i.e.
+   * ```
+   * 1 => 1st
+   * 2 => 2nd
+   * 3 => 3rd
+   * ```
+   */
   ordinalString(): string;
 
+  /**
+   * Return a string front-padded by zeroes to reach a certain number of numeral characters
+   * @param digits - The number of characters desired
+   * @returns The zero-padded number
+   */
   paddedString(digits: number): string;
 
+  /**
+   * Return a string prefaced by the sign of the number (+) or (-)
+   * @returns The signed number as a string
+   */
   signedString(): string;
 
   /**
@@ -110,10 +175,15 @@ declare interface Number {
    */
   toNearest(interval?: number, method?: 'round' | 'ceil' | 'floor'): number;
 
+  /**
+   * A faster numeric between check which avoids type coercion to the Number object
+   * Since this avoids coercion, if non-numbers are passed in unpredictable results will occur. Use with caution.
+   * @param inclusive - (default: `true`)
+   */
   between(a: number, b: number, inclusive?: boolean): boolean;
 }
 
-declare interface NumberConstructor {
+interface NumberConstructor {
   /**
    * A faster numeric between check which avoids type coercion to the Number object
    * Since this avoids coercion, if non-numbers are passed in unpredictable results will occur. Use with caution.
@@ -123,19 +193,27 @@ declare interface NumberConstructor {
 
   /**
    * Test whether a value is numeric
-   * This is the highest performing algorithm currently available
-   * https://jsperf.com/isnan-vs-typeof/5
+   * This is the highest performing algorithm currently available, per https://jsperf.com/isnan-vs-typeof/5
    * @param n - A value to test
    * @returns Is it a number?
    */
   isNumeric(n: unknown): n is number;
 }
 
-declare interface ArrayConstructor {
+interface ArrayConstructor {
+  /**
+   * Create and initialize an array of length n with integers from 0 to n-1
+   * @param n - The desired array length
+   * @returns An array of integers from 0 to n
+   */
   fromRange(n: number): number[];
 }
 
-declare interface Array<T> {
+interface Array<T> {
+  /**
+   * Flatten nested arrays by concatenating their contents
+   * @returns An array containing the concatenated inner values
+   */
   deepFlatten(): Array<Array.Flattened<T>>;
 
   /**
@@ -171,7 +249,7 @@ declare namespace Array {
   type Flattened<T> = T extends Array<infer U> ? Flattened<U> : T;
 }
 
-declare interface Date {
+interface Date {
   /**
    * Test whether a Date instance is valid.
    * A valid date returns a number for its timestamp, and NaN otherwise.
@@ -192,6 +270,11 @@ declare interface Date {
   toTimeInputString(): string;
 }
 
-declare interface RegExpConstructor {
+interface RegExpConstructor {
+  /**
+   * Escape a given input string, prefacing special characters with backslashes for use in a regular expression
+   * @param string - The un-escaped input string
+   * @returns  The escaped string, suitable for use in regular expression
+   */
   escape(string: string): string;
 }