@amazon/vinyl-util 1.0.0

package/dist/types/current/network/RequesterImpl.js

@@ -0,0 +1,321 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { IllegalArgumentError } from '../error/IllegalArgumentError';
+import { EventHostImpl } from '../event/EventHost';
+import { globalRef } from '../global/globalRegistry';
+import { ErrorBodyType, } from './Requester';
+import { RequestFailureType } from './RequesterImplEventMap';
+import { RequestError } from './RequestError';
+import { getResponseInfo, parseRetryAfter, retryAfterJitter, shouldRetry, } from './requesterUtil';
+import { withAbort } from '../util/async/abortUtils';
+import { TimeoutController } from '../util/async/TimeoutController';
+import { mergeDeep } from '../util/object/mergeDeep';
+import { substitute } from '../util/string/string';
+import { createShortUid } from '../util/string/uid';
+import { patchFetch } from '../patch/network/fetch';
+/**
+ * The minimum amount of time to leave for network calls. If the `max try time -
+ * timeout` is less than this value, an IllegalArgumentError will be thrown.
+ */
+export const MIN_SERVICE_TIME = 10;
+/**
+ * @private
+ */
+const locale = {
+    tryBackoffTooSmall: 'timeout - tryBackoff.maxTime must be at least {value}',
+    fetchNotFoundError: 'global fetch not found',
+};
+/**
+ * Distribute requests across the last 50% of the exponential back-off time
+ */
+export function defaultBackoffDistribution() {
+    return Math.random() * 0.5 + 0.5;
+}
+/**
+ * Calculates the timer delay according to an exponential back off strategy.
+ *
+ * @param failedCount The number of times the service has consecutively failed.
+ * @param options Retry timing options (default values from:
+ *   `defaultRetryOptions`)
+ *
+ * @returns The delay to retry a network request in seconds. This will be clamped
+ *   between 1 and `options.maxRetryTime`.
+ */
+export function getBackoffTime(failedCount, options) {
+    if (failedCount <= 0)
+        return 0;
+    return (options.distribution() *
+        Math.min(options.interval * Math.pow(options.exponentBase, failedCount - 1), options.maxTime));
+}
+export const RetryStrategy = {
+    get NO_RETRIES() {
+        /**
+         * Defaults for first try behavior.
+         * Tries should have minimal throttling, enough to be a safety against aberrant client behavior
+         * during a network outage.
+         */
+        const defaultTryBackoff = {
+            exponentBase: 2,
+            interval: 0.5,
+            maxTime: 15,
+            distribution: defaultBackoffDistribution,
+        };
+        /**
+         * Defaults for retry behavior.
+         */
+        const defaultRetryBackoff = {
+            exponentBase: 2,
+            interval: 3,
+            maxTime: 60,
+            distribution: defaultBackoffDistribution,
+        };
+        return {
+            retries: 0,
+            retryBackoff: defaultRetryBackoff,
+            retryFailureCutoff: 5,
+            tryBackoff: defaultTryBackoff,
+            retryAfterJitter,
+            shouldRetry,
+        };
+    },
+    get ONE_RETRY() {
+        return {
+            ...this.NO_RETRIES,
+            retries: 1,
+        };
+    },
+};
+/**
+ * A quality of service wrapper to `global.fetch`.
+ * Handles retries, network status, and emits events that may be used in reporting or metrics.
+ */
+export class RequesterImpl extends EventHostImpl {
+    deps;
+    get [Symbol.toStringTag]() {
+        return 'RequesterImpl';
+    }
+    /**
+     * Default values for fetch options.
+     */
+    _options = {
+        timeout: 60,
+        retryOptions: RetryStrategy.NO_RETRIES,
+    };
+    constructor(deps) {
+        super();
+        this.deps = deps;
+    }
+    /**
+     * The current base options.
+     * {@link request} may override these values.
+     */
+    get options() {
+        return this._options;
+    }
+    /**
+     * Applies the given partial configuration.
+     *
+     * @param newOptions
+     */
+    configure(newOptions) {
+        this._options = mergeDeep([this._options, newOptions]);
+    }
+    async request(input, init, requestOptions) {
+        requestOptions = requestOptions ?? {};
+        const options = this._options;
+        const retryOptions = options.retryOptions;
+        if (options.timeout - retryOptions.tryBackoff.maxTime <
+            MIN_SERVICE_TIME) {
+            throw new IllegalArgumentError(substitute(locale.tryBackoffTooSmall, {
+                value: MIN_SERVICE_TIME,
+            }));
+        }
+        const timeoutController = new TimeoutController(options.timeout, requestOptions.abort);
+        // Replace the request init to use the timeout controller's signal.
+        const finalInit = {
+            ...init,
+            signal: timeoutController.nativeSignal,
+        };
+        const requestInfo = {
+            requestId: createShortUid(),
+            init: finalInit,
+            input,
+            maxRetries: retryOptions.retries,
+            timestamp: Date.now(),
+            requestOptions: {
+                serviceId: requestOptions.serviceId ?? null,
+                readErrorBody: requestOptions.readErrorBody ?? ErrorBodyType.DISABLED,
+            },
+        };
+        this.dispatch('request', { requestInfo });
+        let lastResult = null;
+        let currentTry = 0;
+        do {
+            ++currentTry;
+            const attemptInfo = {
+                currentTry,
+                timestamp: Date.now(),
+            };
+            this.dispatch('requestAttemptStart', {
+                requestInfo,
+                attemptInfo,
+            });
+            lastResult = await this.doRequest(requestInfo, requestOptions, attemptInfo, timeoutController).catch((reason) => {
+                const completeInfo = {
+                    ok: false,
+                    type: requestOptions.abort?.aborted()
+                        ? RequestFailureType.ABORT
+                        : RequestFailureType.INTERNAL,
+                    requestInfo,
+                    reason,
+                    willRetry: false,
+                    timestamp: Date.now(),
+                    retryAfter: null,
+                };
+                return { info: completeInfo, response: null };
+            });
+            timeoutController.dispose();
+            this.reportMetricsEntry(lastResult.info);
+            this.dispatch('requestAttemptComplete', lastResult.info);
+        } while (!lastResult.info.ok && lastResult.info.willRetry);
+        this.dispatch('requestComplete', lastResult.info);
+        if (lastResult.info.ok)
+            return lastResult.response;
+        else
+            throw new RequestError(lastResult.response, lastResult.info);
+    }
+    /**
+     * Executes a single fetch.
+     * If the request is aborted via `requestInfo.init.signal` the promise will be rejected with
+     * the abort reason.
+     *
+     * @throws RequestError
+     * @private
+     */
+    async doRequest(requestInfo, requestOptions, attemptInfo, timeoutController) {
+        const deps = this.deps;
+        const retryOptions = this._options.retryOptions;
+        const firstTry = attemptInfo.currentTry === 1;
+        const serviceId = requestInfo.requestOptions.serviceId;
+        const serviceMetrics = deps.networkMetricsController.getServiceMetrics(serviceId);
+        const failedCount = serviceMetrics.failureTotals.consecutiveCount;
+        const lastTry = attemptInfo.currentTry === retryOptions.retries + 1 ||
+            failedCount + 1 >= retryOptions.retryFailureCutoff;
+        if (serviceMetrics.retryAfter) {
+            await timeoutController.sleep(
+            // OK to give sleep negative values.
+            // Immediately rejects if sleep duration is beyond the timeout.
+            (serviceMetrics.retryAfter - Date.now()) / 1000 +
+                retryOptions.retryAfterJitter());
+        }
+        else {
+            const backoffTime = getBackoffTime(failedCount, firstTry ? retryOptions.tryBackoff : retryOptions.retryBackoff);
+            await timeoutController.sleep(backoffTime);
+        }
+        // Modern browsers support request cancellation by providing an abortSignal.
+        // Whether the browsers support request cancellation or not, we want to stop
+        // waiting for the fetch when the signal is aborted.
+        let failureReason = null;
+        const response = await withAbort(deps.fetch(requestInfo.input, requestInfo.init).catch((reason) => {
+            failureReason = reason;
+            return null;
+        }), requestOptions.abort);
+        if (response?.ok)
+            return {
+                info: {
+                    ok: true,
+                    requestInfo,
+                    attemptInfo,
+                    responseInfo: getResponseInfo(response),
+                    timestamp: Date.now(),
+                },
+                response,
+            };
+        const errorCommon = {
+            ok: false,
+            requestInfo,
+            attemptInfo,
+            timestamp: Date.now(),
+        };
+        if (response) {
+            const shouldRetry = retryOptions.shouldRetry(response.status);
+            let reason = null;
+            try {
+                switch (requestInfo.requestOptions.readErrorBody) {
+                    case ErrorBodyType.TEXT:
+                        reason = await response.text();
+                        break;
+                    case ErrorBodyType.JSON:
+                        reason = await response.json();
+                        break;
+                }
+            }
+            catch (e) {
+                reason = `Failed to read error body: ${e}`;
+            }
+            return {
+                info: {
+                    type: RequestFailureType.RESPONSE,
+                    ...errorCommon,
+                    reason,
+                    responseInfo: getResponseInfo(response),
+                    retryAfter: parseRetryAfter(response.headers.get('retry-after')),
+                    willRetry: shouldRetry && !lastTry,
+                },
+                response,
+            };
+        }
+        else {
+            if (failureReason?.name === 'AbortError' ||
+                // Firefox:
+                (failureReason &&
+                    failureReason === requestOptions.abort?.reason)) {
+                return {
+                    info: {
+                        type: RequestFailureType.ABORT,
+                        ...errorCommon,
+                        reason: requestOptions.abort?.reason,
+                        retryAfter: null,
+                        willRetry: false,
+                    },
+                    response: null,
+                };
+            }
+            else {
+                return {
+                    info: {
+                        type: RequestFailureType.NETWORK,
+                        ...errorCommon,
+                        reason: failureReason,
+                        retryAfter: null,
+                        willRetry: !lastTry,
+                    },
+                    response: null,
+                };
+            }
+        }
+    }
+    reportMetricsEntry(event) {
+        // Do not add a metrics entry for aborts or non-response errors.
+        if (!event.ok && event.type !== RequestFailureType.RESPONSE)
+            return;
+        this.deps.networkMetricsController.addMetricsEntry({
+            ok: event.ok,
+            serviceId: event.requestInfo.requestOptions.serviceId,
+            retryAfter: event.ok ? null : event.retryAfter,
+            responseTime: event.ok
+                ? (event.timestamp - event.requestInfo.timestamp) / 1000
+                : null,
+        });
+    }
+}
+export const nativeFetchRef = globalRef(() => {
+    if (typeof global.fetch !== 'function')
+        return () => {
+            throw new Error(locale.fetchNotFoundError);
+        };
+    const fetch = global.fetch.bind(global);
+    return patchFetch(fetch);
+});

package/dist/types/current/network/RequesterImplEventMap.d.ts

@@ -0,0 +1,230 @@
+import type { Timestamp } from '../util/date/date';
+import type { ErrorBodyType } from '../network/Requester';
+/**
+ * Events {@link RequesterImpl} emits.
+ */
+export interface RequesterImplEventMap {
+    /**
+     * A request has been requested.
+     * This is emitted immediately when {@link Requester.request} is called.
+     */
+    readonly request: RequestEvent;
+    /**
+     * A request attempt has begun. For implementations with retry behavior, this is expected to be
+     * emitted for each try.
+     */
+    readonly requestAttemptStart: RequestAttemptStartEvent;
+    /**
+     * A request attempt has completed.
+     */
+    readonly requestAttemptComplete: RequestCompletedEvent;
+    /**
+     * The request promise is about to settle.
+     */
+    readonly requestComplete: RequestCompletedEvent;
+}
+export interface RequestEvent {
+    /**
+     * Information about the request.
+     */
+    readonly requestInfo: FetchRequestInfo;
+}
+export interface RequestAttemptStartEvent {
+    /**
+     * Information about the request.
+     */
+    readonly requestInfo: FetchRequestInfo;
+    /**
+     * Information about the current attempt.
+     */
+    readonly attemptInfo: RequestAttemptInfo;
+}
+/**
+ * When a request has been made, information about the request is gathered for logging.
+ */
+export interface FetchRequestInfo {
+    /**
+     * The identifier for the request. The request id for the `requesting` event will match its
+     * corresponding `requestComplete` event.
+     */
+    readonly requestId: string;
+    /**
+     * The input parameter passed to `request`.
+     */
+    readonly input: RequestInfo | URL;
+    /**
+     * The init parameter passed to `request`.
+     */
+    readonly init: RequestInit;
+    /**
+     * The maximum number of retries.
+     */
+    readonly maxRetries: number;
+    /**
+     * Options the request is using.
+     */
+    readonly requestOptions: {
+        /**
+         * The resolved service id.
+         */
+        readonly serviceId: string | null;
+        /**
+         * Determines how error responses are read and reported.
+         */
+        readonly readErrorBody: ErrorBodyType;
+    };
+    /**
+     * The timestamp the request was originally requested.
+     */
+    readonly timestamp: Timestamp;
+}
+/**
+ * Information about the current try.
+ */
+export interface RequestAttemptInfo {
+    /**
+     * The current try (1 = first).
+     */
+    readonly currentTry: number;
+    /**
+     * The timestamp the actual request attempt began. This will be after awaiting network
+     * availability.
+     */
+    readonly timestamp: Timestamp;
+}
+/**
+ * Information about a request completion, either from a successful response or a failure.
+ */
+export type RequestCompletedEvent = RequestSuccessEvent | RequestErrorEvent;
+export interface RequestCompletedEventBase {
+    /**
+     * True if the request was successful.
+     */
+    readonly ok: boolean;
+    /**
+     * The local timestamp of the request result or error.
+     */
+    readonly timestamp: Timestamp;
+    /**
+     * Information about the request.
+     */
+    readonly requestInfo: FetchRequestInfo;
+}
+export interface RequestSuccessEvent extends RequestCompletedEventBase {
+    /**
+     * The response was successful.
+     */
+    readonly ok: true;
+    /**
+     * The serializable and loggable response.
+     */
+    readonly responseInfo: ResponseInfo;
+    /**
+     * Information about the current attempt.
+     */
+    readonly attemptInfo: RequestAttemptInfo;
+}
+export declare enum RequestFailureType {
+    /**
+     * The request has been aborted.
+     */
+    ABORT = "abort",
+    /**
+     * The request failed due to a caught internal error.
+     */
+    INTERNAL = "internal",
+    /**
+     * The request failed with a caught error.
+     */
+    NETWORK = "network",
+    /**
+     * An `!ok` response was received.
+     */
+    RESPONSE = "response"
+}
+export type RequestErrorEvent = RequestCaughtErrorEvent | RequestNetworkErrorEvent | RequestResponseErrorEvent;
+export interface RequestErrorEventBase extends RequestCompletedEventBase {
+    /**
+     * The request failed.
+     */
+    readonly ok: false;
+    /**
+     * The failure type.
+     */
+    readonly type: RequestFailureType;
+    /**
+     * If false, the request will not be retried, even if there are more tries remaining.
+     *
+     * This will be false if the error is an internal error, retries have been exhausted or the
+     * response did not pass the `shouldRetry` filter.
+     */
+    readonly willRetry: boolean;
+    /**
+     * The timestamp of the next try.
+     * If `willRetry` is true, the request will try again at this timestamp.
+     */
+    readonly retryAfter: Timestamp | null;
+    /**
+     * The caught or rejected reason.
+     */
+    readonly reason: any;
+}
+export interface RequestCaughtErrorEvent extends RequestErrorEventBase {
+    readonly type: RequestFailureType.INTERNAL | RequestFailureType.ABORT;
+    /**
+     * Caught errors will not be retried.
+     */
+    readonly willRetry: false;
+}
+export interface RequestNetworkErrorEvent extends RequestErrorEventBase {
+    readonly type: RequestFailureType.NETWORK;
+    /**
+     * Information about the current attempt.
+     */
+    readonly attemptInfo: RequestAttemptInfo;
+}
+export interface RequestResponseErrorEvent extends RequestErrorEventBase {
+    readonly type: RequestFailureType.RESPONSE;
+    /**
+     * The serializable and loggable response.
+     */
+    readonly responseInfo: ResponseInfo;
+    /**
+     * Information about the current attempt.
+     */
+    readonly attemptInfo: RequestAttemptInfo;
+}
+/**
+ * Serializable response metadata, excluding the body.
+ */
+export interface ResponseInfo {
+    /**
+     * True if status is in the 200–299 range.
+     */
+    readonly ok: boolean;
+    /**
+     * True if the response resulted from a redirect.
+     */
+    readonly redirected: boolean;
+    /**
+     * HTTP status code (e.g. 200).
+     */
+    readonly status: number;
+    /**
+     * HTTP status text (e.g. "OK").
+     */
+    readonly statusText: string;
+    /**
+     * Type of response (e.g. "basic", "cors").
+     */
+    readonly type: ResponseType;
+    /**
+     * Final resolved URL of the response.
+     */
+    readonly url: string;
+    /**
+     * Size of the response body in bytes, or null if unknown.
+     */
+    readonly contentLength: number | null;
+}
+//# sourceMappingURL=RequesterImplEventMap.d.ts.map

package/dist/types/current/network/RequesterImplEventMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RequesterImplEventMap.d.ts","sourceRoot":"","sources":["../../../../src/network/RequesterImplEventMap.ts"],"names":[],"mappings":"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"}

package/dist/types/current/network/RequesterImplEventMap.js

@@ -0,0 +1,23 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export var RequestFailureType;
+(function (RequestFailureType) {
+    /**
+     * The request has been aborted.
+     */
+    RequestFailureType["ABORT"] = "abort";
+    /**
+     * The request failed due to a caught internal error.
+     */
+    RequestFailureType["INTERNAL"] = "internal";
+    /**
+     * The request failed with a caught error.
+     */
+    RequestFailureType["NETWORK"] = "network";
+    /**
+     * An `!ok` response was received.
+     */
+    RequestFailureType["RESPONSE"] = "response";
+})(RequestFailureType || (RequestFailureType = {}));

package/dist/types/current/network/browser/NetworkInformation.d.ts

@@ -0,0 +1,48 @@
+export interface NetworkInformationEventMap {
+    readonly change: Event;
+}
+export type NetworkInformationEffectiveType = 'slow-2g' | '2g' | '3g' | '4g';
+export type NetworkInformationType = 'bluetooth' | 'cellular' | 'ethernet' | 'none' | 'wifi' | 'wimax' | 'other' | 'unknown';
+/**
+ * Provides information about the system’s current network connection,
+ * such as estimated bandwidth, round-trip time, and connection type.
+ * Also exposes events for monitoring changes to the network state.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/NetworkInformation
+ */
+export interface NetworkInformation extends EventTarget {
+    /**
+     * Approximate downlink speed in megabits per second.
+     * Rounded to the nearest 25 kbps, based on recent throughput
+     * over active connections. May be undefined if no estimate is available.
+     */
+    readonly downlink: number | undefined;
+    /**
+     * A string describing the general quality of the connection
+     * (for example, "4g", "3g"). Determined from both downlink
+     * and latency estimates.
+     */
+    readonly effectiveType: NetworkInformationEffectiveType;
+    /**
+     * Estimated round-trip latency of the current connection in milliseconds,
+     * rounded to the nearest multiple of 25 ms.
+     */
+    readonly rtt: number;
+    /**
+     * Indicates whether the user has requested reduced data usage
+     * in the user agent’s settings.
+     */
+    readonly saveData: boolean;
+    /**
+     * Type of underlying network connection in use
+     * (for example, "wifi", "cellular"). May be omitted if unknown.
+     */
+    readonly type?: NetworkInformationType;
+    addEventListener<K extends keyof NetworkInformationEventMap>(type: K, listener: (this: NetworkInformation, ev: NetworkInformationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof NetworkInformationEventMap>(type: K, listener: (this: NetworkInformation, ev: NetworkInformationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+}
+/**
+ * Returns the browser's NetworkInformation interface, if it's defined.
+ */
+export declare function getNetworkInformation(): NetworkInformation | undefined;
+//# sourceMappingURL=NetworkInformation.d.ts.map

package/dist/types/current/network/browser/NetworkInformation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NetworkInformation.d.ts","sourceRoot":"","sources":["../../../../../src/network/browser/NetworkInformation.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,0BAA0B;IACvC,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAA;CACzB;AAED,MAAM,MAAM,+BAA+B,GAAG,SAAS,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAA;AAC5E,MAAM,MAAM,sBAAsB,GAC5B,WAAW,GACX,UAAU,GACV,UAAU,GACV,MAAM,GACN,MAAM,GACN,OAAO,GACP,OAAO,GACP,SAAS,CAAA;AAEf;;;;;;GAMG;AACH,MAAM,WAAW,kBAAmB,SAAQ,WAAW;IACnD;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAA;IAErC;;;;OAIG;IACH,QAAQ,CAAC,aAAa,EAAE,+BAA+B,CAAA;IAEvD;;;OAGG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IAEpB;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;IAE1B;;;OAGG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,sBAAsB,CAAA;IAEtC,gBAAgB,CAAC,CAAC,SAAS,MAAM,0BAA0B,EACvD,IAAI,EAAE,CAAC,EACP,QAAQ,EAAE,CACN,IAAI,EAAE,kBAAkB,EACxB,EAAE,EAAE,0BAA0B,CAAC,CAAC,CAAC,KAChC,GAAG,EACR,OAAO,CAAC,EAAE,OAAO,GAAG,uBAAuB,GAC5C,IAAI,CAAA;IAEP,mBAAmB,CAAC,CAAC,SAAS,MAAM,0BAA0B,EAC1D,IAAI,EAAE,CAAC,EACP,QAAQ,EAAE,CACN,IAAI,EAAE,kBAAkB,EACxB,EAAE,EAAE,0BAA0B,CAAC,CAAC,CAAC,KAChC,GAAG,EACR,OAAO,CAAC,EAAE,OAAO,GAAG,oBAAoB,GACzC,IAAI,CAAA;CACV;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,kBAAkB,GAAG,SAAS,CAUtE"}

package/dist/types/current/network/browser/NetworkInformation.js

@@ -0,0 +1,17 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Returns the browser's NetworkInformation interface, if it's defined.
+ */
+export function getNetworkInformation() {
+    if (typeof window !== 'undefined' &&
+        typeof window.navigator !== 'undefined' &&
+        'connection' in window.navigator) {
+        return window.navigator.connection;
+    }
+    else {
+        return undefined;
+    }
+}

package/dist/types/current/network/createRequester.d.ts

@@ -0,0 +1,12 @@
+import type { Requester } from './Requester';
+import type { RequesterImplDeps, RequesterImplOptions } from './RequesterImpl';
+import type { Maybe, PartialDeep } from '../util/type';
+/**
+ * Creates a default Requester implementation with optional configuration or dependency overrides.
+ * The new Requester is watched for global logging and network metrics.
+ *
+ * @param options
+ * @param deps
+ */
+export declare function createRequester(options?: Maybe<PartialDeep<RequesterImplOptions>>, deps?: Partial<RequesterImplDeps>): Requester;
+//# sourceMappingURL=createRequester.d.ts.map

package/dist/types/current/network/createRequester.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createRequester.d.ts","sourceRoot":"","sources":["../../../../src/network/createRequester.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAC5C,OAAO,KAAK,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AAG9E,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAErD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC3B,OAAO,CAAC,EAAE,KAAK,CAAC,WAAW,CAAC,oBAAoB,CAAC,CAAC,EAClD,IAAI,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC,GAClC,SAAS,CAYX"}