@amazon/vinyl-util 1.0.0

package/dist/types/current/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/current/util/async/timeout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeout.d.ts","sourceRoot":"","sources":["../../../../../src/util/async/timeout.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAK5C,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AAEpD,eAAO,MAAM,uBAAuB,4BAA4B,CAAA;AAEhE;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,CAAC,EACzB,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC,EACvB,IAAI,CAAC,EAAE,MAAM,EACb,OAAO,SAA0B,EACjC,MAAM,GAAE,MAA6B,EACrC,KAAK,GAAE,UAA6B,GACrC,OAAO,CAAC,CAAC,CAAC,CAUZ;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CACnB,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,aAAa,EACrB,OAAO,SAA4B,EACnC,MAAM,GAAE,MAA6B,EACrC,KAAK,GAAE,UAA6B,GACrC,OAAO,CAAC,IAAI,CAAC,CAcf"}

package/dist/types/current/util/async/timeout.js

@@ -0,0 +1,55 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TimeoutError } from '../../error/TimeoutError';
+import { Abort } from './Abort';
+import { sleep } from './sleep';
+import { substitute } from '../../util/string/string';
+import { ErrorOrigin } from '../../error/ErrorOrigin';
+import { ErrorLevel } from '../../error/ReportableError';
+export 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 function withTimeout(promise, time, message = DEFAULT_TIMEOUT_MESSAGE, origin = ErrorOrigin.INTERNAL, level = ErrorLevel.FATAL) {
+    if (time === undefined)
+        return Promise.resolve(promise);
+    const abort = new Abort();
+    return Promise.race([
+        promise,
+        timeout(time, abort, message, origin, level),
+    ]).then(() => {
+        abort.abort();
+        return promise;
+    });
+}
+/**
+ * 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 function timeout(time, abort, message = 'Timed out after {time}s', origin = ErrorOrigin.INTERNAL, level = ErrorLevel.FATAL) {
+    return new Promise((resolve, reject) => {
+        sleep(time, abort)
+            .then(() => {
+            reject(new TimeoutError(substitute(message, { time }), origin, level));
+        })
+            .catch(() => resolve(void 0));
+    });
+}

package/dist/types/current/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/current/util/browser/searchParams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"searchParams.d.ts","sourceRoot":"","sources":["../../../../../src/util/browser/searchParams.ts"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,eAAO,MAAM,eAAe,6DACf,MAAM,KAAyB,eAAe,CAS1D,CAAA;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C"}

package/dist/types/current/util/browser/searchParams.js

@@ -0,0 +1,26 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { memoize } from '../../util/fun/memoize';
+import { getLocation } from '../../global/environment';
+/**
+ * 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 const getSearchParams = memoize((search = getLocationSearch()) => {
+    const url = new URL('about:blank');
+    url.search = search;
+    // Uses `URL.searchParams` over `new URLSearchParams`; URLSearchParams constructor is not
+    // as widely supported.
+    return url.searchParams;
+}, (search = getLocationSearch()) => search, 1);
+/**
+ * If the environment has a `location` object, returns the location's search. Otherwise,
+ * an empty string.
+ */
+export function getLocationSearch() {
+    return getLocation().search;
+}

package/dist/types/current/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/current/util/buffer/BufferError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BufferError.d.ts","sourceRoot":"","sources":["../../../../../src/util/buffer/BufferError.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAA;AAErE,qBAAa,WAAY,SAAQ,eAAe;IAC5C,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,MAAM,CAEjC;gBAGG,OAAO,EAAE,MAAM,EACf,MAAM,GAAE,MAA0B,EAClC,KAAK,GAAE,UAA6B;CAK3C"}

package/dist/types/current/util/buffer/BufferError.js

@@ -0,0 +1,15 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ErrorOrigin } from '../../error/ErrorOrigin';
+import { ErrorLevel, ReportableError } from '../../error/ReportableError';
+export class BufferError extends ReportableError {
+    get [Symbol.toStringTag]() {
+        return 'BufferError';
+    }
+    constructor(message, origin = ErrorOrigin.MEDIA, level = ErrorLevel.FATAL) {
+        super(message, origin, level);
+        Object.setPrototypeOf(this, BufferError.prototype);
+    }
+}

package/dist/types/current/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/current/util/buffer/BufferReader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BufferReader.d.ts","sourceRoot":"","sources":["../../../../../src/util/buffer/BufferReader.ts"],"names":[],"mappings":"AAQA,qBAAa,YAAY;IACrB,QAAQ,EAAE,MAAM,CAAI;IAEpB,OAAO,CAAC,QAAQ,CAAuB;gBAE3B,MAAM,EAAE,WAAW;IAI/B;;;OAGG;IACH,eAAe,CAAC,IAAI,EAAE,MAAM;IAQ5B,OAAO,IAAI,OAAO;IAIlB,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED,IAAI,CAAC,KAAK,EAAE,MAAM;IAKlB;;;OAGG;IACH,WAAW,CAAC,YAAY,CAAC,EAAE,OAAO,GAAG,MAAM;IAO3C;;;OAGG;IACH,WAAW,CAAC,YAAY,CAAC,EAAE,OAAO,GAAG,MAAM;IAO3C;;OAEG;IACH,QAAQ,IAAI,MAAM;IAKlB;;;OAGG;IACH,SAAS,CAAC,YAAY,CAAC,EAAE,OAAO,GAAG,MAAM;IAOzC;;;OAGG;IACH,SAAS,CAAC,YAAY,CAAC,EAAE,OAAO,GAAG,MAAM;IAOzC;;;OAGG;IACH,SAAS,CAAC,YAAY,CAAC,EAAE,OAAO,GAAG,MAAM;IAOzC;;OAEG;IACH,SAAS,IAAI,MAAM;IAKnB;;;OAGG;IACH,UAAU,CAAC,YAAY,CAAC,EAAE,OAAO,GAAG,MAAM;IAO1C;;;OAGG;IACH,UAAU,CAAC,YAAY,CAAC,EAAE,OAAO,GAAG,MAAM;IAO1C;;;OAGG;IACH,UAAU,CAAC,YAAY,CAAC,EAAE,OAAO,GAAG,MAAM;IAO1C;;;OAGG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW;IAUrC;;;OAGG;IACH,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAIlC;;;OAGG;IACH,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;CAG1C"}

package/dist/types/current/util/buffer/BufferReader.js

@@ -0,0 +1,150 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { bufferToByteStr, bufferToUtf16 } from '../../util/buffer/buffer';
+import { BufferError } from '../../util/buffer/BufferError';
+export class BufferReader {
+    position = 0;
+    dataView;
+    constructor(buffer) {
+        this.dataView = new DataView(buffer);
+    }
+    /**
+     * Asserts that at least `size` bytes are remaining.
+     * @param size
+     */
+    assertRemaining(size) {
+        if (this.remaining < size) {
+            throw new BufferError(`Unexpected end of buffer reached at position: ${this.position}. Reading ${size} bytes, ${this.remaining} available.`);
+        }
+    }
+    hasNext() {
+        return this.remaining > 0;
+    }
+    get remaining() {
+        return this.dataView.byteLength - this.position;
+    }
+    skip(bytes) {
+        this.assertRemaining(bytes);
+        this.position += bytes;
+    }
+    /**
+     * Reads the next Float32 value.
+     * @param littleEndian If false or undefined, a big-endian value should be read.
+     */
+    readFloat32(littleEndian) {
+        this.assertRemaining(4);
+        const value = this.dataView.getFloat32(this.position, littleEndian);
+        this.position += 4;
+        return value;
+    }
+    /**
+     * Reads the next Float64 value.
+     * @param littleEndian If false or undefined, a big-endian value should be read.
+     */
+    readFloat64(littleEndian) {
+        this.assertRemaining(8);
+        const value = this.dataView.getFloat64(this.position, littleEndian);
+        this.position += 8;
+        return value;
+    }
+    /**
+     * Reads the next Int8 value.
+     */
+    readInt8() {
+        this.assertRemaining(1);
+        return this.dataView.getInt8(this.position++);
+    }
+    /**
+     * Reads the next Int16 value.
+     * @param littleEndian If false or undefined, a big-endian value should be read.
+     */
+    readInt16(littleEndian) {
+        this.assertRemaining(2);
+        const value = this.dataView.getInt16(this.position, littleEndian);
+        this.position += 2;
+        return value;
+    }
+    /**
+     * Reads the next Int32 value.
+     * @param littleEndian If false or undefined, a big-endian value should be read.
+     */
+    readInt32(littleEndian) {
+        this.assertRemaining(4);
+        const value = this.dataView.getInt32(this.position, littleEndian);
+        this.position += 4;
+        return value;
+    }
+    /**
+     * Reads the next Int64 value.
+     * @param littleEndian If false or undefined, a big-endian value should be read.
+     */
+    readInt64(littleEndian) {
+        this.assertRemaining(8);
+        const value = this.dataView.getBigInt64(this.position, littleEndian);
+        this.position += 8;
+        return value;
+    }
+    /**
+     * Reads the next Uint8 value.
+     */
+    readUint8() {
+        this.assertRemaining(1);
+        return this.dataView.getUint8(this.position++);
+    }
+    /**
+     * Reads the next Uint16 value.
+     * @param littleEndian If false or undefined, a big-endian value should be read.
+     */
+    readUint16(littleEndian) {
+        this.assertRemaining(2);
+        const value = this.dataView.getUint16(this.position, littleEndian);
+        this.position += 2;
+        return value;
+    }
+    /**
+     * Reads the next Uint32 value.
+     * @param littleEndian If false or undefined, a big-endian value should be read.
+     */
+    readUint32(littleEndian) {
+        this.assertRemaining(4);
+        const value = this.dataView.getUint32(this.position, littleEndian);
+        this.position += 4;
+        return value;
+    }
+    /**
+     * Reads the next Uint64 value.
+     * @param littleEndian If false or undefined, a big-endian value should be read.
+     */
+    readUint64(littleEndian) {
+        this.assertRemaining(8);
+        const value = this.dataView.getBigUint64(this.position, littleEndian);
+        this.position += 8;
+        return value;
+    }
+    /**
+     * Reads from the current position into a sliced array buffer of the given size.
+     * @param count
+     */
+    readBytes(count) {
+        this.assertRemaining(count);
+        const buffer = this.dataView.buffer.slice(this.position, this.position + count);
+        this.position += count;
+        return buffer;
+    }
+    /**
+     * Reads the given number of characters into a byte string.
+     * @param length
+     */
+    readString(length) {
+        return bufferToByteStr(this.readBytes(length));
+    }
+    /**
+     * Reads the given number of characters into a UTF-16 string.
+     * @param length
+     */
+    readUtf16String(length) {
+        return bufferToUtf16(this.readBytes(length));
+    }
+}

package/dist/types/current/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/current/util/buffer/BufferWriter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BufferWriter.d.ts","sourceRoot":"","sources":["../../../../../src/util/buffer/BufferWriter.ts"],"names":[],"mappings":"AAKA;;;GAGG;AACH,qBAAa,YAAY;IACrB,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,QAAQ,CAAU;IAC1B,QAAQ,EAAE,MAAM,CAAI;gBAER,eAAe,GAAE,MAAY;IAKzC,OAAO,CAAC,cAAc;IAWtB,UAAU,CAAC,KAAK,EAAE,MAAM;IAKxB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,OAAO;IAMjD,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,OAAO;IAMjD,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,OAAO;IAMhD,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,OAAO;IAMhD,UAAU,CAAC,IAAI,EAAE,WAAW,GAAG,UAAU;IAOzC;;OAEG;IACH,WAAW,CAAC,GAAG,EAAE,MAAM;IAOvB;;OAEG;IACH,aAAa,IAAI,WAAW;IAI5B;;OAEG;IACH,YAAY,IAAI,UAAU;CAG7B"}

package/dist/types/current/util/buffer/BufferWriter.js

@@ -0,0 +1,80 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * A growable binary buffer writer. Writes big-endian by default, matching
+ * network byte order used by MP4 and MPEG-TS.
+ */
+export class BufferWriter {
+    buffer;
+    dataView;
+    position = 0;
+    constructor(initialCapacity = 256) {
+        this.buffer = new ArrayBuffer(initialCapacity);
+        this.dataView = new DataView(this.buffer);
+    }
+    ensureCapacity(additionalBytes) {
+        const required = this.position + additionalBytes;
+        if (required <= this.buffer.byteLength)
+            return;
+        let newCapacity = this.buffer.byteLength;
+        while (newCapacity < required)
+            newCapacity *= 2;
+        const newBuffer = new ArrayBuffer(newCapacity);
+        new Uint8Array(newBuffer).set(new Uint8Array(this.buffer));
+        this.buffer = newBuffer;
+        this.dataView = new DataView(this.buffer);
+    }
+    writeUint8(value) {
+        this.ensureCapacity(1);
+        this.dataView.setUint8(this.position++, value);
+    }
+    writeUint16(value, littleEndian) {
+        this.ensureCapacity(2);
+        this.dataView.setUint16(this.position, value, littleEndian);
+        this.position += 2;
+    }
+    writeUint32(value, littleEndian) {
+        this.ensureCapacity(4);
+        this.dataView.setUint32(this.position, value, littleEndian);
+        this.position += 4;
+    }
+    writeInt16(value, littleEndian) {
+        this.ensureCapacity(2);
+        this.dataView.setInt16(this.position, value, littleEndian);
+        this.position += 2;
+    }
+    writeInt32(value, littleEndian) {
+        this.ensureCapacity(4);
+        this.dataView.setInt32(this.position, value, littleEndian);
+        this.position += 4;
+    }
+    writeBytes(data) {
+        const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+        this.ensureCapacity(bytes.byteLength);
+        new Uint8Array(this.buffer).set(bytes, this.position);
+        this.position += bytes.byteLength;
+    }
+    /**
+     * Writes a fixed-length ASCII string.
+     */
+    writeString(str) {
+        this.ensureCapacity(str.length);
+        for (let i = 0; i < str.length; i++) {
+            this.dataView.setUint8(this.position++, str.charCodeAt(i));
+        }
+    }
+    /**
+     * Returns the written data as a trimmed ArrayBuffer.
+     */
+    toArrayBuffer() {
+        return this.buffer.slice(0, this.position);
+    }
+    /**
+     * Returns the written data as a Uint8Array view.
+     */
+    toUint8Array() {
+        return new Uint8Array(this.buffer, 0, this.position);
+    }
+}

package/dist/types/current/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<ArrayBuffer>;
+/**
+ * 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<ArrayBuffer>;
+/**
+ * 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<ArrayBuffer>;
+/**
+ * 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<ArrayBuffer> | ArrayLike<number> | ArrayBuffer): Uint8Array<ArrayBuffer>;
+/**
+ * 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/current/util/buffer/buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer.d.ts","sourceRoot":"","sources":["../../../../../src/util/buffer/buffer.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAExC;;;;;GAKG;AACH,wBAAgB,eAAe,CAC3B,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,WAAW,GACxC,MAAM,CAKR;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,CAAC,WAAW,CAAC,CAS3E;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC1B,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,WAAW,GACxC,MAAM,CAER;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAAC,WAAW,CAAC,CAEzE;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,WAAW,GAAG,MAAM,CAK7E;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAAC,WAAW,CAAC,CAOxE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC7B,MAAM,EAAE,UAAU,CAAC,WAAW,CAAC,GAAG,SAAS,CAAC,MAAM,CAAC,GAAG,WAAW,GAClE,UAAU,CAAC,WAAW,CAAC,CAEzB;AAED;;GAEG;AACH,wBAAgB,YAAY,CACxB,OAAO,EAAE,KAAK,CAAC,UAAU,GAAG,SAAS,CAAC,MAAM,CAAC,GAAG,WAAW,CAAC,EAC5D,OAAO,EAAE,KAAK,CAAC,UAAU,GAAG,SAAS,CAAC,MAAM,CAAC,GAAG,WAAW,CAAC,GAC7D,OAAO,CAaT"}

package/dist/types/current/util/buffer/buffer.js

@@ -0,0 +1,99 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Converts a byte buffer to an 8-bit width string.
+ *
+ * @return Returns a single-byte string.
+ * @param buffer
+ */
+export function bufferToByteStr(buffer) {
+    return String.fromCharCode.apply(null, new Uint8Array(buffer));
+}
+/**
+ * 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 function byteStrToByteArray(byteStr) {
+    // This does the same thing as {@link TextEncoder.encode}, but TextEncoder is not available on
+    // Edge Legacy, which we require for PlayReady testing.
+    const n = byteStr.length;
+    const bytes = new Uint8Array(n);
+    for (let i = 0; i < n; i++) {
+        bytes[i] = byteStr.charCodeAt(i);
+    }
+    return bytes;
+}
+/**
+ * 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 function bufferToBase64(buffer) {
+    return global.btoa(bufferToByteStr(buffer));
+}
+/**
+ * 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 function base64ToByteArray(base64) {
+    return byteStrToByteArray(global.atob(base64));
+}
+/**
+ * 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 function bufferToUtf16(buffer) {
+    return String.fromCharCode.apply(null, new Uint16Array(buffer));
+}
+/**
+ * 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 function utf16ToUint16Array(str) {
+    const n = str.length;
+    const uint16Array = new Uint16Array(n);
+    for (let i = 0; i < n; i++) {
+        uint16Array[i] = str.charCodeAt(i);
+    }
+    return uint16Array;
+}
+/**
+ * If a byte array is provided, returns as is, otherwise creates a Uint8Array from an array buffer like.
+ * @param buffer
+ */
+export function bufferToByteArray(buffer) {
+    return buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+}
+/**
+ * Returns true if the two buffers are equal.
+ */
+export function buffersEqual(bufferA, bufferB) {
+    if (bufferA === bufferB)
+        return true;
+    if (!bufferA && !bufferB)
+        return true;
+    if (!bufferA || !bufferB)
+        return false;
+    const arrA = bufferToByteArray(bufferA);
+    const arrB = bufferToByteArray(bufferB);
+    if (arrA.byteLength !== arrB.byteLength)
+        return false;
+    for (let i = 0; i < arrA.byteLength; i++) {
+        if (arrA[i] !== arrB[i])
+            return false;
+    }
+    return true;
+}