@amazon/vinyl-util 1.0.0

package/dist/types/ts4.1/util/collection/LruCache.d.ts

@@ -0,0 +1,96 @@
+import type { CacheMap } from './CacheMap';
+/**
+ * An LRU Cache implementation.
+ * An LRU (Least Recently Used) Cache is a Map with a fixed capacity. When the capacity is
+ * exceeded, the least recently used element will be removed.
+ * An element is considered to be used when it has been retrieved via `get`, or when it's been
+ * `set`.
+ * Iteration does not affect ordering.
+ */
+export declare class LruCache<K, V> implements CacheMap<K, V> {
+    /**
+     * A map of the list nodes.
+     *
+     * @private
+     */
+    private cache;
+    /**
+     * Most recently used elements are at the tail, least recently used are at the head.
+     * @private
+     */
+    private list;
+    /**
+     * An element is about to be removed. Should return true if the element may be evicted,
+     * otherwise false.
+     * If false is returned for all elements, an IllegalStateError is thrown.
+     */
+    onEvicting: ((element: V, key: K, list: CacheMap<K, V>) => boolean) | null;
+    /**
+     * When an element is added when at capacity, the least recently used element will be removed.
+     * This callback can be set to be notified with the element being evicted, which may be used
+     * for disposal.
+     */
+    onEvict: ((element: V, key: K, list: CacheMap<K, V>) => void) | null;
+    private _capacity;
+    constructor(initialCapacity: number);
+    get capacity(): number;
+    set capacity(value: number);
+    get size(): number;
+    /**
+     * @returns boolean indicating whether an element with the specified key exists or not.
+     */
+    has(key: K): boolean;
+    /**
+     * Returns the mapped value for the given key, and moves the element to the most recently
+     * used position.
+     *
+     * @returns Returns the element associated with the given key, or undefined if no such
+     * element exists.
+     */
+    get(key: K): V | undefined;
+    /**
+     * Adds a new element with a specified key and value to the Map. If an element with the
+     * same key already exists, the element will be updated and position moved to most recently
+     * used.
+     */
+    set(key: K, value: V): this;
+    private evictLeastRecentlyUsed;
+    /**
+     * Clears all elements from the cache.
+     */
+    clear(): void;
+    /**
+     * @returns true if an element in the Map existed and has been removed, or false if the element does not exist.
+     */
+    delete(key: K): boolean;
+    /**
+     * Executes a provided function once per each key/value pair in the Map, in insertion order.
+     *
+     * @param callback A callback to invoke for every element in the cache.
+     * @param thisArg Value to use as this when executing callback
+     */
+    forEach(callback: (value: V, key: K, map: this) => void, thisArg?: any): void;
+    /**
+     * Returns an iterable of key, value pairs for every entry in the map.
+     */
+    entries(): IterableIterator<[
+        K,
+        V
+    ]>;
+    /**
+     * Returns an iterable of keys in the map. This will be ordered from least recently used to
+     * most.
+     */
+    keys(): IterableIterator<K>;
+    /**
+     * Returns an iterable of values in the map. This will be ordered from least recently used to
+     * most.
+     */
+    values(): IterableIterator<V>;
+    [Symbol.iterator](): IterableIterator<[
+        K,
+        V
+    ]>;
+    get [Symbol.toStringTag](): string;
+}
+//# sourceMappingURL=LruCache.d.ts.map

package/dist/types/ts4.1/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.1/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.1/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.1/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.1/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.1/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.1/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.1/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.1/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.1/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.1/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.1/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.1/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