@amazon/vinyl-util 1.0.0

package/dist/types/ts4.7/util/async/sleep.d.ts

@@ -0,0 +1,27 @@
+import type { ReadonlyAbort } from './Abort';
+/**
+ * Returns a promise that resolves after the given amount of time.
+ *
+ * Usage example:
+ * ```
+ * async function doThingsWithAbort(abort) {
+ *   await foo();
+ *   await sleep(2, abort);
+ *   await foo();
+ *   await sleep(5, abort);
+ *   await foo();
+ * }
+ *
+ * const abort = new Abort();
+ * doThingsWithAbort(abort).catch(() => console.log('aborted'))';
+ *
+ * abort.abort();
+ * ```
+ *
+ * @param time The time to sleep, in seconds.
+ * @param abort If provided, will reject the returned promise with the signal's abort
+ * reason when aborted. If the signal is already aborted and time is less than or equal to zero,
+ * the abort signal takes precedence.
+ */
+export declare function sleep(time: number, abort?: ReadonlyAbort | null): Promise<void>;
+//# sourceMappingURL=sleep.d.ts.map

package/dist/types/ts4.7/util/async/timeout.d.ts

@@ -0,0 +1,29 @@
+import type { ReadonlyAbort } from './Abort';
+import { ErrorLevel } from '../../error/ReportableError';
+export declare const DEFAULT_TIMEOUT_MESSAGE = "Timed out after {time}s";
+/**
+ * Races a promise with a timeout, rejecting with a {@link TimeoutError} if the timeout is
+ * reached before the provided promise.
+ *
+ * @param promise The promise to race against a timeout.
+ * @param time The number of seconds to wait. If undefined, the promise is returned without
+ * wrapping.
+ * @param message The message to set in the {@link TimeoutError}. Uses `{time}` token.
+ * @param origin The error origin. (default: `ErrorOrigin.INTERNAL`)
+ * @param level The error level (default: `ErrorLevel.FATAL`)
+ */
+export declare function withTimeout<T>(promise: PromiseLike<T>, time?: number, message?: string, origin?: string, level?: ErrorLevel): Promise<T>;
+/**
+ * Returns a promise that will reject after the provided number of seconds.
+ * If the optional abort signal is aborted, the timer will be canceled and the promise resolved.
+ * This is the inverse of {@link sleep}
+ *
+ * @param time The number of seconds to wait.
+ * @param abort If provided, when aborted (regardless of reason) will resolve the returned
+ * promise.
+ * @param message The message to be used in the TimeoutError in case of timeout. Uses `{time}` token.
+ * @param origin The error origin. (default: `ErrorOrigin.INTERNAL`)
+ * @param level The error level (default: `ErrorLevel.FATAL`)
+ */
+export declare function timeout(time: number, abort?: ReadonlyAbort, message?: string, origin?: string, level?: ErrorLevel): Promise<void>;
+//# sourceMappingURL=timeout.d.ts.map

package/dist/types/ts4.7/util/browser/searchParams.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Returns a `URLSearchParams` object for the given search substring. This is memoized for the
+ * last search provided.
+ * @param search (Optional) The window's search substring. Defaults to `location.search`, overridden
+ * only for unit tests.
+ */
+export declare const getSearchParams: import("../../util/fun/memoize").MemoizedFunction & ((search?: string) => URLSearchParams);
+/**
+ * If the environment has a `location` object, returns the location's search. Otherwise,
+ * an empty string.
+ */
+export declare function getLocationSearch(): string;
+//# sourceMappingURL=searchParams.d.ts.map

package/dist/types/ts4.7/util/buffer/BufferError.d.ts

@@ -0,0 +1,6 @@
+import { ErrorLevel, ReportableError } from '../../error/ReportableError';
+export declare class BufferError extends ReportableError {
+    get [Symbol.toStringTag](): string;
+    constructor(message: string, origin?: string, level?: ErrorLevel);
+}
+//# sourceMappingURL=BufferError.d.ts.map

package/dist/types/ts4.7/util/buffer/BufferReader.d.ts

@@ -0,0 +1,77 @@
+export declare class BufferReader {
+    position: number;
+    private dataView;
+    constructor(buffer: ArrayBuffer);
+    /**
+     * Asserts that at least `size` bytes are remaining.
+     * @param size
+     */
+    assertRemaining(size: number): void;
+    hasNext(): boolean;
+    get remaining(): number;
+    skip(bytes: number): void;
+    /**
+     * Reads the next Float32 value.
+     * @param littleEndian If false or undefined, a big-endian value should be read.
+     */
+    readFloat32(littleEndian?: boolean): number;
+    /**
+     * Reads the next Float64 value.
+     * @param littleEndian If false or undefined, a big-endian value should be read.
+     */
+    readFloat64(littleEndian?: boolean): number;
+    /**
+     * Reads the next Int8 value.
+     */
+    readInt8(): number;
+    /**
+     * Reads the next Int16 value.
+     * @param littleEndian If false or undefined, a big-endian value should be read.
+     */
+    readInt16(littleEndian?: boolean): number;
+    /**
+     * Reads the next Int32 value.
+     * @param littleEndian If false or undefined, a big-endian value should be read.
+     */
+    readInt32(littleEndian?: boolean): number;
+    /**
+     * Reads the next Int64 value.
+     * @param littleEndian If false or undefined, a big-endian value should be read.
+     */
+    readInt64(littleEndian?: boolean): bigint;
+    /**
+     * Reads the next Uint8 value.
+     */
+    readUint8(): number;
+    /**
+     * Reads the next Uint16 value.
+     * @param littleEndian If false or undefined, a big-endian value should be read.
+     */
+    readUint16(littleEndian?: boolean): number;
+    /**
+     * Reads the next Uint32 value.
+     * @param littleEndian If false or undefined, a big-endian value should be read.
+     */
+    readUint32(littleEndian?: boolean): number;
+    /**
+     * Reads the next Uint64 value.
+     * @param littleEndian If false or undefined, a big-endian value should be read.
+     */
+    readUint64(littleEndian?: boolean): bigint;
+    /**
+     * Reads from the current position into a sliced array buffer of the given size.
+     * @param count
+     */
+    readBytes(count: number): ArrayBuffer;
+    /**
+     * Reads the given number of characters into a byte string.
+     * @param length
+     */
+    readString(length: number): string;
+    /**
+     * Reads the given number of characters into a UTF-16 string.
+     * @param length
+     */
+    readUtf16String(length: number): string;
+}
+//# sourceMappingURL=BufferReader.d.ts.map

package/dist/types/ts4.7/util/buffer/BufferWriter.d.ts

@@ -0,0 +1,30 @@
+/**
+ * A growable binary buffer writer. Writes big-endian by default, matching
+ * network byte order used by MP4 and MPEG-TS.
+ */
+export declare class BufferWriter {
+    private buffer;
+    private dataView;
+    position: number;
+    constructor(initialCapacity?: number);
+    private ensureCapacity;
+    writeUint8(value: number): void;
+    writeUint16(value: number, littleEndian?: boolean): void;
+    writeUint32(value: number, littleEndian?: boolean): void;
+    writeInt16(value: number, littleEndian?: boolean): void;
+    writeInt32(value: number, littleEndian?: boolean): void;
+    writeBytes(data: ArrayBuffer | Uint8Array): void;
+    /**
+     * Writes a fixed-length ASCII string.
+     */
+    writeString(str: string): void;
+    /**
+     * Returns the written data as a trimmed ArrayBuffer.
+     */
+    toArrayBuffer(): ArrayBuffer;
+    /**
+     * Returns the written data as a Uint8Array view.
+     */
+    toUint8Array(): Uint8Array;
+}
+//# sourceMappingURL=BufferWriter.d.ts.map

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

@@ -0,0 +1,55 @@
+import type { Maybe } from '../../util/type';
+/**
+ * Converts a byte buffer to an 8-bit width string.
+ *
+ * @return Returns a single-byte string.
+ * @param buffer
+ */
+export declare function bufferToByteStr(buffer: ArrayLike<number> | ArrayBuffer): string;
+/**
+ * Converts a byte string to a byte array.
+ *
+ * @param byteStr The 8 bit-width string to convert to a byte array.
+ * @return Returns a byte array representing the byte string.
+ */
+export declare function byteStrToByteArray(byteStr: string): Uint8Array;
+/**
+ * Converts an array buffer of binary data to a Base64 encoded string.
+ *
+ * @param buffer a buffer of binary data.
+ * @return Returns a Base64 encoded string representing the provided binary data.
+ */
+export declare function bufferToBase64(buffer: ArrayLike<number> | ArrayBuffer): string;
+/**
+ * Converts a Base64 encoded string into a byte array.
+ * The 6-bit width Base64 data is converted to a binary string then written to a byte array.
+ *
+ * @param base64 A Base64 encoded string.
+ */
+export declare function base64ToByteArray(base64: string): Uint8Array;
+/**
+ * Converts a 16-bit buffer of any length to a utf-16 string.
+ *
+ * @see https://developer.chrome.com/blog/how-to-convert-arraybuffer-to-and-from-string
+ *
+ * @param buffer An iterable of double-byte code points.
+ * @return Returns a UTF-16 string.
+ */
+export declare function bufferToUtf16(buffer: ArrayLike<number> | ArrayBuffer): string;
+/**
+ * Converts a UTF-16 string to a Uint16Array.
+ *
+ * @see https://developer.chrome.com/blog/how-to-convert-arraybuffer-to-and-from-string
+ * @param str A UTF-16 string.
+ */
+export declare function utf16ToUint16Array(str: string): Uint16Array;
+/**
+ * If a byte array is provided, returns as is, otherwise creates a Uint8Array from an array buffer like.
+ * @param buffer
+ */
+export declare function bufferToByteArray(buffer: Uint8Array | ArrayLike<number> | ArrayBuffer): Uint8Array;
+/**
+ * Returns true if the two buffers are equal.
+ */
+export declare function buffersEqual(bufferA: Maybe<Uint8Array | ArrayLike<number> | ArrayBuffer>, bufferB: Maybe<Uint8Array | ArrayLike<number> | ArrayBuffer>): boolean;
+//# sourceMappingURL=buffer.d.ts.map

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

@@ -0,0 +1,12 @@
+/**
+ * A CacheMap is a Map that notifies when an entry is evicted.
+ */
+export interface CacheMap<K, V> extends Map<K, V> {
+    /**
+     * When an entry is added when at capacity, the least recently used entry will be removed.
+     * This callback can be set to be notified with the element and key being evicted, which may be
+     * used for disposal.
+     */
+    onEvict: ((element: V, key: K, list: CacheMap<K, V>) => void) | null;
+}
+//# sourceMappingURL=CacheMap.d.ts.map

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

@@ -0,0 +1,165 @@
+/**
+ * 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;
+    /**
+     * Returns the current head.
+     */
+    get head(): LinkedNode<T> | null;
+    /**
+     * Returns the current tail.
+     */
+    get tail(): LinkedNode<T> | null;
+    /**
+     * Returns true if the list is empty.
+     */
+    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/ts4.7/util/collection/LruCache.d.ts

@@ -0,0 +1,99 @@
+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);
+    /**
+     * @returns the number of elements in the Map.
+     */
+    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