{"version":3,"file":"static/js/7928.053cc615.chunk.js","mappings":"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","sources":["webpack://power-app-fe/./node_modules/@azure/storage-blob/dist-esm/storage-blob/src/BlobBatch.js","webpack://power-app-fe/./node_modules/@azure/storage-blob/dist-esm/storage-blob/src/BatchResponseParser.js","webpack://power-app-fe/./node_modules/@azure/storage-blob/dist-esm/storage-blob/src/BatchUtils.browser.js","webpack://power-app-fe/./node_modules/@azure/storage-blob/dist-esm/storage-blob/src/BlobBatchClient.js","webpack://power-app-fe/./node_modules/@azure/storage-blob/dist-esm/storage-blob/src/BlobDownloadResponse.browser.js","webpack://power-app-fe/./node_modules/@azure/storage-blob/dist-esm/storage-blob/src/BlobLeaseClient.js","webpack://power-app-fe/./node_modules/@azure/storage-blob/dist-esm/storage-blob/src/BlobQueryResponse.browser.js","webpack://power-app-fe/./node_modules/@azure/storage-blob/dist-esm/storage-blob/src/BlobServiceClient.js"],"sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\nimport { randomUUID } from \"@azure/core-util\";\nimport { isTokenCredential } from \"@azure/core-auth\";\nimport { bearerTokenAuthenticationPolicy, createEmptyPipeline, createHttpHeaders, } from \"@azure/core-rest-pipeline\";\nimport { isNode } from \"@azure/core-util\";\nimport { AnonymousCredential } from \"./credentials/AnonymousCredential\";\nimport { BlobClient } from \"./Clients\";\nimport { Mutex } from \"./utils/Mutex\";\nimport { Pipeline } from \"./Pipeline\";\nimport { getURLPath, getURLPathAndQuery, iEqual } from \"./utils/utils.common\";\nimport { stringifyXML } from \"@azure/core-xml\";\nimport { HeaderConstants, BATCH_MAX_REQUEST, HTTP_VERSION_1_1, HTTP_LINE_ENDING, StorageOAuthScopes, } from \"./utils/constants\";\nimport { StorageSharedKeyCredential } from \"./credentials/StorageSharedKeyCredential\";\nimport { tracingClient } from \"./utils/tracing\";\nimport { authorizeRequestOnTenantChallenge, serializationPolicy } from \"@azure/core-client\";\nimport { storageSharedKeyCredentialPolicy } from \"./policies/StorageSharedKeyCredentialPolicyV2\";\n/**\n * A BlobBatch represents an aggregated set of operations on blobs.\n * Currently, only `delete` and `setAccessTier` are supported.\n */\nexport class BlobBatch {\n    constructor() {\n        this.batch = \"batch\";\n        this.batchRequest = new InnerBatchRequest();\n    }\n    /**\n     * Get the value of Content-Type for a batch request.\n     * The value must be multipart/mixed with a batch boundary.\n     * Example: multipart/mixed; boundary=batch_a81786c8-e301-4e42-a729-a32ca24ae252\n     */\n    getMultiPartContentType() {\n        return this.batchRequest.getMultipartContentType();\n    }\n    /**\n     * Get assembled HTTP request body for sub requests.\n     */\n    getHttpRequestBody() {\n        return this.batchRequest.getHttpRequestBody();\n    }\n    /**\n     * Get sub requests that are added into the batch request.\n     */\n    getSubRequests() {\n        return this.batchRequest.getSubRequests();\n    }\n    async addSubRequestInternal(subRequest, assembleSubRequestFunc) {\n        await Mutex.lock(this.batch);\n        try {\n            this.batchRequest.preAddSubRequest(subRequest);\n            await assembleSubRequestFunc();\n            this.batchRequest.postAddSubRequest(subRequest);\n        }\n        finally {\n            await Mutex.unlock(this.batch);\n        }\n    }\n    setBatchType(batchType) {\n        if (!this.batchType) {\n            this.batchType = batchType;\n        }\n        if (this.batchType !== batchType) {\n            throw new RangeError(`BlobBatch only supports one operation type per batch and it already is being used for ${this.batchType} operations.`);\n        }\n    }\n    async deleteBlob(urlOrBlobClient, credentialOrOptions, options) {\n        let url;\n        let credential;\n        if (typeof urlOrBlobClient === \"string\" &&\n            ((isNode && credentialOrOptions instanceof StorageSharedKeyCredential) ||\n                credentialOrOptions instanceof AnonymousCredential ||\n                isTokenCredential(credentialOrOptions))) {\n            // First overload\n            url = urlOrBlobClient;\n            credential = credentialOrOptions;\n        }\n        else if (urlOrBlobClient instanceof BlobClient) {\n            // Second overload\n            url = urlOrBlobClient.url;\n            credential = urlOrBlobClient.credential;\n            options = credentialOrOptions;\n        }\n        else {\n            throw new RangeError(\"Invalid arguments. Either url and credential, or BlobClient need be provided.\");\n        }\n        if (!options) {\n            options = {};\n        }\n        return tracingClient.withSpan(\"BatchDeleteRequest-addSubRequest\", options, async (updatedOptions) => {\n            this.setBatchType(\"delete\");\n            await this.addSubRequestInternal({\n                url: url,\n                credential: credential,\n            }, async () => {\n                await new BlobClient(url, this.batchRequest.createPipeline(credential)).delete(updatedOptions);\n            });\n        });\n    }\n    async setBlobAccessTier(urlOrBlobClient, credentialOrTier, tierOrOptions, options) {\n        let url;\n        let credential;\n        let tier;\n        if (typeof urlOrBlobClient === \"string\" &&\n            ((isNode && credentialOrTier instanceof StorageSharedKeyCredential) ||\n                credentialOrTier instanceof AnonymousCredential ||\n                isTokenCredential(credentialOrTier))) {\n            // First overload\n            url = urlOrBlobClient;\n            credential = credentialOrTier;\n            tier = tierOrOptions;\n        }\n        else if (urlOrBlobClient instanceof BlobClient) {\n            // Second overload\n            url = urlOrBlobClient.url;\n            credential = urlOrBlobClient.credential;\n            tier = credentialOrTier;\n            options = tierOrOptions;\n        }\n        else {\n            throw new RangeError(\"Invalid arguments. Either url and credential, or BlobClient need be provided.\");\n        }\n        if (!options) {\n            options = {};\n        }\n        return tracingClient.withSpan(\"BatchSetTierRequest-addSubRequest\", options, async (updatedOptions) => {\n            this.setBatchType(\"setAccessTier\");\n            await this.addSubRequestInternal({\n                url: url,\n                credential: credential,\n            }, async () => {\n                await new BlobClient(url, this.batchRequest.createPipeline(credential)).setAccessTier(tier, updatedOptions);\n            });\n        });\n    }\n}\n/**\n * Inner batch request class which is responsible for assembling and serializing sub requests.\n * See https://docs.microsoft.com/en-us/rest/api/storageservices/blob-batch#request-body for how requests are assembled.\n */\nclass InnerBatchRequest {\n    constructor() {\n        this.operationCount = 0;\n        this.body = \"\";\n        const tempGuid = randomUUID();\n        // batch_{batchid}\n        this.boundary = `batch_${tempGuid}`;\n        // --batch_{batchid}\n        // Content-Type: application/http\n        // Content-Transfer-Encoding: binary\n        this.subRequestPrefix = `--${this.boundary}${HTTP_LINE_ENDING}${HeaderConstants.CONTENT_TYPE}: application/http${HTTP_LINE_ENDING}${HeaderConstants.CONTENT_TRANSFER_ENCODING}: binary`;\n        // multipart/mixed; boundary=batch_{batchid}\n        this.multipartContentType = `multipart/mixed; boundary=${this.boundary}`;\n        // --batch_{batchid}--\n        this.batchRequestEnding = `--${this.boundary}--`;\n        this.subRequests = new Map();\n    }\n    /**\n     * Create pipeline to assemble sub requests. The idea here is to use existing\n     * credential and serialization/deserialization components, with additional policies to\n     * filter unnecessary headers, assemble sub requests into request's body\n     * and intercept request from going to wire.\n     * @param credential -  Such as AnonymousCredential, StorageSharedKeyCredential or any credential from the `@azure/identity` package to authenticate requests to the service. You can also provide an object that implements the TokenCredential interface. If not specified, AnonymousCredential is used.\n     */\n    createPipeline(credential) {\n        const corePipeline = createEmptyPipeline();\n        corePipeline.addPolicy(serializationPolicy({\n            stringifyXML,\n            serializerOptions: {\n                xml: {\n                    xmlCharKey: \"#\",\n                },\n            },\n        }), { phase: \"Serialize\" });\n        // Use batch header filter policy to exclude unnecessary headers\n        corePipeline.addPolicy(batchHeaderFilterPolicy());\n        // Use batch assemble policy to assemble request and intercept request from going to wire\n        corePipeline.addPolicy(batchRequestAssemblePolicy(this), { afterPhase: \"Sign\" });\n        if (isTokenCredential(credential)) {\n            corePipeline.addPolicy(bearerTokenAuthenticationPolicy({\n                credential,\n                scopes: StorageOAuthScopes,\n                challengeCallbacks: { authorizeRequestOnChallenge: authorizeRequestOnTenantChallenge },\n            }), { phase: \"Sign\" });\n        }\n        else if (credential instanceof StorageSharedKeyCredential) {\n            corePipeline.addPolicy(storageSharedKeyCredentialPolicy({\n                accountName: credential.accountName,\n                accountKey: credential.accountKey,\n            }), { phase: \"Sign\" });\n        }\n        const pipeline = new Pipeline([]);\n        // attach the v2 pipeline to this one\n        pipeline._credential = credential;\n        pipeline._corePipeline = corePipeline;\n        return pipeline;\n    }\n    appendSubRequestToBody(request) {\n        // Start to assemble sub request\n        this.body += [\n            this.subRequestPrefix, // sub request constant prefix\n            `${HeaderConstants.CONTENT_ID}: ${this.operationCount}`, // sub request's content ID\n            \"\", // empty line after sub request's content ID\n            `${request.method.toString()} ${getURLPathAndQuery(request.url)} ${HTTP_VERSION_1_1}${HTTP_LINE_ENDING}`, // sub request start line with method\n        ].join(HTTP_LINE_ENDING);\n        for (const [name, value] of request.headers) {\n            this.body += `${name}: ${value}${HTTP_LINE_ENDING}`;\n        }\n        this.body += HTTP_LINE_ENDING; // sub request's headers need be ending with an empty line\n        // No body to assemble for current batch request support\n        // End to assemble sub request\n    }\n    preAddSubRequest(subRequest) {\n        if (this.operationCount >= BATCH_MAX_REQUEST) {\n            throw new RangeError(`Cannot exceed ${BATCH_MAX_REQUEST} sub requests in a single batch`);\n        }\n        // Fast fail if url for sub request is invalid\n        const path = getURLPath(subRequest.url);\n        if (!path || path === \"\") {\n            throw new RangeError(`Invalid url for sub request: '${subRequest.url}'`);\n        }\n    }\n    postAddSubRequest(subRequest) {\n        this.subRequests.set(this.operationCount, subRequest);\n        this.operationCount++;\n    }\n    // Return the http request body with assembling the ending line to the sub request body.\n    getHttpRequestBody() {\n        return `${this.body}${this.batchRequestEnding}${HTTP_LINE_ENDING}`;\n    }\n    getMultipartContentType() {\n        return this.multipartContentType;\n    }\n    getSubRequests() {\n        return this.subRequests;\n    }\n}\nfunction batchRequestAssemblePolicy(batchRequest) {\n    return {\n        name: \"batchRequestAssemblePolicy\",\n        async sendRequest(request) {\n            batchRequest.appendSubRequestToBody(request);\n            return {\n                request,\n                status: 200,\n                headers: createHttpHeaders(),\n            };\n        },\n    };\n}\nfunction batchHeaderFilterPolicy() {\n    return {\n        name: \"batchHeaderFilterPolicy\",\n        async sendRequest(request, next) {\n            let xMsHeaderName = \"\";\n            for (const [name] of request.headers) {\n                if (iEqual(name, HeaderConstants.X_MS_VERSION)) {\n                    xMsHeaderName = name;\n                }\n            }\n            if (xMsHeaderName !== \"\") {\n                request.headers.delete(xMsHeaderName); // The subrequests should not have the x-ms-version header.\n            }\n            return next(request);\n        },\n    };\n}\n//# sourceMappingURL=BlobBatch.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\nimport { createHttpHeaders } from \"@azure/core-rest-pipeline\";\nimport { toHttpHeadersLike } from \"@azure/core-http-compat\";\nimport { HTTP_VERSION_1_1, HTTP_LINE_ENDING, HeaderConstants, HTTPURLConnection, } from \"./utils/constants\";\nimport { getBodyAsText } from \"./BatchUtils\";\nimport { logger } from \"./log\";\nconst HTTP_HEADER_DELIMITER = \": \";\nconst SPACE_DELIMITER = \" \";\nconst NOT_FOUND = -1;\n/**\n * Util class for parsing batch response.\n */\nexport class BatchResponseParser {\n    constructor(batchResponse, subRequests) {\n        if (!batchResponse || !batchResponse.contentType) {\n            // In special case(reported), server may return invalid content-type which could not be parsed.\n            throw new RangeError(\"batchResponse is malformed or doesn't contain valid content-type.\");\n        }\n        if (!subRequests || subRequests.size === 0) {\n            // This should be prevent during coding.\n            throw new RangeError(\"Invalid state: subRequests is not provided or size is 0.\");\n        }\n        this.batchResponse = batchResponse;\n        this.subRequests = subRequests;\n        this.responseBatchBoundary = this.batchResponse.contentType.split(\"=\")[1];\n        this.perResponsePrefix = `--${this.responseBatchBoundary}${HTTP_LINE_ENDING}`;\n        this.batchResponseEnding = `--${this.responseBatchBoundary}--`;\n    }\n    // For example of response, please refer to https://docs.microsoft.com/en-us/rest/api/storageservices/blob-batch#response\n    async parseBatchResponse() {\n        // When logic reach here, suppose batch request has already succeeded with 202, so we can further parse\n        // sub request's response.\n        if (this.batchResponse._response.status !== HTTPURLConnection.HTTP_ACCEPTED) {\n            throw new Error(`Invalid state: batch request failed with status: '${this.batchResponse._response.status}'.`);\n        }\n        const responseBodyAsText = await getBodyAsText(this.batchResponse);\n        const subResponses = responseBodyAsText\n            .split(this.batchResponseEnding)[0] // string after ending is useless\n            .split(this.perResponsePrefix)\n            .slice(1); // string before first response boundary is useless\n        const subResponseCount = subResponses.length;\n        // Defensive coding in case of potential error parsing.\n        // Note: subResponseCount == 1 is special case where sub request is invalid.\n        // We try to prevent such cases through early validation, e.g. validate sub request count >= 1.\n        // While in unexpected sub request invalid case, we allow sub response to be parsed and return to user.\n        if (subResponseCount !== this.subRequests.size && subResponseCount !== 1) {\n            throw new Error(\"Invalid state: sub responses' count is not equal to sub requests' count.\");\n        }\n        const deserializedSubResponses = new Array(subResponseCount);\n        let subResponsesSucceededCount = 0;\n        let subResponsesFailedCount = 0;\n        // Parse sub subResponses.\n        for (let index = 0; index < subResponseCount; index++) {\n            const subResponse = subResponses[index];\n            const deserializedSubResponse = {};\n            deserializedSubResponse.headers = toHttpHeadersLike(createHttpHeaders());\n            const responseLines = subResponse.split(`${HTTP_LINE_ENDING}`);\n            let subRespHeaderStartFound = false;\n            let subRespHeaderEndFound = false;\n            let subRespFailed = false;\n            let contentId = NOT_FOUND;\n            for (const responseLine of responseLines) {\n                if (!subRespHeaderStartFound) {\n                    // Convention line to indicate content ID\n                    if (responseLine.startsWith(HeaderConstants.CONTENT_ID)) {\n                        contentId = parseInt(responseLine.split(HTTP_HEADER_DELIMITER)[1]);\n                    }\n                    // Http version line with status code indicates the start of sub request's response.\n                    // Example: HTTP/1.1 202 Accepted\n                    if (responseLine.startsWith(HTTP_VERSION_1_1)) {\n                        subRespHeaderStartFound = true;\n                        const tokens = responseLine.split(SPACE_DELIMITER);\n                        deserializedSubResponse.status = parseInt(tokens[1]);\n                        deserializedSubResponse.statusMessage = tokens.slice(2).join(SPACE_DELIMITER);\n                    }\n                    continue; // Skip convention headers not specifically for sub request i.e. Content-Type: application/http and Content-ID: *\n                }\n                if (responseLine.trim() === \"\") {\n                    // Sub response's header start line already found, and the first empty line indicates header end line found.\n                    if (!subRespHeaderEndFound) {\n                        subRespHeaderEndFound = true;\n                    }\n                    continue; // Skip empty line\n                }\n                // Note: when code reach here, it indicates subRespHeaderStartFound == true\n                if (!subRespHeaderEndFound) {\n                    if (responseLine.indexOf(HTTP_HEADER_DELIMITER) === -1) {\n                        // Defensive coding to prevent from missing valuable lines.\n                        throw new Error(`Invalid state: find non-empty line '${responseLine}' without HTTP header delimiter '${HTTP_HEADER_DELIMITER}'.`);\n                    }\n                    // Parse headers of sub response.\n                    const tokens = responseLine.split(HTTP_HEADER_DELIMITER);\n                    deserializedSubResponse.headers.set(tokens[0], tokens[1]);\n                    if (tokens[0] === HeaderConstants.X_MS_ERROR_CODE) {\n                        deserializedSubResponse.errorCode = tokens[1];\n                        subRespFailed = true;\n                    }\n                }\n                else {\n                    // Assemble body of sub response.\n                    if (!deserializedSubResponse.bodyAsText) {\n                        deserializedSubResponse.bodyAsText = \"\";\n                    }\n                    deserializedSubResponse.bodyAsText += responseLine;\n                }\n            } // Inner for end\n            // The response will contain the Content-ID header for each corresponding subrequest response to use for tracking.\n            // The Content-IDs are set to a valid index in the subrequests we sent. In the status code 202 path, we could expect it\n            // to be 1-1 mapping from the [0, subRequests.size) to the Content-IDs returned. If not, we simply don't return that\n            // unexpected subResponse in the parsed reponse and we can always look it up in the raw response for debugging purpose.\n            if (contentId !== NOT_FOUND &&\n                Number.isInteger(contentId) &&\n                contentId >= 0 &&\n                contentId < this.subRequests.size &&\n                deserializedSubResponses[contentId] === undefined) {\n                deserializedSubResponse._request = this.subRequests.get(contentId);\n                deserializedSubResponses[contentId] = deserializedSubResponse;\n            }\n            else {\n                logger.error(`subResponses[${index}] is dropped as the Content-ID is not found or invalid, Content-ID: ${contentId}`);\n            }\n            if (subRespFailed) {\n                subResponsesFailedCount++;\n            }\n            else {\n                subResponsesSucceededCount++;\n            }\n        }\n        return {\n            subResponses: deserializedSubResponses,\n            subResponsesSucceededCount: subResponsesSucceededCount,\n            subResponsesFailedCount: subResponsesFailedCount,\n        };\n    }\n}\n//# sourceMappingURL=BatchResponseParser.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\nimport { blobToString } from \"./utils/utils.browser\";\nexport async function getBodyAsText(batchResponse) {\n    const blob = (await batchResponse.blobBody);\n    return blobToString(blob);\n}\nexport function utf8ByteLength(str) {\n    return new Blob([str]).size;\n}\n//# sourceMappingURL=BatchUtils.browser.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\nimport { BatchResponseParser } from \"./BatchResponseParser\";\nimport { utf8ByteLength } from \"./BatchUtils\";\nimport { BlobBatch } from \"./BlobBatch\";\nimport { tracingClient } from \"./utils/tracing\";\nimport { AnonymousCredential } from \"./credentials/AnonymousCredential\";\nimport { StorageContextClient } from \"./StorageContextClient\";\nimport { newPipeline, isPipelineLike, getCoreClientOptions } from \"./Pipeline\";\nimport { assertResponse, getURLPath } from \"./utils/utils.common\";\n/**\n * A BlobBatchClient allows you to make batched requests to the Azure Storage Blob service.\n *\n * @see https://docs.microsoft.com/en-us/rest/api/storageservices/blob-batch\n */\nexport class BlobBatchClient {\n    constructor(url, credentialOrPipeline, \n    // Legacy, no fix for eslint error without breaking. Disable it for this interface.\n    /* eslint-disable-next-line @azure/azure-sdk/ts-naming-options*/\n    options) {\n        let pipeline;\n        if (isPipelineLike(credentialOrPipeline)) {\n            pipeline = credentialOrPipeline;\n        }\n        else if (!credentialOrPipeline) {\n            // no credential provided\n            pipeline = newPipeline(new AnonymousCredential(), options);\n        }\n        else {\n            pipeline = newPipeline(credentialOrPipeline, options);\n        }\n        const storageClientContext = new StorageContextClient(url, getCoreClientOptions(pipeline));\n        const path = getURLPath(url);\n        if (path && path !== \"/\") {\n            // Container scoped.\n            this.serviceOrContainerContext = storageClientContext.container;\n        }\n        else {\n            this.serviceOrContainerContext = storageClientContext.service;\n        }\n    }\n    /**\n     * Creates a {@link BlobBatch}.\n     * A BlobBatch represents an aggregated set of operations on blobs.\n     */\n    createBatch() {\n        return new BlobBatch();\n    }\n    async deleteBlobs(urlsOrBlobClients, credentialOrOptions, \n    // Legacy, no fix for eslint error without breaking. Disable it for this interface.\n    /* eslint-disable-next-line @azure/azure-sdk/ts-naming-options*/\n    options) {\n        const batch = new BlobBatch();\n        for (const urlOrBlobClient of urlsOrBlobClients) {\n            if (typeof urlOrBlobClient === \"string\") {\n                await batch.deleteBlob(urlOrBlobClient, credentialOrOptions, options);\n            }\n            else {\n                await batch.deleteBlob(urlOrBlobClient, credentialOrOptions);\n            }\n        }\n        return this.submitBatch(batch);\n    }\n    async setBlobsAccessTier(urlsOrBlobClients, credentialOrTier, tierOrOptions, \n    // Legacy, no fix for eslint error without breaking. Disable it for this interface.\n    /* eslint-disable-next-line @azure/azure-sdk/ts-naming-options*/\n    options) {\n        const batch = new BlobBatch();\n        for (const urlOrBlobClient of urlsOrBlobClients) {\n            if (typeof urlOrBlobClient === \"string\") {\n                await batch.setBlobAccessTier(urlOrBlobClient, credentialOrTier, tierOrOptions, options);\n            }\n            else {\n                await batch.setBlobAccessTier(urlOrBlobClient, credentialOrTier, tierOrOptions);\n            }\n        }\n        return this.submitBatch(batch);\n    }\n    /**\n     * Submit batch request which consists of multiple subrequests.\n     *\n     * Get `blobBatchClient` and other details before running the snippets.\n     * `blobServiceClient.getBlobBatchClient()` gives the `blobBatchClient`\n     *\n     * Example usage:\n     *\n     * ```js\n     * let batchRequest = new BlobBatch();\n     * await batchRequest.deleteBlob(urlInString0, credential0);\n     * await batchRequest.deleteBlob(urlInString1, credential1, {\n     *  deleteSnapshots: \"include\"\n     * });\n     * const batchResp = await blobBatchClient.submitBatch(batchRequest);\n     * console.log(batchResp.subResponsesSucceededCount);\n     * ```\n     *\n     * Example using a lease:\n     *\n     * ```js\n     * let batchRequest = new BlobBatch();\n     * await batchRequest.setBlobAccessTier(blockBlobClient0, \"Cool\");\n     * await batchRequest.setBlobAccessTier(blockBlobClient1, \"Cool\", {\n     *  conditions: { leaseId: leaseId }\n     * });\n     * const batchResp = await blobBatchClient.submitBatch(batchRequest);\n     * console.log(batchResp.subResponsesSucceededCount);\n     * ```\n     *\n     * @see https://docs.microsoft.com/en-us/rest/api/storageservices/blob-batch\n     *\n     * @param batchRequest - A set of Delete or SetTier operations.\n     * @param options -\n     */\n    async submitBatch(batchRequest, options = {}) {\n        if (!batchRequest || batchRequest.getSubRequests().size === 0) {\n            throw new RangeError(\"Batch request should contain one or more sub requests.\");\n        }\n        return tracingClient.withSpan(\"BlobBatchClient-submitBatch\", options, async (updatedOptions) => {\n            const batchRequestBody = batchRequest.getHttpRequestBody();\n            // ServiceSubmitBatchResponseModel and ContainerSubmitBatchResponse are compatible for now.\n            const rawBatchResponse = assertResponse(await this.serviceOrContainerContext.submitBatch(utf8ByteLength(batchRequestBody), batchRequest.getMultiPartContentType(), batchRequestBody, Object.assign({}, updatedOptions)));\n            // Parse the sub responses result, if logic reaches here(i.e. the batch request succeeded with status code 202).\n            const batchResponseParser = new BatchResponseParser(rawBatchResponse, batchRequest.getSubRequests());\n            const responseSummary = await batchResponseParser.parseBatchResponse();\n            const res = {\n                _response: rawBatchResponse._response,\n                contentType: rawBatchResponse.contentType,\n                errorCode: rawBatchResponse.errorCode,\n                requestId: rawBatchResponse.requestId,\n                clientRequestId: rawBatchResponse.clientRequestId,\n                version: rawBatchResponse.version,\n                subResponses: responseSummary.subResponses,\n                subResponsesSucceededCount: responseSummary.subResponsesSucceededCount,\n                subResponsesFailedCount: responseSummary.subResponsesFailedCount,\n            };\n            return res;\n        });\n    }\n}\n//# sourceMappingURL=BlobBatchClient.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n// This file is used as a shim of \"BlobDownloadResponse\" for some browser bundlers\n// when trying to bundle \"BlobDownloadResponse\"\n// \"BlobDownloadResponse\" class is only available in Node.js runtime\nexport const BlobDownloadResponse = 1;\n//# sourceMappingURL=BlobDownloadResponse.browser.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\nimport { randomUUID } from \"@azure/core-util\";\nimport { ETagNone } from \"./utils/constants\";\nimport { tracingClient } from \"./utils/tracing\";\nimport { assertResponse } from \"./utils/utils.common\";\n/**\n * A client that manages leases for a {@link ContainerClient} or a {@link BlobClient}.\n */\nexport class BlobLeaseClient {\n    /**\n     * Gets the lease Id.\n     *\n     * @readonly\n     */\n    get leaseId() {\n        return this._leaseId;\n    }\n    /**\n     * Gets the url.\n     *\n     * @readonly\n     */\n    get url() {\n        return this._url;\n    }\n    /**\n     * Creates an instance of BlobLeaseClient.\n     * @param client - The client to make the lease operation requests.\n     * @param leaseId - Initial proposed lease id.\n     */\n    constructor(client, leaseId) {\n        const clientContext = client.storageClientContext;\n        this._url = client.url;\n        if (client.name === undefined) {\n            this._isContainer = true;\n            this._containerOrBlobOperation = clientContext.container;\n        }\n        else {\n            this._isContainer = false;\n            this._containerOrBlobOperation = clientContext.blob;\n        }\n        if (!leaseId) {\n            leaseId = randomUUID();\n        }\n        this._leaseId = leaseId;\n    }\n    /**\n     * Establishes and manages a lock on a container for delete operations, or on a blob\n     * for write and delete operations.\n     * The lock duration can be 15 to 60 seconds, or can be infinite.\n     * @see https://docs.microsoft.com/en-us/rest/api/storageservices/lease-container\n     * and\n     * @see https://docs.microsoft.com/en-us/rest/api/storageservices/lease-blob\n     *\n     * @param duration - Must be between 15 to 60 seconds, or infinite (-1)\n     * @param options - option to configure lease management operations.\n     * @returns Response data for acquire lease operation.\n     */\n    async acquireLease(duration, options = {}) {\n        var _a, _b, _c, _d, _e;\n        if (this._isContainer &&\n            ((((_a = options.conditions) === null || _a === void 0 ? void 0 : _a.ifMatch) && ((_b = options.conditions) === null || _b === void 0 ? void 0 : _b.ifMatch) !== ETagNone) ||\n                (((_c = options.conditions) === null || _c === void 0 ? void 0 : _c.ifNoneMatch) && ((_d = options.conditions) === null || _d === void 0 ? void 0 : _d.ifNoneMatch) !== ETagNone) ||\n                ((_e = options.conditions) === null || _e === void 0 ? void 0 : _e.tagConditions))) {\n            throw new RangeError(\"The IfMatch, IfNoneMatch and tags access conditions are ignored by the service. Values other than undefined or their default values are not acceptable.\");\n        }\n        return tracingClient.withSpan(\"BlobLeaseClient-acquireLease\", options, async (updatedOptions) => {\n            var _a;\n            return assertResponse(await this._containerOrBlobOperation.acquireLease({\n                abortSignal: options.abortSignal,\n                duration,\n                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),\n                proposedLeaseId: this._leaseId,\n                tracingOptions: updatedOptions.tracingOptions,\n            }));\n        });\n    }\n    /**\n     * To change the ID of the lease.\n     * @see https://docs.microsoft.com/en-us/rest/api/storageservices/lease-container\n     * and\n     * @see https://docs.microsoft.com/en-us/rest/api/storageservices/lease-blob\n     *\n     * @param proposedLeaseId - the proposed new lease Id.\n     * @param options - option to configure lease management operations.\n     * @returns Response data for change lease operation.\n     */\n    async changeLease(proposedLeaseId, options = {}) {\n        var _a, _b, _c, _d, _e;\n        if (this._isContainer &&\n            ((((_a = options.conditions) === null || _a === void 0 ? void 0 : _a.ifMatch) && ((_b = options.conditions) === null || _b === void 0 ? void 0 : _b.ifMatch) !== ETagNone) ||\n                (((_c = options.conditions) === null || _c === void 0 ? void 0 : _c.ifNoneMatch) && ((_d = options.conditions) === null || _d === void 0 ? void 0 : _d.ifNoneMatch) !== ETagNone) ||\n                ((_e = options.conditions) === null || _e === void 0 ? void 0 : _e.tagConditions))) {\n            throw new RangeError(\"The IfMatch, IfNoneMatch and tags access conditions are ignored by the service. Values other than undefined or their default values are not acceptable.\");\n        }\n        return tracingClient.withSpan(\"BlobLeaseClient-changeLease\", options, async (updatedOptions) => {\n            var _a;\n            const response = assertResponse(await this._containerOrBlobOperation.changeLease(this._leaseId, proposedLeaseId, {\n                abortSignal: options.abortSignal,\n                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),\n                tracingOptions: updatedOptions.tracingOptions,\n            }));\n            this._leaseId = proposedLeaseId;\n            return response;\n        });\n    }\n    /**\n     * To free the lease if it is no longer needed so that another client may\n     * immediately acquire a lease against the container or the blob.\n     * @see https://docs.microsoft.com/en-us/rest/api/storageservices/lease-container\n     * and\n     * @see https://docs.microsoft.com/en-us/rest/api/storageservices/lease-blob\n     *\n     * @param options - option to configure lease management operations.\n     * @returns Response data for release lease operation.\n     */\n    async releaseLease(options = {}) {\n        var _a, _b, _c, _d, _e;\n        if (this._isContainer &&\n            ((((_a = options.conditions) === null || _a === void 0 ? void 0 : _a.ifMatch) && ((_b = options.conditions) === null || _b === void 0 ? void 0 : _b.ifMatch) !== ETagNone) ||\n                (((_c = options.conditions) === null || _c === void 0 ? void 0 : _c.ifNoneMatch) && ((_d = options.conditions) === null || _d === void 0 ? void 0 : _d.ifNoneMatch) !== ETagNone) ||\n                ((_e = options.conditions) === null || _e === void 0 ? void 0 : _e.tagConditions))) {\n            throw new RangeError(\"The IfMatch, IfNoneMatch and tags access conditions are ignored by the service. Values other than undefined or their default values are not acceptable.\");\n        }\n        return tracingClient.withSpan(\"BlobLeaseClient-releaseLease\", options, async (updatedOptions) => {\n            var _a;\n            return assertResponse(await this._containerOrBlobOperation.releaseLease(this._leaseId, {\n                abortSignal: options.abortSignal,\n                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),\n                tracingOptions: updatedOptions.tracingOptions,\n            }));\n        });\n    }\n    /**\n     * To renew the lease.\n     * @see https://docs.microsoft.com/en-us/rest/api/storageservices/lease-container\n     * and\n     * @see https://docs.microsoft.com/en-us/rest/api/storageservices/lease-blob\n     *\n     * @param options - Optional option to configure lease management operations.\n     * @returns Response data for renew lease operation.\n     */\n    async renewLease(options = {}) {\n        var _a, _b, _c, _d, _e;\n        if (this._isContainer &&\n            ((((_a = options.conditions) === null || _a === void 0 ? void 0 : _a.ifMatch) && ((_b = options.conditions) === null || _b === void 0 ? void 0 : _b.ifMatch) !== ETagNone) ||\n                (((_c = options.conditions) === null || _c === void 0 ? void 0 : _c.ifNoneMatch) && ((_d = options.conditions) === null || _d === void 0 ? void 0 : _d.ifNoneMatch) !== ETagNone) ||\n                ((_e = options.conditions) === null || _e === void 0 ? void 0 : _e.tagConditions))) {\n            throw new RangeError(\"The IfMatch, IfNoneMatch and tags access conditions are ignored by the service. Values other than undefined or their default values are not acceptable.\");\n        }\n        return tracingClient.withSpan(\"BlobLeaseClient-renewLease\", options, async (updatedOptions) => {\n            var _a;\n            return this._containerOrBlobOperation.renewLease(this._leaseId, {\n                abortSignal: options.abortSignal,\n                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),\n                tracingOptions: updatedOptions.tracingOptions,\n            });\n        });\n    }\n    /**\n     * To end the lease but ensure that another client cannot acquire a new lease\n     * until the current lease period has expired.\n     * @see https://docs.microsoft.com/en-us/rest/api/storageservices/lease-container\n     * and\n     * @see https://docs.microsoft.com/en-us/rest/api/storageservices/lease-blob\n     *\n     * @param breakPeriod - Break period\n     * @param options - Optional options to configure lease management operations.\n     * @returns Response data for break lease operation.\n     */\n    async breakLease(breakPeriod, options = {}) {\n        var _a, _b, _c, _d, _e;\n        if (this._isContainer &&\n            ((((_a = options.conditions) === null || _a === void 0 ? void 0 : _a.ifMatch) && ((_b = options.conditions) === null || _b === void 0 ? void 0 : _b.ifMatch) !== ETagNone) ||\n                (((_c = options.conditions) === null || _c === void 0 ? void 0 : _c.ifNoneMatch) && ((_d = options.conditions) === null || _d === void 0 ? void 0 : _d.ifNoneMatch) !== ETagNone) ||\n                ((_e = options.conditions) === null || _e === void 0 ? void 0 : _e.tagConditions))) {\n            throw new RangeError(\"The IfMatch, IfNoneMatch and tags access conditions are ignored by the service. Values other than undefined or their default values are not acceptable.\");\n        }\n        return tracingClient.withSpan(\"BlobLeaseClient-breakLease\", options, async (updatedOptions) => {\n            var _a;\n            const operationOptions = {\n                abortSignal: options.abortSignal,\n                breakPeriod,\n                modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === void 0 ? void 0 : _a.tagConditions }),\n                tracingOptions: updatedOptions.tracingOptions,\n            };\n            return assertResponse(await this._containerOrBlobOperation.breakLease(operationOptions));\n        });\n    }\n}\n//# sourceMappingURL=BlobLeaseClient.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n/**\n * ONLY AVAILABLE IN BROWSER RUNTIME.\n *\n * BlobQueryResponse implements BlobDownloadResponseModel interface, and in browser runtime it will\n * parse avor data returned by blob query.\n */\nexport class BlobQueryResponse {\n    /**\n     * Indicates that the service supports\n     * requests for partial file content.\n     *\n     * @readonly\n     */\n    get acceptRanges() {\n        return this.originalResponse.acceptRanges;\n    }\n    /**\n     * Returns if it was previously specified\n     * for the file.\n     *\n     * @readonly\n     */\n    get cacheControl() {\n        return this.originalResponse.cacheControl;\n    }\n    /**\n     * Returns the value that was specified\n     * for the 'x-ms-content-disposition' header and specifies how to process the\n     * response.\n     *\n     * @readonly\n     */\n    get contentDisposition() {\n        return this.originalResponse.contentDisposition;\n    }\n    /**\n     * Returns the value that was specified\n     * for the Content-Encoding request header.\n     *\n     * @readonly\n     */\n    get contentEncoding() {\n        return this.originalResponse.contentEncoding;\n    }\n    /**\n     * Returns the value that was specified\n     * for the Content-Language request header.\n     *\n     * @readonly\n     */\n    get contentLanguage() {\n        return this.originalResponse.contentLanguage;\n    }\n    /**\n     * The current sequence number for a\n     * page blob. This header is not returned for block blobs or append blobs.\n     *\n     * @readonly\n     */\n    get blobSequenceNumber() {\n        return this.originalResponse.blobSequenceNumber;\n    }\n    /**\n     * The blob's type. Possible values include:\n     * 'BlockBlob', 'PageBlob', 'AppendBlob'.\n     *\n     * @readonly\n     */\n    get blobType() {\n        return this.originalResponse.blobType;\n    }\n    /**\n     * The number of bytes present in the\n     * response body.\n     *\n     * @readonly\n     */\n    get contentLength() {\n        return this.originalResponse.contentLength;\n    }\n    /**\n     * If the file has an MD5 hash and the\n     * request is to read the full file, this response header is returned so that\n     * the client can check for message content integrity. If the request is to\n     * read a specified range and the 'x-ms-range-get-content-md5' is set to\n     * true, then the request returns an MD5 hash for the range, as long as the\n     * range size is less than or equal to 4 MB. If neither of these sets of\n     * conditions is true, then no value is returned for the 'Content-MD5'\n     * header.\n     *\n     * @readonly\n     */\n    get contentMD5() {\n        return this.originalResponse.contentMD5;\n    }\n    /**\n     * Indicates the range of bytes returned if\n     * the client requested a subset of the file by setting the Range request\n     * header.\n     *\n     * @readonly\n     */\n    get contentRange() {\n        return this.originalResponse.contentRange;\n    }\n    /**\n     * The content type specified for the file.\n     * The default content type is 'application/octet-stream'\n     *\n     * @readonly\n     */\n    get contentType() {\n        return this.originalResponse.contentType;\n    }\n    /**\n     * Conclusion time of the last attempted\n     * Copy File operation where this file was the destination file. This value\n     * can specify the time of a completed, aborted, or failed copy attempt.\n     *\n     * @readonly\n     */\n    get copyCompletedOn() {\n        return undefined;\n    }\n    /**\n     * String identifier for the last attempted Copy\n     * File operation where this file was the destination file.\n     *\n     * @readonly\n     */\n    get copyId() {\n        return this.originalResponse.copyId;\n    }\n    /**\n     * Contains the number of bytes copied and\n     * the total bytes in the source in the last attempted Copy File operation\n     * where this file was the destination file. Can show between 0 and\n     * Content-Length bytes copied.\n     *\n     * @readonly\n     */\n    get copyProgress() {\n        return this.originalResponse.copyProgress;\n    }\n    /**\n     * URL up to 2KB in length that specifies the\n     * source file used in the last attempted Copy File operation where this file\n     * was the destination file.\n     *\n     * @readonly\n     */\n    get copySource() {\n        return this.originalResponse.copySource;\n    }\n    /**\n     * State of the copy operation\n     * identified by 'x-ms-copy-id'. Possible values include: 'pending',\n     * 'success', 'aborted', 'failed'\n     *\n     * @readonly\n     */\n    get copyStatus() {\n        return this.originalResponse.copyStatus;\n    }\n    /**\n     * Only appears when\n     * x-ms-copy-status is failed or pending. Describes cause of fatal or\n     * non-fatal copy operation failure.\n     *\n     * @readonly\n     */\n    get copyStatusDescription() {\n        return this.originalResponse.copyStatusDescription;\n    }\n    /**\n     * When a blob is leased,\n     * specifies whether the lease is of infinite or fixed duration. Possible\n     * values include: 'infinite', 'fixed'.\n     *\n     * @readonly\n     */\n    get leaseDuration() {\n        return this.originalResponse.leaseDuration;\n    }\n    /**\n     * Lease state of the blob. Possible\n     * values include: 'available', 'leased', 'expired', 'breaking', 'broken'.\n     *\n     * @readonly\n     */\n    get leaseState() {\n        return this.originalResponse.leaseState;\n    }\n    /**\n     * The current lease status of the\n     * blob. Possible values include: 'locked', 'unlocked'.\n     *\n     * @readonly\n     */\n    get leaseStatus() {\n        return this.originalResponse.leaseStatus;\n    }\n    /**\n     * A UTC date/time value generated by the service that\n     * indicates the time at which the response was initiated.\n     *\n     * @readonly\n     */\n    get date() {\n        return this.originalResponse.date;\n    }\n    /**\n     * The number of committed blocks\n     * present in the blob. This header is returned only for append blobs.\n     *\n     * @readonly\n     */\n    get blobCommittedBlockCount() {\n        return this.originalResponse.blobCommittedBlockCount;\n    }\n    /**\n     * The ETag contains a value that you can use to\n     * perform operations conditionally, in quotes.\n     *\n     * @readonly\n     */\n    get etag() {\n        return this.originalResponse.etag;\n    }\n    /**\n     * The error code.\n     *\n     * @readonly\n     */\n    get errorCode() {\n        return this.originalResponse.errorCode;\n    }\n    /**\n     * The value of this header is set to\n     * true if the file data and application metadata are completely encrypted\n     * using the specified algorithm. Otherwise, the value is set to false (when\n     * the file is unencrypted, or if only parts of the file/application metadata\n     * are encrypted).\n     *\n     * @readonly\n     */\n    get isServerEncrypted() {\n        return this.originalResponse.isServerEncrypted;\n    }\n    /**\n     * If the blob has a MD5 hash, and if\n     * request contains range header (Range or x-ms-range), this response header\n     * is returned with the value of the whole blob's MD5 value. This value may\n     * or may not be equal to the value returned in Content-MD5 header, with the\n     * latter calculated from the requested range.\n     *\n     * @readonly\n     */\n    get blobContentMD5() {\n        return this.originalResponse.blobContentMD5;\n    }\n    /**\n     * Returns the date and time the file was last\n     * modified. Any operation that modifies the file or its properties updates\n     * the last modified time.\n     *\n     * @readonly\n     */\n    get lastModified() {\n        return this.originalResponse.lastModified;\n    }\n    /**\n     * A name-value pair\n     * to associate with a file storage object.\n     *\n     * @readonly\n     */\n    get metadata() {\n        return this.originalResponse.metadata;\n    }\n    /**\n     * This header uniquely identifies the request\n     * that was made and can be used for troubleshooting the request.\n     *\n     * @readonly\n     */\n    get requestId() {\n        return this.originalResponse.requestId;\n    }\n    /**\n     * If a client request id header is sent in the request, this header will be present in the\n     * response with the same value.\n     *\n     * @readonly\n     */\n    get clientRequestId() {\n        return this.originalResponse.clientRequestId;\n    }\n    /**\n     * Indicates the version of the File service used\n     * to execute the request.\n     *\n     * @readonly\n     */\n    get version() {\n        return this.originalResponse.version;\n    }\n    /**\n     * The SHA-256 hash of the encryption key used to encrypt the blob. This value is only returned\n     * when the blob was encrypted with a customer-provided key.\n     *\n     * @readonly\n     */\n    get encryptionKeySha256() {\n        return this.originalResponse.encryptionKeySha256;\n    }\n    /**\n     * If the request is to read a specified range and the x-ms-range-get-content-crc64 is set to\n     * true, then the request returns a crc64 for the range, as long as the range size is less than\n     * or equal to 4 MB. If both x-ms-range-get-content-crc64 & x-ms-range-get-content-md5 is\n     * specified in the same request, it will fail with 400(Bad Request)\n     */\n    get contentCrc64() {\n        return this.originalResponse.contentCrc64;\n    }\n    /**\n     * The response body as a browser Blob.\n     * Always undefined in node.js.\n     *\n     * @readonly\n     */\n    get blobBody() {\n        throw Error(`Quick query in browser is not supported yet.`);\n    }\n    /**\n     * The response body as a node.js Readable stream.\n     * Always undefined in the browser.\n     *\n     * @readonly\n     */\n    get readableStreamBody() {\n        return undefined;\n    }\n    /**\n     * The HTTP response.\n     */\n    get _response() {\n        return this.originalResponse._response;\n    }\n    /**\n     * Creates an instance of BlobQueryResponse.\n     *\n     * @param originalResponse -\n     * @param options -\n     */\n    constructor(originalResponse, _options = {}) {\n        this.originalResponse = originalResponse;\n    }\n}\n//# sourceMappingURL=BlobQueryResponse.browser.js.map","import { __asyncDelegator, __asyncGenerator, __asyncValues, __await } from \"tslib\";\nimport { isTokenCredential } from \"@azure/core-auth\";\nimport { getDefaultProxySettings } from \"@azure/core-rest-pipeline\";\nimport { isNode } from \"@azure/core-util\";\nimport { newPipeline, isPipelineLike } from \"./Pipeline\";\nimport { ContainerClient } from \"./ContainerClient\";\nimport { appendToURLPath, appendToURLQuery, extractConnectionStringParts, toTags, } from \"./utils/utils.common\";\nimport { StorageSharedKeyCredential } from \"./credentials/StorageSharedKeyCredential\";\nimport { AnonymousCredential } from \"./credentials/AnonymousCredential\";\nimport { truncatedISO8061Date, assertResponse } from \"./utils/utils.common\";\nimport { tracingClient } from \"./utils/tracing\";\nimport { BlobBatchClient } from \"./BlobBatchClient\";\nimport { StorageClient } from \"./StorageClient\";\nimport { AccountSASPermissions } from \"./sas/AccountSASPermissions\";\nimport { generateAccountSASQueryParameters, generateAccountSASQueryParametersInternal, } from \"./sas/AccountSASSignatureValues\";\nimport { AccountSASServices } from \"./sas/AccountSASServices\";\n/**\n * A BlobServiceClient represents a Client to the Azure Storage Blob service allowing you\n * to manipulate blob containers.\n */\nexport class BlobServiceClient extends StorageClient {\n    /**\n     *\n     * Creates an instance of BlobServiceClient from connection string.\n     *\n     * @param connectionString - Account connection string or a SAS connection string of an Azure storage account.\n     *                                  [ Note - Account connection string can only be used in NODE.JS runtime. ]\n     *                                  Account connection string example -\n     *                                  `DefaultEndpointsProtocol=https;AccountName=myaccount;AccountKey=accountKey;EndpointSuffix=core.windows.net`\n     *                                  SAS connection string example -\n     *                                  `BlobEndpoint=https://myaccount.blob.core.windows.net/;QueueEndpoint=https://myaccount.queue.core.windows.net/;FileEndpoint=https://myaccount.file.core.windows.net/;TableEndpoint=https://myaccount.table.core.windows.net/;SharedAccessSignature=sasString`\n     * @param options - Optional. Options to configure the HTTP pipeline.\n     */\n    static fromConnectionString(connectionString, \n    // Legacy, no fix for eslint error without breaking. Disable it for this interface.\n    /* eslint-disable-next-line @azure/azure-sdk/ts-naming-options*/\n    options) {\n        options = options || {};\n        const extractedCreds = extractConnectionStringParts(connectionString);\n        if (extractedCreds.kind === \"AccountConnString\") {\n            if (isNode) {\n                const sharedKeyCredential = new StorageSharedKeyCredential(extractedCreds.accountName, extractedCreds.accountKey);\n                if (!options.proxyOptions) {\n                    options.proxyOptions = getDefaultProxySettings(extractedCreds.proxyUri);\n                }\n                const pipeline = newPipeline(sharedKeyCredential, options);\n                return new BlobServiceClient(extractedCreds.url, pipeline);\n            }\n            else {\n                throw new Error(\"Account connection string is only supported in Node.js environment\");\n            }\n        }\n        else if (extractedCreds.kind === \"SASConnString\") {\n            const pipeline = newPipeline(new AnonymousCredential(), options);\n            return new BlobServiceClient(extractedCreds.url + \"?\" + extractedCreds.accountSas, pipeline);\n        }\n        else {\n            throw new Error(\"Connection string must be either an Account connection string or a SAS connection string\");\n        }\n    }\n    constructor(url, credentialOrPipeline, \n    // Legacy, no fix for eslint error without breaking. Disable it for this interface.\n    /* eslint-disable-next-line @azure/azure-sdk/ts-naming-options*/\n    options) {\n        let pipeline;\n        if (isPipelineLike(credentialOrPipeline)) {\n            pipeline = credentialOrPipeline;\n        }\n        else if ((isNode && credentialOrPipeline instanceof StorageSharedKeyCredential) ||\n            credentialOrPipeline instanceof AnonymousCredential ||\n            isTokenCredential(credentialOrPipeline)) {\n            pipeline = newPipeline(credentialOrPipeline, options);\n        }\n        else {\n            // The second parameter is undefined. Use anonymous credential\n            pipeline = newPipeline(new AnonymousCredential(), options);\n        }\n        super(url, pipeline);\n        this.serviceContext = this.storageClientContext.service;\n    }\n    /**\n     * Creates a {@link ContainerClient} object\n     *\n     * @param containerName - A container name\n     * @returns A new ContainerClient object for the given container name.\n     *\n     * Example usage:\n     *\n     * ```js\n     * const containerClient = blobServiceClient.getContainerClient(\"<container name>\");\n     * ```\n     */\n    getContainerClient(containerName) {\n        return new ContainerClient(appendToURLPath(this.url, encodeURIComponent(containerName)), this.pipeline);\n    }\n    /**\n     * Create a Blob container. @see https://docs.microsoft.com/en-us/rest/api/storageservices/create-container\n     *\n     * @param containerName - Name of the container to create.\n     * @param options - Options to configure Container Create operation.\n     * @returns Container creation response and the corresponding container client.\n     */\n    async createContainer(containerName, options = {}) {\n        return tracingClient.withSpan(\"BlobServiceClient-createContainer\", options, async (updatedOptions) => {\n            const containerClient = this.getContainerClient(containerName);\n            const containerCreateResponse = await containerClient.create(updatedOptions);\n            return {\n                containerClient,\n                containerCreateResponse,\n            };\n        });\n    }\n    /**\n     * Deletes a Blob container.\n     *\n     * @param containerName - Name of the container to delete.\n     * @param options - Options to configure Container Delete operation.\n     * @returns Container deletion response.\n     */\n    async deleteContainer(containerName, options = {}) {\n        return tracingClient.withSpan(\"BlobServiceClient-deleteContainer\", options, async (updatedOptions) => {\n            const containerClient = this.getContainerClient(containerName);\n            return containerClient.delete(updatedOptions);\n        });\n    }\n    /**\n     * Restore a previously deleted Blob container.\n     * This API is only functional if Container Soft Delete is enabled for the storage account associated with the container.\n     *\n     * @param deletedContainerName - Name of the previously deleted container.\n     * @param deletedContainerVersion - Version of the previously deleted container, used to uniquely identify the deleted container.\n     * @param options - Options to configure Container Restore operation.\n     * @returns Container deletion response.\n     */\n    async undeleteContainer(deletedContainerName, deletedContainerVersion, options = {}) {\n        return tracingClient.withSpan(\"BlobServiceClient-undeleteContainer\", options, async (updatedOptions) => {\n            const containerClient = this.getContainerClient(options.destinationContainerName || deletedContainerName);\n            // Hack to access a protected member.\n            const containerContext = containerClient[\"storageClientContext\"].container;\n            const containerUndeleteResponse = assertResponse(await containerContext.restore({\n                deletedContainerName,\n                deletedContainerVersion,\n                tracingOptions: updatedOptions.tracingOptions,\n            }));\n            return { containerClient, containerUndeleteResponse };\n        });\n    }\n    /**\n     * Rename an existing Blob Container.\n     *\n     * @param sourceContainerName - The name of the source container.\n     * @param destinationContainerName - The new name of the container.\n     * @param options - Options to configure Container Rename operation.\n     */\n    /* eslint-disable-next-line @typescript-eslint/ban-ts-comment */\n    // @ts-ignore Need to hide this interface for now. Make it public and turn on the live tests for it when the service is ready.\n    async renameContainer(sourceContainerName, destinationContainerName, options = {}) {\n        return tracingClient.withSpan(\"BlobServiceClient-renameContainer\", options, async (updatedOptions) => {\n            var _a;\n            const containerClient = this.getContainerClient(destinationContainerName);\n            // Hack to access a protected member.\n            const containerContext = containerClient[\"storageClientContext\"].container;\n            const containerRenameResponse = assertResponse(await containerContext.rename(sourceContainerName, Object.assign(Object.assign({}, updatedOptions), { sourceLeaseId: (_a = options.sourceCondition) === null || _a === void 0 ? void 0 : _a.leaseId })));\n            return { containerClient, containerRenameResponse };\n        });\n    }\n    /**\n     * Gets the properties of a storage account’s Blob service, including properties\n     * for Storage Analytics and CORS (Cross-Origin Resource Sharing) rules.\n     * @see https://docs.microsoft.com/en-us/rest/api/storageservices/get-blob-service-properties\n     *\n     * @param options - Options to the Service Get Properties operation.\n     * @returns Response data for the Service Get Properties operation.\n     */\n    async getProperties(options = {}) {\n        return tracingClient.withSpan(\"BlobServiceClient-getProperties\", options, async (updatedOptions) => {\n            return assertResponse(await this.serviceContext.getProperties({\n                abortSignal: options.abortSignal,\n                tracingOptions: updatedOptions.tracingOptions,\n            }));\n        });\n    }\n    /**\n     * Sets properties for a storage account’s Blob service endpoint, including properties\n     * for Storage Analytics, CORS (Cross-Origin Resource Sharing) rules and soft delete settings.\n     * @see https://docs.microsoft.com/en-us/rest/api/storageservices/set-blob-service-properties\n     *\n     * @param properties -\n     * @param options - Options to the Service Set Properties operation.\n     * @returns Response data for the Service Set Properties operation.\n     */\n    async setProperties(properties, options = {}) {\n        return tracingClient.withSpan(\"BlobServiceClient-setProperties\", options, async (updatedOptions) => {\n            return assertResponse(await this.serviceContext.setProperties(properties, {\n                abortSignal: options.abortSignal,\n                tracingOptions: updatedOptions.tracingOptions,\n            }));\n        });\n    }\n    /**\n     * Retrieves statistics related to replication for the Blob service. It is only\n     * available on the secondary location endpoint when read-access geo-redundant\n     * replication is enabled for the storage account.\n     * @see https://docs.microsoft.com/en-us/rest/api/storageservices/get-blob-service-stats\n     *\n     * @param options - Options to the Service Get Statistics operation.\n     * @returns Response data for the Service Get Statistics operation.\n     */\n    async getStatistics(options = {}) {\n        return tracingClient.withSpan(\"BlobServiceClient-getStatistics\", options, async (updatedOptions) => {\n            return assertResponse(await this.serviceContext.getStatistics({\n                abortSignal: options.abortSignal,\n                tracingOptions: updatedOptions.tracingOptions,\n            }));\n        });\n    }\n    /**\n     * The Get Account Information operation returns the sku name and account kind\n     * for the specified account.\n     * The Get Account Information operation is available on service versions beginning\n     * with version 2018-03-28.\n     * @see https://docs.microsoft.com/en-us/rest/api/storageservices/get-account-information\n     *\n     * @param options - Options to the Service Get Account Info operation.\n     * @returns Response data for the Service Get Account Info operation.\n     */\n    async getAccountInfo(options = {}) {\n        return tracingClient.withSpan(\"BlobServiceClient-getAccountInfo\", options, async (updatedOptions) => {\n            return assertResponse(await this.serviceContext.getAccountInfo({\n                abortSignal: options.abortSignal,\n                tracingOptions: updatedOptions.tracingOptions,\n            }));\n        });\n    }\n    /**\n     * Returns a list of the containers under the specified account.\n     * @see https://docs.microsoft.com/en-us/rest/api/storageservices/list-containers2\n     *\n     * @param marker - A string value that identifies the portion of\n     *                        the list of containers to be returned with the next listing operation. The\n     *                        operation returns the continuationToken value within the response body if the\n     *                        listing operation did not return all containers remaining to be listed\n     *                        with the current page. The continuationToken value can be used as the value for\n     *                        the marker parameter in a subsequent call to request the next page of list\n     *                        items. The marker value is opaque to the client.\n     * @param options - Options to the Service List Container Segment operation.\n     * @returns Response data for the Service List Container Segment operation.\n     */\n    async listContainersSegment(marker, options = {}) {\n        return tracingClient.withSpan(\"BlobServiceClient-listContainersSegment\", options, async (updatedOptions) => {\n            return assertResponse(await this.serviceContext.listContainersSegment(Object.assign(Object.assign({ abortSignal: options.abortSignal, marker }, options), { include: typeof options.include === \"string\" ? [options.include] : options.include, tracingOptions: updatedOptions.tracingOptions })));\n        });\n    }\n    /**\n     * The Filter Blobs operation enables callers to list blobs across all containers whose tags\n     * match a given search expression. Filter blobs searches across all containers within a\n     * storage account but can be scoped within the expression to a single container.\n     *\n     * @param tagFilterSqlExpression - The where parameter enables the caller to query blobs whose tags match a given expression.\n     *                                        The given expression must evaluate to true for a blob to be returned in the results.\n     *                                        The[OData - ABNF] filter syntax rule defines the formal grammar for the value of the where query parameter;\n     *                                        however, only a subset of the OData filter syntax is supported in the Blob service.\n     * @param marker - A string value that identifies the portion of\n     *                          the list of blobs to be returned with the next listing operation. The\n     *                          operation returns the continuationToken value within the response body if the\n     *                          listing operation did not return all blobs remaining to be listed\n     *                          with the current page. The continuationToken value can be used as the value for\n     *                          the marker parameter in a subsequent call to request the next page of list\n     *                          items. The marker value is opaque to the client.\n     * @param options - Options to find blobs by tags.\n     */\n    async findBlobsByTagsSegment(tagFilterSqlExpression, marker, options = {}) {\n        return tracingClient.withSpan(\"BlobServiceClient-findBlobsByTagsSegment\", options, async (updatedOptions) => {\n            const response = assertResponse(await this.serviceContext.filterBlobs({\n                abortSignal: options.abortSignal,\n                where: tagFilterSqlExpression,\n                marker,\n                maxPageSize: options.maxPageSize,\n                tracingOptions: updatedOptions.tracingOptions,\n            }));\n            const wrappedResponse = Object.assign(Object.assign({}, response), { _response: response._response, blobs: response.blobs.map((blob) => {\n                    var _a;\n                    let tagValue = \"\";\n                    if (((_a = blob.tags) === null || _a === void 0 ? void 0 : _a.blobTagSet.length) === 1) {\n                        tagValue = blob.tags.blobTagSet[0].value;\n                    }\n                    return Object.assign(Object.assign({}, blob), { tags: toTags(blob.tags), tagValue });\n                }) });\n            return wrappedResponse;\n        });\n    }\n    /**\n     * Returns an AsyncIterableIterator for ServiceFindBlobsByTagsSegmentResponse.\n     *\n     * @param tagFilterSqlExpression -  The where parameter enables the caller to query blobs whose tags match a given expression.\n     *                                         The given expression must evaluate to true for a blob to be returned in the results.\n     *                                         The[OData - ABNF] filter syntax rule defines the formal grammar for the value of the where query parameter;\n     *                                         however, only a subset of the OData filter syntax is supported in the Blob service.\n     * @param marker - A string value that identifies the portion of\n     *                          the list of blobs to be returned with the next listing operation. The\n     *                          operation returns the continuationToken value within the response body if the\n     *                          listing operation did not return all blobs remaining to be listed\n     *                          with the current page. The continuationToken value can be used as the value for\n     *                          the marker parameter in a subsequent call to request the next page of list\n     *                          items. The marker value is opaque to the client.\n     * @param options - Options to find blobs by tags.\n     */\n    findBlobsByTagsSegments(tagFilterSqlExpression_1, marker_1) {\n        return __asyncGenerator(this, arguments, function* findBlobsByTagsSegments_1(tagFilterSqlExpression, marker, options = {}) {\n            let response;\n            if (!!marker || marker === undefined) {\n                do {\n                    response = yield __await(this.findBlobsByTagsSegment(tagFilterSqlExpression, marker, options));\n                    response.blobs = response.blobs || [];\n                    marker = response.continuationToken;\n                    yield yield __await(response);\n                } while (marker);\n            }\n        });\n    }\n    /**\n     * Returns an AsyncIterableIterator for blobs.\n     *\n     * @param tagFilterSqlExpression -  The where parameter enables the caller to query blobs whose tags match a given expression.\n     *                                         The given expression must evaluate to true for a blob to be returned in the results.\n     *                                         The[OData - ABNF] filter syntax rule defines the formal grammar for the value of the where query parameter;\n     *                                         however, only a subset of the OData filter syntax is supported in the Blob service.\n     * @param options - Options to findBlobsByTagsItems.\n     */\n    findBlobsByTagsItems(tagFilterSqlExpression_1) {\n        return __asyncGenerator(this, arguments, function* findBlobsByTagsItems_1(tagFilterSqlExpression, options = {}) {\n            var _a, e_1, _b, _c;\n            let marker;\n            try {\n                for (var _d = true, _e = __asyncValues(this.findBlobsByTagsSegments(tagFilterSqlExpression, marker, options)), _f; _f = yield __await(_e.next()), _a = _f.done, !_a; _d = true) {\n                    _c = _f.value;\n                    _d = false;\n                    const segment = _c;\n                    yield __await(yield* __asyncDelegator(__asyncValues(segment.blobs)));\n                }\n            }\n            catch (e_1_1) { e_1 = { error: e_1_1 }; }\n            finally {\n                try {\n                    if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));\n                }\n                finally { if (e_1) throw e_1.error; }\n            }\n        });\n    }\n    /**\n     * Returns an async iterable iterator to find all blobs with specified tag\n     * under the specified account.\n     *\n     * .byPage() returns an async iterable iterator to list the blobs in pages.\n     *\n     * @see https://docs.microsoft.com/en-us/rest/api/storageservices/get-blob-service-properties\n     *\n     * Example using `for await` syntax:\n     *\n     * ```js\n     * let i = 1;\n     * for await (const blob of blobServiceClient.findBlobsByTags(\"tagkey='tagvalue'\")) {\n     *   console.log(`Blob ${i++}: ${container.name}`);\n     * }\n     * ```\n     *\n     * Example using `iter.next()`:\n     *\n     * ```js\n     * let i = 1;\n     * const iter = blobServiceClient.findBlobsByTags(\"tagkey='tagvalue'\");\n     * let blobItem = await iter.next();\n     * while (!blobItem.done) {\n     *   console.log(`Blob ${i++}: ${blobItem.value.name}`);\n     *   blobItem = await iter.next();\n     * }\n     * ```\n     *\n     * Example using `byPage()`:\n     *\n     * ```js\n     * // passing optional maxPageSize in the page settings\n     * let i = 1;\n     * for await (const response of blobServiceClient.findBlobsByTags(\"tagkey='tagvalue'\").byPage({ maxPageSize: 20 })) {\n     *   if (response.blobs) {\n     *     for (const blob of response.blobs) {\n     *       console.log(`Blob ${i++}: ${blob.name}`);\n     *     }\n     *   }\n     * }\n     * ```\n     *\n     * Example using paging with a marker:\n     *\n     * ```js\n     * let i = 1;\n     * let iterator = blobServiceClient.findBlobsByTags(\"tagkey='tagvalue'\").byPage({ maxPageSize: 2 });\n     * let response = (await iterator.next()).value;\n     *\n     * // Prints 2 blob names\n     * if (response.blobs) {\n     *   for (const blob of response.blobs) {\n     *     console.log(`Blob ${i++}: ${blob.name}`);\n     *   }\n     * }\n     *\n     * // Gets next marker\n     * let marker = response.continuationToken;\n     * // Passing next marker as continuationToken\n     * iterator = blobServiceClient\n     *   .findBlobsByTags(\"tagkey='tagvalue'\")\n     *   .byPage({ continuationToken: marker, maxPageSize: 10 });\n     * response = (await iterator.next()).value;\n     *\n     * // Prints blob names\n     * if (response.blobs) {\n     *   for (const blob of response.blobs) {\n     *      console.log(`Blob ${i++}: ${blob.name}`);\n     *   }\n     * }\n     * ```\n     *\n     * @param tagFilterSqlExpression -  The where parameter enables the caller to query blobs whose tags match a given expression.\n     *                                         The given expression must evaluate to true for a blob to be returned in the results.\n     *                                         The[OData - ABNF] filter syntax rule defines the formal grammar for the value of the where query parameter;\n     *                                         however, only a subset of the OData filter syntax is supported in the Blob service.\n     * @param options - Options to find blobs by tags.\n     */\n    findBlobsByTags(tagFilterSqlExpression, options = {}) {\n        // AsyncIterableIterator to iterate over blobs\n        const listSegmentOptions = Object.assign({}, options);\n        const iter = this.findBlobsByTagsItems(tagFilterSqlExpression, listSegmentOptions);\n        return {\n            /**\n             * The next method, part of the iteration protocol\n             */\n            next() {\n                return iter.next();\n            },\n            /**\n             * The connection to the async iterator, part of the iteration protocol\n             */\n            [Symbol.asyncIterator]() {\n                return this;\n            },\n            /**\n             * Return an AsyncIterableIterator that works a page at a time\n             */\n            byPage: (settings = {}) => {\n                return this.findBlobsByTagsSegments(tagFilterSqlExpression, settings.continuationToken, Object.assign({ maxPageSize: settings.maxPageSize }, listSegmentOptions));\n            },\n        };\n    }\n    /**\n     * Returns an AsyncIterableIterator for ServiceListContainersSegmentResponses\n     *\n     * @param marker - A string value that identifies the portion of\n     *                        the list of containers to be returned with the next listing operation. The\n     *                        operation returns the continuationToken value within the response body if the\n     *                        listing operation did not return all containers remaining to be listed\n     *                        with the current page. The continuationToken value can be used as the value for\n     *                        the marker parameter in a subsequent call to request the next page of list\n     *                        items. The marker value is opaque to the client.\n     * @param options - Options to list containers operation.\n     */\n    listSegments(marker_1) {\n        return __asyncGenerator(this, arguments, function* listSegments_1(marker, options = {}) {\n            let listContainersSegmentResponse;\n            if (!!marker || marker === undefined) {\n                do {\n                    listContainersSegmentResponse = yield __await(this.listContainersSegment(marker, options));\n                    listContainersSegmentResponse.containerItems =\n                        listContainersSegmentResponse.containerItems || [];\n                    marker = listContainersSegmentResponse.continuationToken;\n                    yield yield __await(yield __await(listContainersSegmentResponse));\n                } while (marker);\n            }\n        });\n    }\n    /**\n     * Returns an AsyncIterableIterator for Container Items\n     *\n     * @param options - Options to list containers operation.\n     */\n    listItems() {\n        return __asyncGenerator(this, arguments, function* listItems_1(options = {}) {\n            var _a, e_2, _b, _c;\n            let marker;\n            try {\n                for (var _d = true, _e = __asyncValues(this.listSegments(marker, options)), _f; _f = yield __await(_e.next()), _a = _f.done, !_a; _d = true) {\n                    _c = _f.value;\n                    _d = false;\n                    const segment = _c;\n                    yield __await(yield* __asyncDelegator(__asyncValues(segment.containerItems)));\n                }\n            }\n            catch (e_2_1) { e_2 = { error: e_2_1 }; }\n            finally {\n                try {\n                    if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));\n                }\n                finally { if (e_2) throw e_2.error; }\n            }\n        });\n    }\n    /**\n     * Returns an async iterable iterator to list all the containers\n     * under the specified account.\n     *\n     * .byPage() returns an async iterable iterator to list the containers in pages.\n     *\n     * Example using `for await` syntax:\n     *\n     * ```js\n     * let i = 1;\n     * for await (const container of blobServiceClient.listContainers()) {\n     *   console.log(`Container ${i++}: ${container.name}`);\n     * }\n     * ```\n     *\n     * Example using `iter.next()`:\n     *\n     * ```js\n     * let i = 1;\n     * const iter = blobServiceClient.listContainers();\n     * let containerItem = await iter.next();\n     * while (!containerItem.done) {\n     *   console.log(`Container ${i++}: ${containerItem.value.name}`);\n     *   containerItem = await iter.next();\n     * }\n     * ```\n     *\n     * Example using `byPage()`:\n     *\n     * ```js\n     * // passing optional maxPageSize in the page settings\n     * let i = 1;\n     * for await (const response of blobServiceClient.listContainers().byPage({ maxPageSize: 20 })) {\n     *   if (response.containerItems) {\n     *     for (const container of response.containerItems) {\n     *       console.log(`Container ${i++}: ${container.name}`);\n     *     }\n     *   }\n     * }\n     * ```\n     *\n     * Example using paging with a marker:\n     *\n     * ```js\n     * let i = 1;\n     * let iterator = blobServiceClient.listContainers().byPage({ maxPageSize: 2 });\n     * let response = (await iterator.next()).value;\n     *\n     * // Prints 2 container names\n     * if (response.containerItems) {\n     *   for (const container of response.containerItems) {\n     *     console.log(`Container ${i++}: ${container.name}`);\n     *   }\n     * }\n     *\n     * // Gets next marker\n     * let marker = response.continuationToken;\n     * // Passing next marker as continuationToken\n     * iterator = blobServiceClient\n     *   .listContainers()\n     *   .byPage({ continuationToken: marker, maxPageSize: 10 });\n     * response = (await iterator.next()).value;\n     *\n     * // Prints 10 container names\n     * if (response.containerItems) {\n     *   for (const container of response.containerItems) {\n     *      console.log(`Container ${i++}: ${container.name}`);\n     *   }\n     * }\n     * ```\n     *\n     * @param options - Options to list containers.\n     * @returns An asyncIterableIterator that supports paging.\n     */\n    listContainers(options = {}) {\n        if (options.prefix === \"\") {\n            options.prefix = undefined;\n        }\n        const include = [];\n        if (options.includeDeleted) {\n            include.push(\"deleted\");\n        }\n        if (options.includeMetadata) {\n            include.push(\"metadata\");\n        }\n        if (options.includeSystem) {\n            include.push(\"system\");\n        }\n        // AsyncIterableIterator to iterate over containers\n        const listSegmentOptions = Object.assign(Object.assign({}, options), (include.length > 0 ? { include } : {}));\n        const iter = this.listItems(listSegmentOptions);\n        return {\n            /**\n             * The next method, part of the iteration protocol\n             */\n            next() {\n                return iter.next();\n            },\n            /**\n             * The connection to the async iterator, part of the iteration protocol\n             */\n            [Symbol.asyncIterator]() {\n                return this;\n            },\n            /**\n             * Return an AsyncIterableIterator that works a page at a time\n             */\n            byPage: (settings = {}) => {\n                return this.listSegments(settings.continuationToken, Object.assign({ maxPageSize: settings.maxPageSize }, listSegmentOptions));\n            },\n        };\n    }\n    /**\n     * ONLY AVAILABLE WHEN USING BEARER TOKEN AUTHENTICATION (TokenCredential).\n     *\n     * Retrieves a user delegation key for the Blob service. This is only a valid operation when using\n     * bearer token authentication.\n     *\n     * @see https://docs.microsoft.com/en-us/rest/api/storageservices/get-user-delegation-key\n     *\n     * @param startsOn -      The start time for the user delegation SAS. Must be within 7 days of the current time\n     * @param expiresOn -     The end time for the user delegation SAS. Must be within 7 days of the current time\n     */\n    async getUserDelegationKey(startsOn, expiresOn, options = {}) {\n        return tracingClient.withSpan(\"BlobServiceClient-getUserDelegationKey\", options, async (updatedOptions) => {\n            const response = assertResponse(await this.serviceContext.getUserDelegationKey({\n                startsOn: truncatedISO8061Date(startsOn, false),\n                expiresOn: truncatedISO8061Date(expiresOn, false),\n            }, {\n                abortSignal: options.abortSignal,\n                tracingOptions: updatedOptions.tracingOptions,\n            }));\n            const userDelegationKey = {\n                signedObjectId: response.signedObjectId,\n                signedTenantId: response.signedTenantId,\n                signedStartsOn: new Date(response.signedStartsOn),\n                signedExpiresOn: new Date(response.signedExpiresOn),\n                signedService: response.signedService,\n                signedVersion: response.signedVersion,\n                value: response.value,\n            };\n            const res = Object.assign({ _response: response._response, requestId: response.requestId, clientRequestId: response.clientRequestId, version: response.version, date: response.date, errorCode: response.errorCode }, userDelegationKey);\n            return res;\n        });\n    }\n    /**\n     * Creates a BlobBatchClient object to conduct batch operations.\n     *\n     * @see https://docs.microsoft.com/en-us/rest/api/storageservices/blob-batch\n     *\n     * @returns A new BlobBatchClient object for this service.\n     */\n    getBlobBatchClient() {\n        return new BlobBatchClient(this.url, this.pipeline);\n    }\n    /**\n     * Only available for BlobServiceClient constructed with a shared key credential.\n     *\n     * Generates a Blob account Shared Access Signature (SAS) URI based on the client properties\n     * and parameters passed in. The SAS is signed by the shared key credential of the client.\n     *\n     * @see https://docs.microsoft.com/en-us/rest/api/storageservices/create-account-sas\n     *\n     * @param expiresOn - Optional. The time at which the shared access signature becomes invalid. Default to an hour later if not provided.\n     * @param permissions - Specifies the list of permissions to be associated with the SAS.\n     * @param resourceTypes - Specifies the resource types associated with the shared access signature.\n     * @param options - Optional parameters.\n     * @returns An account SAS URI consisting of the URI to the resource represented by this client, followed by the generated SAS token.\n     */\n    generateAccountSasUrl(expiresOn, permissions = AccountSASPermissions.parse(\"r\"), resourceTypes = \"sco\", options = {}) {\n        if (!(this.credential instanceof StorageSharedKeyCredential)) {\n            throw RangeError(\"Can only generate the account SAS when the client is initialized with a shared key credential\");\n        }\n        if (expiresOn === undefined) {\n            const now = new Date();\n            expiresOn = new Date(now.getTime() + 3600 * 1000);\n        }\n        const sas = generateAccountSASQueryParameters(Object.assign({ permissions,\n            expiresOn,\n            resourceTypes, services: AccountSASServices.parse(\"b\").toString() }, options), this.credential).toString();\n        return appendToURLQuery(this.url, sas);\n    }\n    /**\n     * Only available for BlobServiceClient constructed with a shared key credential.\n     *\n     * Generates string to sign for a Blob account Shared Access Signature (SAS) URI based on\n     * the client properties and parameters passed in. The SAS is signed by the shared key credential of the client.\n     *\n     * @see https://docs.microsoft.com/en-us/rest/api/storageservices/create-account-sas\n     *\n     * @param expiresOn - Optional. The time at which the shared access signature becomes invalid. Default to an hour later if not provided.\n     * @param permissions - Specifies the list of permissions to be associated with the SAS.\n     * @param resourceTypes - Specifies the resource types associated with the shared access signature.\n     * @param options - Optional parameters.\n     * @returns An account SAS URI consisting of the URI to the resource represented by this client, followed by the generated SAS token.\n     */\n    generateSasStringToSign(expiresOn, permissions = AccountSASPermissions.parse(\"r\"), resourceTypes = \"sco\", options = {}) {\n        if (!(this.credential instanceof StorageSharedKeyCredential)) {\n            throw RangeError(\"Can only generate the account SAS when the client is initialized with a shared key credential\");\n        }\n        if (expiresOn === undefined) {\n            const now = new Date();\n            expiresOn = new Date(now.getTime() + 3600 * 1000);\n        }\n        return generateAccountSASQueryParametersInternal(Object.assign({ permissions,\n            expiresOn,\n            resourceTypes, services: AccountSASServices.parse(\"b\").toString() }, options), this.credential).stringToSign;\n    }\n}\n//# sourceMappingURL=BlobServiceClient.js.map"],"names":["BlobBatch","constructor","this","batch","batchRequest","InnerBatchRequest","getMultiPartContentType","getMultipartContentType","getHttpRequestBody","getSubRequests","addSubRequestInternal","subRequest","assembleSubRequestFunc","lock","preAddSubRequest","postAddSubRequest","unlock","setBatchType","batchType","RangeError","deleteBlob","urlOrBlobClient","credentialOrOptions","options","url","credential","withSpan","async","updatedOptions","createPipeline","delete","setBlobAccessTier","credentialOrTier","tierOrOptions","tier","setAccessTier","operationCount","body","tempGuid","boundary","subRequestPrefix","CONTENT_TYPE","CONTENT_TRANSFER_ENCODING","multipartContentType","batchRequestEnding","subRequests","Map","corePipeline","addPolicy","stringifyXML","serializerOptions","xml","xmlCharKey","phase","name","sendRequest","request","next","xMsHeaderName","headers","X_MS_VERSION","appendSubRequestToBody","status","afterPhase","scopes","challengeCallbacks","authorizeRequestOnChallenge","accountName","accountKey","pipeline","_credential","_corePipeline","CONTENT_ID","method","toString","join","value","path","set","HTTP_HEADER_DELIMITER","BatchResponseParser","batchResponse","contentType","size","responseBatchBoundary","split","perResponsePrefix","batchResponseEnding","parseBatchResponse","_response","HTTP_ACCEPTED","Error","subResponses","blob","blobBody","getBodyAsText","slice","subResponseCount","length","deserializedSubResponses","Array","subResponsesSucceededCount","subResponsesFailedCount","index","subResponse","deserializedSubResponse","responseLines","subRespHeaderStartFound","subRespHeaderEndFound","subRespFailed","contentId","responseLine","trim","bodyAsText","indexOf","tokens","X_MS_ERROR_CODE","errorCode","startsWith","parseInt","statusMessage","Number","isInteger","undefined","_request","get","log","error","BlobBatchClient","credentialOrPipeline","AnonymousCredential","storageClientContext","StorageContextClient","S","serviceOrContainerContext","container","service","createBatch","deleteBlobs","urlsOrBlobClients","submitBatch","setBlobsAccessTier","tracing","batchRequestBody","rawBatchResponse","str","Blob","Object","assign","batchResponseParser","responseSummary","requestId","clientRequestId","version","BlobDownloadResponse","BlobLeaseClient","leaseId","_leaseId","_url","client","clientContext","_isContainer","_containerOrBlobOperation","acquireLease","duration","_a","_b","_c","_d","_e","conditions","ifMatch","ifNoneMatch","tagConditions","abortSignal","modifiedAccessConditions","ifTags","proposedLeaseId","tracingOptions","changeLease","response","releaseLease","renewLease","breakLease","breakPeriod","operationOptions","BlobQueryResponse","acceptRanges","originalResponse","cacheControl","contentDisposition","contentEncoding","contentLanguage","blobSequenceNumber","blobType","contentLength","contentMD5","contentRange","copyCompletedOn","copyId","copyProgress","copySource","copyStatus","copyStatusDescription","leaseDuration","leaseState","leaseStatus","date","blobCommittedBlockCount","etag","isServerEncrypted","blobContentMD5","lastModified","metadata","encryptionKeySha256","contentCrc64","readableStreamBody","_options","BlobServiceClient","fromConnectionString","connectionString","extractedCreds","kind","sharedKeyCredential","proxyOptions","proxyUri","accountSas","super","serviceContext","getContainerClient","containerName","encodeURIComponent","createContainer","containerClient","containerCreateResponse","create","deleteContainer","undeleteContainer","deletedContainerName","deletedContainerVersion","destinationContainerName","containerContext","containerUndeleteResponse","restore","renameContainer","sourceContainerName","containerRenameResponse","rename","sourceLeaseId","sourceCondition","getProperties","setProperties","properties","getStatistics","getAccountInfo","listContainersSegment","marker","include","findBlobsByTagsSegment","tagFilterSqlExpression","filterBlobs","where","maxPageSize","blobs","map","tagValue","tags","blobTagSet","findBlobsByTagsSegments","tagFilterSqlExpression_1","marker_1","arguments","continuationToken","findBlobsByTagsItems","e_1","_f","done","segment","e_1_1","return","call","findBlobsByTags","listSegmentOptions","iter","Symbol","asyncIterator","byPage","settings","listSegments","listContainersSegmentResponse","containerItems","listItems","e_2","e_2_1","listContainers","prefix","includeDeleted","push","includeMetadata","includeSystem","getUserDelegationKey","startsOn","expiresOn","userDelegationKey","signedObjectId","signedTenantId","signedStartsOn","Date","signedExpiresOn","signedService","signedVersion","getBlobBatchClient","generateAccountSasUrl","permissions","parse","resourceTypes","now","getTime","sas","services","generateSasStringToSign","stringToSign"],"sourceRoot":""}