@amazon/vinyl-util 1.0.0

package/dist/types/ts4.7/util/collection/array.d.ts

@@ -0,0 +1,207 @@
+import { type Comparator } from '../../util/comparison/compare';
+import type { Maybe, MaybePromise, Primitive } from '../../util/type';
+export type FilterPredicateAsync<T> = (value: T, index: number, array: ArrayLike<T>) => Promise<boolean>;
+export type FilterPredicate<T> = (value: T, index: number, array: ArrayLike<T>) => boolean;
+/**
+ * indexOf on ArrayLike objects.
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf
+ */
+export declare function indexOf<E>(arrayLike: ArrayLike<E>, element: E): number;
+/**
+ * lastIndexOf on ArrayLike objects.
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf
+ */
+export declare function lastIndexOf<E>(arrayLike: ArrayLike<E>, element: E): number;
+export declare function filter<T, S extends T>(arrayLike: ArrayLike<T>, predicate: (value: T, index: number, array: ArrayLike<T>) => value is S, thisArg?: any): S[];
+export declare function filter<T>(arrayLike: ArrayLike<T>, predicate: (value: T, index: number, array: ArrayLike<T>) => boolean, thisArg?: any): T[];
+/**
+ * Filter an ArrayLike with an asynchronous predicate.
+ *
+ * Runs the predicate across all elements, then filters the elements by the booleans
+ * resolved by the predicate.
+ *
+ * @param arrayLike The array-like object to filter
+ * @param predicate Async function that tests each element
+ * @param options Optional configuration object
+ * @param options.simultaneous Maximum number of predicates to run simultaneously (default: 1)
+ */
+export declare function filterAsync<T>(arrayLike: MaybePromise<ArrayLike<T>>, predicate: (value: T, index: number, array: ArrayLike<T>) => Promise<boolean>, options?: {
+    readonly simultaneous?: number;
+}): Promise<T[]>;
+/**
+ * map on ArrayLike objects.
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map
+ */
+export declare function map<T, U>(arrayLike: ArrayLike<T>, transform: (value: T, index: number, array: ArrayLike<T>) => U, thisArg?: any): U[];
+/**
+ * Map on ArrayLike objects with an asynchronous transformer.
+ *
+ * @param arrayLike The array-like object to transform
+ * @param transform Async function that transforms each element
+ * @param options Optional configuration object
+ * @param options.simultaneous Maximum number of transforms to run simultaneously (default: 1)
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map
+ */
+export declare function mapAsync<T, U>(arrayLike: MaybePromise<ArrayLike<T>>, transform: (value: T, index: number, array: ArrayLike<T>) => Promise<U>, options?: {
+    readonly simultaneous?: number;
+}): Promise<U[]>;
+/**
+ * Determines whether all the members of an array satisfy the specified test.
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every
+ */
+export declare function every<T>(arrayLike: ArrayLike<T>, predicate: (value: T, index: number, array: ArrayLike<T>) => boolean, thisArg?: any): boolean;
+/**
+ * Determines whether any the members of an array satisfy the specified test.
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some
+ */
+export declare function some<T>(arrayLike: ArrayLike<T>, predicate: (value: T, index: number, array: ArrayLike<T>) => boolean, thisArg?: any): boolean;
+/**
+ * Determines whether all the members of an array satisfy the specified asynchronous test.
+ *
+ * @param arrayLike The array-like object to test
+ * @param predicate Async function that tests each element
+ * @param options Optional configuration object
+ * @param options.simultaneous Maximum number of predicates to run simultaneously (default: 1)
+ */
+export declare function everyAsync<T>(arrayLike: MaybePromise<ArrayLike<T>>, predicate: (value: T, index: number, array: ArrayLike<T>) => Promise<boolean>, options?: {
+    readonly simultaneous?: number;
+}): Promise<boolean>;
+/**
+ * Determines whether any the members of an array satisfy the specified asynchronous test.
+ *
+ * @param arrayLike The array-like object to test
+ * @param predicate Async function that tests each element
+ * @param options Optional configuration object
+ * @param options.simultaneous Maximum number of predicates to run simultaneously (default: 1)
+ */
+export declare function someAsync<T>(arrayLike: MaybePromise<ArrayLike<T>>, predicate: (value: T, index: number, array: ArrayLike<T>) => Promise<boolean>, options?: {
+    readonly simultaneous?: number;
+}): Promise<boolean>;
+/**
+ * forEach on ArrayLike objects.
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach
+ */
+export declare function forEach<T>(arrayLike: ArrayLike<T>, action: (value: T, index: number, array: ArrayLike<T>) => void, thisArg?: any): void;
+/**
+ * Executes an asynchronous function on each element in an array.
+ *
+ * @param arrayLike The array-like object to iterate over
+ * @param executor Async function to execute for each element
+ * @param options Optional configuration object
+ * @param options.simultaneous Maximum number of executors to run simultaneously (default: 1)
+ */
+export declare function forEachAsync<T>(arrayLike: MaybePromise<ArrayLike<T>>, executor: (value: T, index: number, array: ArrayLike<T>) => Promise<void>, options?: {
+    readonly simultaneous?: number;
+}): Promise<void>;
+export declare function find<T, S extends T>(arrayLike: ArrayLike<T>, predicate: (this: void, value: T, index: number, obj: T[]) => value is S, thisArg?: any): S | undefined;
+export declare function find<T>(arrayLike: ArrayLike<T>, predicate: (value: T, index: number, obj: T[]) => boolean, thisArg?: any): T | undefined;
+/**
+ * findIndex on ArrayLike objects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex
+ */
+export declare function findIndex<T>(arrayLike: ArrayLike<T>, predicate: (value: T, index: number, obj: ArrayLike<T>) => unknown, thisArg?: any): number;
+/**
+ * Returns the first element of an ArrayLike.
+ */
+export declare function first<T>(arrayLike: Maybe<ArrayLike<T>>): T | undefined;
+/**
+ * Returns the last element of an ArrayLike.
+ */
+export declare function last<T>(arrayLike: Maybe<ArrayLike<T>>): T | undefined;
+/**
+ * Returns the first `count` elements of an ArrayLike.
+ * @param arrayLike
+ * @param count
+ */
+export declare function takeFirst<T>(arrayLike: ArrayLike<T>, count: number): T[];
+/**
+ * Returns the last `count` elements of an ArrayLike.
+ *
+ * @param arrayLike
+ * @param count
+ */
+export declare function takeLast<T>(arrayLike: ArrayLike<T>, count: number): T[];
+/**
+ * Returns a subsection of an array-like.
+ * For both start and end, a negative index can be used to indicate an offset from the end of
+ * the array.
+ * For example, -2 refers to the second to last element of the array.
+ *
+ * @param arrayLike An ArrayLike to copy.
+ * @param start The beginning index of the array-like. Default: 0
+ * @param end The end index of the specified portion of the array-like (exclusive). Default: length
+ */
+export declare function slice<T>(arrayLike: ArrayLike<T>, start?: number, end?: number): T[];
+/**
+ * Removes an element from the array, returning true if it was found.
+ */
+export declare function remove<T>(array: T[], element: T): boolean;
+/**
+ * Removes an element from the array at the given index, returning the removed element if the index
+ * was within range.
+ * @param array The Array to update.
+ * @param index If negative, will remove from the end of the list (-1 is last element), if
+ * greater than or equal to the list length, undefined will be returned.
+ */
+export declare function removeAt<T>(array: T[], index: number): T | undefined;
+/**
+ * Returns the index of the first element in the given array with the highest value according to
+ * the comparator.
+ * @param array
+ * @param comparator
+ */
+export declare function indexOfHighest<T>(array: ArrayLike<T>, comparator: Comparator<T>): number;
+/**
+ * Returns the index of the last element in the given array with the highest value according to
+ * the comparator.
+ * To find the index of the lowest value, use `util.comparator.reversed`
+ * @param array
+ * @param comparator
+ */
+export declare function lastIndexOfHighest<T>(array: ArrayLike<T>, comparator: Comparator<T>): number;
+/**
+ * Given an array using the given comparator function, finds the insertion index of an element.
+ *
+ * @param array An array sorted using the comparator.
+ * @param element The element to compare against array elements.
+ * @param comparator A function where given the return value of `comparator(element, array[i])`
+ * if less than zero the returned index will be before i, otherwise after.
+ * @param start The starting index (inclusive). Default: 0
+ * @param end The ending index (exclusive). Default: array.length
+ */
+export declare function sortedInsertionIndex<T, U = T>(array: ArrayLike<T>, element: U, comparator: Comparator<U, T>, start?: number, end?: number): number;
+/**
+ * Creates an iterator for an ArrayLike.
+ * If the given ArrayLike is iterable, then use its provided iterator.
+ *
+ * @param arrayLike
+ */
+export declare function createArrayLikeIterator<T>(arrayLike: ArrayLike<T>): IterableIterator<T>;
+/**
+ * Gets the element in the ArrayLike at the given index, or throws an IllegalArgumentError if out of range.
+ */
+export declare function getElementAt<T>(array: ArrayLike<T>, index: number): T;
+/**
+ * Gets the element in the ArrayLike at the given index, or returns the provided default value.
+ */
+export declare function getElementOrDefault<T, V>(array: ArrayLike<T>, index: number, defaultValue: V): T | V;
+/**
+ * Counts the number of elements in an array that return true when passed to a predicate function.
+ *
+ * @param array
+ * @param predicate
+ */
+export declare function countElements<T>(array: ArrayLike<T>, predicate: (value: T, index: number, obj: ArrayLike<T>) => boolean): number;
+/**
+ * Splits an array into chunks of the specified size.
+ *
+ * @param array The array to chunk
+ * @param chunkSize Maximum size of each chunk
+ * @returns Array of chunks
+ */
+export declare function chunk<T>(array: ArrayLike<T>, chunkSize: number): T[][];
+export declare function min<T extends Exclude<Primitive, symbol>>(arrayLike: ArrayLike<T>): T | undefined;
+export declare function min<T>(arrayLike: ArrayLike<T>, comparator: Comparator<T>): T | undefined;
+export declare function max<T extends Exclude<Primitive, symbol>>(arrayLike: ArrayLike<T>): T | undefined;
+export declare function max<T>(arrayLike: ArrayLike<T>, comparator: Comparator<T>): T | undefined;
+//# sourceMappingURL=array.d.ts.map

package/dist/types/ts4.7/util/collection/typedArray.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Array views of a data buffer.
+ */
+export type TypedArray = Float32Array | Float64Array | Int16Array | Int32Array | Int8Array | Uint16Array | Uint32Array | Uint8Array | Uint8ClampedArray;
+/**
+ * Creates a new typed array with identical contents as the source.
+ *
+ * @param array
+ */
+export declare function cloneTypedArray<T extends TypedArray>(array: T): T;
+/**
+ * Returns true if the given value is an instance of one of the typed array types.
+ *
+ * @param value
+ */
+export declare function isTypedArray(value: any): value is TypedArray;
+//# sourceMappingURL=typedArray.d.ts.map

package/dist/types/ts4.7/util/comparison/compare.d.ts

@@ -0,0 +1,33 @@
+import type { Maybe, Primitive } from '../../util/type';
+/**
+ * A function that can be used as a comparator for sorting.
+ * Return > 0 if `a` is greater than `b`
+ * Return = 0 if `a` equals `b`
+ * Return < 0 if `a` is less than `b
+ */
+export type Comparator<A, B = A> = (a: A, b: B) => number;
+/**
+ * Provides a primitive value plucked from an element. Used in {@link compareBy} for building a comparator.
+ */
+export type CompareBySelector<T> = (value: T) => Exclude<Primitive, symbol>;
+/**
+ * Creates a comparator for objects of type T by using a selector to pick a primitive value.
+ *
+ * @param selectors
+ */
+export declare function compareBy<T>(...selectors: CompareBySelector<T>[]): Comparator<Maybe<T>>;
+/**
+ * Reverses the order of a comparator.
+ *
+ * @param comparator
+ */
+export declare function reversed<A, B>(comparator: Comparator<A, B>): Comparator<A, B>;
+/**
+ * Compares two primitive values.
+ *
+ * Return 1 if `a` is greater than `b`
+ * Return 0 if `a` equals `b`
+ * Return -1 if `a` is less than `b
+ */
+export declare function compare<T extends Exclude<Primitive, symbol>>(a: T | null, b: T | null): number;
+//# sourceMappingURL=compare.d.ts.map

package/dist/types/ts4.7/util/config/ValueProvider.d.ts

@@ -0,0 +1,17 @@
+import type { MaybePromise } from '../../util/type';
+/**
+ * A value of type T, a function returning T, or an async function returning a Promise<T>.
+ * To be used with `resolveValueProvider`.
+ */
+export type ValueProvider<T> = T | (() => MaybePromise<T>);
+/**
+ * Resolves a ValueProvider to its underlying value.
+ *
+ * Handles all three ValueProvider forms: direct values, synchronous functions,
+ * and async functions, returning a Promise that resolves to the value.
+ *
+ * @param valueProvider - The value, function, or async function to resolve
+ * @returns A Promise resolving to the provided value of type T
+ */
+export declare function resolveValueProvider<T>(valueProvider: ValueProvider<T>): Promise<T>;
+//# sourceMappingURL=ValueProvider.d.ts.map

package/dist/types/ts4.7/util/date/date.d.ts

@@ -0,0 +1,32 @@
+import type { ReadonlyDate } from '../../util/object/readonlyType';
+/**
+ * Returns the signed time difference of end - start, in seconds.
+ *
+ * @param start The beginning date
+ * @param end The later date
+ */
+export declare function timeDelta(start: ReadonlyDate, end: ReadonlyDate): number;
+/**
+ * A type alias to clarify that a number represents a unix timestamp
+ * (milliseconds from 1970-1-1 00:00).
+ */
+export type Timestamp = number;
+/**
+ * Parses a string into a unix Timestamp using `Date.parse`, if the date is invalid, throws a
+ * `ValidationError`
+ * @param str
+ */
+export declare function parseTimestamp(str: string): Timestamp;
+/**
+ * Parses a string into a date using `Date.parse`, if the date is invalid, throws a
+ * `ValidationError`
+ * @param str
+ */
+export declare function parseDate(str: string): Date;
+/**
+ * Returns the iso 8601 string representation of a `Date` value.
+ *
+ * @param value
+ */
+export declare function stringifyDate(value: ReadonlyDate): string;
+//# sourceMappingURL=date.d.ts.map

package/dist/types/ts4.7/util/error/stack.d.ts

@@ -0,0 +1,79 @@
+import type { Maybe } from '../../util/type';
+/**
+ * A location in code.
+ */
+export interface CodeLocation {
+    /**
+     * The source location - may provide the function name or in some browsers the source file if
+     * source maps are enabled.
+     */
+    readonly source: string | null;
+    /**
+     * The url to the file.
+     */
+    readonly file: string | null;
+    /**
+     * The row (line) number.
+     */
+    readonly row: number;
+    /**
+     * The column number. May not be present on all browsers (e.g. Firefox < 30).
+     */
+    readonly col: number | null;
+}
+/**
+ * A Comparator for determining if one code location is before or after another.
+ *
+ * @private
+ */
+export declare const codeLocationComparator: import("../../util/comparison/compare").Comparator<Maybe<CodeLocation>, Maybe<CodeLocation>>;
+/**
+ * Boundary code locations, used to determine if an error is within a certain range of code.
+ * The start and end boundaries must be the same path and file to be a valid range.
+ */
+export interface CodeRange {
+    /**
+     * The starting code location (inclusive)
+     */
+    readonly start: CodeLocation | null;
+    /**
+     * The ending code location (exclusive)
+     */
+    readonly end: CodeLocation | null;
+}
+/**
+ * Creates a code range object from two error markers.
+ * @see parseStackLocation
+ */
+export declare function createRangeFromErrorMarkers(start: Error | undefined, end: Error | undefined): CodeRange;
+/**
+ * Returns true if the given location is within a range of code.
+ *
+ * @param location The location of the code to check if within bounds. If falsy, false is
+ * returned.
+ * @param range The boundaries to check against. If both start and end are null, false is
+ * returned. The range will consider `range.start` to be inclusive, and `range.end` to be exclusive.
+ */
+export declare function isCodeLocationInRange(location: Maybe<CodeLocation>, range: CodeRange): boolean;
+/**
+ * Returns the location of the stack's first line match; the location the error was constructed.
+ *
+ * @param stack
+ */
+export declare function parseStackLocation(stack?: Maybe<string>): CodeLocation | null;
+/**
+ * Used in comparison with `stackNoiseError2` to determine what leading stack lines should be
+ * trimmed.
+ * @private
+ */
+export declare const stackNoiseError1: Error;
+/**
+ * @private
+ */
+export declare const stackNoiseError2: Error;
+/**
+ * When corejs polyfills Error with clearErrorStack, the stack may begin with the polyfill
+ * location. Trim the beginning of stacks with the leading lines common to all errors.
+ */
+export declare const stackNoise: import("../../util/object/lazy").Lazy<string>;
+//# sourceMappingURL=stack.d.ts.map

package/dist/types/ts4.7/util/fun/debounce.d.ts

@@ -0,0 +1,12 @@
+import type { Disposable } from '../../core/disposable';
+export type DebounceCallback = Disposable & (() => void);
+/**
+ * Debounce wraps a callback, ensuring it only executes after a certain period of inactivity.
+ *
+ * @param inner The function to execute after a given period of inactivity.
+ * @param duration The number of seconds the returned wrapper function must not be called before the inner function
+ * is invoked.
+ * @return Returns callback wrapper that enforces inactivity. This may be disposed.
+ */
+export declare function debounce(inner: () => void, duration: number): DebounceCallback;
+//# sourceMappingURL=debounce.d.ts.map

package/dist/types/ts4.7/util/fun/flow.d.ts

@@ -0,0 +1,38 @@
+import type { MaybePromise } from '../type';
+/**
+ * Creates a function that is the composition of the provided functions.
+ * Each function consumes the return value of the function that follows.
+ */
+export declare function flow<A, B>(f1: (a: A) => B): (a: A) => B;
+export declare function flow<A, B, C>(f1: (a: A) => B, f2: (b: B) => C): (a: A) => C;
+export declare function flow<A, B, C, D>(f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D): (a: A) => D;
+export declare function flow<A, B, C, D, E>(f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E): (a: A) => E;
+export declare function flow<A, B, C, D, E, F>(f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E, f5: (e: E) => F): (a: A) => F;
+/**
+ * Creates a function that is the composition of the provided functions.
+ * Each function consumes the return value of the function that precedes.
+ */
+export declare function flowRight<A, B>(f1: (a: A) => B): (a: A) => B;
+export declare function flowRight<A, B, C>(f1: (b: B) => C, f2: (a: A) => B): (a: A) => C;
+export declare function flowRight<A, B, C, D>(f1: (c: C) => D, f2: (b: B) => C, f3: (a: A) => B): (a: A) => D;
+export declare function flowRight<A, B, C, D, E>(f1: (d: D) => E, f2: (c: C) => D, f3: (b: B) => C, f4: (a: A) => B): (a: A) => E;
+export declare function flowRight<A, B, C, D, E, F>(f1: (e: E) => F, f2: (d: D) => E, f3: (c: C) => D, f4: (b: B) => C, f5: (a: A) => B): (a: A) => F;
+/**
+ * Creates a function that is the composition of the provided async functions.
+ * Each function consumes the return value of the function that follows.
+ */
+export declare function flowAsync<A, B>(f1: (a: A) => MaybePromise<B>): (a: A) => Promise<B>;
+export declare function flowAsync<A, B, C>(f1: (a: A) => MaybePromise<B>, f2: (b: B) => MaybePromise<C>): (a: A) => Promise<C>;
+export declare function flowAsync<A, B, C, D>(f1: (a: A) => MaybePromise<B>, f2: (b: B) => MaybePromise<C>, f3: (c: C) => MaybePromise<D>): (a: A) => Promise<D>;
+export declare function flowAsync<A, B, C, D, E>(f1: (a: A) => MaybePromise<B>, f2: (b: B) => MaybePromise<C>, f3: (c: C) => MaybePromise<D>, f4: (d: D) => MaybePromise<E>): (a: A) => Promise<E>;
+export declare function flowAsync<A, B, C, D, E, F>(f1: (a: A) => MaybePromise<B>, f2: (b: B) => MaybePromise<C>, f3: (c: C) => MaybePromise<D>, f4: (d: D) => MaybePromise<E>, f5: (e: E) => MaybePromise<F>): (a: A) => Promise<F>;
+/**
+ * Creates a function that is the composition of the provided async functions.
+ * Each function consumes the return value of the function that precedes.
+ */
+export declare function flowRightAsync<A, B>(f1: (a: A) => MaybePromise<B>): (a: A) => Promise<B>;
+export declare function flowRightAsync<A, B, C>(f1: (b: B) => MaybePromise<C>, f2: (a: A) => MaybePromise<B>): (a: A) => Promise<C>;
+export declare function flowRightAsync<A, B, C, D>(f1: (c: C) => MaybePromise<D>, f2: (b: B) => MaybePromise<C>, f3: (a: A) => MaybePromise<B>): (a: A) => Promise<D>;
+export declare function flowRightAsync<A, B, C, D, E>(f1: (d: D) => MaybePromise<E>, f2: (c: C) => MaybePromise<D>, f3: (b: B) => MaybePromise<C>, f4: (a: A) => MaybePromise<B>): (a: A) => Promise<E>;
+export declare function flowRightAsync<A, B, C, D, E, F>(f1: (e: E) => MaybePromise<F>, f2: (d: D) => MaybePromise<E>, f3: (c: C) => MaybePromise<D>, f4: (b: B) => MaybePromise<C>, f5: (a: A) => MaybePromise<B>): (a: A) => Promise<F>;
+//# sourceMappingURL=flow.d.ts.map

package/dist/types/ts4.7/util/fun/function.d.ts

@@ -0,0 +1,5 @@
+/**
+ * No-op, does nothing.
+ */
+export declare function noop(..._: any[]): void;
+//# sourceMappingURL=function.d.ts.map

package/dist/types/ts4.7/util/fun/memoize.d.ts

@@ -0,0 +1,24 @@
+import type { Fun } from '../../util/type';
+export interface MemoizedFunction {
+    clear(): void;
+}
+/**
+ * Returns a wrapper function where when called, retains the return value of `inner`, returning that
+ * value on consecutive calls without invoking `inner` again.
+ *
+ * @param inner The function to memoize results.
+ * @return Returns a memoized function with a `clear` method to reset the cached value.
+ */
+export declare function memoize<T extends () => any>(inner: T): MemoizedFunction & T;
+/**
+ * Returns a wrapper function where when called, retains the return value of `inner`, returning that
+ * value on consecutive calls without invoking `inner` again.
+ *
+ * @param inner The function to memoize results.
+ * @param keyProvider When more than one parameter is expected, a keyProvider is required, which
+ * returns a unique key given the arguments provided to the memoized function.
+ * @param capacity
+ * @return Returns a memoized function with a `clear` method to reset the cache.
+ */
+export declare function memoize<T extends Fun>(inner: T, keyProvider: (...args: Parameters<T>) => any, capacity?: number): MemoizedFunction & T;
+//# sourceMappingURL=memoize.d.ts.map

package/dist/types/ts4.7/util/fun/throttle.d.ts

@@ -0,0 +1,34 @@
+import type { Disposable } from '../../core/disposable';
+export interface ThrottleOptions {
+    /**
+     * If true, the first invocation of a throttled function will pass through.
+     */
+    readonly leading: boolean;
+    /**
+     * If true, when the throttle window time has elapsed, the function will be invoked.
+     * Either leading or trailing must be true.
+     * When trailing is true, timers will be used
+     */
+    readonly trailing: boolean;
+}
+export interface ThrottledCallback extends Disposable {
+    (): void;
+    /**
+     * Resets the throttle timer.
+     * If an inner call is pending, it will be immediately invoked.
+     */
+    reset(): void;
+}
+/**
+ * Throttle returns a function that limits the rate of invocations.
+ *
+ * @param inner The function to invoke at a throttled rate.
+ * @param duration The interval (in seconds) for which the throttled function will be limited.
+ * @param options Options for which ends of the window the function should be invoked. If omitted,
+ * leading and trailing will be true.
+ * @return Returns a method that, when invoked, will invoke the inner method at a throttled rate.
+ * The returned method will have a `dispose` handle to clear any active timers and prevent
+ * further invocation.
+ */
+export declare function throttle(inner: () => void, duration: number, options?: Partial<ThrottleOptions>): ThrottledCallback;
+//# sourceMappingURL=throttle.d.ts.map

package/dist/types/ts4.7/util/iteration/iterable.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Returns an array of numbers between start and end, incrementing by step.
+ *
+ * E.g.
+ * ```
+ * range(1, 10) // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+ * range(5, 2) // [5, 4, 3, 2]
+ * range(5, 4, -0.2) // [5.0, 4.8, 4.6, 4.4, 4.2, 4.0]
+ * ```
+ * @param start Start position (inclusive)
+ * @param endInclusive End position (inclusive)
+ * @param step The amount to increment.
+ */
+export declare function createRangeIter(start: number, endInclusive: number, step?: number): IterableIterator<number>;
+/**
+ * Maps an iterable object using the given transform.
+ * Unlike `Array#map`, this doesn't create a new Array in memory, the transform is done on
+ * iteration.
+ *
+ * @param iterable
+ * @param transform Transforms each element as it's requested.
+ */
+export declare function mapIter<T, U>(iterable: Iterable<T>, transform: (element: T) => U): IterableIterator<U>;
+export declare function filterIter<T, S extends T>(iterable: Iterable<T>, predicate: (value: T) => value is S): IterableIterator<S>;
+export declare function filterIter<T>(iterable: Iterable<T>, predicate: (value: T) => boolean): IterableIterator<T>;
+//# sourceMappingURL=iterable.d.ts.map

package/dist/types/ts4.7/util/map/map.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Gets the value on map for the given key if it exists, otherwise sets [key] to `defaultValue`,
+ * returning the newly set value.
+ *
+ * @param map
+ * @param key
+ * @param defaultValue
+ */
+export declare function getOrSet<K, V>(map: Map<K, V>, key: K, defaultValue: (key: K) => V): V;
+/**
+ * Flips a map so that the keys become the values and the values become the keys.
+ *
+ * @param map
+ * @return Returns a new map.
+ */
+export declare function flipMap<K, V>(map: ReadonlyMap<K, V>): Map<V, K>;
+//# sourceMappingURL=map.d.ts.map

package/dist/types/ts4.7/util/math/math.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Clamps the given value between `min` and `max`.
+ *
+ * @param value
+ * @param min The lower bounds.
+ * @param max The upper bounds. If this value is less than min, this value will always be returned.
+ */
+export declare function clamp(value: number, min: number, max: number): number;
+/**
+ * Linearly interpolates between `from` and `to` given a percentage.
+ *
+ * @param from The alpha = 0.0 value
+ * @param to The alpha = 1.0 value
+ * @param alpha A percentage where 0 is `from`, and 1 is `to`. E.g. 0.5 would return halfway
+ * between `from` and `to`.
+ */
+export declare function lerp(from: number, to: number, alpha: number): number;
+/**
+ * Floors a value to the nearest snap interval.
+ *
+ * Examples:
+ *
+ * ```
+ * floorToNearest(3, 2) // 2
+ * floorToNearest(16, 5) // 15
+ * floorToNearest(16, 5, 2) // 17
+ * ```
+ *
+ * @param value The value to floor with the given snap interval and offset.
+ * @param snap The interval between output values. Should be a finite, non-zero number.
+ * @param offset The offset of the interval. E.g. if snap is 10 and offset is 1, values will be
+ * snapped to `-19, -9, 1, 11, 21, 31, 41, ...`
+ */
+export declare function floorToNearest(value: number, snap: number, offset?: number): number;
+/**
+ * Ceilings a value to the nearest snap interval.
+ *
+ * Examples:
+ *
+ * ```
+ * ceilToNearest(3, 2) // 4
+ * ceilToNearest(16, 5) // 20
+ * ceilToNearest(10, 5) // 10
+ * ceilToNearest(16, 5, 2) // 22
+ * ```
+ *
+ * @param value The value to ceil with the given snap interval and offset.
+ * @param snap The interval between output values. Should be a finite, non-zero number.
+ * @param offset The offset of the interval. E.g. if snap is 10 and offset is 1, values will be
+ * snapped to `-19, -9, 1, 11, 21, 31, 41, ...`
+ */
+export declare function ceilToNearest(value: number, snap: number, offset?: number): number;
+/**
+ * Rounds a value to the nearest snap interval.
+ *
+ * Examples:
+ *
+ * ```
+ * roundToNearest(3, 2) // 4
+ * roundToNearest(16, 5) // 15
+ * roundToNearest(18, 5) // 20
+ * roundToNearest(16, 10, 2) // 22
+ * ```
+ *
+ * @param value The value to round with the given snap interval and offset.
+ * @param snap The interval between output values. Should be a finite, non-zero number.
+ * @param offset The offset of the interval. E.g. if snap is 10 and offset is 1, values will be
+ * snapped to `-19, -9, 1, 11, 21, 31, 41, ...`
+ */
+export declare function roundToNearest(value: number, snap: number, offset?: number): number;
+/**
+ * Returns true if `x` is within `tolerance` of `y`.
+ *
+ * @param x
+ * @param y
+ * @param tolerance
+ */
+export declare function closeTo(x: number, y: number, tolerance?: number): boolean;
+//# sourceMappingURL=math.d.ts.map