@amazon/vinyl-util 1.0.0

package/dist/types/ts3.7/util/collection/LinkedList.d.ts

@@ -0,0 +1,156 @@
+/**
+ * A doubly-linked node.
+ *
+ * If a node is to move from one list to another, it must be removed first.
+ */
+export interface LinkedNode<T> {
+    previous: LinkedNode<T> | null;
+    value: T;
+    removed: boolean;
+    next: LinkedNode<T> | null;
+}
+/**
+ * A standard doubly-linked list implementation.
+ */
+export declare class LinkedList<T> implements Iterable<T> {
+    private _head;
+    private _tail;
+    get head(): (LinkedNode<T> | null);
+    get tail(): (LinkedNode<T> | null);
+    get empty(): boolean;
+    /**
+     * Creates a new node for the given value, adding it to the end of the list.
+     *
+     * @param value
+     * @return Returns the newly created node.
+     */
+    push(value: T): LinkedNode<T>;
+    /**
+     * Appends all given values to the end of this list.
+     *
+     * @param values
+     */
+    pushAll(...values: T[]): void;
+    /**
+     * Appends the given node to the tail of this list.
+     * If the node is already at the tail, it will no-op.
+     * If the node is in this list, it will be removed.
+     *
+     * @param node The node to add or move to the tail of this list.
+     */
+    pushNode(node: LinkedNode<T>): void;
+    /**
+     * Removes the last node (the tail), returning it.
+     * If this list is empty, null is returned.
+     */
+    pop(): LinkedNode<T> | null;
+    /**
+     * Creates a new node, adding it to the front of the list.
+     *
+     * @param value The value to box in a linked node.
+     * @return Returns the new node.
+     */
+    unshift(value: T): LinkedNode<T>;
+    /**
+     * Prepends all the given values to the head of this list.
+     * The values will maintain their order.
+     *
+     * E.g.
+     * ```
+     * list.unshiftAll(8, 9, 10)   // 8, 9, 10
+     * list.unshiftAll(4, 5, 6, 7) // 4, 5, 6, 7, 8, 9, 10
+     * list.unshiftAll(1, 2, 3)    // 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
+     * ```
+     *
+     * @param values The values to box in linked nodes.
+     */
+    unshiftAll(...values: T[]): void;
+    /**
+     * Prepends the given node to the head of this list.
+     * - If the node is already at the head, it will no-op.
+     * - If the node is in this list, it will be removed.
+     *
+     * @param node The node to add or move to the head of this list.
+     */
+    unshiftNode(node: LinkedNode<T>): void;
+    /**
+     * Removes the first node (the head), returning it.
+     * - If this list is empty, null is returned.
+     */
+    shift(): LinkedNode<T> | null;
+    /**
+     * Removes the given linked node.
+     *
+     * @param node
+     */
+    remove(node: LinkedNode<T>): void;
+    /**
+     * Inserts the given node before pointer node.
+     *
+     * @param node The node to insert before pointer. If this node is currently in this list, it
+     * will first be removed.
+     * @param pointer The pointer node.
+     */
+    insertNodeBefore(node: LinkedNode<T>, pointer: LinkedNode<T>): void;
+    /**
+     * Inserts the given node after pointer node.
+     *
+     * @param node The node to insert after pointer. If this node is currently in this list, it
+     * will first be removed.
+     * @param pointer The pointer node.
+     */
+    insertNodeAfter(node: LinkedNode<T>, pointer: LinkedNode<T>): void;
+    /**
+     * Iterates over every element, invoking the given callback.
+     *
+     * @param callback
+     */
+    forEach(callback: (element: T) => void): void;
+    /**
+     * Similar to `Array.prototype.some`, returns true if at least one element passes the given
+     * predicate.
+     *
+     * @param predicate
+     */
+    some(predicate: (element: T) => boolean): boolean;
+    /**
+     * Returns the first node matching the given predicate.
+     *
+     * @param predicate A function where, when true is returned, returns the current node.
+     */
+    find(predicate: (element: T) => boolean): LinkedNode<T> | null;
+    /**
+     * Returns the last node matching the given predicate.
+     *
+     * @param predicate A function where, when true is returned, returns the current node.
+     */
+    findLast(predicate: (element: T) => boolean): LinkedNode<T> | null;
+    /**
+     * Clears this list.
+     */
+    clear(): void;
+    /**
+     * Returns a new iterator, starting at the head.
+     */
+    [Symbol.iterator](): IterableIterator<T>;
+    /**
+     * Returns a new reversed iterable where the iterator starts at the tail, moving backwards
+     * to the head.
+     */
+    reversed(): IterableIterator<T>;
+    /**
+     * Creates an iterable iterator, starting at the specified node, getting the next node from
+     * the next() function.
+     *
+     * Note that using iterators is not as performant as {@link some} or {@link forEach}
+     *
+     * @param start The starting node. (inclusive)
+     * @param end The ending node (exclusive).
+     * @param next A method that is given the current node, and returns the next node.
+     */
+    createIterator(start: LinkedNode<T> | null, end: LinkedNode<T> | null, next: (current: LinkedNode<T>) => LinkedNode<T> | null): {
+        [Symbol.iterator](): IterableIterator<T>;
+        next: () => IteratorResult<T>;
+    };
+}
+//# sourceMappingURL=LinkedList.d.ts.map

package/dist/types/ts3.7/util/collection/LruCache.d.ts

@@ -0,0 +1,96 @@
+import { 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/ts3.7/util/collection/array.d.ts

@@ -0,0 +1,207 @@
+import { Comparator } from '../../util/comparison/compare';
+import { 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/ts3.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/ts3.7/util/comparison/compare.d.ts

@@ -0,0 +1,33 @@
+import { 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/ts3.7/util/config/ValueProvider.d.ts

@@ -0,0 +1,17 @@
+import { 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/ts3.7/util/date/date.d.ts

@@ -0,0 +1,32 @@
+import { 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/ts3.7/util/error/stack.d.ts

@@ -0,0 +1,79 @@
+import { 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/ts3.7/util/fun/debounce.d.ts

@@ -0,0 +1,12 @@
+import { 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