@amazon/vinyl-util 1.0.0

package/dist/types/current/util/iteration/iterable.js

@@ -0,0 +1,97 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { IllegalArgumentError } from '../../error/IllegalArgumentError';
+/**
+ * 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 function createRangeIter(start, endInclusive, step = 1) {
+    const positive = endInclusive >= start;
+    if ((endInclusive > start && step <= 0) ||
+        (endInclusive < start && step >= 0)) {
+        throw new IllegalArgumentError('Iterator will never complete.');
+    }
+    let i = start;
+    return {
+        [Symbol.iterator]() {
+            return this;
+        },
+        next: () => {
+            const result = {
+                value: i,
+                done: positive ? i > endInclusive : i < endInclusive,
+            };
+            i += step;
+            return result;
+        },
+    };
+}
+/**
+ * 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 function mapIter(iterable, transform) {
+    const it = iterable[Symbol.iterator]();
+    return {
+        [Symbol.iterator]() {
+            return mapIter(iterable, transform);
+        },
+        next: () => {
+            const result = it.next();
+            if (result.done)
+                return result;
+            return {
+                value: transform(result.value),
+                done: false,
+            };
+        },
+    };
+}
+/**
+ * Filters an iterable object using the given predicate.
+ * Unlike `Array#filter`, this doesn't create a new Array in memory, the filter is done on
+ * iteration.
+ *
+ * @param iterable
+ * @param predicate Returns true if the element should be included in the new iteration.
+ */
+export function filterIter(iterable, predicate) {
+    const it = iterable[Symbol.iterator]();
+    return {
+        [Symbol.iterator]() {
+            return filterIter(iterable, predicate);
+        },
+        next: () => {
+            while (true) {
+                const next = it.next();
+                if (next.done) {
+                    return {
+                        value: undefined,
+                        done: true,
+                    };
+                }
+                else if (predicate(next.value)) {
+                    return {
+                        value: next.value,
+                        done: false,
+                    };
+                }
+            }
+        },
+    };
+}

package/dist/types/current/util/map/map.d.ts

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

package/dist/types/current/util/map/map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../../../../src/util/map/map.ts"],"names":[],"mappings":"AAKA;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EACzB,GAAG,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,EACd,GAAG,EAAE,CAAC,EACN,YAAY,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,GAC5B,CAAC,CAQH;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAM/D"}

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

@@ -0,0 +1,35 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * 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 function getOrSet(map, key, defaultValue) {
+    if (map.has(key)) {
+        return map.get(key);
+    }
+    else {
+        const value = defaultValue(key);
+        map.set(key, value);
+        return value;
+    }
+}
+/**
+ * Flips a map so that the keys become the values and the values become the keys.
+ *
+ * @param map
+ * @return Returns a new map.
+ */
+export function flipMap(map) {
+    const result = new Map();
+    for (const [key, value] of map) {
+        result.set(value, key);
+    }
+    return result;
+}

package/dist/types/current/util/math/math.d.ts

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

package/dist/types/current/util/math/math.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.d.ts","sourceRoot":"","sources":["../../../../../src/util/math/math.ts"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAErE;AAED;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAEpE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,cAAc,CAC1B,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,MAAM,SAAI,GACX,MAAM,CAER;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,SAAI,GAAG,MAAM,CAE7E;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAC1B,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,MAAM,SAAI,GACX,MAAM,CAER;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CACnB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,SAAS,GAAE,MAAuB,GACnC,OAAO,CAET"}

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

@@ -0,0 +1,94 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Clamps the given value between `min` and `max`.
+ *
+ * @param value
+ * @param min The lower bounds.
+ * @param max The upper bounds. If this value is less than min, this value will always be returned.
+ */
+export function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}
+/**
+ * Linearly interpolates between `from` and `to` given a percentage.
+ *
+ * @param from The alpha = 0.0 value
+ * @param to The alpha = 1.0 value
+ * @param alpha A percentage where 0 is `from`, and 1 is `to`. E.g. 0.5 would return halfway
+ * between `from` and `to`.
+ */
+export function lerp(from, to, alpha) {
+    return from + (to - from) * alpha;
+}
+/**
+ * Floors a value to the nearest snap interval.
+ *
+ * Examples:
+ *
+ * ```
+ * floorToNearest(3, 2) // 2
+ * floorToNearest(16, 5) // 15
+ * floorToNearest(16, 5, 2) // 17
+ * ```
+ *
+ * @param value The value to floor with the given snap interval and offset.
+ * @param snap The interval between output values. Should be a finite, non-zero number.
+ * @param offset The offset of the interval. E.g. if snap is 10 and offset is 1, values will be
+ * snapped to `-19, -9, 1, 11, 21, 31, 41, ...`
+ */
+export function floorToNearest(value, snap, offset = 0) {
+    return Math.floor((value - offset) / snap) * snap + offset;
+}
+/**
+ * Ceilings a value to the nearest snap interval.
+ *
+ * Examples:
+ *
+ * ```
+ * ceilToNearest(3, 2) // 4
+ * ceilToNearest(16, 5) // 20
+ * ceilToNearest(10, 5) // 10
+ * ceilToNearest(16, 5, 2) // 22
+ * ```
+ *
+ * @param value The value to ceil with the given snap interval and offset.
+ * @param snap The interval between output values. Should be a finite, non-zero number.
+ * @param offset The offset of the interval. E.g. if snap is 10 and offset is 1, values will be
+ * snapped to `-19, -9, 1, 11, 21, 31, 41, ...`
+ */
+export function ceilToNearest(value, snap, offset = 0) {
+    return Math.ceil((value - offset) / snap) * snap + offset;
+}
+/**
+ * Rounds a value to the nearest snap interval.
+ *
+ * Examples:
+ *
+ * ```
+ * roundToNearest(3, 2) // 4
+ * roundToNearest(16, 5) // 15
+ * roundToNearest(18, 5) // 20
+ * roundToNearest(16, 10, 2) // 22
+ * ```
+ *
+ * @param value The value to round with the given snap interval and offset.
+ * @param snap The interval between output values. Should be a finite, non-zero number.
+ * @param offset The offset of the interval. E.g. if snap is 10 and offset is 1, values will be
+ * snapped to `-19, -9, 1, 11, 21, 31, 41, ...`
+ */
+export function roundToNearest(value, snap, offset = 0) {
+    return Math.round((value - offset) / snap) * snap + offset;
+}
+/**
+ * Returns true if `x` is within `tolerance` of `y`.
+ *
+ * @param x
+ * @param y
+ * @param tolerance
+ */
+export function closeTo(x, y, tolerance = Number.EPSILON) {
+    return Math.abs(x - y) <= tolerance;
+}

package/dist/types/current/util/mpeg/parseSidxBox.d.ts

@@ -0,0 +1,100 @@
+/**
+ * ISO_IEC_14496-12 Segment Index Box
+ * @module
+ */
+/**
+ * Represents the base structure of a Segment Index ('sidx') Box.
+ * The 'sidx' box is used in MPEG-4 media files to provide indexing information for efficient data access and retrieval.
+ */
+export interface SidxBoxBase {
+    /**
+     * The version, 0 and 1 supported.
+     */
+    readonly version: number;
+    /**
+     * The ID of the track.
+     */
+    readonly referenceId: number;
+    /**
+     * The timescale for the media in this 'sidx' box. It is a 32-bit unsigned integer.
+     * This value represents the number of time units that pass in one second.
+     */
+    readonly timescale: number;
+    /**
+     * An array of segment references. Each segment reference provides information about individual media segments.
+     */
+    readonly references: readonly SidxSegmentReference[];
+}
+/**
+ * Properties specific to version 0 of a Segment Index ('sidx') Box.
+ */
+export interface SidxBoxV0 extends SidxBoxBase {
+    readonly version: 0;
+    /**
+     * The earliest presentation time of any access unit in the media segments that are referenced by this 'sidx' box.
+     */
+    readonly earliestPresentationTime: number;
+    /**
+     * The byte offset from the end of this 'sidx' box to the first media segment in this 'sidx'.
+     * For version 0, this is a 32-bit unsigned integer.
+     */
+    readonly firstOffset: number;
+}
+/**
+ * Properties specific to version 1 of a Segment Index ('sidx') Box.
+ */
+export interface SidxBoxV1 extends SidxBoxBase {
+    readonly version: 1;
+    /**
+     * The earliest presentation time of any access unit in the media segments that are referenced by this 'sidx' box.
+     */
+    readonly earliestPresentationTime: bigint;
+    /**
+     * The byte offset from the end of this 'sidx' box to the first media segment in this 'sidx'.
+     */
+    readonly firstOffset: bigint;
+}
+export type SidxBox = SidxBoxV0 | SidxBoxV1;
+/**
+ * A single segment reference within a sidx box.
+ */
+export interface SidxSegmentReference {
+    /**
+     * Indicates the reference type. A value of 0 means the reference is to a media segment. A value of 1 indicates
+     * the reference is to a hint track segment.
+     */
+    readonly referenceType: number;
+    /**
+     * The size of the referenced segment in bytes.
+     */
+    readonly referencedSize: number;
+    /**
+     * The duration of the subsegment. This is expressed in the timescale provided in the 'sidx' box.
+     */
+    readonly subsegmentDuration: number;
+    /**
+     * Indicates if the segment starts with a SAP (Stream Access Point). If `true`, the segment starts with a SAP,
+     * facilitating random access and efficient streaming.
+     */
+    readonly startsWithSap: boolean;
+    /**
+     * The SAP type indicates the type of stream access point that starts the segment. This is a 3-bit field. The
+     * SAP types are defined in ISO/IEC 14496-12, and they describe the characteristics of the stream access points.
+     */
+    readonly sapType: number;
+    /**
+     * The SAP delta time specifies the difference in time (in the timescale of the 'sidx' box) between the earliest
+     * presentation time of the segment and the first SAP within it. This allows players to quickly locate the SAP
+     * for efficient playback startup or seeking.
+     */
+    readonly sapDeltaTime: number;
+}
+export declare function parseSidxBox(buffer: ArrayBuffer): SidxBox;
+/**
+ * Creates a timeline of the segment start times, in timescale units.
+ * The last element will be the last segment's end time.
+ *
+ * @param sidx
+ */
+export declare function getSidxSampleTimes(sidx: SidxBox): number[];
+//# sourceMappingURL=parseSidxBox.d.ts.map

package/dist/types/current/util/mpeg/parseSidxBox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseSidxBox.d.ts","sourceRoot":"","sources":["../../../../../src/util/mpeg/parseSidxBox.ts"],"names":[],"mappings":"AAUA;;;GAGG;AAEH;;;GAGG;AACH,MAAM,WAAW,WAAW;IACxB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IAExB;;OAEG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAE5B;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAE1B;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,SAAS,oBAAoB,EAAE,CAAA;CACvD;AAED;;GAEG;AACH,MAAM,WAAW,SAAU,SAAQ,WAAW;IAC1C,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAA;IAEnB;;OAEG;IACH,QAAQ,CAAC,wBAAwB,EAAE,MAAM,CAAA;IAEzC;;;OAGG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,SAAU,SAAQ,WAAW;IAC1C,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAA;IAEnB;;OAEG;IACH,QAAQ,CAAC,wBAAwB,EAAE,MAAM,CAAA;IAEzC;;OAEG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;CAC/B;AAED,MAAM,MAAM,OAAO,GAAG,SAAS,GAAG,SAAS,CAAA;AAE3C;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACjC;;;OAGG;IACH,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAE9B;;OAEG;IACH,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAE/B;;OAEG;IACH,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAA;IAEnC;;;OAGG;IACH,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAA;IAE/B;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IAExB;;;;OAIG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;CAChC;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAsGzD;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,OAAO,YAU/C"}

package/dist/types/current/util/mpeg/parseSidxBox.js

@@ -0,0 +1,91 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BufferReader } from '../../util/buffer/BufferReader';
+import { ValidationError } from '../../error/ValidationError';
+import { ErrorOrigin } from '../../error/ErrorOrigin';
+import { MediaUnsupportedError } from '../../error/MediaUnsupportedError';
+export function parseSidxBox(buffer) {
+    const reader = new BufferReader(buffer);
+    reader.skip(4); // box size
+    const boxType = reader.readString(4);
+    if (boxType !== 'sidx')
+        throw new ValidationError(`expected 'sidx' box but had box type: '${boxType}'`, ErrorOrigin.MEDIA);
+    const version = reader.readUint8();
+    // Skip flags
+    reader.skip(3);
+    const referenceId = reader.readUint32();
+    const timescale = reader.readUint32();
+    let versionedProps;
+    if (version === 0) {
+        versionedProps = {
+            version: 0,
+            earliestPresentationTime: reader.readUint32(),
+            firstOffset: reader.readUint32(),
+        };
+    }
+    else {
+        // version > 1 may be backwards compatible for our use cases, but may not be. Log a warning.
+        if (version !== 1)
+            throw new MediaUnsupportedError(`sidx box version ${version} not supported`, 'unsupported-sidx-version');
+        if (typeof BigInt === 'undefined')
+            throw new MediaUnsupportedError(`sidx box version 1 not supported on this platform`, 'client-unsupported-sidx-version');
+        versionedProps = {
+            version: 1,
+            earliestPresentationTime: reader.readUint64(),
+            firstOffset: reader.readUint64(),
+        };
+    }
+    // Skip reserved bits
+    reader.skip(2);
+    const referenceCount = reader.readUint16();
+    const references = new Array(referenceCount);
+    for (let i = 0; i < referenceCount; i++) {
+        const refTypeAndSize = reader.readUint32();
+        // 1 bit
+        const referenceType = (refTypeAndSize & 0x80000000) >>> 31;
+        if (referenceType !== 0) {
+            // ISO_IEC_14496-12 K.2.2
+            throw new MediaUnsupportedError('hierarchical sidx reference type not supported', 'unsupported-sidx-reference-type');
+        }
+        // 31 bits
+        const referencedSize = refTypeAndSize & 0x7fffffff;
+        const subsegmentDuration = reader.readUint32();
+        const sap = reader.readUint32();
+        const startsWithSap = (sap & 0x80000000) >>> 31 === 1;
+        const sapType = (sap >>> 28) & 0x07;
+        const sapDeltaTime = sap & 0x0fffffff;
+        references[i] = {
+            referenceType,
+            referencedSize,
+            subsegmentDuration,
+            startsWithSap,
+            sapType,
+            sapDeltaTime,
+        };
+    }
+    return {
+        ...versionedProps,
+        referenceId,
+        timescale,
+        references,
+    };
+}
+/**
+ * Creates a timeline of the segment start times, in timescale units.
+ * The last element will be the last segment's end time.
+ *
+ * @param sidx
+ */
+export function getSidxSampleTimes(sidx) {
+    let sampleTime = Number(sidx.earliestPresentationTime);
+    const n = sidx.references.length;
+    const sampleTimes = new Array(n + 1);
+    for (let i = 0; i < n; i++) {
+        sampleTimes[i] = sampleTime;
+        sampleTime += sidx.references[i].subsegmentDuration;
+    }
+    sampleTimes[n] = sampleTime;
+    return sampleTimes;
+}

package/dist/types/current/util/network/request.d.ts

@@ -0,0 +1,18 @@
+import type { Maybe } from '../../util/type';
+/**
+ * Given request parameters, returns the header for the given key, or null.
+ */
+export declare function getHeaderFromRequestParams(input: RequestInfo | URL, init: Maybe<RequestInit>, key: string): string | null;
+export declare function getHeaderFromHeadersInit(headers: Readonly<HeadersInit>, key: string): string | null;
+/**
+ * Given fetch input, clones the input, transforms the URL and returns a new `RequestInfo | URL` input parameter.
+ */
+export declare function changeRequestInputUrl(input: RequestInfo | URL, transform: (url: URL) => void): RequestInfo | URL;
+/**
+ * Given an object of HeadersInit type (a Headers instance, array of key-value pairs, or and object of key-value pairs),
+ * returns a Record of key-value pairs.
+ *
+ * @param headers
+ */
+export declare function normalizeHeadersInit(headers: Maybe<HeadersInit>): Record<string, string>;
+//# sourceMappingURL=request.d.ts.map

package/dist/types/current/util/network/request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.d.ts","sourceRoot":"","sources":["../../../../../src/util/network/request.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAGxC;;GAEG;AACH,wBAAgB,0BAA0B,CACtC,KAAK,EAAE,WAAW,GAAG,GAAG,EACxB,IAAI,EAAE,KAAK,CAAC,WAAW,CAAC,EACxB,GAAG,EAAE,MAAM,GACZ,MAAM,GAAG,IAAI,CAOf;AAED,wBAAgB,wBAAwB,CACpC,OAAO,EAAE,QAAQ,CAAC,WAAW,CAAC,EAC9B,GAAG,EAAE,MAAM,GACZ,MAAM,GAAG,IAAI,CAcf;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACjC,KAAK,EAAE,WAAW,GAAG,GAAG,EACxB,SAAS,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI,GAC9B,WAAW,GAAG,GAAG,CAcnB;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAChC,OAAO,EAAE,KAAK,CAAC,WAAW,CAAC,GAC5B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAiBxB"}

package/dist/types/current/util/network/request.js

@@ -0,0 +1,79 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { IllegalArgumentError } from '../../error/IllegalArgumentError';
+/**
+ * Given request parameters, returns the header for the given key, or null.
+ */
+export function getHeaderFromRequestParams(input, init, key) {
+    if (input instanceof Request) {
+        return getHeaderFromHeadersInit(input.headers, key);
+    }
+    else if (init?.headers) {
+        return getHeaderFromHeadersInit(init.headers, key);
+    }
+    return null;
+}
+export function getHeaderFromHeadersInit(headers, key) {
+    key = key.toLowerCase();
+    if (headers instanceof Headers) {
+        return headers.get(key);
+    }
+    else if (Array.isArray(headers)) {
+        const header = headers.find(([iKey]) => iKey.toLowerCase() === key);
+        return header ? header[1] : null;
+    }
+    else if (typeof headers === 'object') {
+        const foundKey = Object.keys(headers).find((iKey) => iKey.toLowerCase() === key);
+        return foundKey ? headers[foundKey] : null;
+    }
+    throw new IllegalArgumentError('Unexpected headers type');
+}
+/**
+ * Given fetch input, clones the input, transforms the URL and returns a new `RequestInfo | URL` input parameter.
+ */
+export function changeRequestInputUrl(input, transform) {
+    if (input instanceof URL) {
+        const url = new URL(input);
+        transform(url);
+        return url;
+    }
+    else if (typeof input === 'string') {
+        const url = new URL(input);
+        transform(url);
+        return url;
+    }
+    else {
+        const url = new URL(input.url);
+        transform(url);
+        return new Request(url.toString(), input);
+    }
+}
+/**
+ * Given an object of HeadersInit type (a Headers instance, array of key-value pairs, or and object of key-value pairs),
+ * returns a Record of key-value pairs.
+ *
+ * @param headers
+ */
+export function normalizeHeadersInit(headers) {
+    if (!headers)
+        return {};
+    if (Array.isArray(headers)) {
+        const out = {};
+        for (const [key, value] of headers) {
+            out[key] = value;
+        }
+        return out;
+    }
+    else if (headers instanceof Headers) {
+        const out = {};
+        for (const [key, value] of headers.entries()) {
+            out[key] = value;
+        }
+        return out;
+    }
+    else {
+        return headers;
+    }
+}