{"version":3,"file":"static/js/1377_9c5fe3ef0d8fe362566d.js","mappings":"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","sources":["file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+storage-blob@12.15.0/node_modules/@azure/storage-blob/dist-esm/storage-blob/src/ContainerClient.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+storage-blob@12.15.0/node_modules/@azure/storage-blob/dist-esm/storage-blob/src/PageBlobRangeResponse.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+storage-blob@12.15.0/node_modules/@azure/storage-blob/dist-esm/storage-blob/src/Pipeline.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@azure+storage-blob@12.15.0/node_modules/@azure/storage-blob/dist-esm/storage-blob/src/Range.js"],"sourcesContent":["import { __asyncDelegator, __asyncGenerator, __asyncValues, __await } from \"tslib\";\nimport { getDefaultProxySettings, isNode, isTokenCredential, URLBuilder, } from \"@azure/core-http\";\nimport { SpanStatusCode } from \"@azure/core-tracing\";\nimport { AnonymousCredential } from \"./credentials/AnonymousCredential\";\nimport { StorageSharedKeyCredential } from \"./credentials/StorageSharedKeyCredential\";\nimport { Container } from \"./generated/src/operations\";\nimport { newPipeline, isPipelineLike } from \"./Pipeline\";\nimport { StorageClient } from \"./StorageClient\";\nimport { convertTracingToRequestOptionsBase, createSpan } from \"./utils/tracing\";\nimport { appendToURLPath, appendToURLQuery, BlobNameToString, ConvertInternalResponseOfListBlobFlat, ConvertInternalResponseOfListBlobHierarchy, EscapePath, extractConnectionStringParts, isIpEndpointStyle, parseObjectReplicationRecord, toTags, truncatedISO8061Date, } from \"./utils/utils.common\";\nimport { generateBlobSASQueryParameters } from \"./sas/BlobSASSignatureValues\";\nimport { BlobLeaseClient } from \"./BlobLeaseClient\";\nimport { AppendBlobClient, BlobClient, BlockBlobClient, PageBlobClient, } from \"./Clients\";\nimport { BlobBatchClient } from \"./BlobBatchClient\";\n/**\n * A ContainerClient represents a URL to the Azure Storage container allowing you to manipulate its blobs.\n */\nexport class ContainerClient extends StorageClient {\n    constructor(urlOrConnectionString, credentialOrPipelineOrContainerName, \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        let url;\n        options = options || {};\n        if (isPipelineLike(credentialOrPipelineOrContainerName)) {\n            // (url: string, pipeline: Pipeline)\n            url = urlOrConnectionString;\n            pipeline = credentialOrPipelineOrContainerName;\n        }\n        else if ((isNode && credentialOrPipelineOrContainerName instanceof StorageSharedKeyCredential) ||\n            credentialOrPipelineOrContainerName instanceof AnonymousCredential ||\n            isTokenCredential(credentialOrPipelineOrContainerName)) {\n            // (url: string, credential?: StorageSharedKeyCredential | AnonymousCredential | TokenCredential, options?: StoragePipelineOptions)\n            url = urlOrConnectionString;\n            pipeline = newPipeline(credentialOrPipelineOrContainerName, options);\n        }\n        else if (!credentialOrPipelineOrContainerName &&\n            typeof credentialOrPipelineOrContainerName !== \"string\") {\n            // (url: string, credential?: StorageSharedKeyCredential | AnonymousCredential | TokenCredential, options?: StoragePipelineOptions)\n            // The second parameter is undefined. Use anonymous credential.\n            url = urlOrConnectionString;\n            pipeline = newPipeline(new AnonymousCredential(), options);\n        }\n        else if (credentialOrPipelineOrContainerName &&\n            typeof credentialOrPipelineOrContainerName === \"string\") {\n            // (connectionString: string, containerName: string, blobName: string, options?: StoragePipelineOptions)\n            const containerName = credentialOrPipelineOrContainerName;\n            const extractedCreds = extractConnectionStringParts(urlOrConnectionString);\n            if (extractedCreds.kind === \"AccountConnString\") {\n                if (isNode) {\n                    const sharedKeyCredential = new StorageSharedKeyCredential(extractedCreds.accountName, extractedCreds.accountKey);\n                    url = appendToURLPath(extractedCreds.url, encodeURIComponent(containerName));\n                    if (!options.proxyOptions) {\n                        options.proxyOptions = getDefaultProxySettings(extractedCreds.proxyUri);\n                    }\n                    pipeline = newPipeline(sharedKeyCredential, options);\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                url =\n                    appendToURLPath(extractedCreds.url, encodeURIComponent(containerName)) +\n                        \"?\" +\n                        extractedCreds.accountSas;\n                pipeline = newPipeline(new AnonymousCredential(), options);\n            }\n            else {\n                throw new Error(\"Connection string must be either an Account connection string or a SAS connection string\");\n            }\n        }\n        else {\n            throw new Error(\"Expecting non-empty strings for containerName parameter\");\n        }\n        super(url, pipeline);\n        this._containerName = this.getContainerNameFromUrl();\n        this.containerContext = new Container(this.storageClientContext);\n    }\n    /**\n     * The name of the container.\n     */\n    get containerName() {\n        return this._containerName;\n    }\n    /**\n     * Creates a new container under the specified account. If the container with\n     * the same name already exists, the operation fails.\n     * @see https://docs.microsoft.com/en-us/rest/api/storageservices/create-container\n     * Naming rules: @see https://learn.microsoft.com/rest/api/storageservices/naming-and-referencing-containers--blobs--and-metadata\n     *\n     * @param options - Options to Container Create operation.\n     *\n     *\n     * Example usage:\n     *\n     * ```js\n     * const containerClient = blobServiceClient.getContainerClient(\"<container name>\");\n     * const createContainerResponse = await containerClient.create();\n     * console.log(\"Container was created successfully\", createContainerResponse.requestId);\n     * ```\n     */\n    async create(options = {}) {\n        const { span, updatedOptions } = createSpan(\"ContainerClient-create\", options);\n        try {\n            // Spread operator in destructuring assignments,\n            // this will filter out unwanted properties from the response object into result object\n            return await this.containerContext.create(Object.assign(Object.assign({}, options), convertTracingToRequestOptionsBase(updatedOptions)));\n        }\n        catch (e) {\n            span.setStatus({\n                code: SpanStatusCode.ERROR,\n                message: e.message,\n            });\n            throw e;\n        }\n        finally {\n            span.end();\n        }\n    }\n    /**\n     * Creates a new container under the specified account. If the container with\n     * the same name already exists, it is not changed.\n     * @see https://docs.microsoft.com/en-us/rest/api/storageservices/create-container\n     * Naming rules: @see https://learn.microsoft.com/rest/api/storageservices/naming-and-referencing-containers--blobs--and-metadata\n     *\n     * @param options -\n     */\n    async createIfNotExists(options = {}) {\n        var _a, _b;\n        const { span, updatedOptions } = createSpan(\"ContainerClient-createIfNotExists\", options);\n        try {\n            const res = await this.create(updatedOptions);\n            return Object.assign(Object.assign({ succeeded: true }, res), { _response: res._response });\n        }\n        catch (e) {\n            if (((_a = e.details) === null || _a === void 0 ? void 0 : _a.errorCode) === \"ContainerAlreadyExists\") {\n                span.setStatus({\n                    code: SpanStatusCode.ERROR,\n                    message: \"Expected exception when creating a container only if it does not already exist.\",\n                });\n                return Object.assign(Object.assign({ succeeded: false }, (_b = e.response) === null || _b === void 0 ? void 0 : _b.parsedHeaders), { _response: e.response });\n            }\n            span.setStatus({\n                code: SpanStatusCode.ERROR,\n                message: e.message,\n            });\n            throw e;\n        }\n        finally {\n            span.end();\n        }\n    }\n    /**\n     * Returns true if the Azure container resource represented by this client exists; false otherwise.\n     *\n     * NOTE: use this function with care since an existing container might be deleted by other clients or\n     * applications. Vice versa new containers with the same name might be added by other clients or\n     * applications after this function completes.\n     *\n     * @param options -\n     */\n    async exists(options = {}) {\n        const { span, updatedOptions } = createSpan(\"ContainerClient-exists\", options);\n        try {\n            await this.getProperties({\n                abortSignal: options.abortSignal,\n                tracingOptions: updatedOptions.tracingOptions,\n            });\n            return true;\n        }\n        catch (e) {\n            if (e.statusCode === 404) {\n                span.setStatus({\n                    code: SpanStatusCode.ERROR,\n                    message: \"Expected exception when checking container existence\",\n                });\n                return false;\n            }\n            span.setStatus({\n                code: SpanStatusCode.ERROR,\n                message: e.message,\n            });\n            throw e;\n        }\n        finally {\n            span.end();\n        }\n    }\n    /**\n     * Creates a {@link BlobClient}\n     *\n     * @param blobName - A blob name\n     * @returns A new BlobClient object for the given blob name.\n     */\n    getBlobClient(blobName) {\n        return new BlobClient(appendToURLPath(this.url, EscapePath(blobName)), this.pipeline);\n    }\n    /**\n     * Creates an {@link AppendBlobClient}\n     *\n     * @param blobName - An append blob name\n     */\n    getAppendBlobClient(blobName) {\n        return new AppendBlobClient(appendToURLPath(this.url, EscapePath(blobName)), this.pipeline);\n    }\n    /**\n     * Creates a {@link BlockBlobClient}\n     *\n     * @param blobName - A block blob name\n     *\n     *\n     * Example usage:\n     *\n     * ```js\n     * const content = \"Hello world!\";\n     *\n     * const blockBlobClient = containerClient.getBlockBlobClient(\"<blob name>\");\n     * const uploadBlobResponse = await blockBlobClient.upload(content, content.length);\n     * ```\n     */\n    getBlockBlobClient(blobName) {\n        return new BlockBlobClient(appendToURLPath(this.url, EscapePath(blobName)), this.pipeline);\n    }\n    /**\n     * Creates a {@link PageBlobClient}\n     *\n     * @param blobName - A page blob name\n     */\n    getPageBlobClient(blobName) {\n        return new PageBlobClient(appendToURLPath(this.url, EscapePath(blobName)), this.pipeline);\n    }\n    /**\n     * Returns all user-defined metadata and system properties for the specified\n     * container. The data returned does not include the container's list of blobs.\n     * @see https://docs.microsoft.com/en-us/rest/api/storageservices/get-container-properties\n     *\n     * WARNING: The `metadata` object returned in the response will have its keys in lowercase, even if\n     * they originally contained uppercase characters. This differs from the metadata keys returned by\n     * the `listContainers` method of {@link BlobServiceClient} using the `includeMetadata` option, which\n     * will retain their original casing.\n     *\n     * @param options - Options to Container Get Properties operation.\n     */\n    async getProperties(options = {}) {\n        if (!options.conditions) {\n            options.conditions = {};\n        }\n        const { span, updatedOptions } = createSpan(\"ContainerClient-getProperties\", options);\n        try {\n            return await this.containerContext.getProperties(Object.assign(Object.assign({ abortSignal: options.abortSignal }, options.conditions), convertTracingToRequestOptionsBase(updatedOptions)));\n        }\n        catch (e) {\n            span.setStatus({\n                code: SpanStatusCode.ERROR,\n                message: e.message,\n            });\n            throw e;\n        }\n        finally {\n            span.end();\n        }\n    }\n    /**\n     * Marks the specified container for deletion. The container and any blobs\n     * contained within it are later deleted during garbage collection.\n     * @see https://docs.microsoft.com/en-us/rest/api/storageservices/delete-container\n     *\n     * @param options - Options to Container Delete operation.\n     */\n    async delete(options = {}) {\n        if (!options.conditions) {\n            options.conditions = {};\n        }\n        const { span, updatedOptions } = createSpan(\"ContainerClient-delete\", options);\n        try {\n            return await this.containerContext.delete(Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, modifiedAccessConditions: options.conditions }, convertTracingToRequestOptionsBase(updatedOptions)));\n        }\n        catch (e) {\n            span.setStatus({\n                code: SpanStatusCode.ERROR,\n                message: e.message,\n            });\n            throw e;\n        }\n        finally {\n            span.end();\n        }\n    }\n    /**\n     * Marks the specified container for deletion if it exists. The container and any blobs\n     * contained within it are later deleted during garbage collection.\n     * @see https://docs.microsoft.com/en-us/rest/api/storageservices/delete-container\n     *\n     * @param options - Options to Container Delete operation.\n     */\n    async deleteIfExists(options = {}) {\n        var _a, _b;\n        const { span, updatedOptions } = createSpan(\"ContainerClient-deleteIfExists\", options);\n        try {\n            const res = await this.delete(updatedOptions);\n            return Object.assign(Object.assign({ succeeded: true }, res), { _response: res._response });\n        }\n        catch (e) {\n            if (((_a = e.details) === null || _a === void 0 ? void 0 : _a.errorCode) === \"ContainerNotFound\") {\n                span.setStatus({\n                    code: SpanStatusCode.ERROR,\n                    message: \"Expected exception when deleting a container only if it exists.\",\n                });\n                return Object.assign(Object.assign({ succeeded: false }, (_b = e.response) === null || _b === void 0 ? void 0 : _b.parsedHeaders), { _response: e.response });\n            }\n            span.setStatus({\n                code: SpanStatusCode.ERROR,\n                message: e.message,\n            });\n            throw e;\n        }\n        finally {\n            span.end();\n        }\n    }\n    /**\n     * Sets one or more user-defined name-value pairs for the specified container.\n     *\n     * If no option provided, or no metadata defined in the parameter, the container\n     * metadata will be removed.\n     *\n     * @see https://docs.microsoft.com/en-us/rest/api/storageservices/set-container-metadata\n     *\n     * @param metadata - Replace existing metadata with this value.\n     *                            If no value provided the existing metadata will be removed.\n     * @param options - Options to Container Set Metadata operation.\n     */\n    async setMetadata(metadata, options = {}) {\n        if (!options.conditions) {\n            options.conditions = {};\n        }\n        if (options.conditions.ifUnmodifiedSince) {\n            throw new RangeError(\"the IfUnmodifiedSince must have their default values because they are ignored by the blob service\");\n        }\n        const { span, updatedOptions } = createSpan(\"ContainerClient-setMetadata\", options);\n        try {\n            return await this.containerContext.setMetadata(Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, metadata, modifiedAccessConditions: options.conditions }, convertTracingToRequestOptionsBase(updatedOptions)));\n        }\n        catch (e) {\n            span.setStatus({\n                code: SpanStatusCode.ERROR,\n                message: e.message,\n            });\n            throw e;\n        }\n        finally {\n            span.end();\n        }\n    }\n    /**\n     * Gets the permissions for the specified container. The permissions indicate\n     * whether container data may be accessed publicly.\n     *\n     * WARNING: JavaScript Date will potentially lose precision when parsing startsOn and expiresOn strings.\n     * For example, new Date(\"2018-12-31T03:44:23.8827891Z\").toISOString() will get \"2018-12-31T03:44:23.882Z\".\n     *\n     * @see https://docs.microsoft.com/en-us/rest/api/storageservices/get-container-acl\n     *\n     * @param options - Options to Container Get Access Policy operation.\n     */\n    async getAccessPolicy(options = {}) {\n        if (!options.conditions) {\n            options.conditions = {};\n        }\n        const { span, updatedOptions } = createSpan(\"ContainerClient-getAccessPolicy\", options);\n        try {\n            const response = await this.containerContext.getAccessPolicy(Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions }, convertTracingToRequestOptionsBase(updatedOptions)));\n            const res = {\n                _response: response._response,\n                blobPublicAccess: response.blobPublicAccess,\n                date: response.date,\n                etag: response.etag,\n                errorCode: response.errorCode,\n                lastModified: response.lastModified,\n                requestId: response.requestId,\n                clientRequestId: response.clientRequestId,\n                signedIdentifiers: [],\n                version: response.version,\n            };\n            for (const identifier of response) {\n                let accessPolicy = undefined;\n                if (identifier.accessPolicy) {\n                    accessPolicy = {\n                        permissions: identifier.accessPolicy.permissions,\n                    };\n                    if (identifier.accessPolicy.expiresOn) {\n                        accessPolicy.expiresOn = new Date(identifier.accessPolicy.expiresOn);\n                    }\n                    if (identifier.accessPolicy.startsOn) {\n                        accessPolicy.startsOn = new Date(identifier.accessPolicy.startsOn);\n                    }\n                }\n                res.signedIdentifiers.push({\n                    accessPolicy,\n                    id: identifier.id,\n                });\n            }\n            return res;\n        }\n        catch (e) {\n            span.setStatus({\n                code: SpanStatusCode.ERROR,\n                message: e.message,\n            });\n            throw e;\n        }\n        finally {\n            span.end();\n        }\n    }\n    /**\n     * Sets the permissions for the specified container. The permissions indicate\n     * whether blobs in a container may be accessed publicly.\n     *\n     * When you set permissions for a container, the existing permissions are replaced.\n     * If no access or containerAcl provided, the existing container ACL will be\n     * removed.\n     *\n     * When you establish a stored access policy on a container, it may take up to 30 seconds to take effect.\n     * During this interval, a shared access signature that is associated with the stored access policy will\n     * fail with status code 403 (Forbidden), until the access policy becomes active.\n     * @see https://docs.microsoft.com/en-us/rest/api/storageservices/set-container-acl\n     *\n     * @param access - The level of public access to data in the container.\n     * @param containerAcl - Array of elements each having a unique Id and details of the access policy.\n     * @param options - Options to Container Set Access Policy operation.\n     */\n    async setAccessPolicy(access, containerAcl, options = {}) {\n        options.conditions = options.conditions || {};\n        const { span, updatedOptions } = createSpan(\"ContainerClient-setAccessPolicy\", options);\n        try {\n            const acl = [];\n            for (const identifier of containerAcl || []) {\n                acl.push({\n                    accessPolicy: {\n                        expiresOn: identifier.accessPolicy.expiresOn\n                            ? truncatedISO8061Date(identifier.accessPolicy.expiresOn)\n                            : \"\",\n                        permissions: identifier.accessPolicy.permissions,\n                        startsOn: identifier.accessPolicy.startsOn\n                            ? truncatedISO8061Date(identifier.accessPolicy.startsOn)\n                            : \"\",\n                    },\n                    id: identifier.id,\n                });\n            }\n            return await this.containerContext.setAccessPolicy(Object.assign({ abortSignal: options.abortSignal, access, containerAcl: acl, leaseAccessConditions: options.conditions, modifiedAccessConditions: options.conditions }, convertTracingToRequestOptionsBase(updatedOptions)));\n        }\n        catch (e) {\n            span.setStatus({\n                code: SpanStatusCode.ERROR,\n                message: e.message,\n            });\n            throw e;\n        }\n        finally {\n            span.end();\n        }\n    }\n    /**\n     * Get a {@link BlobLeaseClient} that manages leases on the container.\n     *\n     * @param proposeLeaseId - Initial proposed lease Id.\n     * @returns A new BlobLeaseClient object for managing leases on the container.\n     */\n    getBlobLeaseClient(proposeLeaseId) {\n        return new BlobLeaseClient(this, proposeLeaseId);\n    }\n    /**\n     * Creates a new block blob, or updates the content of an existing block blob.\n     *\n     * Updating an existing block blob overwrites any existing metadata on the blob.\n     * Partial updates are not supported; the content of the existing blob is\n     * overwritten with the new content. To perform a partial update of a block blob's,\n     * use {@link BlockBlobClient.stageBlock} and {@link BlockBlobClient.commitBlockList}.\n     *\n     * This is a non-parallel uploading method, please use {@link BlockBlobClient.uploadFile},\n     * {@link BlockBlobClient.uploadStream} or {@link BlockBlobClient.uploadBrowserData} for better\n     * performance with concurrency uploading.\n     *\n     * @see https://docs.microsoft.com/rest/api/storageservices/put-blob\n     *\n     * @param blobName - Name of the block blob to create or update.\n     * @param body - Blob, string, ArrayBuffer, ArrayBufferView or a function\n     *                               which returns a new Readable stream whose offset is from data source beginning.\n     * @param contentLength - Length of body in bytes. Use Buffer.byteLength() to calculate body length for a\n     *                               string including non non-Base64/Hex-encoded characters.\n     * @param options - Options to configure the Block Blob Upload operation.\n     * @returns Block Blob upload response data and the corresponding BlockBlobClient instance.\n     */\n    async uploadBlockBlob(blobName, body, contentLength, options = {}) {\n        const { span, updatedOptions } = createSpan(\"ContainerClient-uploadBlockBlob\", options);\n        try {\n            const blockBlobClient = this.getBlockBlobClient(blobName);\n            const response = await blockBlobClient.upload(body, contentLength, updatedOptions);\n            return {\n                blockBlobClient,\n                response,\n            };\n        }\n        catch (e) {\n            span.setStatus({\n                code: SpanStatusCode.ERROR,\n                message: e.message,\n            });\n            throw e;\n        }\n        finally {\n            span.end();\n        }\n    }\n    /**\n     * Marks the specified blob or snapshot for deletion. The blob is later deleted\n     * during garbage collection. Note that in order to delete a blob, you must delete\n     * all of its snapshots. You can delete both at the same time with the Delete\n     * Blob operation.\n     * @see https://docs.microsoft.com/en-us/rest/api/storageservices/delete-blob\n     *\n     * @param blobName -\n     * @param options - Options to Blob Delete operation.\n     * @returns Block blob deletion response data.\n     */\n    async deleteBlob(blobName, options = {}) {\n        const { span, updatedOptions } = createSpan(\"ContainerClient-deleteBlob\", options);\n        try {\n            let blobClient = this.getBlobClient(blobName);\n            if (options.versionId) {\n                blobClient = blobClient.withVersion(options.versionId);\n            }\n            return await blobClient.delete(updatedOptions);\n        }\n        catch (e) {\n            span.setStatus({\n                code: SpanStatusCode.ERROR,\n                message: e.message,\n            });\n            throw e;\n        }\n        finally {\n            span.end();\n        }\n    }\n    /**\n     * listBlobFlatSegment returns a single segment of blobs starting from the\n     * specified Marker. Use an empty Marker to start enumeration from the beginning.\n     * After getting a segment, process it, and then call listBlobsFlatSegment again\n     * (passing the the previously-returned Marker) to get the next segment.\n     * @see https://docs.microsoft.com/rest/api/storageservices/list-blobs\n     *\n     * @param marker - A string value that identifies the portion of the list to be returned with the next list operation.\n     * @param options - Options to Container List Blob Flat Segment operation.\n     */\n    async listBlobFlatSegment(marker, options = {}) {\n        const { span, updatedOptions } = createSpan(\"ContainerClient-listBlobFlatSegment\", options);\n        try {\n            const response = await this.containerContext.listBlobFlatSegment(Object.assign(Object.assign({ marker }, options), convertTracingToRequestOptionsBase(updatedOptions)));\n            const wrappedResponse = Object.assign(Object.assign({}, response), { _response: Object.assign(Object.assign({}, response._response), { parsedBody: ConvertInternalResponseOfListBlobFlat(response._response.parsedBody) }), segment: Object.assign(Object.assign({}, response.segment), { blobItems: response.segment.blobItems.map((blobItemInteral) => {\n                        const blobItem = Object.assign(Object.assign({}, blobItemInteral), { name: BlobNameToString(blobItemInteral.name), tags: toTags(blobItemInteral.blobTags), objectReplicationSourceProperties: parseObjectReplicationRecord(blobItemInteral.objectReplicationMetadata) });\n                        return blobItem;\n                    }) }) });\n            return wrappedResponse;\n        }\n        catch (e) {\n            span.setStatus({\n                code: SpanStatusCode.ERROR,\n                message: e.message,\n            });\n            throw e;\n        }\n        finally {\n            span.end();\n        }\n    }\n    /**\n     * listBlobHierarchySegment returns a single segment of blobs starting from\n     * the specified Marker. Use an empty Marker to start enumeration from the\n     * beginning. After getting a segment, process it, and then call listBlobsHierarchicalSegment\n     * again (passing the the previously-returned Marker) to get the next segment.\n     * @see https://docs.microsoft.com/rest/api/storageservices/list-blobs\n     *\n     * @param delimiter - The character or string used to define the virtual hierarchy\n     * @param marker - A string value that identifies the portion of the list to be returned with the next list operation.\n     * @param options - Options to Container List Blob Hierarchy Segment operation.\n     */\n    async listBlobHierarchySegment(delimiter, marker, options = {}) {\n        var _a;\n        const { span, updatedOptions } = createSpan(\"ContainerClient-listBlobHierarchySegment\", options);\n        try {\n            const response = await this.containerContext.listBlobHierarchySegment(delimiter, Object.assign(Object.assign({ marker }, options), convertTracingToRequestOptionsBase(updatedOptions)));\n            const wrappedResponse = Object.assign(Object.assign({}, response), { _response: Object.assign(Object.assign({}, response._response), { parsedBody: ConvertInternalResponseOfListBlobHierarchy(response._response.parsedBody) }), segment: Object.assign(Object.assign({}, response.segment), { blobItems: response.segment.blobItems.map((blobItemInteral) => {\n                        const blobItem = Object.assign(Object.assign({}, blobItemInteral), { name: BlobNameToString(blobItemInteral.name), tags: toTags(blobItemInteral.blobTags), objectReplicationSourceProperties: parseObjectReplicationRecord(blobItemInteral.objectReplicationMetadata) });\n                        return blobItem;\n                    }), blobPrefixes: (_a = response.segment.blobPrefixes) === null || _a === void 0 ? void 0 : _a.map((blobPrefixInternal) => {\n                        const blobPrefix = Object.assign(Object.assign({}, blobPrefixInternal), { name: BlobNameToString(blobPrefixInternal.name) });\n                        return blobPrefix;\n                    }) }) });\n            return wrappedResponse;\n        }\n        catch (e) {\n            span.setStatus({\n                code: SpanStatusCode.ERROR,\n                message: e.message,\n            });\n            throw e;\n        }\n        finally {\n            span.end();\n        }\n    }\n    /**\n     * Returns an AsyncIterableIterator for ContainerListBlobFlatSegmentResponse\n     *\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 list blobs operation.\n     */\n    listSegments(marker, options = {}) {\n        return __asyncGenerator(this, arguments, function* listSegments_1() {\n            let listBlobsFlatSegmentResponse;\n            if (!!marker || marker === undefined) {\n                do {\n                    listBlobsFlatSegmentResponse = yield __await(this.listBlobFlatSegment(marker, options));\n                    marker = listBlobsFlatSegmentResponse.continuationToken;\n                    yield yield __await(yield __await(listBlobsFlatSegmentResponse));\n                } while (marker);\n            }\n        });\n    }\n    /**\n     * Returns an AsyncIterableIterator of {@link BlobItem} objects\n     *\n     * @param options - Options to list blobs operation.\n     */\n    listItems(options = {}) {\n        return __asyncGenerator(this, arguments, function* listItems_1() {\n            var e_1, _a;\n            let marker;\n            try {\n                for (var _b = __asyncValues(this.listSegments(marker, options)), _c; _c = yield __await(_b.next()), !_c.done;) {\n                    const listBlobsFlatSegmentResponse = _c.value;\n                    yield __await(yield* __asyncDelegator(__asyncValues(listBlobsFlatSegmentResponse.segment.blobItems)));\n                }\n            }\n            catch (e_1_1) { e_1 = { error: e_1_1 }; }\n            finally {\n                try {\n                    if (_c && !_c.done && (_a = _b.return)) yield __await(_a.call(_b));\n                }\n                finally { if (e_1) throw e_1.error; }\n            }\n        });\n    }\n    /**\n     * Returns an async iterable iterator to list all the blobs\n     * under the specified account.\n     *\n     * .byPage() returns an async iterable iterator to list the blobs in pages.\n     *\n     * Example using `for await` syntax:\n     *\n     * ```js\n     * // Get the containerClient before you run these snippets,\n     * // Can be obtained from `blobServiceClient.getContainerClient(\"<your-container-name>\");`\n     * let i = 1;\n     * for await (const blob of containerClient.listBlobsFlat()) {\n     *   console.log(`Blob ${i++}: ${blob.name}`);\n     * }\n     * ```\n     *\n     * Example using `iter.next()`:\n     *\n     * ```js\n     * let i = 1;\n     * let iter = containerClient.listBlobsFlat();\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 containerClient.listBlobsFlat().byPage({ maxPageSize: 20 })) {\n     *   for (const blob of response.segment.blobItems) {\n     *     console.log(`Blob ${i++}: ${blob.name}`);\n     *   }\n     * }\n     * ```\n     *\n     * Example using paging with a marker:\n     *\n     * ```js\n     * let i = 1;\n     * let iterator = containerClient.listBlobsFlat().byPage({ maxPageSize: 2 });\n     * let response = (await iterator.next()).value;\n     *\n     * // Prints 2 blob names\n     * for (const blob of response.segment.blobItems) {\n     *   console.log(`Blob ${i++}: ${blob.name}`);\n     * }\n     *\n     * // Gets next marker\n     * let marker = response.continuationToken;\n     *\n     * // Passing next marker as continuationToken\n     *\n     * iterator = containerClient.listBlobsFlat().byPage({ continuationToken: marker, maxPageSize: 10 });\n     * response = (await iterator.next()).value;\n     *\n     * // Prints 10 blob names\n     * for (const blob of response.segment.blobItems) {\n     *   console.log(`Blob ${i++}: ${blob.name}`);\n     * }\n     * ```\n     *\n     * @param options - Options to list blobs.\n     * @returns An asyncIterableIterator that supports paging.\n     */\n    listBlobsFlat(options = {}) {\n        const include = [];\n        if (options.includeCopy) {\n            include.push(\"copy\");\n        }\n        if (options.includeDeleted) {\n            include.push(\"deleted\");\n        }\n        if (options.includeMetadata) {\n            include.push(\"metadata\");\n        }\n        if (options.includeSnapshots) {\n            include.push(\"snapshots\");\n        }\n        if (options.includeVersions) {\n            include.push(\"versions\");\n        }\n        if (options.includeUncommitedBlobs) {\n            include.push(\"uncommittedblobs\");\n        }\n        if (options.includeTags) {\n            include.push(\"tags\");\n        }\n        if (options.includeDeletedWithVersions) {\n            include.push(\"deletedwithversions\");\n        }\n        if (options.includeImmutabilityPolicy) {\n            include.push(\"immutabilitypolicy\");\n        }\n        if (options.includeLegalHold) {\n            include.push(\"legalhold\");\n        }\n        if (options.prefix === \"\") {\n            options.prefix = undefined;\n        }\n        const updatedOptions = Object.assign(Object.assign({}, options), (include.length > 0 ? { include: include } : {}));\n        // AsyncIterableIterator to iterate over blobs\n        const iter = this.listItems(updatedOptions);\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 }, updatedOptions));\n            },\n        };\n    }\n    /**\n     * Returns an AsyncIterableIterator for ContainerListBlobHierarchySegmentResponse\n     *\n     * @param delimiter - The character or string used to define the virtual hierarchy\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 list blobs operation.\n     */\n    listHierarchySegments(delimiter, marker, options = {}) {\n        return __asyncGenerator(this, arguments, function* listHierarchySegments_1() {\n            let listBlobsHierarchySegmentResponse;\n            if (!!marker || marker === undefined) {\n                do {\n                    listBlobsHierarchySegmentResponse = yield __await(this.listBlobHierarchySegment(delimiter, marker, options));\n                    marker = listBlobsHierarchySegmentResponse.continuationToken;\n                    yield yield __await(yield __await(listBlobsHierarchySegmentResponse));\n                } while (marker);\n            }\n        });\n    }\n    /**\n     * Returns an AsyncIterableIterator for {@link BlobPrefix} and {@link BlobItem} objects.\n     *\n     * @param delimiter - The character or string used to define the virtual hierarchy\n     * @param options - Options to list blobs operation.\n     */\n    listItemsByHierarchy(delimiter, options = {}) {\n        return __asyncGenerator(this, arguments, function* listItemsByHierarchy_1() {\n            var e_2, _a;\n            let marker;\n            try {\n                for (var _b = __asyncValues(this.listHierarchySegments(delimiter, marker, options)), _c; _c = yield __await(_b.next()), !_c.done;) {\n                    const listBlobsHierarchySegmentResponse = _c.value;\n                    const segment = listBlobsHierarchySegmentResponse.segment;\n                    if (segment.blobPrefixes) {\n                        for (const prefix of segment.blobPrefixes) {\n                            yield yield __await(Object.assign({ kind: \"prefix\" }, prefix));\n                        }\n                    }\n                    for (const blob of segment.blobItems) {\n                        yield yield __await(Object.assign({ kind: \"blob\" }, blob));\n                    }\n                }\n            }\n            catch (e_2_1) { e_2 = { error: e_2_1 }; }\n            finally {\n                try {\n                    if (_c && !_c.done && (_a = _b.return)) yield __await(_a.call(_b));\n                }\n                finally { if (e_2) throw e_2.error; }\n            }\n        });\n    }\n    /**\n     * Returns an async iterable iterator to list all the blobs by hierarchy.\n     * under the specified account.\n     *\n     * .byPage() returns an async iterable iterator to list the blobs by hierarchy in pages.\n     *\n     * Example using `for await` syntax:\n     *\n     * ```js\n     * for await (const item of containerClient.listBlobsByHierarchy(\"/\")) {\n     *   if (item.kind === \"prefix\") {\n     *     console.log(`\\tBlobPrefix: ${item.name}`);\n     *   } else {\n     *     console.log(`\\tBlobItem: name - ${item.name}`);\n     *   }\n     * }\n     * ```\n     *\n     * Example using `iter.next()`:\n     *\n     * ```js\n     * let iter = containerClient.listBlobsByHierarchy(\"/\", { prefix: \"prefix1/\" });\n     * let entity = await iter.next();\n     * while (!entity.done) {\n     *   let item = entity.value;\n     *   if (item.kind === \"prefix\") {\n     *     console.log(`\\tBlobPrefix: ${item.name}`);\n     *   } else {\n     *     console.log(`\\tBlobItem: name - ${item.name}`);\n     *   }\n     *   entity = await iter.next();\n     * }\n     * ```\n     *\n     * Example using `byPage()`:\n     *\n     * ```js\n     * console.log(\"Listing blobs by hierarchy by page\");\n     * for await (const response of containerClient.listBlobsByHierarchy(\"/\").byPage()) {\n     *   const segment = response.segment;\n     *   if (segment.blobPrefixes) {\n     *     for (const prefix of segment.blobPrefixes) {\n     *       console.log(`\\tBlobPrefix: ${prefix.name}`);\n     *     }\n     *   }\n     *   for (const blob of response.segment.blobItems) {\n     *     console.log(`\\tBlobItem: name - ${blob.name}`);\n     *   }\n     * }\n     * ```\n     *\n     * Example using paging with a max page size:\n     *\n     * ```js\n     * console.log(\"Listing blobs by hierarchy by page, specifying a prefix and a max page size\");\n     *\n     * let i = 1;\n     * for await (const response of containerClient\n     *   .listBlobsByHierarchy(\"/\", { prefix: \"prefix2/sub1/\" })\n     *   .byPage({ maxPageSize: 2 })) {\n     *   console.log(`Page ${i++}`);\n     *   const segment = response.segment;\n     *\n     *   if (segment.blobPrefixes) {\n     *     for (const prefix of segment.blobPrefixes) {\n     *       console.log(`\\tBlobPrefix: ${prefix.name}`);\n     *     }\n     *   }\n     *\n     *   for (const blob of response.segment.blobItems) {\n     *     console.log(`\\tBlobItem: name - ${blob.name}`);\n     *   }\n     * }\n     * ```\n     *\n     * @param delimiter - The character or string used to define the virtual hierarchy\n     * @param options - Options to list blobs operation.\n     */\n    listBlobsByHierarchy(delimiter, options = {}) {\n        if (delimiter === \"\") {\n            throw new RangeError(\"delimiter should contain one or more characters\");\n        }\n        const include = [];\n        if (options.includeCopy) {\n            include.push(\"copy\");\n        }\n        if (options.includeDeleted) {\n            include.push(\"deleted\");\n        }\n        if (options.includeMetadata) {\n            include.push(\"metadata\");\n        }\n        if (options.includeSnapshots) {\n            include.push(\"snapshots\");\n        }\n        if (options.includeVersions) {\n            include.push(\"versions\");\n        }\n        if (options.includeUncommitedBlobs) {\n            include.push(\"uncommittedblobs\");\n        }\n        if (options.includeTags) {\n            include.push(\"tags\");\n        }\n        if (options.includeDeletedWithVersions) {\n            include.push(\"deletedwithversions\");\n        }\n        if (options.includeImmutabilityPolicy) {\n            include.push(\"immutabilitypolicy\");\n        }\n        if (options.includeLegalHold) {\n            include.push(\"legalhold\");\n        }\n        if (options.prefix === \"\") {\n            options.prefix = undefined;\n        }\n        const updatedOptions = Object.assign(Object.assign({}, options), (include.length > 0 ? { include: include } : {}));\n        // AsyncIterableIterator to iterate over blob prefixes and blobs\n        const iter = this.listItemsByHierarchy(delimiter, updatedOptions);\n        return {\n            /**\n             * The next method, part of the iteration protocol\n             */\n            async 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.listHierarchySegments(delimiter, settings.continuationToken, Object.assign({ maxPageSize: settings.maxPageSize }, updatedOptions));\n            },\n        };\n    }\n    /**\n     * The Filter Blobs operation enables callers to list blobs in the container whose tags\n     * match a given search expression.\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        const { span, updatedOptions } = createSpan(\"ContainerClient-findBlobsByTagsSegment\", options);\n        try {\n            const response = await this.containerContext.filterBlobs(Object.assign({ abortSignal: options.abortSignal, where: tagFilterSqlExpression, marker, maxPageSize: options.maxPageSize }, convertTracingToRequestOptionsBase(updatedOptions)));\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        catch (e) {\n            span.setStatus({\n                code: SpanStatusCode.ERROR,\n                message: e.message,\n            });\n            throw e;\n        }\n        finally {\n            span.end();\n        }\n    }\n    /**\n     * Returns an AsyncIterableIterator for ContainerFindBlobsByTagsSegmentResponse.\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, marker, options = {}) {\n        return __asyncGenerator(this, arguments, function* findBlobsByTagsSegments_1() {\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, options = {}) {\n        return __asyncGenerator(this, arguments, function* findBlobsByTagsItems_1() {\n            var e_3, _a;\n            let marker;\n            try {\n                for (var _b = __asyncValues(this.findBlobsByTagsSegments(tagFilterSqlExpression, marker, options)), _c; _c = yield __await(_b.next()), !_c.done;) {\n                    const segment = _c.value;\n                    yield __await(yield* __asyncDelegator(__asyncValues(segment.blobs)));\n                }\n            }\n            catch (e_3_1) { e_3 = { error: e_3_1 }; }\n            finally {\n                try {\n                    if (_c && !_c.done && (_a = _b.return)) yield __await(_a.call(_b));\n                }\n                finally { if (e_3) throw e_3.error; }\n            }\n        });\n    }\n    /**\n     * Returns an async iterable iterator to find all blobs with specified tag\n     * under the specified container.\n     *\n     * .byPage() returns an async iterable iterator to list the blobs in pages.\n     *\n     * Example using `for await` syntax:\n     *\n     * ```js\n     * let i = 1;\n     * for await (const blob of containerClient.findBlobsByTags(\"tagkey='tagvalue'\")) {\n     *   console.log(`Blob ${i++}: ${blob.name}`);\n     * }\n     * ```\n     *\n     * Example using `iter.next()`:\n     *\n     * ```js\n     * let i = 1;\n     * const iter = containerClient.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 containerClient.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 = containerClient.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 = containerClient\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    getContainerNameFromUrl() {\n        let containerName;\n        try {\n            //  URL may look like the following\n            // \"https://myaccount.blob.core.windows.net/mycontainer?sasString\";\n            // \"https://myaccount.blob.core.windows.net/mycontainer\";\n            // IPv4/IPv6 address hosts, Endpoints - `http://127.0.0.1:10000/devstoreaccount1/containername`\n            // http://localhost:10001/devstoreaccount1/containername\n            const parsedUrl = URLBuilder.parse(this.url);\n            if (parsedUrl.getHost().split(\".\")[1] === \"blob\") {\n                // \"https://myaccount.blob.core.windows.net/containername\".\n                // \"https://customdomain.com/containername\".\n                // .getPath() -> /containername\n                containerName = parsedUrl.getPath().split(\"/\")[1];\n            }\n            else if (isIpEndpointStyle(parsedUrl)) {\n                // IPv4/IPv6 address hosts... Example - http://192.0.0.10:10001/devstoreaccount1/containername\n                // Single word domain without a [dot] in the endpoint... Example - http://localhost:10001/devstoreaccount1/containername\n                // .getPath() -> /devstoreaccount1/containername\n                containerName = parsedUrl.getPath().split(\"/\")[2];\n            }\n            else {\n                // \"https://customdomain.com/containername\".\n                // .getPath() -> /containername\n                containerName = parsedUrl.getPath().split(\"/\")[1];\n            }\n            // decode the encoded containerName - to get all the special characters that might be present in it\n            containerName = decodeURIComponent(containerName);\n            if (!containerName) {\n                throw new Error(\"Provided containerName is invalid.\");\n            }\n            return containerName;\n        }\n        catch (error) {\n            throw new Error(\"Unable to extract containerName with provided information.\");\n        }\n    }\n    /**\n     * Only available for ContainerClient constructed with a shared key credential.\n     *\n     * Generates a Blob Container Service 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/constructing-a-service-sas\n     *\n     * @param options - Optional parameters.\n     * @returns The SAS URI consisting of the URI to the resource represented by this client, followed by the generated SAS token.\n     */\n    generateSasUrl(options) {\n        return new Promise((resolve) => {\n            if (!(this.credential instanceof StorageSharedKeyCredential)) {\n                throw new RangeError(\"Can only generate the SAS when the client is initialized with a shared key credential\");\n            }\n            const sas = generateBlobSASQueryParameters(Object.assign({ containerName: this._containerName }, options), this.credential).toString();\n            resolve(appendToURLQuery(this.url, sas));\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 container.\n     */\n    getBlobBatchClient() {\n        return new BlobBatchClient(this.url, this.pipeline);\n    }\n}\n//# sourceMappingURL=ContainerClient.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n/**\n * Function that converts PageRange and ClearRange to a common Range object.\n * PageRange and ClearRange have start and end while Range offset and count\n * this function normalizes to Range.\n * @param response - Model PageBlob Range response\n */\nexport function rangeResponseFromModel(response) {\n    const pageRange = (response._response.parsedBody.pageRange || []).map((x) => ({\n        offset: x.start,\n        count: x.end - x.start,\n    }));\n    const clearRange = (response._response.parsedBody.clearRange || []).map((x) => ({\n        offset: x.start,\n        count: x.end - x.start,\n    }));\n    return Object.assign(Object.assign({}, response), { pageRange,\n        clearRange, _response: Object.assign(Object.assign({}, response._response), { parsedBody: {\n                pageRange,\n                clearRange,\n            } }) });\n}\n//# sourceMappingURL=PageBlobRangeResponse.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\nimport { BaseRequestPolicy, deserializationPolicy, disableResponseDecompressionPolicy, HttpHeaders, RequestPolicyOptions, WebResource, proxyPolicy, isNode, isTokenCredential, tracingPolicy, logPolicy, keepAlivePolicy, generateClientRequestIdPolicy, } from \"@azure/core-http\";\nimport { logger } from \"./log\";\nimport { StorageBrowserPolicyFactory } from \"./StorageBrowserPolicyFactory\";\nimport { StorageRetryPolicyFactory } from \"./StorageRetryPolicyFactory\";\nimport { AnonymousCredential } from \"./credentials/AnonymousCredential\";\nimport { StorageOAuthScopes, StorageBlobLoggingAllowedHeaderNames, StorageBlobLoggingAllowedQueryParameters, } from \"./utils/constants\";\nimport { TelemetryPolicyFactory } from \"./TelemetryPolicyFactory\";\nimport { getCachedDefaultHttpClient } from \"./utils/cache\";\nimport { attachCredential } from \"./utils/utils.common\";\nimport { storageBearerTokenChallengeAuthenticationPolicy } from \"./policies/StorageBearerTokenChallengeAuthenticationPolicy\";\n// Export following interfaces and types for customers who want to implement their\n// own RequestPolicy or HTTPClient\nexport { BaseRequestPolicy, StorageOAuthScopes, deserializationPolicy, HttpHeaders, WebResource, RequestPolicyOptions, };\n/**\n * A helper to decide if a given argument satisfies the Pipeline contract\n * @param pipeline - An argument that may be a Pipeline\n * @returns true when the argument satisfies the Pipeline contract\n */\nexport function isPipelineLike(pipeline) {\n    if (!pipeline || typeof pipeline !== \"object\") {\n        return false;\n    }\n    const castPipeline = pipeline;\n    return (Array.isArray(castPipeline.factories) &&\n        typeof castPipeline.options === \"object\" &&\n        typeof castPipeline.toServiceClientOptions === \"function\");\n}\n/**\n * A Pipeline class containing HTTP request policies.\n * You can create a default Pipeline by calling {@link newPipeline}.\n * Or you can create a Pipeline with your own policies by the constructor of Pipeline.\n *\n * Refer to {@link newPipeline} and provided policies before implementing your\n * customized Pipeline.\n */\nexport class Pipeline {\n    /**\n     * Creates an instance of Pipeline. Customize HTTPClient by implementing IHttpClient interface.\n     *\n     * @param factories -\n     * @param options -\n     */\n    constructor(factories, options = {}) {\n        this.factories = factories;\n        // when options.httpClient is not specified, passing in a DefaultHttpClient instance to\n        // avoid each client creating its own http client.\n        this.options = Object.assign(Object.assign({}, options), { httpClient: options.httpClient || getCachedDefaultHttpClient() });\n    }\n    /**\n     * Transfer Pipeline object to ServiceClientOptions object which is required by\n     * ServiceClient constructor.\n     *\n     * @returns The ServiceClientOptions object from this Pipeline.\n     */\n    toServiceClientOptions() {\n        return {\n            httpClient: this.options.httpClient,\n            requestPolicyFactories: this.factories,\n        };\n    }\n}\n/**\n * Creates a new Pipeline object with Credential provided.\n *\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 * @param pipelineOptions - Optional. Options.\n * @returns A new Pipeline object.\n */\nexport function newPipeline(credential, pipelineOptions = {}) {\n    var _a;\n    if (credential === undefined) {\n        credential = new AnonymousCredential();\n    }\n    // Order is important. Closer to the API at the top & closer to the network at the bottom.\n    // The credential's policy factory must appear close to the wire so it can sign any\n    // changes made by other factories (like UniqueRequestIDPolicyFactory)\n    const telemetryPolicy = new TelemetryPolicyFactory(pipelineOptions.userAgentOptions);\n    const factories = [\n        tracingPolicy({ userAgent: telemetryPolicy.telemetryString }),\n        keepAlivePolicy(pipelineOptions.keepAliveOptions),\n        telemetryPolicy,\n        generateClientRequestIdPolicy(),\n        new StorageBrowserPolicyFactory(),\n        new StorageRetryPolicyFactory(pipelineOptions.retryOptions),\n        // Default deserializationPolicy is provided by protocol layer\n        // Use customized XML char key of \"#\" so we could deserialize metadata\n        // with \"_\" key\n        deserializationPolicy(undefined, { xmlCharKey: \"#\" }),\n        logPolicy({\n            logger: logger.info,\n            allowedHeaderNames: StorageBlobLoggingAllowedHeaderNames,\n            allowedQueryParameters: StorageBlobLoggingAllowedQueryParameters,\n        }),\n    ];\n    if (isNode) {\n        // policies only available in Node.js runtime, not in browsers\n        factories.push(proxyPolicy(pipelineOptions.proxyOptions));\n        factories.push(disableResponseDecompressionPolicy());\n    }\n    factories.push(isTokenCredential(credential)\n        ? attachCredential(storageBearerTokenChallengeAuthenticationPolicy(credential, (_a = pipelineOptions.audience) !== null && _a !== void 0 ? _a : StorageOAuthScopes), credential)\n        : credential);\n    return new Pipeline(factories, pipelineOptions);\n}\n//# sourceMappingURL=Pipeline.js.map","// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n/**\n * Generate a range string. For example:\n *\n * \"bytes=255-\" or \"bytes=0-511\"\n *\n * @param iRange -\n */\nexport function rangeToString(iRange) {\n    if (iRange.offset < 0) {\n        throw new RangeError(`Range.offset cannot be smaller than 0.`);\n    }\n    if (iRange.count && iRange.count <= 0) {\n        throw new RangeError(`Range.count must be larger than 0. Leave it undefined if you want a range from offset to the end.`);\n    }\n    return iRange.count\n        ? `bytes=${iRange.offset}-${iRange.offset + iRange.count - 1}`\n        : `bytes=${iRange.offset}-`;\n}\n//# sourceMappingURL=Range.js.map"],"names":["ContainerClient","constructor","urlOrConnectionString","credentialOrPipelineOrContainerName","options","pipeline","url","Error","containerName","extractedCreds","kind","sharedKeyCredential","accountName","accountKey","encodeURIComponent","proxyOptions","proxyUri","accountSas","super","this","_containerName","getContainerNameFromUrl","containerContext","storageClientContext","create","span","updatedOptions","Object","assign","e","setStatus","code","message","end","createIfNotExists","_a","_b","res","succeeded","_response","details","errorCode","response","parsedHeaders","exists","getProperties","abortSignal","tracingOptions","statusCode","getBlobClient","blobName","getAppendBlobClient","getBlockBlobClient","getPageBlobClient","conditions","delete","leaseAccessConditions","modifiedAccessConditions","deleteIfExists","setMetadata","metadata","ifUnmodifiedSince","RangeError","getAccessPolicy","blobPublicAccess","date","etag","lastModified","requestId","clientRequestId","signedIdentifiers","version","identifier","accessPolicy","permissions","expiresOn","Date","startsOn","push","id","setAccessPolicy","access","containerAcl","acl","getBlobLeaseClient","proposeLeaseId","uploadBlockBlob","body","contentLength","blockBlobClient","upload","deleteBlob","blobClient","versionId","withVersion","listBlobFlatSegment","marker","parsedBody","segment","blobItems","map","blobItemInteral","name","tags","blobTags","objectReplicationSourceProperties","objectReplicationMetadata","listBlobHierarchySegment","delimiter","blobPrefixes","blobPrefixInternal","listSegments","arguments","listBlobsFlatSegmentResponse","undefined","continuationToken","listItems","e_1","_c","next","done","value","e_1_1","error","return","call","listBlobsFlat","include","includeCopy","includeDeleted","includeMetadata","includeSnapshots","includeVersions","includeUncommitedBlobs","includeTags","includeDeletedWithVersions","includeImmutabilityPolicy","includeLegalHold","prefix","length","iter","Symbol","asyncIterator","byPage","settings","maxPageSize","listHierarchySegments","listBlobsHierarchySegmentResponse","listItemsByHierarchy","e_2","blob","e_2_1","listBlobsByHierarchy","async","findBlobsByTagsSegment","tagFilterSqlExpression","filterBlobs","where","blobs","tagValue","blobTagSet","findBlobsByTagsSegments","findBlobsByTagsItems","e_3","e_3_1","findBlobsByTags","listSegmentOptions","parsedUrl","getHost","split","getPath","decodeURIComponent","generateSasUrl","Promise","resolve","credential","sas","toString","getBlobBatchClient","rangeResponseFromModel","pageRange","x","offset","start","count","clearRange","isPipelineLike","castPipeline","Array","isArray","factories","toServiceClientOptions","Pipeline","httpClient","requestPolicyFactories","newPipeline","pipelineOptions","telemetryPolicy","userAgentOptions","userAgent","telemetryString","keepAliveOptions","retryOptions","xmlCharKey","logger","allowedHeaderNames","allowedQueryParameters","audience","rangeToString","iRange"],"sourceRoot":""}