{"version":3,"file":"static/js/2125_e721a29c158b77baacfd.js","mappings":"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","sources":["file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-lro@2.5.4/node_modules/@azure/core-lro/dist-esm/src/legacy/poller.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-rest-pipeline@1.13.0/node_modules/@azure/core-rest-pipeline/dist-esm/src/policies/logPolicy.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-rest-pipeline@1.13.0/node_modules/@azure/core-rest-pipeline/dist-esm/src/pipeline.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-rest-pipeline@1.13.0/node_modules/@azure/core-rest-pipeline/dist-esm/src/policies/redirectPolicy.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-rest-pipeline@1.13.0/node_modules/@azure/core-rest-pipeline/dist-esm/src/constants.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-rest-pipeline@1.13.0/node_modules/@azure/core-rest-pipeline/dist-esm/src/util/userAgent.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-rest-pipeline@1.13.0/node_modules/@azure/core-rest-pipeline/dist-esm/src/util/userAgentPlatform.browser.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-rest-pipeline@1.13.0/node_modules/@azure/core-rest-pipeline/dist-esm/src/policies/userAgentPolicy.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-rest-pipeline@1.13.0/node_modules/@azure/core-rest-pipeline/dist-esm/src/retryStrategies/throttlingRetryStrategy.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-rest-pipeline@1.13.0/node_modules/@azure/core-rest-pipeline/dist-esm/src/retryStrategies/exponentialRetryStrategy.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-util@1.6.1/node_modules/@azure/core-util/dist-esm/src/random.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-rest-pipeline@1.13.0/node_modules/@azure/core-rest-pipeline/dist-esm/src/policies/retryPolicy.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-rest-pipeline@1.13.0/node_modules/@azure/core-rest-pipeline/dist-esm/src/policies/defaultRetryPolicy.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-util@1.6.1/node_modules/@azure/core-util/dist-esm/src/bytesEncoding.browser.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-rest-pipeline@1.13.0/node_modules/@azure/core-rest-pipeline/dist-esm/src/policies/formDataPolicy.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-rest-pipeline@1.13.0/node_modules/@azure/core-rest-pipeline/dist-esm/src/policies/proxyPolicy.browser.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-rest-pipeline@1.13.0/node_modules/@azure/core-rest-pipeline/dist-esm/src/policies/setClientRequestIdPolicy.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-rest-pipeline@1.13.0/node_modules/@azure/core-rest-pipeline/dist-esm/src/policies/tlsPolicy.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-rest-pipeline@1.13.0/node_modules/@azure/core-rest-pipeline/dist-esm/src/policies/tracingPolicy.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-rest-pipeline@1.13.0/node_modules/@azure/core-rest-pipeline/dist-esm/src/util/stream.browser.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-rest-pipeline@1.13.0/node_modules/@azure/core-rest-pipeline/dist-esm/src/policies/multipartPolicy.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-rest-pipeline@1.13.0/node_modules/@azure/core-rest-pipeline/dist-esm/src/createPipelineFromOptions.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-rest-pipeline@1.13.0/node_modules/@azure/core-rest-pipeline/dist-esm/src/policies/decompressResponsePolicy.browser.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-rest-pipeline@1.13.0/node_modules/@azure/core-rest-pipeline/dist-esm/src/fetchHttpClient.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-rest-pipeline@1.13.0/node_modules/@azure/core-rest-pipeline/dist-esm/src/defaultHttpClient.browser.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-rest-pipeline@1.13.0/node_modules/@azure/core-rest-pipeline/dist-esm/src/httpHeaders.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-rest-pipeline@1.13.0/node_modules/@azure/core-rest-pipeline/dist-esm/src/log.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-rest-pipeline@1.13.0/node_modules/@azure/core-rest-pipeline/dist-esm/src/pipelineRequest.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-rest-pipeline@1.13.0/node_modules/@azure/core-rest-pipeline/dist-esm/src/util/tokenCycler.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-rest-pipeline@1.13.0/node_modules/@azure/core-rest-pipeline/dist-esm/src/policies/bearerTokenAuthenticationPolicy.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-rest-pipeline@1.13.0/node_modules/@azure/core-rest-pipeline/dist-esm/src/util/inspect.browser.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-rest-pipeline@1.13.0/node_modules/@azure/core-rest-pipeline/dist-esm/src/restError.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-rest-pipeline@1.13.0/node_modules/@azure/core-rest-pipeline/dist-esm/src/util/helpers.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-rest-pipeline@1.13.0/node_modules/@azure/core-rest-pipeline/dist-esm/src/util/sanitizer.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-rest-pipeline@1.13.0/node_modules/@azure/core-rest-pipeline/dist-esm/src/util/typeGuards.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-tracing@1.0.0-preview.13/node_modules/@azure/core-tracing/dist-esm/src/createSpan.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-tracing@1.0.0-preview.13/node_modules/@azure/core-tracing/dist-esm/src/interfaces.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-tracing@1.0.0-preview.13/node_modules/@azure/core-tracing/dist-esm/src/utils/traceParentHeader.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-tracing@1.0.1/node_modules/@azure/core-tracing/dist-esm/src/tracingContext.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-tracing@1.0.1/node_modules/@azure/core-tracing/dist-esm/src/instrumenter.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-tracing@1.0.1/node_modules/@azure/core-tracing/dist-esm/src/tracingClient.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-util@1.6.1/node_modules/@azure/core-util/dist-esm/src/checkEnvironment.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-util@1.6.1/node_modules/@azure/core-util/dist-esm/src/delay.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-util@1.6.1/node_modules/@azure/core-util/dist-esm/src/createAbortablePromise.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-util@1.6.1/node_modules/@azure/core-util/dist-esm/src/error.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-util@1.6.1/node_modules/@azure/core-util/dist-esm/src/object.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-util@1.6.1/node_modules/@azure/core-util/dist-esm/src/uuidUtils.native.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+core-util@1.6.1/node_modules/@azure/core-util/dist-esm/src/uuidUtils.browser.js"],"sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n/**\n * When a poller is manually stopped through the `stopPolling` method,\n * the poller will be rejected with an instance of the PollerStoppedError.\n */\nexport class PollerStoppedError extends Error {\n    constructor(message) {\n        super(message);\n        this.name = \"PollerStoppedError\";\n        Object.setPrototypeOf(this, PollerStoppedError.prototype);\n    }\n}\n/**\n * When the operation is cancelled, the poller will be rejected with an instance\n * of the PollerCancelledError.\n */\nexport class PollerCancelledError extends Error {\n    constructor(message) {\n        super(message);\n        this.name = \"PollerCancelledError\";\n        Object.setPrototypeOf(this, PollerCancelledError.prototype);\n    }\n}\n/**\n * A class that represents the definition of a program that polls through consecutive requests\n * until it reaches a state of completion.\n *\n * A poller can be executed manually, by polling request by request by calling to the `poll()` method repeatedly, until its operation is completed.\n * It also provides a way to wait until the operation completes, by calling `pollUntilDone()` and waiting until the operation finishes.\n * Pollers can also request the cancellation of the ongoing process to whom is providing the underlying long running operation.\n *\n * ```ts\n * const poller = new MyPoller();\n *\n * // Polling just once:\n * await poller.poll();\n *\n * // We can try to cancel the request here, by calling:\n * //\n * //     await poller.cancelOperation();\n * //\n *\n * // Getting the final result:\n * const result = await poller.pollUntilDone();\n * ```\n *\n * The Poller is defined by two types, a type representing the state of the poller, which\n * must include a basic set of properties from `PollOperationState<TResult>`,\n * and a return type defined by `TResult`, which can be anything.\n *\n * The Poller class implements the `PollerLike` interface, which allows poller implementations to avoid having\n * to export the Poller's class directly, and instead only export the already instantiated poller with the PollerLike type.\n *\n * ```ts\n * class Client {\n *   public async makePoller: PollerLike<MyOperationState, MyResult> {\n *     const poller = new MyPoller({});\n *     // It might be preferred to return the poller after the first request is made,\n *     // so that some information can be obtained right away.\n *     await poller.poll();\n *     return poller;\n *   }\n * }\n *\n * const poller: PollerLike<MyOperationState, MyResult> = myClient.makePoller();\n * ```\n *\n * A poller can be created through its constructor, then it can be polled until it's completed.\n * At any point in time, the state of the poller can be obtained without delay through the getOperationState method.\n * At any point in time, the intermediate forms of the result type can be requested without delay.\n * Once the underlying operation is marked as completed, the poller will stop and the final value will be returned.\n *\n * ```ts\n * const poller = myClient.makePoller();\n * const state: MyOperationState = poller.getOperationState();\n *\n * // The intermediate result can be obtained at any time.\n * const result: MyResult | undefined = poller.getResult();\n *\n * // The final result can only be obtained after the poller finishes.\n * const result: MyResult = await poller.pollUntilDone();\n * ```\n *\n */\n// eslint-disable-next-line no-use-before-define\nexport class Poller {\n    /**\n     * A poller needs to be initialized by passing in at least the basic properties of the `PollOperation<TState, TResult>`.\n     *\n     * When writing an implementation of a Poller, this implementation needs to deal with the initialization\n     * of any custom state beyond the basic definition of the poller. The basic poller assumes that the poller's\n     * operation has already been defined, at least its basic properties. The code below shows how to approach\n     * the definition of the constructor of a new custom poller.\n     *\n     * ```ts\n     * export class MyPoller extends Poller<MyOperationState, string> {\n     *   constructor({\n     *     // Anything you might need outside of the basics\n     *   }) {\n     *     let state: MyOperationState = {\n     *       privateProperty: private,\n     *       publicProperty: public,\n     *     };\n     *\n     *     const operation = {\n     *       state,\n     *       update,\n     *       cancel,\n     *       toString\n     *     }\n     *\n     *     // Sending the operation to the parent's constructor.\n     *     super(operation);\n     *\n     *     // You can assign more local properties here.\n     *   }\n     * }\n     * ```\n     *\n     * Inside of this constructor, a new promise is created. This will be used to\n     * tell the user when the poller finishes (see `pollUntilDone()`). The promise's\n     * resolve and reject methods are also used internally to control when to resolve\n     * or reject anyone waiting for the poller to finish.\n     *\n     * The constructor of a custom implementation of a poller is where any serialized version of\n     * a previous poller's operation should be deserialized into the operation sent to the\n     * base constructor. For example:\n     *\n     * ```ts\n     * export class MyPoller extends Poller<MyOperationState, string> {\n     *   constructor(\n     *     baseOperation: string | undefined\n     *   ) {\n     *     let state: MyOperationState = {};\n     *     if (baseOperation) {\n     *       state = {\n     *         ...JSON.parse(baseOperation).state,\n     *         ...state\n     *       };\n     *     }\n     *     const operation = {\n     *       state,\n     *       // ...\n     *     }\n     *     super(operation);\n     *   }\n     * }\n     * ```\n     *\n     * @param operation - Must contain the basic properties of `PollOperation<State, TResult>`.\n     */\n    constructor(operation) {\n        /** controls whether to throw an error if the operation failed or was canceled. */\n        this.resolveOnUnsuccessful = false;\n        this.stopped = true;\n        this.pollProgressCallbacks = [];\n        this.operation = operation;\n        this.promise = new Promise((resolve, reject) => {\n            this.resolve = resolve;\n            this.reject = reject;\n        });\n        // This prevents the UnhandledPromiseRejectionWarning in node.js from being thrown.\n        // The above warning would get thrown if `poller.poll` is called, it returns an error,\n        // and pullUntilDone did not have a .catch or await try/catch on it's return value.\n        this.promise.catch(() => {\n            /* intentionally blank */\n        });\n    }\n    /**\n     * Starts a loop that will break only if the poller is done\n     * or if the poller is stopped.\n     */\n    async startPolling(pollOptions = {}) {\n        if (this.stopped) {\n            this.stopped = false;\n        }\n        while (!this.isStopped() && !this.isDone()) {\n            await this.poll(pollOptions);\n            await this.delay();\n        }\n    }\n    /**\n     * pollOnce does one polling, by calling to the update method of the underlying\n     * poll operation to make any relevant change effective.\n     *\n     * It only optionally receives an object with an abortSignal property, from \\@azure/abort-controller's AbortSignalLike.\n     *\n     * @param options - Optional properties passed to the operation's update method.\n     */\n    async pollOnce(options = {}) {\n        if (!this.isDone()) {\n            this.operation = await this.operation.update({\n                abortSignal: options.abortSignal,\n                fireProgress: this.fireProgress.bind(this),\n            });\n        }\n        this.processUpdatedState();\n    }\n    /**\n     * fireProgress calls the functions passed in via onProgress the method of the poller.\n     *\n     * It loops over all of the callbacks received from onProgress, and executes them, sending them\n     * the current operation state.\n     *\n     * @param state - The current operation state.\n     */\n    fireProgress(state) {\n        for (const callback of this.pollProgressCallbacks) {\n            callback(state);\n        }\n    }\n    /**\n     * Invokes the underlying operation's cancel method.\n     */\n    async cancelOnce(options = {}) {\n        this.operation = await this.operation.cancel(options);\n    }\n    /**\n     * Returns a promise that will resolve once a single polling request finishes.\n     * It does this by calling the update method of the Poller's operation.\n     *\n     * It only optionally receives an object with an abortSignal property, from \\@azure/abort-controller's AbortSignalLike.\n     *\n     * @param options - Optional properties passed to the operation's update method.\n     */\n    poll(options = {}) {\n        if (!this.pollOncePromise) {\n            this.pollOncePromise = this.pollOnce(options);\n            const clearPollOncePromise = () => {\n                this.pollOncePromise = undefined;\n            };\n            this.pollOncePromise.then(clearPollOncePromise, clearPollOncePromise).catch(this.reject);\n        }\n        return this.pollOncePromise;\n    }\n    processUpdatedState() {\n        if (this.operation.state.error) {\n            this.stopped = true;\n            if (!this.resolveOnUnsuccessful) {\n                this.reject(this.operation.state.error);\n                throw this.operation.state.error;\n            }\n        }\n        if (this.operation.state.isCancelled) {\n            this.stopped = true;\n            if (!this.resolveOnUnsuccessful) {\n                const error = new PollerCancelledError(\"Operation was canceled\");\n                this.reject(error);\n                throw error;\n            }\n        }\n        if (this.isDone() && this.resolve) {\n            // If the poller has finished polling, this means we now have a result.\n            // However, it can be the case that TResult is instantiated to void, so\n            // we are not expecting a result anyway. To assert that we might not\n            // have a result eventually after finishing polling, we cast the result\n            // to TResult.\n            this.resolve(this.getResult());\n        }\n    }\n    /**\n     * Returns a promise that will resolve once the underlying operation is completed.\n     */\n    async pollUntilDone(pollOptions = {}) {\n        if (this.stopped) {\n            this.startPolling(pollOptions).catch(this.reject);\n        }\n        // This is needed because the state could have been updated by\n        // `cancelOperation`, e.g. the operation is canceled or an error occurred.\n        this.processUpdatedState();\n        return this.promise;\n    }\n    /**\n     * Invokes the provided callback after each polling is completed,\n     * sending the current state of the poller's operation.\n     *\n     * It returns a method that can be used to stop receiving updates on the given callback function.\n     */\n    onProgress(callback) {\n        this.pollProgressCallbacks.push(callback);\n        return () => {\n            this.pollProgressCallbacks = this.pollProgressCallbacks.filter((c) => c !== callback);\n        };\n    }\n    /**\n     * Returns true if the poller has finished polling.\n     */\n    isDone() {\n        const state = this.operation.state;\n        return Boolean(state.isCompleted || state.isCancelled || state.error);\n    }\n    /**\n     * Stops the poller from continuing to poll.\n     */\n    stopPolling() {\n        if (!this.stopped) {\n            this.stopped = true;\n            if (this.reject) {\n                this.reject(new PollerStoppedError(\"This poller is already stopped\"));\n            }\n        }\n    }\n    /**\n     * Returns true if the poller is stopped.\n     */\n    isStopped() {\n        return this.stopped;\n    }\n    /**\n     * Attempts to cancel the underlying operation.\n     *\n     * It only optionally receives an object with an abortSignal property, from \\@azure/abort-controller's AbortSignalLike.\n     *\n     * If it's called again before it finishes, it will throw an error.\n     *\n     * @param options - Optional properties passed to the operation's update method.\n     */\n    cancelOperation(options = {}) {\n        if (!this.cancelPromise) {\n            this.cancelPromise = this.cancelOnce(options);\n        }\n        else if (options.abortSignal) {\n            throw new Error(\"A cancel request is currently pending\");\n        }\n        return this.cancelPromise;\n    }\n    /**\n     * Returns the state of the operation.\n     *\n     * Even though TState will be the same type inside any of the methods of any extension of the Poller class,\n     * implementations of the pollers can customize what's shared with the public by writing their own\n     * version of the `getOperationState` method, and by defining two types, one representing the internal state of the poller\n     * and a public type representing a safe to share subset of the properties of the internal state.\n     * Their definition of getOperationState can then return their public type.\n     *\n     * Example:\n     *\n     * ```ts\n     * // Let's say we have our poller's operation state defined as:\n     * interface MyOperationState extends PollOperationState<ResultType> {\n     *   privateProperty?: string;\n     *   publicProperty?: string;\n     * }\n     *\n     * // To allow us to have a true separation of public and private state, we have to define another interface:\n     * interface PublicState extends PollOperationState<ResultType> {\n     *   publicProperty?: string;\n     * }\n     *\n     * // Then, we define our Poller as follows:\n     * export class MyPoller extends Poller<MyOperationState, ResultType> {\n     *   // ... More content is needed here ...\n     *\n     *   public getOperationState(): PublicState {\n     *     const state: PublicState = this.operation.state;\n     *     return {\n     *       // Properties from PollOperationState<TResult>\n     *       isStarted: state.isStarted,\n     *       isCompleted: state.isCompleted,\n     *       isCancelled: state.isCancelled,\n     *       error: state.error,\n     *       result: state.result,\n     *\n     *       // The only other property needed by PublicState.\n     *       publicProperty: state.publicProperty\n     *     }\n     *   }\n     * }\n     * ```\n     *\n     * You can see this in the tests of this repository, go to the file:\n     * `../test/utils/testPoller.ts`\n     * and look for the getOperationState implementation.\n     */\n    getOperationState() {\n        return this.operation.state;\n    }\n    /**\n     * Returns the result value of the operation,\n     * regardless of the state of the poller.\n     * It can return undefined or an incomplete form of the final TResult value\n     * depending on the implementation.\n     */\n    getResult() {\n        const state = this.operation.state;\n        return state.result;\n    }\n    /**\n     * Returns a serialized version of the poller's operation\n     * by invoking the operation's toString method.\n     */\n    toString() {\n        return this.operation.toString();\n    }\n}\n//# sourceMappingURL=poller.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { logger as coreLogger } from \"../log\";\nimport { Sanitizer } from \"../util/sanitizer\";\n/**\n * The programmatic identifier of the logPolicy.\n */\nexport const logPolicyName = \"logPolicy\";\n/**\n * A policy that logs all requests and responses.\n * @param options - Options to configure logPolicy.\n */\nexport function logPolicy(options = {}) {\n    var _a;\n    const logger = (_a = options.logger) !== null && _a !== void 0 ? _a : coreLogger.info;\n    const sanitizer = new Sanitizer({\n        additionalAllowedHeaderNames: options.additionalAllowedHeaderNames,\n        additionalAllowedQueryParameters: options.additionalAllowedQueryParameters,\n    });\n    return {\n        name: logPolicyName,\n        async sendRequest(request, next) {\n            if (!logger.enabled) {\n                return next(request);\n            }\n            logger(`Request: ${sanitizer.sanitize(request)}`);\n            const response = await next(request);\n            logger(`Response status code: ${response.status}`);\n            logger(`Headers: ${sanitizer.sanitize(response.headers)}`);\n            return response;\n        },\n    };\n}\n//# sourceMappingURL=logPolicy.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nconst ValidPhaseNames = new Set([\"Deserialize\", \"Serialize\", \"Retry\", \"Sign\"]);\n/**\n * A private implementation of Pipeline.\n * Do not export this class from the package.\n * @internal\n */\nclass HttpPipeline {\n    constructor(policies) {\n        var _a;\n        this._policies = [];\n        this._policies = (_a = policies === null || policies === void 0 ? void 0 : policies.slice(0)) !== null && _a !== void 0 ? _a : [];\n        this._orderedPolicies = undefined;\n    }\n    addPolicy(policy, options = {}) {\n        if (options.phase && options.afterPhase) {\n            throw new Error(\"Policies inside a phase cannot specify afterPhase.\");\n        }\n        if (options.phase && !ValidPhaseNames.has(options.phase)) {\n            throw new Error(`Invalid phase name: ${options.phase}`);\n        }\n        if (options.afterPhase && !ValidPhaseNames.has(options.afterPhase)) {\n            throw new Error(`Invalid afterPhase name: ${options.afterPhase}`);\n        }\n        this._policies.push({\n            policy,\n            options,\n        });\n        this._orderedPolicies = undefined;\n    }\n    removePolicy(options) {\n        const removedPolicies = [];\n        this._policies = this._policies.filter((policyDescriptor) => {\n            if ((options.name && policyDescriptor.policy.name === options.name) ||\n                (options.phase && policyDescriptor.options.phase === options.phase)) {\n                removedPolicies.push(policyDescriptor.policy);\n                return false;\n            }\n            else {\n                return true;\n            }\n        });\n        this._orderedPolicies = undefined;\n        return removedPolicies;\n    }\n    sendRequest(httpClient, request) {\n        const policies = this.getOrderedPolicies();\n        const pipeline = policies.reduceRight((next, policy) => {\n            return (req) => {\n                return policy.sendRequest(req, next);\n            };\n        }, (req) => httpClient.sendRequest(req));\n        return pipeline(request);\n    }\n    getOrderedPolicies() {\n        if (!this._orderedPolicies) {\n            this._orderedPolicies = this.orderPolicies();\n        }\n        return this._orderedPolicies;\n    }\n    clone() {\n        return new HttpPipeline(this._policies);\n    }\n    static create() {\n        return new HttpPipeline();\n    }\n    orderPolicies() {\n        /**\n         * The goal of this method is to reliably order pipeline policies\n         * based on their declared requirements when they were added.\n         *\n         * Order is first determined by phase:\n         *\n         * 1. Serialize Phase\n         * 2. Policies not in a phase\n         * 3. Deserialize Phase\n         * 4. Retry Phase\n         * 5. Sign Phase\n         *\n         * Within each phase, policies are executed in the order\n         * they were added unless they were specified to execute\n         * before/after other policies or after a particular phase.\n         *\n         * To determine the final order, we will walk the policy list\n         * in phase order multiple times until all dependencies are\n         * satisfied.\n         *\n         * `afterPolicies` are the set of policies that must be\n         * executed before a given policy. This requirement is\n         * considered satisfied when each of the listed policies\n         * have been scheduled.\n         *\n         * `beforePolicies` are the set of policies that must be\n         * executed after a given policy. Since this dependency\n         * can be expressed by converting it into a equivalent\n         * `afterPolicies` declarations, they are normalized\n         * into that form for simplicity.\n         *\n         * An `afterPhase` dependency is considered satisfied when all\n         * policies in that phase have scheduled.\n         *\n         */\n        const result = [];\n        // Track all policies we know about.\n        const policyMap = new Map();\n        function createPhase(name) {\n            return {\n                name,\n                policies: new Set(),\n                hasRun: false,\n                hasAfterPolicies: false,\n            };\n        }\n        // Track policies for each phase.\n        const serializePhase = createPhase(\"Serialize\");\n        const noPhase = createPhase(\"None\");\n        const deserializePhase = createPhase(\"Deserialize\");\n        const retryPhase = createPhase(\"Retry\");\n        const signPhase = createPhase(\"Sign\");\n        // a list of phases in order\n        const orderedPhases = [serializePhase, noPhase, deserializePhase, retryPhase, signPhase];\n        // Small helper function to map phase name to each Phase\n        function getPhase(phase) {\n            if (phase === \"Retry\") {\n                return retryPhase;\n            }\n            else if (phase === \"Serialize\") {\n                return serializePhase;\n            }\n            else if (phase === \"Deserialize\") {\n                return deserializePhase;\n            }\n            else if (phase === \"Sign\") {\n                return signPhase;\n            }\n            else {\n                return noPhase;\n            }\n        }\n        // First walk each policy and create a node to track metadata.\n        for (const descriptor of this._policies) {\n            const policy = descriptor.policy;\n            const options = descriptor.options;\n            const policyName = policy.name;\n            if (policyMap.has(policyName)) {\n                throw new Error(\"Duplicate policy names not allowed in pipeline\");\n            }\n            const node = {\n                policy,\n                dependsOn: new Set(),\n                dependants: new Set(),\n            };\n            if (options.afterPhase) {\n                node.afterPhase = getPhase(options.afterPhase);\n                node.afterPhase.hasAfterPolicies = true;\n            }\n            policyMap.set(policyName, node);\n            const phase = getPhase(options.phase);\n            phase.policies.add(node);\n        }\n        // Now that each policy has a node, connect dependency references.\n        for (const descriptor of this._policies) {\n            const { policy, options } = descriptor;\n            const policyName = policy.name;\n            const node = policyMap.get(policyName);\n            if (!node) {\n                throw new Error(`Missing node for policy ${policyName}`);\n            }\n            if (options.afterPolicies) {\n                for (const afterPolicyName of options.afterPolicies) {\n                    const afterNode = policyMap.get(afterPolicyName);\n                    if (afterNode) {\n                        // Linking in both directions helps later\n                        // when we want to notify dependants.\n                        node.dependsOn.add(afterNode);\n                        afterNode.dependants.add(node);\n                    }\n                }\n            }\n            if (options.beforePolicies) {\n                for (const beforePolicyName of options.beforePolicies) {\n                    const beforeNode = policyMap.get(beforePolicyName);\n                    if (beforeNode) {\n                        // To execute before another node, make it\n                        // depend on the current node.\n                        beforeNode.dependsOn.add(node);\n                        node.dependants.add(beforeNode);\n                    }\n                }\n            }\n        }\n        function walkPhase(phase) {\n            phase.hasRun = true;\n            // Sets iterate in insertion order\n            for (const node of phase.policies) {\n                if (node.afterPhase && (!node.afterPhase.hasRun || node.afterPhase.policies.size)) {\n                    // If this node is waiting on a phase to complete,\n                    // we need to skip it for now.\n                    // Even if the phase is empty, we should wait for it\n                    // to be walked to avoid re-ordering policies.\n                    continue;\n                }\n                if (node.dependsOn.size === 0) {\n                    // If there's nothing else we're waiting for, we can\n                    // add this policy to the result list.\n                    result.push(node.policy);\n                    // Notify anything that depends on this policy that\n                    // the policy has been scheduled.\n                    for (const dependant of node.dependants) {\n                        dependant.dependsOn.delete(node);\n                    }\n                    policyMap.delete(node.policy.name);\n                    phase.policies.delete(node);\n                }\n            }\n        }\n        function walkPhases() {\n            for (const phase of orderedPhases) {\n                walkPhase(phase);\n                // if the phase isn't complete\n                if (phase.policies.size > 0 && phase !== noPhase) {\n                    if (!noPhase.hasRun) {\n                        // Try running noPhase to see if that unblocks this phase next tick.\n                        // This can happen if a phase that happens before noPhase\n                        // is waiting on a noPhase policy to complete.\n                        walkPhase(noPhase);\n                    }\n                    // Don't proceed to the next phase until this phase finishes.\n                    return;\n                }\n                if (phase.hasAfterPolicies) {\n                    // Run any policies unblocked by this phase\n                    walkPhase(noPhase);\n                }\n            }\n        }\n        // Iterate until we've put every node in the result list.\n        let iteration = 0;\n        while (policyMap.size > 0) {\n            iteration++;\n            const initialResultLength = result.length;\n            // Keep walking each phase in order until we can order every node.\n            walkPhases();\n            // The result list *should* get at least one larger each time\n            // after the first full pass.\n            // Otherwise, we're going to loop forever.\n            if (result.length <= initialResultLength && iteration > 1) {\n                throw new Error(\"Cannot satisfy policy dependencies due to requirements cycle.\");\n            }\n        }\n        return result;\n    }\n}\n/**\n * Creates a totally empty pipeline.\n * Useful for testing or creating a custom one.\n */\nexport function createEmptyPipeline() {\n    return HttpPipeline.create();\n}\n//# sourceMappingURL=pipeline.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n/**\n * The programmatic identifier of the redirectPolicy.\n */\nexport const redirectPolicyName = \"redirectPolicy\";\n/**\n * Methods that are allowed to follow redirects 301 and 302\n */\nconst allowedRedirect = [\"GET\", \"HEAD\"];\n/**\n * A policy to follow Location headers from the server in order\n * to support server-side redirection.\n * In the browser, this policy is not used.\n * @param options - Options to control policy behavior.\n */\nexport function redirectPolicy(options = {}) {\n    const { maxRetries = 20 } = options;\n    return {\n        name: redirectPolicyName,\n        async sendRequest(request, next) {\n            const response = await next(request);\n            return handleRedirect(next, response, maxRetries);\n        },\n    };\n}\nasync function handleRedirect(next, response, maxRetries, currentRetries = 0) {\n    const { request, status, headers } = response;\n    const locationHeader = headers.get(\"location\");\n    if (locationHeader &&\n        (status === 300 ||\n            (status === 301 && allowedRedirect.includes(request.method)) ||\n            (status === 302 && allowedRedirect.includes(request.method)) ||\n            (status === 303 && request.method === \"POST\") ||\n            status === 307) &&\n        currentRetries < maxRetries) {\n        const url = new URL(locationHeader, request.url);\n        request.url = url.toString();\n        // POST request with Status code 303 should be converted into a\n        // redirected GET request if the redirect url is present in the location header\n        if (status === 303) {\n            request.method = \"GET\";\n            request.headers.delete(\"Content-Length\");\n            delete request.body;\n        }\n        request.headers.delete(\"Authorization\");\n        const res = await next(request);\n        return handleRedirect(next, res, maxRetries, currentRetries + 1);\n    }\n    return response;\n}\n//# sourceMappingURL=redirectPolicy.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nexport const SDK_VERSION = \"1.12.3\";\nexport const DEFAULT_RETRY_POLICY_COUNT = 3;\n//# sourceMappingURL=constants.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { getHeaderName, setPlatformSpecificData } from \"./userAgentPlatform\";\nimport { SDK_VERSION } from \"../constants\";\nfunction getUserAgentString(telemetryInfo) {\n    const parts = [];\n    for (const [key, value] of telemetryInfo) {\n        const token = value ? `${key}/${value}` : key;\n        parts.push(token);\n    }\n    return parts.join(\" \");\n}\n/**\n * @internal\n */\nexport function getUserAgentHeaderName() {\n    return getHeaderName();\n}\n/**\n * @internal\n */\nexport function getUserAgentValue(prefix) {\n    const runtimeInfo = new Map();\n    runtimeInfo.set(\"core-rest-pipeline\", SDK_VERSION);\n    setPlatformSpecificData(runtimeInfo);\n    const defaultAgent = getUserAgentString(runtimeInfo);\n    const userAgentValue = prefix ? `${prefix} ${defaultAgent}` : defaultAgent;\n    return userAgentValue;\n}\n//# sourceMappingURL=userAgent.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n/*\n * NOTE: When moving this file, please update \"browser\" section in package.json.\n */\n/**\n * @internal\n */\nexport function getHeaderName() {\n    return \"x-ms-useragent\";\n}\n/**\n * @internal\n */\nexport function setPlatformSpecificData(map) {\n    var _a, _b, _c;\n    const localNavigator = globalThis.navigator;\n    map.set(\"OS\", ((_c = (_b = (_a = localNavigator === null || localNavigator === void 0 ? void 0 : localNavigator.userAgentData) === null || _a === void 0 ? void 0 : _a.platform) !== null && _b !== void 0 ? _b : localNavigator === null || localNavigator === void 0 ? void 0 : localNavigator.platform) !== null && _c !== void 0 ? _c : \"unknown\").replace(\" \", \"\"));\n}\n//# sourceMappingURL=userAgentPlatform.browser.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { getUserAgentHeaderName, getUserAgentValue } from \"../util/userAgent\";\nconst UserAgentHeaderName = getUserAgentHeaderName();\n/**\n * The programmatic identifier of the userAgentPolicy.\n */\nexport const userAgentPolicyName = \"userAgentPolicy\";\n/**\n * A policy that sets the User-Agent header (or equivalent) to reflect\n * the library version.\n * @param options - Options to customize the user agent value.\n */\nexport function userAgentPolicy(options = {}) {\n    const userAgentValue = getUserAgentValue(options.userAgentPrefix);\n    return {\n        name: userAgentPolicyName,\n        async sendRequest(request, next) {\n            if (!request.headers.has(UserAgentHeaderName)) {\n                request.headers.set(UserAgentHeaderName, userAgentValue);\n            }\n            return next(request);\n        },\n    };\n}\n//# sourceMappingURL=userAgentPolicy.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { parseHeaderValueAsNumber } from \"../util/helpers\";\n/**\n * The header that comes back from Azure services representing\n * the amount of time (minimum) to wait to retry (in seconds or timestamp after which we can retry).\n */\nconst RetryAfterHeader = \"Retry-After\";\n/**\n * The headers that come back from Azure services representing\n * the amount of time (minimum) to wait to retry.\n *\n * \"retry-after-ms\", \"x-ms-retry-after-ms\" : milliseconds\n * \"Retry-After\" : seconds or timestamp\n */\nconst AllRetryAfterHeaders = [\"retry-after-ms\", \"x-ms-retry-after-ms\", RetryAfterHeader];\n/**\n * A response is a throttling retry response if it has a throttling status code (429 or 503),\n * as long as one of the [ \"Retry-After\" or \"retry-after-ms\" or \"x-ms-retry-after-ms\" ] headers has a valid value.\n *\n * Returns the `retryAfterInMs` value if the response is a throttling retry response.\n * If not throttling retry response, returns `undefined`.\n *\n * @internal\n */\nfunction getRetryAfterInMs(response) {\n    if (!(response && [429, 503].includes(response.status)))\n        return undefined;\n    try {\n        // Headers: \"retry-after-ms\", \"x-ms-retry-after-ms\", \"Retry-After\"\n        for (const header of AllRetryAfterHeaders) {\n            const retryAfterValue = parseHeaderValueAsNumber(response, header);\n            if (retryAfterValue === 0 || retryAfterValue) {\n                // \"Retry-After\" header ==> seconds\n                // \"retry-after-ms\", \"x-ms-retry-after-ms\" headers ==> milli-seconds\n                const multiplyingFactor = header === RetryAfterHeader ? 1000 : 1;\n                return retryAfterValue * multiplyingFactor; // in milli-seconds\n            }\n        }\n        // RetryAfterHeader (\"Retry-After\") has a special case where it might be formatted as a date instead of a number of seconds\n        const retryAfterHeader = response.headers.get(RetryAfterHeader);\n        if (!retryAfterHeader)\n            return;\n        const date = Date.parse(retryAfterHeader);\n        const diff = date - Date.now();\n        // negative diff would mean a date in the past, so retry asap with 0 milliseconds\n        return Number.isFinite(diff) ? Math.max(0, diff) : undefined;\n    }\n    catch (e) {\n        return undefined;\n    }\n}\n/**\n * A response is a retry response if it has a throttling status code (429 or 503),\n * as long as one of the [ \"Retry-After\" or \"retry-after-ms\" or \"x-ms-retry-after-ms\" ] headers has a valid value.\n */\nexport function isThrottlingRetryResponse(response) {\n    return Number.isFinite(getRetryAfterInMs(response));\n}\nexport function throttlingRetryStrategy() {\n    return {\n        name: \"throttlingRetryStrategy\",\n        retry({ response }) {\n            const retryAfterInMs = getRetryAfterInMs(response);\n            if (!Number.isFinite(retryAfterInMs)) {\n                return { skipStrategy: true };\n            }\n            return {\n                retryAfterInMs,\n            };\n        },\n    };\n}\n//# sourceMappingURL=throttlingRetryStrategy.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { getRandomIntegerInclusive } from \"@azure/core-util\";\nimport { isThrottlingRetryResponse } from \"./throttlingRetryStrategy\";\n// intervals are in milliseconds\nconst DEFAULT_CLIENT_RETRY_INTERVAL = 1000;\nconst DEFAULT_CLIENT_MAX_RETRY_INTERVAL = 1000 * 64;\n/**\n * A retry strategy that retries with an exponentially increasing delay in these two cases:\n * - When there are errors in the underlying transport layer (e.g. DNS lookup failures).\n * - Or otherwise if the outgoing request fails (408, greater or equal than 500, except for 501 and 505).\n */\nexport function exponentialRetryStrategy(options = {}) {\n    var _a, _b;\n    const retryInterval = (_a = options.retryDelayInMs) !== null && _a !== void 0 ? _a : DEFAULT_CLIENT_RETRY_INTERVAL;\n    const maxRetryInterval = (_b = options.maxRetryDelayInMs) !== null && _b !== void 0 ? _b : DEFAULT_CLIENT_MAX_RETRY_INTERVAL;\n    let retryAfterInMs = retryInterval;\n    return {\n        name: \"exponentialRetryStrategy\",\n        retry({ retryCount, response, responseError }) {\n            const matchedSystemError = isSystemError(responseError);\n            const ignoreSystemErrors = matchedSystemError && options.ignoreSystemErrors;\n            const isExponential = isExponentialRetryResponse(response);\n            const ignoreExponentialResponse = isExponential && options.ignoreHttpStatusCodes;\n            const unknownResponse = response && (isThrottlingRetryResponse(response) || !isExponential);\n            if (unknownResponse || ignoreExponentialResponse || ignoreSystemErrors) {\n                return { skipStrategy: true };\n            }\n            if (responseError && !matchedSystemError && !isExponential) {\n                return { errorToThrow: responseError };\n            }\n            // Exponentially increase the delay each time\n            const exponentialDelay = retryAfterInMs * Math.pow(2, retryCount);\n            // Don't let the delay exceed the maximum\n            const clampedExponentialDelay = Math.min(maxRetryInterval, exponentialDelay);\n            // Allow the final value to have some \"jitter\" (within 50% of the delay size) so\n            // that retries across multiple clients don't occur simultaneously.\n            retryAfterInMs =\n                clampedExponentialDelay / 2 + getRandomIntegerInclusive(0, clampedExponentialDelay / 2);\n            return { retryAfterInMs };\n        },\n    };\n}\n/**\n * A response is a retry response if it has status codes:\n * - 408, or\n * - Greater or equal than 500, except for 501 and 505.\n */\nexport function isExponentialRetryResponse(response) {\n    return Boolean(response &&\n        response.status !== undefined &&\n        (response.status >= 500 || response.status === 408) &&\n        response.status !== 501 &&\n        response.status !== 505);\n}\n/**\n * Determines whether an error from a pipeline response was triggered in the network layer.\n */\nexport function isSystemError(err) {\n    if (!err) {\n        return false;\n    }\n    return (err.code === \"ETIMEDOUT\" ||\n        err.code === \"ESOCKETTIMEDOUT\" ||\n        err.code === \"ECONNREFUSED\" ||\n        err.code === \"ECONNRESET\" ||\n        err.code === \"ENOENT\" ||\n        err.code === \"ENOTFOUND\");\n}\n//# sourceMappingURL=exponentialRetryStrategy.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n/**\n * Returns a random integer value between a lower and upper bound,\n * inclusive of both bounds.\n * Note that this uses Math.random and isn't secure. If you need to use\n * this for any kind of security purpose, find a better source of random.\n * @param min - The smallest integer value allowed.\n * @param max - The largest integer value allowed.\n */\nexport function getRandomIntegerInclusive(min, max) {\n    // Make sure inputs are integers.\n    min = Math.ceil(min);\n    max = Math.floor(max);\n    // Pick a random offset from zero to the size of the range.\n    // Since Math.random() can never return 1, we have to make the range one larger\n    // in order to be inclusive of the maximum value after we take the floor.\n    const offset = Math.floor(Math.random() * (max - min + 1));\n    return offset + min;\n}\n//# sourceMappingURL=random.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { delay } from \"../util/helpers\";\nimport { createClientLogger } from \"@azure/logger\";\nimport { AbortError } from \"@azure/abort-controller\";\nimport { DEFAULT_RETRY_POLICY_COUNT } from \"../constants\";\nconst retryPolicyLogger = createClientLogger(\"core-rest-pipeline retryPolicy\");\n/**\n * The programmatic identifier of the retryPolicy.\n */\nconst retryPolicyName = \"retryPolicy\";\n/**\n * retryPolicy is a generic policy to enable retrying requests when certain conditions are met\n */\nexport function retryPolicy(strategies, options = { maxRetries: DEFAULT_RETRY_POLICY_COUNT }) {\n    const logger = options.logger || retryPolicyLogger;\n    return {\n        name: retryPolicyName,\n        async sendRequest(request, next) {\n            var _a, _b;\n            let response;\n            let responseError;\n            let retryCount = -1;\n            // eslint-disable-next-line no-constant-condition\n            retryRequest: while (true) {\n                retryCount += 1;\n                response = undefined;\n                responseError = undefined;\n                try {\n                    logger.info(`Retry ${retryCount}: Attempting to send request`, request.requestId);\n                    response = await next(request);\n                    logger.info(`Retry ${retryCount}: Received a response from request`, request.requestId);\n                }\n                catch (e) {\n                    logger.error(`Retry ${retryCount}: Received an error from request`, request.requestId);\n                    // RestErrors are valid targets for the retry strategies.\n                    // If none of the retry strategies can work with them, they will be thrown later in this policy.\n                    // If the received error is not a RestError, it is immediately thrown.\n                    responseError = e;\n                    if (!e || responseError.name !== \"RestError\") {\n                        throw e;\n                    }\n                    response = responseError.response;\n                }\n                if ((_a = request.abortSignal) === null || _a === void 0 ? void 0 : _a.aborted) {\n                    logger.error(`Retry ${retryCount}: Request aborted.`);\n                    const abortError = new AbortError();\n                    throw abortError;\n                }\n                if (retryCount >= ((_b = options.maxRetries) !== null && _b !== void 0 ? _b : DEFAULT_RETRY_POLICY_COUNT)) {\n                    logger.info(`Retry ${retryCount}: Maximum retries reached. Returning the last received response, or throwing the last received error.`);\n                    if (responseError) {\n                        throw responseError;\n                    }\n                    else if (response) {\n                        return response;\n                    }\n                    else {\n                        throw new Error(\"Maximum retries reached with no response or error to throw\");\n                    }\n                }\n                logger.info(`Retry ${retryCount}: Processing ${strategies.length} retry strategies.`);\n                strategiesLoop: for (const strategy of strategies) {\n                    const strategyLogger = strategy.logger || retryPolicyLogger;\n                    strategyLogger.info(`Retry ${retryCount}: Processing retry strategy ${strategy.name}.`);\n                    const modifiers = strategy.retry({\n                        retryCount,\n                        response,\n                        responseError,\n                    });\n                    if (modifiers.skipStrategy) {\n                        strategyLogger.info(`Retry ${retryCount}: Skipped.`);\n                        continue strategiesLoop;\n                    }\n                    const { errorToThrow, retryAfterInMs, redirectTo } = modifiers;\n                    if (errorToThrow) {\n                        strategyLogger.error(`Retry ${retryCount}: Retry strategy ${strategy.name} throws error:`, errorToThrow);\n                        throw errorToThrow;\n                    }\n                    if (retryAfterInMs || retryAfterInMs === 0) {\n                        strategyLogger.info(`Retry ${retryCount}: Retry strategy ${strategy.name} retries after ${retryAfterInMs}`);\n                        await delay(retryAfterInMs, undefined, { abortSignal: request.abortSignal });\n                        continue retryRequest;\n                    }\n                    if (redirectTo) {\n                        strategyLogger.info(`Retry ${retryCount}: Retry strategy ${strategy.name} redirects to ${redirectTo}`);\n                        request.url = redirectTo;\n                        continue retryRequest;\n                    }\n                }\n                if (responseError) {\n                    logger.info(`None of the retry strategies could work with the received error. Throwing it.`);\n                    throw responseError;\n                }\n                if (response) {\n                    logger.info(`None of the retry strategies could work with the received response. Returning it.`);\n                    return response;\n                }\n                // If all the retries skip and there's no response,\n                // we're still in the retry loop, so a new request will be sent\n                // until `maxRetries` is reached.\n            }\n        },\n    };\n}\n//# sourceMappingURL=retryPolicy.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { exponentialRetryStrategy } from \"../retryStrategies/exponentialRetryStrategy\";\nimport { throttlingRetryStrategy } from \"../retryStrategies/throttlingRetryStrategy\";\nimport { retryPolicy } from \"./retryPolicy\";\nimport { DEFAULT_RETRY_POLICY_COUNT } from \"../constants\";\n/**\n * Name of the {@link defaultRetryPolicy}\n */\nexport const defaultRetryPolicyName = \"defaultRetryPolicy\";\n/**\n * A policy that retries according to three strategies:\n * - When the server sends a 429 response with a Retry-After header.\n * - When there are errors in the underlying transport layer (e.g. DNS lookup failures).\n * - Or otherwise if the outgoing request fails, it will retry with an exponentially increasing delay.\n */\nexport function defaultRetryPolicy(options = {}) {\n    var _a;\n    return {\n        name: defaultRetryPolicyName,\n        sendRequest: retryPolicy([throttlingRetryStrategy(), exponentialRetryStrategy(options)], {\n            maxRetries: (_a = options.maxRetries) !== null && _a !== void 0 ? _a : DEFAULT_RETRY_POLICY_COUNT,\n        }).sendRequest,\n    };\n}\n//# sourceMappingURL=defaultRetryPolicy.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n/**\n * The helper that transforms bytes with specific character encoding into string\n * @param bytes - the uint8array bytes\n * @param format - the format we use to encode the byte\n * @returns a string of the encoded string\n */\nexport function uint8ArrayToString(bytes, format) {\n    switch (format) {\n        case \"utf-8\":\n            return uint8ArrayToUtf8String(bytes);\n        case \"base64\":\n            return uint8ArrayToBase64(bytes);\n        case \"base64url\":\n            return uint8ArrayToBase64Url(bytes);\n        case \"hex\":\n            return uint8ArrayToHexString(bytes);\n    }\n}\n/**\n * The helper that transforms string to specific character encoded bytes array.\n * @param value - the string to be converted\n * @param format - the format we use to decode the value\n * @returns a uint8array\n */\nexport function stringToUint8Array(value, format) {\n    switch (format) {\n        case \"utf-8\":\n            return utf8StringToUint8Array(value);\n        case \"base64\":\n            return base64ToUint8Array(value);\n        case \"base64url\":\n            return base64UrlToUint8Array(value);\n        case \"hex\":\n            return hexStringToUint8Array(value);\n    }\n}\n/**\n * Decodes a Uint8Array into a Base64 string.\n * @internal\n */\nexport function uint8ArrayToBase64(bytes) {\n    return btoa([...bytes].map((x) => String.fromCharCode(x)).join(\"\"));\n}\n/**\n * Decodes a Uint8Array into a Base64Url string.\n * @internal\n */\nexport function uint8ArrayToBase64Url(bytes) {\n    return uint8ArrayToBase64(bytes).replace(/\\+/g, \"-\").replace(/\\//g, \"_\").replace(/=/g, \"\");\n}\n/**\n * Decodes a Uint8Array into a javascript string.\n * @internal\n */\nexport function uint8ArrayToUtf8String(bytes) {\n    const decoder = new TextDecoder();\n    const dataString = decoder.decode(bytes);\n    return dataString;\n}\n/**\n * Decodes a Uint8Array into a hex string\n * @internal\n */\nexport function uint8ArrayToHexString(bytes) {\n    return [...bytes].map((x) => x.toString(16).padStart(2, \"0\")).join(\"\");\n}\n/**\n * Encodes a JavaScript string into a Uint8Array.\n * @internal\n */\nexport function utf8StringToUint8Array(value) {\n    return new TextEncoder().encode(value);\n}\n/**\n * Encodes a Base64 string into a Uint8Array.\n * @internal\n */\nexport function base64ToUint8Array(value) {\n    return new Uint8Array([...atob(value)].map((x) => x.charCodeAt(0)));\n}\n/**\n * Encodes a Base64Url string into a Uint8Array.\n * @internal\n */\nexport function base64UrlToUint8Array(value) {\n    const base64String = value.replace(/-/g, \"+\").replace(/_/g, \"/\");\n    return base64ToUint8Array(base64String);\n}\nconst hexDigits = new Set(\"0123456789abcdefABCDEF\");\n/**\n * Encodes a hex string into a Uint8Array\n * @internal\n */\nexport function hexStringToUint8Array(value) {\n    // If value has odd length, the last character will be ignored, consistent with NodeJS Buffer behavior\n    const bytes = new Uint8Array(value.length / 2);\n    for (let i = 0; i < value.length / 2; ++i) {\n        const highNibble = value[2 * i];\n        const lowNibble = value[2 * i + 1];\n        if (!hexDigits.has(highNibble) || !hexDigits.has(lowNibble)) {\n            // Replicate Node Buffer behavior by exiting early when we encounter an invalid byte\n            return bytes.slice(0, i);\n        }\n        bytes[i] = parseInt(`${highNibble}${lowNibble}`, 16);\n    }\n    return bytes;\n}\n//# sourceMappingURL=bytesEncoding.browser.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { stringToUint8Array } from \"@azure/core-util\";\nimport { createHttpHeaders } from \"../httpHeaders\";\n/**\n * The programmatic identifier of the formDataPolicy.\n */\nexport const formDataPolicyName = \"formDataPolicy\";\n/**\n * A policy that encodes FormData on the request into the body.\n */\nexport function formDataPolicy() {\n    return {\n        name: formDataPolicyName,\n        async sendRequest(request, next) {\n            if (request.formData) {\n                const contentType = request.headers.get(\"Content-Type\");\n                if (contentType && contentType.indexOf(\"application/x-www-form-urlencoded\") !== -1) {\n                    request.body = wwwFormUrlEncode(request.formData);\n                }\n                else {\n                    await prepareFormData(request.formData, request);\n                }\n                request.formData = undefined;\n            }\n            return next(request);\n        },\n    };\n}\nfunction wwwFormUrlEncode(formData) {\n    const urlSearchParams = new URLSearchParams();\n    for (const [key, value] of Object.entries(formData)) {\n        if (Array.isArray(value)) {\n            for (const subValue of value) {\n                urlSearchParams.append(key, subValue.toString());\n            }\n        }\n        else {\n            urlSearchParams.append(key, value.toString());\n        }\n    }\n    return urlSearchParams.toString();\n}\nasync function prepareFormData(formData, request) {\n    // validate content type (multipart/form-data)\n    const contentType = request.headers.get(\"Content-Type\");\n    if (contentType && !contentType.startsWith(\"multipart/form-data\")) {\n        // content type is specified and is not multipart/form-data. Exit.\n        return;\n    }\n    request.headers.set(\"Content-Type\", contentType !== null && contentType !== void 0 ? contentType : \"multipart/form-data\");\n    // set body to MultipartRequestBody using content from FormDataMap\n    const parts = [];\n    for (const [fieldName, values] of Object.entries(formData)) {\n        for (const value of Array.isArray(values) ? values : [values]) {\n            if (typeof value === \"string\") {\n                parts.push({\n                    headers: createHttpHeaders({\n                        \"Content-Disposition\": `form-data; name=\"${fieldName}\"`,\n                    }),\n                    body: stringToUint8Array(value, \"utf-8\"),\n                });\n            }\n            else {\n                // using || instead of ?? here since if value.name is empty we should create a file name\n                const fileName = value.name || \"blob\";\n                const headers = createHttpHeaders();\n                headers.set(\"Content-Disposition\", `form-data; name=\"${fieldName}\"; filename=\"${fileName}\"`);\n                if (value.type) {\n                    headers.set(\"Content-Type\", value.type);\n                }\n                parts.push({\n                    headers,\n                    body: value,\n                });\n            }\n        }\n        request.multipartBody = { parts };\n    }\n}\n//# sourceMappingURL=formDataPolicy.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n/*\n * NOTE: When moving this file, please update \"browser\" section in package.json\n */\nexport const proxyPolicyName = \"proxyPolicy\";\nconst errorMessage = \"proxyPolicy is not supported in browser environment\";\nexport function getDefaultProxySettings() {\n    throw new Error(errorMessage);\n}\n/**\n * proxyPolicy is not supported in the browser and attempting\n * to use it will raise an error.\n */\nexport function proxyPolicy() {\n    throw new Error(errorMessage);\n}\n/**\n * A function to reset the cached agents.\n * proxyPolicy is not supported in the browser and attempting\n * to use it will raise an error.\n * @internal\n */\nexport function resetCachedProxyAgents() {\n    throw new Error(errorMessage);\n}\n//# sourceMappingURL=proxyPolicy.browser.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n/**\n * The programmatic identifier of the setClientRequestIdPolicy.\n */\nexport const setClientRequestIdPolicyName = \"setClientRequestIdPolicy\";\n/**\n * Each PipelineRequest gets a unique id upon creation.\n * This policy passes that unique id along via an HTTP header to enable better\n * telemetry and tracing.\n * @param requestIdHeaderName - The name of the header to pass the request ID to.\n */\nexport function setClientRequestIdPolicy(requestIdHeaderName = \"x-ms-client-request-id\") {\n    return {\n        name: setClientRequestIdPolicyName,\n        async sendRequest(request, next) {\n            if (!request.headers.has(requestIdHeaderName)) {\n                request.headers.set(requestIdHeaderName, request.requestId);\n            }\n            return next(request);\n        },\n    };\n}\n//# sourceMappingURL=setClientRequestIdPolicy.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n/**\n * Name of the TLS Policy\n */\nexport const tlsPolicyName = \"tlsPolicy\";\n/**\n * Gets a pipeline policy that adds the client certificate to the HttpClient agent for authentication.\n */\nexport function tlsPolicy(tlsSettings) {\n    return {\n        name: tlsPolicyName,\n        sendRequest: async (req, next) => {\n            // Users may define a request tlsSettings, honor those over the client level one\n            if (!req.tlsSettings) {\n                req.tlsSettings = tlsSettings;\n            }\n            return next(req);\n        },\n    };\n}\n//# sourceMappingURL=tlsPolicy.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { createTracingClient, } from \"@azure/core-tracing\";\nimport { SDK_VERSION } from \"../constants\";\nimport { getUserAgentValue } from \"../util/userAgent\";\nimport { logger } from \"../log\";\nimport { getErrorMessage, isError } from \"@azure/core-util\";\nimport { isRestError } from \"../restError\";\n/**\n * The programmatic identifier of the tracingPolicy.\n */\nexport const tracingPolicyName = \"tracingPolicy\";\n/**\n * A simple policy to create OpenTelemetry Spans for each request made by the pipeline\n * that has SpanOptions with a parent.\n * Requests made without a parent Span will not be recorded.\n * @param options - Options to configure the telemetry logged by the tracing policy.\n */\nexport function tracingPolicy(options = {}) {\n    const userAgent = getUserAgentValue(options.userAgentPrefix);\n    const tracingClient = tryCreateTracingClient();\n    return {\n        name: tracingPolicyName,\n        async sendRequest(request, next) {\n            var _a, _b;\n            if (!tracingClient || !((_a = request.tracingOptions) === null || _a === void 0 ? void 0 : _a.tracingContext)) {\n                return next(request);\n            }\n            const { span, tracingContext } = (_b = tryCreateSpan(tracingClient, request, userAgent)) !== null && _b !== void 0 ? _b : {};\n            if (!span || !tracingContext) {\n                return next(request);\n            }\n            try {\n                const response = await tracingClient.withContext(tracingContext, next, request);\n                tryProcessResponse(span, response);\n                return response;\n            }\n            catch (err) {\n                tryProcessError(span, err);\n                throw err;\n            }\n        },\n    };\n}\nfunction tryCreateTracingClient() {\n    try {\n        return createTracingClient({\n            namespace: \"\",\n            packageName: \"@azure/core-rest-pipeline\",\n            packageVersion: SDK_VERSION,\n        });\n    }\n    catch (e) {\n        logger.warning(`Error when creating the TracingClient: ${getErrorMessage(e)}`);\n        return undefined;\n    }\n}\nfunction tryCreateSpan(tracingClient, request, userAgent) {\n    try {\n        // As per spec, we do not need to differentiate between HTTP and HTTPS in span name.\n        const { span, updatedOptions } = tracingClient.startSpan(`HTTP ${request.method}`, { tracingOptions: request.tracingOptions }, {\n            spanKind: \"client\",\n            spanAttributes: {\n                \"http.method\": request.method,\n                \"http.url\": request.url,\n                requestId: request.requestId,\n            },\n        });\n        // If the span is not recording, don't do any more work.\n        if (!span.isRecording()) {\n            span.end();\n            return undefined;\n        }\n        if (userAgent) {\n            span.setAttribute(\"http.user_agent\", userAgent);\n        }\n        // set headers\n        const headers = tracingClient.createRequestHeaders(updatedOptions.tracingOptions.tracingContext);\n        for (const [key, value] of Object.entries(headers)) {\n            request.headers.set(key, value);\n        }\n        return { span, tracingContext: updatedOptions.tracingOptions.tracingContext };\n    }\n    catch (e) {\n        logger.warning(`Skipping creating a tracing span due to an error: ${getErrorMessage(e)}`);\n        return undefined;\n    }\n}\nfunction tryProcessError(span, error) {\n    try {\n        span.setStatus({\n            status: \"error\",\n            error: isError(error) ? error : undefined,\n        });\n        if (isRestError(error) && error.statusCode) {\n            span.setAttribute(\"http.status_code\", error.statusCode);\n        }\n        span.end();\n    }\n    catch (e) {\n        logger.warning(`Skipping tracing span processing due to an error: ${getErrorMessage(e)}`);\n    }\n}\nfunction tryProcessResponse(span, response) {\n    try {\n        span.setAttribute(\"http.status_code\", response.status);\n        const serviceRequestId = response.headers.get(\"x-ms-request-id\");\n        if (serviceRequestId) {\n            span.setAttribute(\"serviceRequestId\", serviceRequestId);\n        }\n        span.setStatus({\n            status: \"success\",\n        });\n        span.end();\n    }\n    catch (e) {\n        logger.warning(`Skipping tracing span processing due to an error: ${getErrorMessage(e)}`);\n    }\n}\n//# sourceMappingURL=tracingPolicy.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { isBlob, isWebReadableStream } from \"./typeGuards\";\nexport function toStream(source) {\n    if (source instanceof Uint8Array) {\n        return new Blob([source]).stream();\n    }\n    else if (isWebReadableStream(source)) {\n        return source;\n    }\n    else if (isBlob(source)) {\n        return source.stream();\n    }\n    else {\n        throw new Error(\"Unsupported type. Only ReadableStream, Uint8Array and Blob are supported in browser\");\n    }\n}\nexport function toWebStream(stream) {\n    if (isWebReadableStream(stream)) {\n        return stream;\n    }\n    else {\n        throw new Error(\"Did not expect a Node stream in browser environment\");\n    }\n}\nexport function concatenateStreams(streams) {\n    var _a;\n    const remainingStreams = Array.from(streams);\n    let reader = (_a = remainingStreams.shift()) === null || _a === void 0 ? void 0 : _a.getReader();\n    async function doPull(controller) {\n        var _a;\n        if (!reader) {\n            controller.close();\n            return;\n        }\n        let value;\n        let done;\n        try {\n            ({ value, done } = await reader.read());\n        }\n        catch (e) {\n            controller.error(e);\n            reader.releaseLock();\n            return;\n        }\n        if (done) {\n            reader.releaseLock();\n            reader = (_a = remainingStreams.shift()) === null || _a === void 0 ? void 0 : _a.getReader();\n            await doPull(controller);\n        }\n        else {\n            controller.enqueue(value);\n        }\n    }\n    return new ReadableStream({\n        pull(controller) {\n            return doPull(controller);\n        },\n        cancel(reason) {\n            reader === null || reader === void 0 ? void 0 : reader.cancel(reason);\n        },\n    });\n}\n//# sourceMappingURL=stream.browser.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { randomUUID, stringToUint8Array } from \"@azure/core-util\";\nimport { toStream, concatenateStreams } from \"../util/stream\";\nimport { isBlob } from \"../util/typeGuards\";\nfunction generateBoundary() {\n    return `----AzSDKFormBoundary${randomUUID()}`;\n}\nfunction encodeHeaders(headers) {\n    let result = \"\";\n    for (const [key, value] of headers) {\n        result += `${key}: ${value}\\r\\n`;\n    }\n    return result;\n}\nfunction getLength(source) {\n    if (source instanceof Uint8Array) {\n        return source.byteLength;\n    }\n    else if (isBlob(source)) {\n        // if was created using createFile then -1 means we have an unknown size\n        return source.size === -1 ? undefined : source.size;\n    }\n    else {\n        return undefined;\n    }\n}\nfunction getTotalLength(sources) {\n    let total = 0;\n    for (const source of sources) {\n        const partLength = getLength(source);\n        if (partLength === undefined) {\n            return undefined;\n        }\n        else {\n            total += partLength;\n        }\n    }\n    return total;\n}\nfunction buildRequestBody(request, parts, boundary) {\n    const sources = [\n        stringToUint8Array(`--${boundary}`, \"utf-8\"),\n        ...parts.flatMap((part) => [\n            stringToUint8Array(\"\\r\\n\", \"utf-8\"),\n            stringToUint8Array(encodeHeaders(part.headers), \"utf-8\"),\n            stringToUint8Array(\"\\r\\n\", \"utf-8\"),\n            part.body,\n            stringToUint8Array(`\\r\\n--${boundary}`, \"utf-8\"),\n        ]),\n        stringToUint8Array(\"--\\r\\n\\r\\n\", \"utf-8\"),\n    ];\n    const contentLength = getTotalLength(sources);\n    if (contentLength) {\n        request.headers.set(\"Content-Length\", contentLength);\n    }\n    request.body = (() => concatenateStreams(sources.map((source) => (typeof source === \"function\" ? source() : source)).map(toStream)));\n}\n/**\n * Name of multipart policy\n */\nexport const multipartPolicyName = \"multipartPolicy\";\nconst maxBoundaryLength = 70;\nconst validBoundaryCharacters = new Set(`abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'()+,-./:=?`);\nfunction assertValidBoundary(boundary) {\n    if (boundary.length > maxBoundaryLength) {\n        throw new Error(`Multipart boundary \"${boundary}\" exceeds maximum length of 70 characters`);\n    }\n    if (Array.from(boundary).some((x) => !validBoundaryCharacters.has(x))) {\n        throw new Error(`Multipart boundary \"${boundary}\" contains invalid characters`);\n    }\n}\n/**\n * Pipeline policy for multipart requests\n */\nexport function multipartPolicy() {\n    return {\n        name: multipartPolicyName,\n        sendRequest(request, next) {\n            var _a;\n            if (!request.multipartBody) {\n                return next(request);\n            }\n            if (request.body) {\n                throw new Error(\"multipartBody and regular body cannot be set at the same time\");\n            }\n            let boundary = request.multipartBody.boundary;\n            const contentTypeHeader = (_a = request.headers.get(\"Content-Type\")) !== null && _a !== void 0 ? _a : \"multipart/mixed\";\n            const parsedHeader = contentTypeHeader.match(/^(multipart\\/[^ ;]+)(?:; *boundary=(.+))?$/);\n            if (!parsedHeader) {\n                throw new Error(`Got multipart request body, but content-type header was not multipart: ${contentTypeHeader}`);\n            }\n            const [, contentType, parsedBoundary] = parsedHeader;\n            if (parsedBoundary && boundary && parsedBoundary !== boundary) {\n                throw new Error(`Multipart boundary was specified as ${parsedBoundary} in the header, but got ${boundary} in the request body`);\n            }\n            boundary !== null && boundary !== void 0 ? boundary : (boundary = parsedBoundary);\n            if (boundary) {\n                assertValidBoundary(boundary);\n            }\n            else {\n                boundary = generateBoundary();\n            }\n            request.headers.set(\"Content-Type\", `${contentType}; boundary=${boundary}`);\n            buildRequestBody(request, request.multipartBody.parts, boundary);\n            request.multipartBody = undefined;\n            return next(request);\n        },\n    };\n}\n//# sourceMappingURL=multipartPolicy.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { logPolicy } from \"./policies/logPolicy\";\nimport { createEmptyPipeline } from \"./pipeline\";\nimport { redirectPolicy } from \"./policies/redirectPolicy\";\nimport { userAgentPolicy } from \"./policies/userAgentPolicy\";\nimport { decompressResponsePolicy } from \"./policies/decompressResponsePolicy\";\nimport { defaultRetryPolicy } from \"./policies/defaultRetryPolicy\";\nimport { formDataPolicy } from \"./policies/formDataPolicy\";\nimport { isNode } from \"@azure/core-util\";\nimport { proxyPolicy } from \"./policies/proxyPolicy\";\nimport { setClientRequestIdPolicy } from \"./policies/setClientRequestIdPolicy\";\nimport { tlsPolicy } from \"./policies/tlsPolicy\";\nimport { tracingPolicy } from \"./policies/tracingPolicy\";\nimport { multipartPolicy } from \"./policies/multipartPolicy\";\n/**\n * Create a new pipeline with a default set of customizable policies.\n * @param options - Options to configure a custom pipeline.\n */\nexport function createPipelineFromOptions(options) {\n    var _a;\n    const pipeline = createEmptyPipeline();\n    if (isNode) {\n        if (options.tlsOptions) {\n            pipeline.addPolicy(tlsPolicy(options.tlsOptions));\n        }\n        pipeline.addPolicy(proxyPolicy(options.proxyOptions));\n        pipeline.addPolicy(decompressResponsePolicy());\n    }\n    pipeline.addPolicy(formDataPolicy());\n    pipeline.addPolicy(userAgentPolicy(options.userAgentOptions));\n    pipeline.addPolicy(setClientRequestIdPolicy((_a = options.telemetryOptions) === null || _a === void 0 ? void 0 : _a.clientRequestIdHeaderName));\n    // The multipart policy is added after policies with no phase, so that\n    // policies can be added between it and formDataPolicy to modify\n    // properties (e.g., making the boundary constant in recorded tests).\n    pipeline.addPolicy(multipartPolicy(), { afterPhase: \"Deserialize\" });\n    pipeline.addPolicy(defaultRetryPolicy(options.retryOptions), { phase: \"Retry\" });\n    pipeline.addPolicy(tracingPolicy(options.userAgentOptions), { afterPhase: \"Retry\" });\n    if (isNode) {\n        // Both XHR and Fetch expect to handle redirects automatically,\n        // so only include this policy when we're in Node.\n        pipeline.addPolicy(redirectPolicy(options.redirectOptions), { afterPhase: \"Retry\" });\n    }\n    pipeline.addPolicy(logPolicy(options.loggingOptions), { afterPhase: \"Sign\" });\n    return pipeline;\n}\n//# sourceMappingURL=createPipelineFromOptions.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n/*\n * NOTE: When moving this file, please update \"browser\" section in package.json\n */\nexport const decompressResponsePolicyName = \"decompressResponsePolicy\";\n/**\n * decompressResponsePolicy is not supported in the browser and attempting\n * to use it will raise an error.\n */\nexport function decompressResponsePolicy() {\n    throw new Error(\"decompressResponsePolicy is not supported in browser environment\");\n}\n//# sourceMappingURL=decompressResponsePolicy.browser.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { AbortError } from \"@azure/abort-controller\";\nimport { RestError } from \"./restError\";\nimport { createHttpHeaders } from \"./httpHeaders\";\nimport { isNodeReadableStream, isWebReadableStream } from \"./util/typeGuards\";\n/**\n * Checks if the body is a Blob or Blob-like\n */\nfunction isBlob(body) {\n    // File objects count as a type of Blob, so we want to use instanceof explicitly\n    return (typeof Blob === \"function\" || typeof Blob === \"object\") && body instanceof Blob;\n}\n/**\n * A HttpClient implementation that uses window.fetch to send HTTP requests.\n * @internal\n */\nclass FetchHttpClient {\n    /**\n     * Makes a request over an underlying transport layer and returns the response.\n     * @param request - The request to be made.\n     */\n    async sendRequest(request) {\n        const url = new URL(request.url);\n        const isInsecure = url.protocol !== \"https:\";\n        if (isInsecure && !request.allowInsecureConnection) {\n            throw new Error(`Cannot connect to ${request.url} while allowInsecureConnection is false.`);\n        }\n        if (request.proxySettings) {\n            throw new Error(\"HTTP proxy is not supported in browser environment\");\n        }\n        try {\n            return await makeRequest(request);\n        }\n        catch (e) {\n            throw getError(e, request);\n        }\n    }\n}\n/**\n * Sends a request\n */\nasync function makeRequest(request) {\n    const { abortController, abortControllerCleanup } = setupAbortSignal(request);\n    try {\n        const headers = buildFetchHeaders(request.headers);\n        const { streaming, body: requestBody } = buildRequestBody(request);\n        const requestInit = Object.assign(Object.assign({ body: requestBody, method: request.method, headers: headers, signal: abortController.signal }, (\"credentials\" in Request.prototype\n            ? { credentials: request.withCredentials ? \"include\" : \"same-origin\" }\n            : {})), (\"cache\" in Request.prototype ? { cache: \"no-store\" } : {}));\n        // According to https://fetch.spec.whatwg.org/#fetch-method,\n        // init.duplex must be set when body is a ReadableStream object.\n        // currently \"half\" is the only valid value.\n        if (streaming) {\n            requestInit.duplex = \"half\";\n        }\n        /**\n         * Developers of the future:\n         * Do not set redirect: \"manual\" as part\n         * of request options.\n         * It will not work as you expect.\n         */\n        const response = await fetch(request.url, requestInit);\n        // If we're uploading a blob, we need to fire the progress event manually\n        if (isBlob(request.body) && request.onUploadProgress) {\n            request.onUploadProgress({ loadedBytes: request.body.size });\n        }\n        return buildPipelineResponse(response, request, abortControllerCleanup);\n    }\n    catch (e) {\n        abortControllerCleanup === null || abortControllerCleanup === void 0 ? void 0 : abortControllerCleanup();\n        throw e;\n    }\n}\n/**\n * Creates a pipeline response from a Fetch response;\n */\nasync function buildPipelineResponse(httpResponse, request, abortControllerCleanup) {\n    var _a, _b;\n    const headers = buildPipelineHeaders(httpResponse);\n    const response = {\n        request,\n        headers,\n        status: httpResponse.status,\n    };\n    const bodyStream = isWebReadableStream(httpResponse.body)\n        ? buildBodyStream(httpResponse.body, {\n            onProgress: request.onDownloadProgress,\n            onEnd: abortControllerCleanup,\n        })\n        : httpResponse.body;\n    if (\n    // Value of POSITIVE_INFINITY in streamResponseStatusCodes is considered as any status code\n    ((_a = request.streamResponseStatusCodes) === null || _a === void 0 ? void 0 : _a.has(Number.POSITIVE_INFINITY)) ||\n        ((_b = request.streamResponseStatusCodes) === null || _b === void 0 ? void 0 : _b.has(response.status))) {\n        if (request.enableBrowserStreams) {\n            response.browserStreamBody = bodyStream !== null && bodyStream !== void 0 ? bodyStream : undefined;\n        }\n        else {\n            const responseStream = new Response(bodyStream);\n            response.blobBody = responseStream.blob();\n            abortControllerCleanup === null || abortControllerCleanup === void 0 ? void 0 : abortControllerCleanup();\n        }\n    }\n    else {\n        const responseStream = new Response(bodyStream);\n        response.bodyAsText = await responseStream.text();\n        abortControllerCleanup === null || abortControllerCleanup === void 0 ? void 0 : abortControllerCleanup();\n    }\n    return response;\n}\nfunction setupAbortSignal(request) {\n    const abortController = new AbortController();\n    // Cleanup function\n    let abortControllerCleanup;\n    /**\n     * Attach an abort listener to the request\n     */\n    let abortListener;\n    if (request.abortSignal) {\n        if (request.abortSignal.aborted) {\n            throw new AbortError(\"The operation was aborted.\");\n        }\n        abortListener = (event) => {\n            if (event.type === \"abort\") {\n                abortController.abort();\n            }\n        };\n        request.abortSignal.addEventListener(\"abort\", abortListener);\n        abortControllerCleanup = () => {\n            var _a;\n            if (abortListener) {\n                (_a = request.abortSignal) === null || _a === void 0 ? void 0 : _a.removeEventListener(\"abort\", abortListener);\n            }\n        };\n    }\n    // If a timeout was passed, call the abort signal once the time elapses\n    if (request.timeout > 0) {\n        setTimeout(() => {\n            abortController.abort();\n        }, request.timeout);\n    }\n    return { abortController, abortControllerCleanup };\n}\n/**\n * Gets the specific error\n */\nfunction getError(e, request) {\n    var _a;\n    if (e && (e === null || e === void 0 ? void 0 : e.name) === \"AbortError\") {\n        return e;\n    }\n    else {\n        return new RestError(`Error sending request: ${e.message}`, {\n            code: (_a = e === null || e === void 0 ? void 0 : e.code) !== null && _a !== void 0 ? _a : RestError.REQUEST_SEND_ERROR,\n            request,\n        });\n    }\n}\n/**\n * Converts PipelineRequest headers to Fetch headers\n */\nfunction buildFetchHeaders(pipelineHeaders) {\n    const headers = new Headers();\n    for (const [name, value] of pipelineHeaders) {\n        headers.append(name, value);\n    }\n    return headers;\n}\nfunction buildPipelineHeaders(httpResponse) {\n    const responseHeaders = createHttpHeaders();\n    for (const [name, value] of httpResponse.headers) {\n        responseHeaders.set(name, value);\n    }\n    return responseHeaders;\n}\nfunction buildRequestBody(request) {\n    const body = typeof request.body === \"function\" ? request.body() : request.body;\n    if (isNodeReadableStream(body)) {\n        throw new Error(\"Node streams are not supported in browser environment.\");\n    }\n    return isWebReadableStream(body)\n        ? { streaming: true, body: buildBodyStream(body, { onProgress: request.onUploadProgress }) }\n        : { streaming: false, body };\n}\n/**\n * Reads the request/response original stream and stream it through a new\n * ReadableStream, this is done to be able to report progress in a way that\n * all modern browsers support. TransformStreams would be an alternative,\n * however they are not yet supported by all browsers i.e Firefox\n */\nfunction buildBodyStream(readableStream, options = {}) {\n    let loadedBytes = 0;\n    const { onProgress, onEnd } = options;\n    // If the current browser supports pipeThrough we use a TransformStream\n    // to report progress\n    if (isTransformStreamSupported(readableStream)) {\n        return readableStream.pipeThrough(new TransformStream({\n            transform(chunk, controller) {\n                if (chunk === null) {\n                    controller.terminate();\n                    return;\n                }\n                controller.enqueue(chunk);\n                loadedBytes += chunk.length;\n                if (onProgress) {\n                    onProgress({ loadedBytes });\n                }\n            },\n            flush() {\n                onEnd === null || onEnd === void 0 ? void 0 : onEnd();\n            },\n        }));\n    }\n    else {\n        // If we can't use transform streams, wrap the original stream in a new readable stream\n        // and use pull to enqueue each chunk and report progress.\n        const reader = readableStream.getReader();\n        return new ReadableStream({\n            async pull(controller) {\n                var _a;\n                const { done, value } = await reader.read();\n                // When no more data needs to be consumed, break the reading\n                if (done || !value) {\n                    onEnd === null || onEnd === void 0 ? void 0 : onEnd();\n                    // Close the stream\n                    controller.close();\n                    reader.releaseLock();\n                    return;\n                }\n                loadedBytes += (_a = value === null || value === void 0 ? void 0 : value.length) !== null && _a !== void 0 ? _a : 0;\n                // Enqueue the next data chunk into our target stream\n                controller.enqueue(value);\n                if (onProgress) {\n                    onProgress({ loadedBytes });\n                }\n            },\n            cancel(reason) {\n                onEnd === null || onEnd === void 0 ? void 0 : onEnd();\n                return reader.cancel(reason);\n            },\n        });\n    }\n}\n/**\n * Create a new HttpClient instance for the browser environment.\n * @internal\n */\nexport function createFetchHttpClient() {\n    return new FetchHttpClient();\n}\nfunction isTransformStreamSupported(readableStream) {\n    return readableStream.pipeThrough !== undefined && self.TransformStream !== undefined;\n}\n//# sourceMappingURL=fetchHttpClient.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { createFetchHttpClient } from \"./fetchHttpClient\";\n/**\n * Create the correct HttpClient for the current environment.\n */\nexport function createDefaultHttpClient() {\n    return createFetchHttpClient();\n}\n//# sourceMappingURL=defaultHttpClient.browser.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nfunction normalizeName(name) {\n    return name.toLowerCase();\n}\nfunction* headerIterator(map) {\n    for (const entry of map.values()) {\n        yield [entry.name, entry.value];\n    }\n}\nclass HttpHeadersImpl {\n    constructor(rawHeaders) {\n        this._headersMap = new Map();\n        if (rawHeaders) {\n            for (const headerName of Object.keys(rawHeaders)) {\n                this.set(headerName, rawHeaders[headerName]);\n            }\n        }\n    }\n    /**\n     * Set a header in this collection with the provided name and value. The name is\n     * case-insensitive.\n     * @param name - The name of the header to set. This value is case-insensitive.\n     * @param value - The value of the header to set.\n     */\n    set(name, value) {\n        this._headersMap.set(normalizeName(name), { name, value: String(value).trim() });\n    }\n    /**\n     * Get the header value for the provided header name, or undefined if no header exists in this\n     * collection with the provided name.\n     * @param name - The name of the header. This value is case-insensitive.\n     */\n    get(name) {\n        var _a;\n        return (_a = this._headersMap.get(normalizeName(name))) === null || _a === void 0 ? void 0 : _a.value;\n    }\n    /**\n     * Get whether or not this header collection contains a header entry for the provided header name.\n     * @param name - The name of the header to set. This value is case-insensitive.\n     */\n    has(name) {\n        return this._headersMap.has(normalizeName(name));\n    }\n    /**\n     * Remove the header with the provided headerName.\n     * @param name - The name of the header to remove.\n     */\n    delete(name) {\n        this._headersMap.delete(normalizeName(name));\n    }\n    /**\n     * Get the JSON object representation of this HTTP header collection.\n     */\n    toJSON(options = {}) {\n        const result = {};\n        if (options.preserveCase) {\n            for (const entry of this._headersMap.values()) {\n                result[entry.name] = entry.value;\n            }\n        }\n        else {\n            for (const [normalizedName, entry] of this._headersMap) {\n                result[normalizedName] = entry.value;\n            }\n        }\n        return result;\n    }\n    /**\n     * Get the string representation of this HTTP header collection.\n     */\n    toString() {\n        return JSON.stringify(this.toJSON({ preserveCase: true }));\n    }\n    /**\n     * Iterate over tuples of header [name, value] pairs.\n     */\n    [Symbol.iterator]() {\n        return headerIterator(this._headersMap);\n    }\n}\n/**\n * Creates an object that satisfies the `HttpHeaders` interface.\n * @param rawHeaders - A simple object representing initial headers\n */\nexport function createHttpHeaders(rawHeaders) {\n    return new HttpHeadersImpl(rawHeaders);\n}\n//# sourceMappingURL=httpHeaders.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { createClientLogger } from \"@azure/logger\";\nexport const logger = createClientLogger(\"core-rest-pipeline\");\n//# sourceMappingURL=log.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { createHttpHeaders } from \"./httpHeaders\";\nimport { randomUUID } from \"@azure/core-util\";\nclass PipelineRequestImpl {\n    constructor(options) {\n        var _a, _b, _c, _d, _e, _f, _g;\n        this.url = options.url;\n        this.body = options.body;\n        this.headers = (_a = options.headers) !== null && _a !== void 0 ? _a : createHttpHeaders();\n        this.method = (_b = options.method) !== null && _b !== void 0 ? _b : \"GET\";\n        this.timeout = (_c = options.timeout) !== null && _c !== void 0 ? _c : 0;\n        this.multipartBody = options.multipartBody;\n        this.formData = options.formData;\n        this.disableKeepAlive = (_d = options.disableKeepAlive) !== null && _d !== void 0 ? _d : false;\n        this.proxySettings = options.proxySettings;\n        this.streamResponseStatusCodes = options.streamResponseStatusCodes;\n        this.withCredentials = (_e = options.withCredentials) !== null && _e !== void 0 ? _e : false;\n        this.abortSignal = options.abortSignal;\n        this.tracingOptions = options.tracingOptions;\n        this.onUploadProgress = options.onUploadProgress;\n        this.onDownloadProgress = options.onDownloadProgress;\n        this.requestId = options.requestId || randomUUID();\n        this.allowInsecureConnection = (_f = options.allowInsecureConnection) !== null && _f !== void 0 ? _f : false;\n        this.enableBrowserStreams = (_g = options.enableBrowserStreams) !== null && _g !== void 0 ? _g : false;\n    }\n}\n/**\n * Creates a new pipeline request with the given options.\n * This method is to allow for the easy setting of default values and not required.\n * @param options - The options to create the request with.\n */\nexport function createPipelineRequest(options) {\n    return new PipelineRequestImpl(options);\n}\n//# sourceMappingURL=pipelineRequest.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { delay } from \"./helpers\";\n// Default options for the cycler if none are provided\nexport const DEFAULT_CYCLER_OPTIONS = {\n    forcedRefreshWindowInMs: 1000,\n    retryIntervalInMs: 3000,\n    refreshWindowInMs: 1000 * 60 * 2, // Start refreshing 2m before expiry\n};\n/**\n * Converts an an unreliable access token getter (which may resolve with null)\n * into an AccessTokenGetter by retrying the unreliable getter in a regular\n * interval.\n *\n * @param getAccessToken - A function that produces a promise of an access token that may fail by returning null.\n * @param retryIntervalInMs - The time (in milliseconds) to wait between retry attempts.\n * @param refreshTimeout - The timestamp after which the refresh attempt will fail, throwing an exception.\n * @returns - A promise that, if it resolves, will resolve with an access token.\n */\nasync function beginRefresh(getAccessToken, retryIntervalInMs, refreshTimeout) {\n    // This wrapper handles exceptions gracefully as long as we haven't exceeded\n    // the timeout.\n    async function tryGetAccessToken() {\n        if (Date.now() < refreshTimeout) {\n            try {\n                return await getAccessToken();\n            }\n            catch (_a) {\n                return null;\n            }\n        }\n        else {\n            const finalToken = await getAccessToken();\n            // Timeout is up, so throw if it's still null\n            if (finalToken === null) {\n                throw new Error(\"Failed to refresh access token.\");\n            }\n            return finalToken;\n        }\n    }\n    let token = await tryGetAccessToken();\n    while (token === null) {\n        await delay(retryIntervalInMs);\n        token = await tryGetAccessToken();\n    }\n    return token;\n}\n/**\n * Creates a token cycler from a credential, scopes, and optional settings.\n *\n * A token cycler represents a way to reliably retrieve a valid access token\n * from a TokenCredential. It will handle initializing the token, refreshing it\n * when it nears expiration, and synchronizes refresh attempts to avoid\n * concurrency hazards.\n *\n * @param credential - the underlying TokenCredential that provides the access\n * token\n * @param tokenCyclerOptions - optionally override default settings for the cycler\n *\n * @returns - a function that reliably produces a valid access token\n */\nexport function createTokenCycler(credential, tokenCyclerOptions) {\n    let refreshWorker = null;\n    let token = null;\n    let tenantId;\n    const options = Object.assign(Object.assign({}, DEFAULT_CYCLER_OPTIONS), tokenCyclerOptions);\n    /**\n     * This little holder defines several predicates that we use to construct\n     * the rules of refreshing the token.\n     */\n    const cycler = {\n        /**\n         * Produces true if a refresh job is currently in progress.\n         */\n        get isRefreshing() {\n            return refreshWorker !== null;\n        },\n        /**\n         * Produces true if the cycler SHOULD refresh (we are within the refresh\n         * window and not already refreshing)\n         */\n        get shouldRefresh() {\n            var _a;\n            return (!cycler.isRefreshing &&\n                ((_a = token === null || token === void 0 ? void 0 : token.expiresOnTimestamp) !== null && _a !== void 0 ? _a : 0) - options.refreshWindowInMs < Date.now());\n        },\n        /**\n         * Produces true if the cycler MUST refresh (null or nearly-expired\n         * token).\n         */\n        get mustRefresh() {\n            return (token === null || token.expiresOnTimestamp - options.forcedRefreshWindowInMs < Date.now());\n        },\n    };\n    /**\n     * Starts a refresh job or returns the existing job if one is already\n     * running.\n     */\n    function refresh(scopes, getTokenOptions) {\n        var _a;\n        if (!cycler.isRefreshing) {\n            // We bind `scopes` here to avoid passing it around a lot\n            const tryGetAccessToken = () => credential.getToken(scopes, getTokenOptions);\n            // Take advantage of promise chaining to insert an assignment to `token`\n            // before the refresh can be considered done.\n            refreshWorker = beginRefresh(tryGetAccessToken, options.retryIntervalInMs, \n            // If we don't have a token, then we should timeout immediately\n            (_a = token === null || token === void 0 ? void 0 : token.expiresOnTimestamp) !== null && _a !== void 0 ? _a : Date.now())\n                .then((_token) => {\n                refreshWorker = null;\n                token = _token;\n                tenantId = getTokenOptions.tenantId;\n                return token;\n            })\n                .catch((reason) => {\n                // We also should reset the refresher if we enter a failed state.  All\n                // existing awaiters will throw, but subsequent requests will start a\n                // new retry chain.\n                refreshWorker = null;\n                token = null;\n                tenantId = undefined;\n                throw reason;\n            });\n        }\n        return refreshWorker;\n    }\n    return async (scopes, tokenOptions) => {\n        //\n        // Simple rules:\n        // - If we MUST refresh, then return the refresh task, blocking\n        //   the pipeline until a token is available.\n        // - If we SHOULD refresh, then run refresh but don't return it\n        //   (we can still use the cached token).\n        // - Return the token, since it's fine if we didn't return in\n        //   step 1.\n        //\n        // If the tenantId passed in token options is different to the one we have\n        // Or if we are in claim challenge and the token was rejected and a new access token need to be issued, we need to\n        // refresh the token with the new tenantId or token.\n        const mustRefresh = tenantId !== tokenOptions.tenantId || Boolean(tokenOptions.claims) || cycler.mustRefresh;\n        if (mustRefresh)\n            return refresh(scopes, tokenOptions);\n        if (cycler.shouldRefresh) {\n            refresh(scopes, tokenOptions);\n        }\n        return token;\n    };\n}\n//# sourceMappingURL=tokenCycler.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { createTokenCycler } from \"../util/tokenCycler\";\nimport { logger as coreLogger } from \"../log\";\n/**\n * The programmatic identifier of the bearerTokenAuthenticationPolicy.\n */\nexport const bearerTokenAuthenticationPolicyName = \"bearerTokenAuthenticationPolicy\";\n/**\n * Default authorize request handler\n */\nasync function defaultAuthorizeRequest(options) {\n    const { scopes, getAccessToken, request } = options;\n    const getTokenOptions = {\n        abortSignal: request.abortSignal,\n        tracingOptions: request.tracingOptions,\n    };\n    const accessToken = await getAccessToken(scopes, getTokenOptions);\n    if (accessToken) {\n        options.request.headers.set(\"Authorization\", `Bearer ${accessToken.token}`);\n    }\n}\n/**\n * We will retrieve the challenge only if the response status code was 401,\n * and if the response contained the header \"WWW-Authenticate\" with a non-empty value.\n */\nfunction getChallenge(response) {\n    const challenge = response.headers.get(\"WWW-Authenticate\");\n    if (response.status === 401 && challenge) {\n        return challenge;\n    }\n    return;\n}\n/**\n * A policy that can request a token from a TokenCredential implementation and\n * then apply it to the Authorization header of a request as a Bearer token.\n */\nexport function bearerTokenAuthenticationPolicy(options) {\n    var _a;\n    const { credential, scopes, challengeCallbacks } = options;\n    const logger = options.logger || coreLogger;\n    const callbacks = Object.assign({ authorizeRequest: (_a = challengeCallbacks === null || challengeCallbacks === void 0 ? void 0 : challengeCallbacks.authorizeRequest) !== null && _a !== void 0 ? _a : defaultAuthorizeRequest, authorizeRequestOnChallenge: challengeCallbacks === null || challengeCallbacks === void 0 ? void 0 : challengeCallbacks.authorizeRequestOnChallenge }, challengeCallbacks);\n    // This function encapsulates the entire process of reliably retrieving the token\n    // The options are left out of the public API until there's demand to configure this.\n    // Remember to extend `BearerTokenAuthenticationPolicyOptions` with `TokenCyclerOptions`\n    // in order to pass through the `options` object.\n    const getAccessToken = credential\n        ? createTokenCycler(credential /* , options */)\n        : () => Promise.resolve(null);\n    return {\n        name: bearerTokenAuthenticationPolicyName,\n        /**\n         * If there's no challenge parameter:\n         * - It will try to retrieve the token using the cache, or the credential's getToken.\n         * - Then it will try the next policy with or without the retrieved token.\n         *\n         * It uses the challenge parameters to:\n         * - Skip a first attempt to get the token from the credential if there's no cached token,\n         *   since it expects the token to be retrievable only after the challenge.\n         * - Prepare the outgoing request if the `prepareRequest` method has been provided.\n         * - Send an initial request to receive the challenge if it fails.\n         * - Process a challenge if the response contains it.\n         * - Retrieve a token with the challenge information, then re-send the request.\n         */\n        async sendRequest(request, next) {\n            if (!request.url.toLowerCase().startsWith(\"https://\")) {\n                throw new Error(\"Bearer token authentication is not permitted for non-TLS protected (non-https) URLs.\");\n            }\n            await callbacks.authorizeRequest({\n                scopes: Array.isArray(scopes) ? scopes : [scopes],\n                request,\n                getAccessToken,\n                logger,\n            });\n            let response;\n            let error;\n            try {\n                response = await next(request);\n            }\n            catch (err) {\n                error = err;\n                response = err.response;\n            }\n            if (callbacks.authorizeRequestOnChallenge &&\n                (response === null || response === void 0 ? void 0 : response.status) === 401 &&\n                getChallenge(response)) {\n                // processes challenge\n                const shouldSendRequest = await callbacks.authorizeRequestOnChallenge({\n                    scopes: Array.isArray(scopes) ? scopes : [scopes],\n                    request,\n                    response,\n                    getAccessToken,\n                    logger,\n                });\n                if (shouldSendRequest) {\n                    return next(request);\n                }\n            }\n            if (error) {\n                throw error;\n            }\n            else {\n                return response;\n            }\n        },\n    };\n}\n//# sourceMappingURL=bearerTokenAuthenticationPolicy.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nexport const custom = {};\n//# sourceMappingURL=inspect.browser.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { isError } from \"@azure/core-util\";\nimport { custom } from \"./util/inspect\";\nimport { Sanitizer } from \"./util/sanitizer\";\nconst errorSanitizer = new Sanitizer();\n/**\n * A custom error type for failed pipeline requests.\n */\nexport class RestError extends Error {\n    constructor(message, options = {}) {\n        super(message);\n        this.name = \"RestError\";\n        this.code = options.code;\n        this.statusCode = options.statusCode;\n        this.request = options.request;\n        this.response = options.response;\n        Object.setPrototypeOf(this, RestError.prototype);\n    }\n    /**\n     * Logging method for util.inspect in Node\n     */\n    [custom]() {\n        return `RestError: ${this.message} \\n ${errorSanitizer.sanitize(this)}`;\n    }\n}\n/**\n * Something went wrong when making the request.\n * This means the actual request failed for some reason,\n * such as a DNS issue or the connection being lost.\n */\nRestError.REQUEST_SEND_ERROR = \"REQUEST_SEND_ERROR\";\n/**\n * This means that parsing the response from the server failed.\n * It may have been malformed.\n */\nRestError.PARSE_ERROR = \"PARSE_ERROR\";\n/**\n * Typeguard for RestError\n * @param e - Something caught by a catch clause.\n */\nexport function isRestError(e) {\n    if (e instanceof RestError) {\n        return true;\n    }\n    return isError(e) && e.name === \"RestError\";\n}\n//# sourceMappingURL=restError.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { AbortError } from \"@azure/abort-controller\";\nconst StandardAbortMessage = \"The operation was aborted.\";\n/**\n * A wrapper for setTimeout that resolves a promise after delayInMs milliseconds.\n * @param delayInMs - The number of milliseconds to be delayed.\n * @param value - The value to be resolved with after a timeout of t milliseconds.\n * @param options - The options for delay - currently abort options\n *                  - abortSignal - The abortSignal associated with containing operation.\n *                  - abortErrorMsg - The abort error message associated with containing operation.\n * @returns Resolved promise\n */\nexport function delay(delayInMs, value, options) {\n    return new Promise((resolve, reject) => {\n        let timer = undefined;\n        let onAborted = undefined;\n        const rejectOnAbort = () => {\n            return reject(new AbortError((options === null || options === void 0 ? void 0 : options.abortErrorMsg) ? options === null || options === void 0 ? void 0 : options.abortErrorMsg : StandardAbortMessage));\n        };\n        const removeListeners = () => {\n            if ((options === null || options === void 0 ? void 0 : options.abortSignal) && onAborted) {\n                options.abortSignal.removeEventListener(\"abort\", onAborted);\n            }\n        };\n        onAborted = () => {\n            if (timer) {\n                clearTimeout(timer);\n            }\n            removeListeners();\n            return rejectOnAbort();\n        };\n        if ((options === null || options === void 0 ? void 0 : options.abortSignal) && options.abortSignal.aborted) {\n            return rejectOnAbort();\n        }\n        timer = setTimeout(() => {\n            removeListeners();\n            resolve(value);\n        }, delayInMs);\n        if (options === null || options === void 0 ? void 0 : options.abortSignal) {\n            options.abortSignal.addEventListener(\"abort\", onAborted);\n        }\n    });\n}\n/**\n * @internal\n * @returns the parsed value or undefined if the parsed value is invalid.\n */\nexport function parseHeaderValueAsNumber(response, headerName) {\n    const value = response.headers.get(headerName);\n    if (!value)\n        return;\n    const valueAsNum = Number(value);\n    if (Number.isNaN(valueAsNum))\n        return;\n    return valueAsNum;\n}\n//# sourceMappingURL=helpers.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { isObject } from \"@azure/core-util\";\nconst RedactedString = \"REDACTED\";\n// Make sure this list is up-to-date with the one under core/logger/Readme#Keyconcepts\nconst defaultAllowedHeaderNames = [\n    \"x-ms-client-request-id\",\n    \"x-ms-return-client-request-id\",\n    \"x-ms-useragent\",\n    \"x-ms-correlation-request-id\",\n    \"x-ms-request-id\",\n    \"client-request-id\",\n    \"ms-cv\",\n    \"return-client-request-id\",\n    \"traceparent\",\n    \"Access-Control-Allow-Credentials\",\n    \"Access-Control-Allow-Headers\",\n    \"Access-Control-Allow-Methods\",\n    \"Access-Control-Allow-Origin\",\n    \"Access-Control-Expose-Headers\",\n    \"Access-Control-Max-Age\",\n    \"Access-Control-Request-Headers\",\n    \"Access-Control-Request-Method\",\n    \"Origin\",\n    \"Accept\",\n    \"Accept-Encoding\",\n    \"Cache-Control\",\n    \"Connection\",\n    \"Content-Length\",\n    \"Content-Type\",\n    \"Date\",\n    \"ETag\",\n    \"Expires\",\n    \"If-Match\",\n    \"If-Modified-Since\",\n    \"If-None-Match\",\n    \"If-Unmodified-Since\",\n    \"Last-Modified\",\n    \"Pragma\",\n    \"Request-Id\",\n    \"Retry-After\",\n    \"Server\",\n    \"Transfer-Encoding\",\n    \"User-Agent\",\n    \"WWW-Authenticate\",\n];\nconst defaultAllowedQueryParameters = [\"api-version\"];\n/**\n * @internal\n */\nexport class Sanitizer {\n    constructor({ additionalAllowedHeaderNames: allowedHeaderNames = [], additionalAllowedQueryParameters: allowedQueryParameters = [], } = {}) {\n        allowedHeaderNames = defaultAllowedHeaderNames.concat(allowedHeaderNames);\n        allowedQueryParameters = defaultAllowedQueryParameters.concat(allowedQueryParameters);\n        this.allowedHeaderNames = new Set(allowedHeaderNames.map((n) => n.toLowerCase()));\n        this.allowedQueryParameters = new Set(allowedQueryParameters.map((p) => p.toLowerCase()));\n    }\n    sanitize(obj) {\n        const seen = new Set();\n        return JSON.stringify(obj, (key, value) => {\n            // Ensure Errors include their interesting non-enumerable members\n            if (value instanceof Error) {\n                return Object.assign(Object.assign({}, value), { name: value.name, message: value.message });\n            }\n            if (key === \"headers\") {\n                return this.sanitizeHeaders(value);\n            }\n            else if (key === \"url\") {\n                return this.sanitizeUrl(value);\n            }\n            else if (key === \"query\") {\n                return this.sanitizeQuery(value);\n            }\n            else if (key === \"body\") {\n                // Don't log the request body\n                return undefined;\n            }\n            else if (key === \"response\") {\n                // Don't log response again\n                return undefined;\n            }\n            else if (key === \"operationSpec\") {\n                // When using sendOperationRequest, the request carries a massive\n                // field with the autorest spec. No need to log it.\n                return undefined;\n            }\n            else if (Array.isArray(value) || isObject(value)) {\n                if (seen.has(value)) {\n                    return \"[Circular]\";\n                }\n                seen.add(value);\n            }\n            return value;\n        }, 2);\n    }\n    sanitizeHeaders(obj) {\n        const sanitized = {};\n        for (const key of Object.keys(obj)) {\n            if (this.allowedHeaderNames.has(key.toLowerCase())) {\n                sanitized[key] = obj[key];\n            }\n            else {\n                sanitized[key] = RedactedString;\n            }\n        }\n        return sanitized;\n    }\n    sanitizeQuery(value) {\n        if (typeof value !== \"object\" || value === null) {\n            return value;\n        }\n        const sanitized = {};\n        for (const k of Object.keys(value)) {\n            if (this.allowedQueryParameters.has(k.toLowerCase())) {\n                sanitized[k] = value[k];\n            }\n            else {\n                sanitized[k] = RedactedString;\n            }\n        }\n        return sanitized;\n    }\n    sanitizeUrl(value) {\n        if (typeof value !== \"string\" || value === null) {\n            return value;\n        }\n        const url = new URL(value);\n        if (!url.search) {\n            return value;\n        }\n        for (const [key] of url.searchParams) {\n            if (!this.allowedQueryParameters.has(key.toLowerCase())) {\n                url.searchParams.set(key, RedactedString);\n            }\n        }\n        return url.toString();\n    }\n}\n//# sourceMappingURL=sanitizer.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nexport function isNodeReadableStream(x) {\n    return Boolean(x && typeof x[\"pipe\"] === \"function\");\n}\nexport function isWebReadableStream(x) {\n    return Boolean(x &&\n        typeof x.getReader === \"function\" &&\n        typeof x.tee === \"function\");\n}\nexport function isReadableStream(x) {\n    return isNodeReadableStream(x) || isWebReadableStream(x);\n}\nexport function isBlob(x) {\n    return typeof x.stream === \"function\";\n}\n//# sourceMappingURL=typeGuards.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { SpanKind, setSpan, context as otContext, getTracer } from \"./interfaces\";\nimport { trace, INVALID_SPAN_CONTEXT } from \"@opentelemetry/api\";\nexport function isTracingDisabled() {\n    var _a;\n    if (typeof process === \"undefined\") {\n        // not supported in browser for now without polyfills\n        return false;\n    }\n    const azureTracingDisabledValue = (_a = process.env.AZURE_TRACING_DISABLED) === null || _a === void 0 ? void 0 : _a.toLowerCase();\n    if (azureTracingDisabledValue === \"false\" || azureTracingDisabledValue === \"0\") {\n        return false;\n    }\n    return Boolean(azureTracingDisabledValue);\n}\n/**\n * Creates a function that can be used to create spans using the global tracer.\n *\n * Usage:\n *\n * ```typescript\n * // once\n * const createSpan = createSpanFunction({ packagePrefix: \"Azure.Data.AppConfiguration\", namespace: \"Microsoft.AppConfiguration\" });\n *\n * // in each operation\n * const span = createSpan(\"deleteConfigurationSetting\", operationOptions);\n *    // code...\n * span.end();\n * ```\n *\n * @hidden\n * @param args - allows configuration of the prefix for each span as well as the az.namespace field.\n */\nexport function createSpanFunction(args) {\n    return function (operationName, operationOptions) {\n        const tracer = getTracer();\n        const tracingOptions = (operationOptions === null || operationOptions === void 0 ? void 0 : operationOptions.tracingOptions) || {};\n        const spanOptions = Object.assign({ kind: SpanKind.INTERNAL }, tracingOptions.spanOptions);\n        const spanName = args.packagePrefix ? `${args.packagePrefix}.${operationName}` : operationName;\n        let span;\n        if (isTracingDisabled()) {\n            span = trace.wrapSpanContext(INVALID_SPAN_CONTEXT);\n        }\n        else {\n            span = tracer.startSpan(spanName, spanOptions, tracingOptions.tracingContext);\n        }\n        if (args.namespace) {\n            span.setAttribute(\"az.namespace\", args.namespace);\n        }\n        let newSpanOptions = tracingOptions.spanOptions || {};\n        if (span.isRecording() && args.namespace) {\n            newSpanOptions = Object.assign(Object.assign({}, tracingOptions.spanOptions), { attributes: Object.assign(Object.assign({}, spanOptions.attributes), { \"az.namespace\": args.namespace }) });\n        }\n        const newTracingOptions = Object.assign(Object.assign({}, tracingOptions), { spanOptions: newSpanOptions, tracingContext: setSpan(tracingOptions.tracingContext || otContext.active(), span) });\n        const newOperationOptions = Object.assign(Object.assign({}, operationOptions), { tracingOptions: newTracingOptions });\n        return {\n            span,\n            updatedOptions: newOperationOptions\n        };\n    };\n}\n//# sourceMappingURL=createSpan.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { context as otContext, trace as otTrace } from \"@opentelemetry/api\";\n/**\n * The kind of span.\n */\nexport var SpanKind;\n(function (SpanKind) {\n    /** Default value. Indicates that the span is used internally. */\n    SpanKind[SpanKind[\"INTERNAL\"] = 0] = \"INTERNAL\";\n    /**\n     * Indicates that the span covers server-side handling of an RPC or other\n     * remote request.\n     */\n    SpanKind[SpanKind[\"SERVER\"] = 1] = \"SERVER\";\n    /**\n     * Indicates that the span covers the client-side wrapper around an RPC or\n     * other remote request.\n     */\n    SpanKind[SpanKind[\"CLIENT\"] = 2] = \"CLIENT\";\n    /**\n     * Indicates that the span describes producer sending a message to a\n     * broker. Unlike client and server, there is no direct critical path latency\n     * relationship between producer and consumer spans.\n     */\n    SpanKind[SpanKind[\"PRODUCER\"] = 3] = \"PRODUCER\";\n    /**\n     * Indicates that the span describes consumer receiving a message from a\n     * broker. Unlike client and server, there is no direct critical path latency\n     * relationship between producer and consumer spans.\n     */\n    SpanKind[SpanKind[\"CONSUMER\"] = 4] = \"CONSUMER\";\n})(SpanKind || (SpanKind = {}));\n/**\n * Return the span if one exists\n *\n * @param context - context to get span from\n */\nexport function getSpan(context) {\n    return otTrace.getSpan(context);\n}\n/**\n * Set the span on a context\n *\n * @param context - context to use as parent\n * @param span - span to set active\n */\nexport function setSpan(context, span) {\n    return otTrace.setSpan(context, span);\n}\n/**\n * Wrap span context in a NoopSpan and set as span in a new\n * context\n *\n * @param context - context to set active span on\n * @param spanContext - span context to be wrapped\n */\nexport function setSpanContext(context, spanContext) {\n    return otTrace.setSpanContext(context, spanContext);\n}\n/**\n * Get the span context of the span if it exists.\n *\n * @param context - context to get values from\n */\nexport function getSpanContext(context) {\n    return otTrace.getSpanContext(context);\n}\n/**\n * Returns true of the given {@link SpanContext} is valid.\n * A valid {@link SpanContext} is one which has a valid trace ID and span ID as per the spec.\n *\n * @param context - the {@link SpanContext} to validate.\n *\n * @returns true if the {@link SpanContext} is valid, false otherwise.\n */\nexport function isSpanContextValid(context) {\n    return otTrace.isSpanContextValid(context);\n}\nexport function getTracer(name, version) {\n    return otTrace.getTracer(name || \"azure/core-tracing\", version);\n}\n/** Entrypoint for context API */\nexport const context = otContext;\n/** SpanStatusCode */\nexport var SpanStatusCode;\n(function (SpanStatusCode) {\n    /**\n     * The default status.\n     */\n    SpanStatusCode[SpanStatusCode[\"UNSET\"] = 0] = \"UNSET\";\n    /**\n     * The operation has been validated by an Application developer or\n     * Operator to have completed successfully.\n     */\n    SpanStatusCode[SpanStatusCode[\"OK\"] = 1] = \"OK\";\n    /**\n     * The operation contains an error.\n     */\n    SpanStatusCode[SpanStatusCode[\"ERROR\"] = 2] = \"ERROR\";\n})(SpanStatusCode || (SpanStatusCode = {}));\n//# sourceMappingURL=interfaces.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nconst VERSION = \"00\";\n/**\n * Generates a `SpanContext` given a `traceparent` header value.\n * @param traceParent - Serialized span context data as a `traceparent` header value.\n * @returns The `SpanContext` generated from the `traceparent` value.\n */\nexport function extractSpanContextFromTraceParentHeader(traceParentHeader) {\n    const parts = traceParentHeader.split(\"-\");\n    if (parts.length !== 4) {\n        return;\n    }\n    const [version, traceId, spanId, traceOptions] = parts;\n    if (version !== VERSION) {\n        return;\n    }\n    const traceFlags = parseInt(traceOptions, 16);\n    const spanContext = {\n        spanId,\n        traceId,\n        traceFlags\n    };\n    return spanContext;\n}\n/**\n * Generates a `traceparent` value given a span context.\n * @param spanContext - Contains context for a specific span.\n * @returns The `spanContext` represented as a `traceparent` value.\n */\nexport function getTraceParentHeader(spanContext) {\n    const missingFields = [];\n    if (!spanContext.traceId) {\n        missingFields.push(\"traceId\");\n    }\n    if (!spanContext.spanId) {\n        missingFields.push(\"spanId\");\n    }\n    if (missingFields.length) {\n        return;\n    }\n    const flags = spanContext.traceFlags || 0 /* NONE */;\n    const hexFlags = flags.toString(16);\n    const traceFlags = hexFlags.length === 1 ? `0${hexFlags}` : hexFlags;\n    // https://www.w3.org/TR/trace-context/#traceparent-header-field-values\n    return `${VERSION}-${spanContext.traceId}-${spanContext.spanId}-${traceFlags}`;\n}\n//# sourceMappingURL=traceParentHeader.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n/** @internal */\nexport const knownContextKeys = {\n    span: Symbol.for(\"@azure/core-tracing span\"),\n    namespace: Symbol.for(\"@azure/core-tracing namespace\"),\n};\n/**\n * Creates a new {@link TracingContext} with the given options.\n * @param options - A set of known keys that may be set on the context.\n * @returns A new {@link TracingContext} with the given options.\n *\n * @internal\n */\nexport function createTracingContext(options = {}) {\n    let context = new TracingContextImpl(options.parentContext);\n    if (options.span) {\n        context = context.setValue(knownContextKeys.span, options.span);\n    }\n    if (options.namespace) {\n        context = context.setValue(knownContextKeys.namespace, options.namespace);\n    }\n    return context;\n}\n/** @internal */\nexport class TracingContextImpl {\n    constructor(initialContext) {\n        this._contextMap =\n            initialContext instanceof TracingContextImpl\n                ? new Map(initialContext._contextMap)\n                : new Map();\n    }\n    setValue(key, value) {\n        const newContext = new TracingContextImpl(this);\n        newContext._contextMap.set(key, value);\n        return newContext;\n    }\n    getValue(key) {\n        return this._contextMap.get(key);\n    }\n    deleteValue(key) {\n        const newContext = new TracingContextImpl(this);\n        newContext._contextMap.delete(key);\n        return newContext;\n    }\n}\n//# sourceMappingURL=tracingContext.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { createTracingContext } from \"./tracingContext\";\nexport function createDefaultTracingSpan() {\n    return {\n        end: () => {\n            // noop\n        },\n        isRecording: () => false,\n        recordException: () => {\n            // noop\n        },\n        setAttribute: () => {\n            // noop\n        },\n        setStatus: () => {\n            // noop\n        },\n    };\n}\nexport function createDefaultInstrumenter() {\n    return {\n        createRequestHeaders: () => {\n            return {};\n        },\n        parseTraceparentHeader: () => {\n            return undefined;\n        },\n        startSpan: (_name, spanOptions) => {\n            return {\n                span: createDefaultTracingSpan(),\n                tracingContext: createTracingContext({ parentContext: spanOptions.tracingContext }),\n            };\n        },\n        withContext(_context, callback, ...callbackArgs) {\n            return callback(...callbackArgs);\n        },\n    };\n}\n/** @internal */\nlet instrumenterImplementation;\n/**\n * Extends the Azure SDK with support for a given instrumenter implementation.\n *\n * @param instrumenter - The instrumenter implementation to use.\n */\nexport function useInstrumenter(instrumenter) {\n    instrumenterImplementation = instrumenter;\n}\n/**\n * Gets the currently set instrumenter, a No-Op instrumenter by default.\n *\n * @returns The currently set instrumenter\n */\nexport function getInstrumenter() {\n    if (!instrumenterImplementation) {\n        instrumenterImplementation = createDefaultInstrumenter();\n    }\n    return instrumenterImplementation;\n}\n//# sourceMappingURL=instrumenter.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { getInstrumenter } from \"./instrumenter\";\nimport { knownContextKeys } from \"./tracingContext\";\n/**\n * Creates a new tracing client.\n *\n * @param options - Options used to configure the tracing client.\n * @returns - An instance of {@link TracingClient}.\n */\nexport function createTracingClient(options) {\n    const { namespace, packageName, packageVersion } = options;\n    function startSpan(name, operationOptions, spanOptions) {\n        var _a;\n        const startSpanResult = getInstrumenter().startSpan(name, Object.assign(Object.assign({}, spanOptions), { packageName: packageName, packageVersion: packageVersion, tracingContext: (_a = operationOptions === null || operationOptions === void 0 ? void 0 : operationOptions.tracingOptions) === null || _a === void 0 ? void 0 : _a.tracingContext }));\n        let tracingContext = startSpanResult.tracingContext;\n        const span = startSpanResult.span;\n        if (!tracingContext.getValue(knownContextKeys.namespace)) {\n            tracingContext = tracingContext.setValue(knownContextKeys.namespace, namespace);\n        }\n        span.setAttribute(\"az.namespace\", tracingContext.getValue(knownContextKeys.namespace));\n        const updatedOptions = Object.assign({}, operationOptions, {\n            tracingOptions: Object.assign(Object.assign({}, operationOptions === null || operationOptions === void 0 ? void 0 : operationOptions.tracingOptions), { tracingContext }),\n        });\n        return {\n            span,\n            updatedOptions,\n        };\n    }\n    async function withSpan(name, operationOptions, callback, spanOptions) {\n        const { span, updatedOptions } = startSpan(name, operationOptions, spanOptions);\n        try {\n            const result = await withContext(updatedOptions.tracingOptions.tracingContext, () => Promise.resolve(callback(updatedOptions, span)));\n            span.setStatus({ status: \"success\" });\n            return result;\n        }\n        catch (err) {\n            span.setStatus({ status: \"error\", error: err });\n            throw err;\n        }\n        finally {\n            span.end();\n        }\n    }\n    function withContext(context, callback, ...callbackArgs) {\n        return getInstrumenter().withContext(context, callback, ...callbackArgs);\n    }\n    /**\n     * Parses a traceparent header value into a span identifier.\n     *\n     * @param traceparentHeader - The traceparent header to parse.\n     * @returns An implementation-specific identifier for the span.\n     */\n    function parseTraceparentHeader(traceparentHeader) {\n        return getInstrumenter().parseTraceparentHeader(traceparentHeader);\n    }\n    /**\n     * Creates a set of request headers to propagate tracing information to a backend.\n     *\n     * @param tracingContext - The context containing the span to serialize.\n     * @returns The set of headers to add to a request.\n     */\n    function createRequestHeaders(tracingContext) {\n        return getInstrumenter().createRequestHeaders(tracingContext);\n    }\n    return {\n        startSpan,\n        withSpan,\n        withContext,\n        parseTraceparentHeader,\n        createRequestHeaders,\n    };\n}\n//# sourceMappingURL=tracingClient.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nvar _a, _b, _c, _d;\n/**\n * A constant that indicates whether the environment the code is running is a Web Browser.\n */\n// eslint-disable-next-line @azure/azure-sdk/ts-no-window\nexport const isBrowser = typeof window !== \"undefined\" && typeof window.document !== \"undefined\";\n/**\n * A constant that indicates whether the environment the code is running is a Web Worker.\n */\nexport const isWebWorker = typeof self === \"object\" &&\n    typeof (self === null || self === void 0 ? void 0 : self.importScripts) === \"function\" &&\n    (((_a = self.constructor) === null || _a === void 0 ? void 0 : _a.name) === \"DedicatedWorkerGlobalScope\" ||\n        ((_b = self.constructor) === null || _b === void 0 ? void 0 : _b.name) === \"ServiceWorkerGlobalScope\" ||\n        ((_c = self.constructor) === null || _c === void 0 ? void 0 : _c.name) === \"SharedWorkerGlobalScope\");\n/**\n * A constant that indicates whether the environment the code is running is Deno.\n */\nexport const isDeno = typeof Deno !== \"undefined\" &&\n    typeof Deno.version !== \"undefined\" &&\n    typeof Deno.version.deno !== \"undefined\";\n/**\n * A constant that indicates whether the environment the code is running is Node.JS.\n */\nexport const isNode = typeof process !== \"undefined\" &&\n    Boolean(process.version) &&\n    Boolean((_d = process.versions) === null || _d === void 0 ? void 0 : _d.node) &&\n    // Deno thought it was a good idea to spoof process.versions.node, see https://deno.land/std@0.177.0/node/process.ts?s=versions\n    !isDeno;\n/**\n * A constant that indicates whether the environment the code is running is Bun.sh.\n */\nexport const isBun = typeof Bun !== \"undefined\" && typeof Bun.version !== \"undefined\";\n/**\n * A constant that indicates whether the environment the code is running is in React-Native.\n */\n// https://github.com/facebook/react-native/blob/main/packages/react-native/Libraries/Core/setUpNavigator.js\nexport const isReactNative = typeof navigator !== \"undefined\" && (navigator === null || navigator === void 0 ? void 0 : navigator.product) === \"ReactNative\";\n//# sourceMappingURL=checkEnvironment.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { createAbortablePromise } from \"./createAbortablePromise\";\nconst StandardAbortMessage = \"The delay was aborted.\";\n/**\n * A wrapper for setTimeout that resolves a promise after timeInMs milliseconds.\n * @param timeInMs - The number of milliseconds to be delayed.\n * @param options - The options for delay - currently abort options\n * @returns Promise that is resolved after timeInMs\n */\nexport function delay(timeInMs, options) {\n    let token;\n    const { abortSignal, abortErrorMsg } = options !== null && options !== void 0 ? options : {};\n    return createAbortablePromise((resolve) => {\n        token = setTimeout(resolve, timeInMs);\n    }, {\n        cleanupBeforeAbort: () => clearTimeout(token),\n        abortSignal,\n        abortErrorMsg: abortErrorMsg !== null && abortErrorMsg !== void 0 ? abortErrorMsg : StandardAbortMessage,\n    });\n}\n//# sourceMappingURL=delay.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { AbortError } from \"@azure/abort-controller\";\n/**\n * Creates an abortable promise.\n * @param buildPromise - A function that takes the resolve and reject functions as parameters.\n * @param options - The options for the abortable promise.\n * @returns A promise that can be aborted.\n */\nexport function createAbortablePromise(buildPromise, options) {\n    const { cleanupBeforeAbort, abortSignal, abortErrorMsg } = options !== null && options !== void 0 ? options : {};\n    return new Promise((resolve, reject) => {\n        function rejectOnAbort() {\n            reject(new AbortError(abortErrorMsg !== null && abortErrorMsg !== void 0 ? abortErrorMsg : \"The operation was aborted.\"));\n        }\n        function removeListeners() {\n            abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.removeEventListener(\"abort\", onAbort);\n        }\n        function onAbort() {\n            cleanupBeforeAbort === null || cleanupBeforeAbort === void 0 ? void 0 : cleanupBeforeAbort();\n            removeListeners();\n            rejectOnAbort();\n        }\n        if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {\n            return rejectOnAbort();\n        }\n        try {\n            buildPromise((x) => {\n                removeListeners();\n                resolve(x);\n            }, (x) => {\n                removeListeners();\n                reject(x);\n            });\n        }\n        catch (err) {\n            reject(err);\n        }\n        abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.addEventListener(\"abort\", onAbort);\n    });\n}\n//# sourceMappingURL=createAbortablePromise.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { isObject } from \"./object\";\n/**\n * Typeguard for an error object shape (has name and message)\n * @param e - Something caught by a catch clause.\n */\nexport function isError(e) {\n    if (isObject(e)) {\n        const hasName = typeof e.name === \"string\";\n        const hasMessage = typeof e.message === \"string\";\n        return hasName && hasMessage;\n    }\n    return false;\n}\n/**\n * Given what is thought to be an error object, return the message if possible.\n * If the message is missing, returns a stringified version of the input.\n * @param e - Something thrown from a try block\n * @returns The error message or a string of the input\n */\nexport function getErrorMessage(e) {\n    if (isError(e)) {\n        return e.message;\n    }\n    else {\n        let stringified;\n        try {\n            if (typeof e === \"object\" && e) {\n                stringified = JSON.stringify(e);\n            }\n            else {\n                stringified = String(e);\n            }\n        }\n        catch (err) {\n            stringified = \"[unable to stringify input]\";\n        }\n        return `Unknown error ${stringified}`;\n    }\n}\n//# sourceMappingURL=error.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n/**\n * Helper to determine when an input is a generic JS object.\n * @returns true when input is an object type that is not null, Array, RegExp, or Date.\n */\nexport function isObject(input) {\n    return (typeof input === \"object\" &&\n        input !== null &&\n        !Array.isArray(input) &&\n        !(input instanceof RegExp) &&\n        !(input instanceof Date));\n}\n//# sourceMappingURL=object.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n/*\n * NOTE: When moving this file, please update \"react-native\" section in package.json.\n */\n/**\n * Generated Universally Unique Identifier\n *\n * @returns RFC4122 v4 UUID.\n */\nexport function generateUUID() {\n    let uuid = \"\";\n    for (let i = 0; i < 32; i++) {\n        // Generate a random number between 0 and 15\n        const randomNumber = Math.floor(Math.random() * 16);\n        // Set the UUID version to 4 in the 13th position\n        if (i === 12) {\n            uuid += \"4\";\n        }\n        else if (i === 16) {\n            // Set the UUID variant to \"10\" in the 17th position\n            uuid += (randomNumber & 0x3) | 0x8;\n        }\n        else {\n            // Add a random hexadecimal digit to the UUID string\n            uuid += randomNumber.toString(16);\n        }\n        // Add hyphens to the UUID string at the appropriate positions\n        if (i === 7 || i === 11 || i === 15 || i === 19) {\n            uuid += \"-\";\n        }\n    }\n    return uuid;\n}\n/**\n * Generated Universally Unique Identifier\n *\n * @returns RFC4122 v4 UUID.\n */\nexport function randomUUID() {\n    return generateUUID();\n}\n//# sourceMappingURL=uuidUtils.native.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nvar _a;\nimport { generateUUID } from \"./uuidUtils.native\";\n// NOTE: This could be undefined if not used in a secure context\nconst uuidFunction = typeof ((_a = globalThis === null || globalThis === void 0 ? void 0 : globalThis.crypto) === null || _a === void 0 ? void 0 : _a.randomUUID) === \"function\"\n    ? globalThis.crypto.randomUUID.bind(globalThis.crypto)\n    : generateUUID;\n/**\n * Generated Universally Unique Identifier\n *\n * @returns RFC4122 v4 UUID.\n */\nexport function randomUUID() {\n    return uuidFunction();\n}\n//# sourceMappingURL=uuidUtils.browser.js.map"],"names":["PollerStoppedError","Error","constructor","message","super","this","name","Object","setPrototypeOf","prototype","PollerCancelledError","Poller","operation","resolveOnUnsuccessful","stopped","pollProgressCallbacks","promise","Promise","resolve","reject","catch","startPolling","pollOptions","isStopped","isDone","poll","delay","pollOnce","options","update","abortSignal","fireProgress","bind","processUpdatedState","state","callback","cancelOnce","cancel","pollOncePromise","clearPollOncePromise","undefined","then","error","isCancelled","getResult","pollUntilDone","onProgress","push","filter","c","Boolean","isCompleted","stopPolling","cancelOperation","cancelPromise","getOperationState","result","toString","logPolicyName","ValidPhaseNames","Set","HttpPipeline","policies","_a","_policies","slice","_orderedPolicies","addPolicy","policy","phase","afterPhase","has","removePolicy","removedPolicies","policyDescriptor","sendRequest","httpClient","request","getOrderedPolicies","reduceRight","next","req","pipeline","orderPolicies","clone","create","policyMap","Map","createPhase","hasRun","hasAfterPolicies","serializePhase","noPhase","deserializePhase","retryPhase","signPhase","orderedPhases","getPhase","descriptor","policyName","node","dependsOn","dependants","set","add","get","afterPolicies","afterPolicyName","afterNode","beforePolicies","beforePolicyName","beforeNode","walkPhase","size","dependant","delete","walkPhases","iteration","initialResultLength","length","redirectPolicyName","allowedRedirect","redirectPolicy","maxRetries","response","handleRedirect","async","currentRetries","status","headers","locationHeader","includes","method","url","URL","body","res","SDK_VERSION","DEFAULT_RETRY_POLICY_COUNT","getUserAgentValue","prefix","runtimeInfo","map","_b","_c","localNavigator","globalThis","navigator","userAgentData","platform","replace","setPlatformSpecificData","defaultAgent","telemetryInfo","parts","key","value","token","join","getUserAgentString","UserAgentHeaderName","userAgentPolicyName","RetryAfterHeader","AllRetryAfterHeaders","getRetryAfterInMs","header","retryAfterValue","retryAfterHeader","diff","Date","parse","now","Number","isFinite","Math","max","e","DEFAULT_CLIENT_RETRY_INTERVAL","DEFAULT_CLIENT_MAX_RETRY_INTERVAL","exponentialRetryStrategy","retryInterval","retryDelayInMs","maxRetryInterval","maxRetryDelayInMs","retryAfterInMs","retry","retryCount","responseError","matchedSystemError","err","code","isSystemError","ignoreSystemErrors","isExponential","isExponentialRetryResponse","ignoreExponentialResponse","ignoreHttpStatusCodes","unknownResponse","isThrottlingRetryResponse","skipStrategy","errorToThrow","exponentialDelay","pow","clampedExponentialDelay","min","ceil","floor","random","retryPolicyLogger","createClientLogger","retryPolicyName","retryPolicy","strategies","logger","retryRequest","info","requestId","aborted","strategiesLoop","strategy","strategyLogger","modifiers","redirectTo","defaultRetryPolicyName","stringToUint8Array","format","TextEncoder","encode","utf8StringToUint8Array","base64ToUint8Array","base64String","base64UrlToUint8Array","bytes","Uint8Array","i","highNibble","lowNibble","hexDigits","parseInt","hexStringToUint8Array","atob","x","charCodeAt","formDataPolicyName","formDataPolicy","formData","contentType","indexOf","urlSearchParams","URLSearchParams","entries","Array","isArray","subValue","append","wwwFormUrlEncode","startsWith","fieldName","values","fileName","type","multipartBody","prepareFormData","errorMessage","setClientRequestIdPolicyName","tlsPolicyName","tracingPolicyName","tracingPolicy","userAgent","userAgentPrefix","tracingClient","tryCreateTracingClient","tracingOptions","tracingContext","span","updatedOptions","startSpan","spanKind","spanAttributes","isRecording","end","setAttribute","createRequestHeaders","log","tryCreateSpan","withContext","serviceRequestId","setStatus","tryProcessResponse","statusCode","tryProcessError","namespace","packageName","packageVersion","toStream","source","Blob","stream","concatenateStreams","streams","remainingStreams","from","reader","shift","getReader","doPull","controller","close","done","read","releaseLock","enqueue","ReadableStream","pull","reason","encodeHeaders","getLength","byteLength","buildRequestBody","boundary","sources","flatMap","part","contentLength","total","partLength","getTotalLength","multipartPolicyName","maxBoundaryLength","validBoundaryCharacters","multipartPolicy","contentTypeHeader","parsedHeader","match","parsedBoundary","some","assertValidBoundary","createPipelineFromOptions","tlsSettings","tlsOptions","proxyPolicy","proxyOptions","decompressResponsePolicy","userAgentValue","userAgentPolicy","userAgentOptions","requestIdHeaderName","setClientRequestIdPolicy","telemetryOptions","clientRequestIdHeaderName","defaultRetryPolicy","retryOptions","redirectOptions","sanitizer","additionalAllowedHeaderNames","additionalAllowedQueryParameters","enabled","sanitize","logPolicy","loggingOptions","FetchHttpClient","protocol","allowInsecureConnection","proxySettings","abortController","abortControllerCleanup","AbortController","abortListener","event","abort","addEventListener","removeEventListener","timeout","setTimeout","setupAbortSignal","pipelineHeaders","Headers","buildFetchHeaders","streaming","requestBody","buildBodyStream","onUploadProgress","requestInit","assign","signal","Request","credentials","withCredentials","cache","duplex","fetch","loadedBytes","httpResponse","responseHeaders","buildPipelineHeaders","bodyStream","onDownloadProgress","onEnd","streamResponseStatusCodes","POSITIVE_INFINITY","enableBrowserStreams","browserStreamBody","responseStream","Response","blobBody","blob","bodyAsText","text","buildPipelineResponse","makeRequest","getError","readableStream","pipeThrough","self","TransformStream","isTransformStreamSupported","transform","chunk","terminate","flush","createDefaultHttpClient","normalizeName","toLowerCase","HttpHeadersImpl","rawHeaders","_headersMap","headerName","keys","String","trim","toJSON","preserveCase","entry","normalizedName","JSON","stringify","Symbol","iterator","headerIterator","createHttpHeaders","PipelineRequestImpl","_d","_e","_f","_g","disableKeepAlive","createPipelineRequest","DEFAULT_CYCLER_OPTIONS","forcedRefreshWindowInMs","retryIntervalInMs","refreshWindowInMs","createTokenCycler","credential","tokenCyclerOptions","tenantId","refreshWorker","cycler","isRefreshing","shouldRefresh","expiresOnTimestamp","mustRefresh","refresh","scopes","getTokenOptions","getAccessToken","refreshTimeout","tryGetAccessToken","finalToken","beginRefresh","getToken","_token","tokenOptions","claims","bearerTokenAuthenticationPolicyName","defaultAuthorizeRequest","accessToken","bearerTokenAuthenticationPolicy","challengeCallbacks","callbacks","authorizeRequest","authorizeRequestOnChallenge","challenge","getChallenge","custom","errorSanitizer","RestError","isRestError","REQUEST_SEND_ERROR","PARSE_ERROR","StandardAbortMessage","delayInMs","timer","onAborted","rejectOnAbort","abortErrorMsg","removeListeners","clearTimeout","parseHeaderValueAsNumber","valueAsNum","isNaN","RedactedString","defaultAllowedHeaderNames","defaultAllowedQueryParameters","Sanitizer","allowedHeaderNames","allowedQueryParameters","concat","n","p","obj","seen","sanitizeHeaders","sanitizeUrl","sanitizeQuery","sanitized","k","search","searchParams","isNodeReadableStream","isWebReadableStream","tee","isBlob","createSpanFunction","args","operationName","operationOptions","tracer","spanOptions","kind","spanName","packagePrefix","process","azureTracingDisabledValue","AZURE_TRACING_DISABLED","isTracingDisabled","newSpanOptions","attributes","newTracingOptions","SpanKind","setSpan","context","isSpanContextValid","getTracer","version","SpanStatusCode","VERSION","getTraceParentHeader","spanContext","missingFields","traceId","spanId","hexFlags","traceFlags","knownContextKeys","for","createTracingContext","TracingContextImpl","parentContext","setValue","initialContext","_contextMap","newContext","getValue","deleteValue","instrumenterImplementation","getInstrumenter","parseTraceparentHeader","_name","recordException","_context","callbackArgs","createTracingClient","startSpanResult","withSpan","traceparentHeader","window","document","importScripts","isDeno","Deno","deno","isNode","versions","Bun","product","timeInMs","buildPromise","cleanupBeforeAbort","onAbort","createAbortablePromise","isError","hasName","hasMessage","getErrorMessage","stringified","isObject","input","RegExp","generateUUID","uuid","randomNumber","uuidFunction","crypto","randomUUID"],"sourceRoot":""}