{"version":3,"file":"static/js/vendors-24ca9119.b1b50224.js","mappings":"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","sources":["../node_modules/@smithy/types/dist-es/auth/auth.js","../node_modules/@smithy/types/dist-es/auth/HttpApiKeyAuth.js","../node_modules/@smithy/types/dist-es/endpoint.js","../node_modules/@smithy/types/dist-es/extensions/checksum.js","../node_modules/@smithy/types/dist-es/http.js","../node_modules/@smithy/types/dist-es/middleware.js","../node_modules/@smithy/types/dist-es/profile.js","../node_modules/@smithy/types/dist-es/transfer.js","../node_modules/@smithy/url-parser/dist-es/index.js","../node_modules/@smithy/util-base64/dist-es/constants.browser.js","../node_modules/@smithy/util-base64/dist-es/fromBase64.browser.js","../node_modules/@smithy/util-base64/dist-es/toBase64.browser.js","../node_modules/@smithy/util-body-length-browser/dist-es/calculateBodyLength.js","../node_modules/@smithy/util-config-provider/dist-es/booleanSelector.js","../node_modules/@smithy/util-config-provider/dist-es/types.js","../node_modules/@smithy/util-defaults-mode-browser/dist-es/constants.js","../node_modules/@smithy/util-defaults-mode-browser/dist-es/resolveDefaultsModeConfig.js","../node_modules/@smithy/util-endpoints/dist-es/cache/EndpointCache.js","../node_modules/@smithy/util-endpoints/dist-es/lib/isIpAddress.js","../node_modules/@smithy/util-endpoints/dist-es/lib/isValidHostLabel.js","../node_modules/@smithy/util-endpoints/dist-es/utils/customEndpointFunctions.js","../node_modules/@smithy/util-endpoints/dist-es/debug/debugId.js","../node_modules/@smithy/util-endpoints/dist-es/debug/toDebugString.js","../node_modules/@smithy/util-endpoints/dist-es/types/EndpointError.js","../node_modules/@smithy/util-endpoints/dist-es/lib/booleanEquals.js","../node_modules/@smithy/util-endpoints/dist-es/lib/getAttr.js","../node_modules/@smithy/util-endpoints/dist-es/lib/getAttrPathList.js","../node_modules/@smithy/util-endpoints/dist-es/lib/parseURL.js","../node_modules/@smithy/util-endpoints/dist-es/utils/endpointFunctions.js","../node_modules/@smithy/util-endpoints/dist-es/lib/isSet.js","../node_modules/@smithy/util-endpoints/dist-es/lib/not.js","../node_modules/@smithy/util-endpoints/dist-es/lib/stringEquals.js","../node_modules/@smithy/util-endpoints/dist-es/lib/substring.js","../node_modules/@smithy/util-endpoints/dist-es/lib/uriEncode.js","../node_modules/@smithy/util-endpoints/dist-es/utils/evaluateTemplate.js","../node_modules/@smithy/util-endpoints/dist-es/utils/evaluateExpression.js","../node_modules/@smithy/util-endpoints/dist-es/utils/getReferenceValue.js","../node_modules/@smithy/util-endpoints/dist-es/utils/callFunction.js","../node_modules/@smithy/util-endpoints/dist-es/utils/evaluateCondition.js","../node_modules/@smithy/util-endpoints/dist-es/utils/evaluateConditions.js","../node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointHeaders.js","../node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointProperty.js","../node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointProperties.js","../node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointUrl.js","../node_modules/@smithy/util-endpoints/dist-es/utils/evaluateEndpointRule.js","../node_modules/@smithy/util-endpoints/dist-es/utils/evaluateErrorRule.js","../node_modules/@smithy/util-endpoints/dist-es/utils/evaluateTreeRule.js","../node_modules/@smithy/util-endpoints/dist-es/utils/evaluateRules.js","../node_modules/@smithy/util-endpoints/dist-es/resolveEndpoint.js","../node_modules/@smithy/util-hex-encoding/dist-es/index.js","../node_modules/@smithy/util-middleware/dist-es/getSmithyContext.js","../node_modules/@smithy/util-middleware/dist-es/normalizeProvider.js","../node_modules/@smithy/util-retry/dist-es/config.js","../node_modules/@smithy/util-retry/dist-es/DefaultRateLimiter.js","../node_modules/@smithy/util-retry/dist-es/constants.js","../node_modules/@smithy/util-retry/dist-es/defaultRetryToken.js","../node_modules/@smithy/util-retry/dist-es/StandardRetryStrategy.js","../node_modules/@smithy/util-retry/dist-es/defaultRetryBackoffStrategy.js","../node_modules/@smithy/util-retry/dist-es/AdaptiveRetryStrategy.js","../node_modules/@smithy/util-stream/dist-es/blob/Uint8ArrayBlobAdapter.js","../node_modules/@smithy/util-stream/dist-es/blob/transforms.js","../node_modules/@smithy/util-stream/dist-es/getAwsChunkedEncodingStream.browser.js","../node_modules/@smithy/util-stream/dist-es/stream-type-check.js","../node_modules/@smithy/util-stream/dist-es/sdk-stream-mixin.browser.js","../node_modules/@smithy/util-stream/dist-es/splitStream.browser.js","../node_modules/@smithy/util-stream/dist-es/headStream.browser.js","../node_modules/@smithy/util-stream/dist-es/checksum/ChecksumStream.browser.js","../node_modules/@smithy/util-stream/dist-es/checksum/createChecksumStream.browser.js","../node_modules/@smithy/util-uri-escape/dist-es/escape-uri.js","../node_modules/@smithy/util-utf8/dist-es/fromUtf8.browser.js","../node_modules/@smithy/util-utf8/dist-es/toUint8Array.js","../node_modules/@smithy/util-utf8/dist-es/toUtf8.browser.js","../node_modules/@smithy/util-waiter/dist-es/waiter.js"],"sourcesContent":["export var HttpAuthLocation;\n(function (HttpAuthLocation) {\n    HttpAuthLocation[\"HEADER\"] = \"header\";\n    HttpAuthLocation[\"QUERY\"] = \"query\";\n})(HttpAuthLocation || (HttpAuthLocation = {}));\n","export var HttpApiKeyAuthLocation;\n(function (HttpApiKeyAuthLocation) {\n    HttpApiKeyAuthLocation[\"HEADER\"] = \"header\";\n    HttpApiKeyAuthLocation[\"QUERY\"] = \"query\";\n})(HttpApiKeyAuthLocation || (HttpApiKeyAuthLocation = {}));\n","export var EndpointURLScheme;\n(function (EndpointURLScheme) {\n    EndpointURLScheme[\"HTTP\"] = \"http\";\n    EndpointURLScheme[\"HTTPS\"] = \"https\";\n})(EndpointURLScheme || (EndpointURLScheme = {}));\n","export var AlgorithmId;\n(function (AlgorithmId) {\n    AlgorithmId[\"MD5\"] = \"md5\";\n    AlgorithmId[\"CRC32\"] = \"crc32\";\n    AlgorithmId[\"CRC32C\"] = \"crc32c\";\n    AlgorithmId[\"SHA1\"] = \"sha1\";\n    AlgorithmId[\"SHA256\"] = \"sha256\";\n})(AlgorithmId || (AlgorithmId = {}));\nexport const getChecksumConfiguration = (runtimeConfig) => {\n    const checksumAlgorithms = [];\n    if (runtimeConfig.sha256 !== undefined) {\n        checksumAlgorithms.push({\n            algorithmId: () => AlgorithmId.SHA256,\n            checksumConstructor: () => runtimeConfig.sha256,\n        });\n    }\n    if (runtimeConfig.md5 != undefined) {\n        checksumAlgorithms.push({\n            algorithmId: () => AlgorithmId.MD5,\n            checksumConstructor: () => runtimeConfig.md5,\n        });\n    }\n    return {\n        _checksumAlgorithms: checksumAlgorithms,\n        addChecksumAlgorithm(algo) {\n            this._checksumAlgorithms.push(algo);\n        },\n        checksumAlgorithms() {\n            return this._checksumAlgorithms;\n        },\n    };\n};\nexport const resolveChecksumRuntimeConfig = (clientConfig) => {\n    const runtimeConfig = {};\n    clientConfig.checksumAlgorithms().forEach((checksumAlgorithm) => {\n        runtimeConfig[checksumAlgorithm.algorithmId()] = checksumAlgorithm.checksumConstructor();\n    });\n    return runtimeConfig;\n};\n","export var FieldPosition;\n(function (FieldPosition) {\n    FieldPosition[FieldPosition[\"HEADER\"] = 0] = \"HEADER\";\n    FieldPosition[FieldPosition[\"TRAILER\"] = 1] = \"TRAILER\";\n})(FieldPosition || (FieldPosition = {}));\n","export const SMITHY_CONTEXT_KEY = \"__smithy_context\";\n","export var IniSectionType;\n(function (IniSectionType) {\n    IniSectionType[\"PROFILE\"] = \"profile\";\n    IniSectionType[\"SSO_SESSION\"] = \"sso-session\";\n    IniSectionType[\"SERVICES\"] = \"services\";\n})(IniSectionType || (IniSectionType = {}));\n","export var RequestHandlerProtocol;\n(function (RequestHandlerProtocol) {\n    RequestHandlerProtocol[\"HTTP_0_9\"] = \"http/0.9\";\n    RequestHandlerProtocol[\"HTTP_1_0\"] = \"http/1.0\";\n    RequestHandlerProtocol[\"TDS_8_0\"] = \"tds/8.0\";\n})(RequestHandlerProtocol || (RequestHandlerProtocol = {}));\n","import { parseQueryString } from \"@smithy/querystring-parser\";\nexport const parseUrl = (url) => {\n    if (typeof url === \"string\") {\n        return parseUrl(new URL(url));\n    }\n    const { hostname, pathname, port, protocol, search } = url;\n    let query;\n    if (search) {\n        query = parseQueryString(search);\n    }\n    return {\n        hostname,\n        port: port ? parseInt(port) : undefined,\n        protocol,\n        path: pathname,\n        query,\n    };\n};\n","const alphabetByEncoding = {};\nconst alphabetByValue = new Array(64);\nfor (let i = 0, start = \"A\".charCodeAt(0), limit = \"Z\".charCodeAt(0); i + start <= limit; i++) {\n    const char = String.fromCharCode(i + start);\n    alphabetByEncoding[char] = i;\n    alphabetByValue[i] = char;\n}\nfor (let i = 0, start = \"a\".charCodeAt(0), limit = \"z\".charCodeAt(0); i + start <= limit; i++) {\n    const char = String.fromCharCode(i + start);\n    const index = i + 26;\n    alphabetByEncoding[char] = index;\n    alphabetByValue[index] = char;\n}\nfor (let i = 0; i < 10; i++) {\n    alphabetByEncoding[i.toString(10)] = i + 52;\n    const char = i.toString(10);\n    const index = i + 52;\n    alphabetByEncoding[char] = index;\n    alphabetByValue[index] = char;\n}\nalphabetByEncoding[\"+\"] = 62;\nalphabetByValue[62] = \"+\";\nalphabetByEncoding[\"/\"] = 63;\nalphabetByValue[63] = \"/\";\nconst bitsPerLetter = 6;\nconst bitsPerByte = 8;\nconst maxLetterValue = 0b111111;\nexport { alphabetByEncoding, alphabetByValue, bitsPerLetter, bitsPerByte, maxLetterValue };\n","import { alphabetByEncoding, bitsPerByte, bitsPerLetter } from \"./constants.browser\";\nexport const fromBase64 = (input) => {\n    let totalByteLength = (input.length / 4) * 3;\n    if (input.slice(-2) === \"==\") {\n        totalByteLength -= 2;\n    }\n    else if (input.slice(-1) === \"=\") {\n        totalByteLength--;\n    }\n    const out = new ArrayBuffer(totalByteLength);\n    const dataView = new DataView(out);\n    for (let i = 0; i < input.length; i += 4) {\n        let bits = 0;\n        let bitLength = 0;\n        for (let j = i, limit = i + 3; j <= limit; j++) {\n            if (input[j] !== \"=\") {\n                if (!(input[j] in alphabetByEncoding)) {\n                    throw new TypeError(`Invalid character ${input[j]} in base64 string.`);\n                }\n                bits |= alphabetByEncoding[input[j]] << ((limit - j) * bitsPerLetter);\n                bitLength += bitsPerLetter;\n            }\n            else {\n                bits >>= bitsPerLetter;\n            }\n        }\n        const chunkOffset = (i / 4) * 3;\n        bits >>= bitLength % bitsPerByte;\n        const byteLength = Math.floor(bitLength / bitsPerByte);\n        for (let k = 0; k < byteLength; k++) {\n            const offset = (byteLength - k - 1) * bitsPerByte;\n            dataView.setUint8(chunkOffset + k, (bits & (255 << offset)) >> offset);\n        }\n    }\n    return new Uint8Array(out);\n};\n","import { fromUtf8 } from \"@smithy/util-utf8\";\nimport { alphabetByValue, bitsPerByte, bitsPerLetter, maxLetterValue } from \"./constants.browser\";\nexport function toBase64(_input) {\n    let input;\n    if (typeof _input === \"string\") {\n        input = fromUtf8(_input);\n    }\n    else {\n        input = _input;\n    }\n    const isArrayLike = typeof input === \"object\" && typeof input.length === \"number\";\n    const isUint8Array = typeof input === \"object\" &&\n        typeof input.byteOffset === \"number\" &&\n        typeof input.byteLength === \"number\";\n    if (!isArrayLike && !isUint8Array) {\n        throw new Error(\"@smithy/util-base64: toBase64 encoder function only accepts string | Uint8Array.\");\n    }\n    let str = \"\";\n    for (let i = 0; i < input.length; i += 3) {\n        let bits = 0;\n        let bitLength = 0;\n        for (let j = i, limit = Math.min(i + 3, input.length); j < limit; j++) {\n            bits |= input[j] << ((limit - j - 1) * bitsPerByte);\n            bitLength += bitsPerByte;\n        }\n        const bitClusterCount = Math.ceil(bitLength / bitsPerLetter);\n        bits <<= bitClusterCount * bitsPerLetter - bitLength;\n        for (let k = 1; k <= bitClusterCount; k++) {\n            const offset = (bitClusterCount - k) * bitsPerLetter;\n            str += alphabetByValue[(bits & (maxLetterValue << offset)) >> offset];\n        }\n        str += \"==\".slice(0, 4 - bitClusterCount);\n    }\n    return str;\n}\n","const TEXT_ENCODER = typeof TextEncoder == \"function\" ? new TextEncoder() : null;\nexport const calculateBodyLength = (body) => {\n    if (typeof body === \"string\") {\n        if (TEXT_ENCODER) {\n            return TEXT_ENCODER.encode(body).byteLength;\n        }\n        let len = body.length;\n        for (let i = len - 1; i >= 0; i--) {\n            const code = body.charCodeAt(i);\n            if (code > 0x7f && code <= 0x7ff)\n                len++;\n            else if (code > 0x7ff && code <= 0xffff)\n                len += 2;\n            if (code >= 0xdc00 && code <= 0xdfff)\n                i--;\n        }\n        return len;\n    }\n    else if (typeof body.byteLength === \"number\") {\n        return body.byteLength;\n    }\n    else if (typeof body.size === \"number\") {\n        return body.size;\n    }\n    throw new Error(`Body Length computation failed for ${body}`);\n};\n","export const booleanSelector = (obj, key, type) => {\n    if (!(key in obj))\n        return undefined;\n    if (obj[key] === \"true\")\n        return true;\n    if (obj[key] === \"false\")\n        return false;\n    throw new Error(`Cannot load ${type} \"${key}\". Expected \"true\" or \"false\", got ${obj[key]}.`);\n};\n","export var SelectorType;\n(function (SelectorType) {\n    SelectorType[\"ENV\"] = \"env\";\n    SelectorType[\"CONFIG\"] = \"shared config entry\";\n})(SelectorType || (SelectorType = {}));\n","export const DEFAULTS_MODE_OPTIONS = [\"in-region\", \"cross-region\", \"mobile\", \"standard\", \"legacy\"];\n","import { memoize } from \"@smithy/property-provider\";\nimport bowser from \"bowser\";\nimport { DEFAULTS_MODE_OPTIONS } from \"./constants\";\nexport const resolveDefaultsModeConfig = ({ defaultsMode, } = {}) => memoize(async () => {\n    const mode = typeof defaultsMode === \"function\" ? await defaultsMode() : defaultsMode;\n    switch (mode?.toLowerCase()) {\n        case \"auto\":\n            return Promise.resolve(isMobileBrowser() ? \"mobile\" : \"standard\");\n        case \"mobile\":\n        case \"in-region\":\n        case \"cross-region\":\n        case \"standard\":\n        case \"legacy\":\n            return Promise.resolve(mode?.toLocaleLowerCase());\n        case undefined:\n            return Promise.resolve(\"legacy\");\n        default:\n            throw new Error(`Invalid parameter for \"defaultsMode\", expect ${DEFAULTS_MODE_OPTIONS.join(\", \")}, got ${mode}`);\n    }\n});\nconst isMobileBrowser = () => {\n    const parsedUA = typeof window !== \"undefined\" && window?.navigator?.userAgent\n        ? bowser.parse(window.navigator.userAgent)\n        : undefined;\n    const platform = parsedUA?.platform?.type;\n    return platform === \"tablet\" || platform === \"mobile\";\n};\n","export class EndpointCache {\n    constructor({ size, params }) {\n        this.data = new Map();\n        this.parameters = [];\n        this.capacity = size ?? 50;\n        if (params) {\n            this.parameters = params;\n        }\n    }\n    get(endpointParams, resolver) {\n        const key = this.hash(endpointParams);\n        if (key === false) {\n            return resolver();\n        }\n        if (!this.data.has(key)) {\n            if (this.data.size > this.capacity + 10) {\n                const keys = this.data.keys();\n                let i = 0;\n                while (true) {\n                    const { value, done } = keys.next();\n                    this.data.delete(value);\n                    if (done || ++i > 10) {\n                        break;\n                    }\n                }\n            }\n            this.data.set(key, resolver());\n        }\n        return this.data.get(key);\n    }\n    size() {\n        return this.data.size;\n    }\n    hash(endpointParams) {\n        let buffer = \"\";\n        const { parameters } = this;\n        if (parameters.length === 0) {\n            return false;\n        }\n        for (const param of parameters) {\n            const val = String(endpointParams[param] ?? \"\");\n            if (val.includes(\"|;\")) {\n                return false;\n            }\n            buffer += val + \"|;\";\n        }\n        return buffer;\n    }\n}\n","const IP_V4_REGEX = new RegExp(`^(?:25[0-5]|2[0-4]\\\\d|1\\\\d\\\\d|[1-9]\\\\d|\\\\d)(?:\\\\.(?:25[0-5]|2[0-4]\\\\d|1\\\\d\\\\d|[1-9]\\\\d|\\\\d)){3}$`);\nexport const isIpAddress = (value) => IP_V4_REGEX.test(value) || (value.startsWith(\"[\") && value.endsWith(\"]\"));\n","const VALID_HOST_LABEL_REGEX = new RegExp(`^(?!.*-$)(?!-)[a-zA-Z0-9-]{1,63}$`);\nexport const isValidHostLabel = (value, allowSubDomains = false) => {\n    if (!allowSubDomains) {\n        return VALID_HOST_LABEL_REGEX.test(value);\n    }\n    const labels = value.split(\".\");\n    for (const label of labels) {\n        if (!isValidHostLabel(label)) {\n            return false;\n        }\n    }\n    return true;\n};\n","export const customEndpointFunctions = {};\n","export const debugId = \"endpoints\";\n","export function toDebugString(input) {\n    if (typeof input !== \"object\" || input == null) {\n        return input;\n    }\n    if (\"ref\" in input) {\n        return `$${toDebugString(input.ref)}`;\n    }\n    if (\"fn\" in input) {\n        return `${input.fn}(${(input.argv || []).map(toDebugString).join(\", \")})`;\n    }\n    return JSON.stringify(input, null, 2);\n}\n","export class EndpointError extends Error {\n    constructor(message) {\n        super(message);\n        this.name = \"EndpointError\";\n    }\n}\n","export const booleanEquals = (value1, value2) => value1 === value2;\n","import { EndpointError } from \"../types\";\nimport { getAttrPathList } from \"./getAttrPathList\";\nexport const getAttr = (value, path) => getAttrPathList(path).reduce((acc, index) => {\n    if (typeof acc !== \"object\") {\n        throw new EndpointError(`Index '${index}' in '${path}' not found in '${JSON.stringify(value)}'`);\n    }\n    else if (Array.isArray(acc)) {\n        return acc[parseInt(index)];\n    }\n    return acc[index];\n}, value);\n","import { EndpointError } from \"../types\";\nexport const getAttrPathList = (path) => {\n    const parts = path.split(\".\");\n    const pathList = [];\n    for (const part of parts) {\n        const squareBracketIndex = part.indexOf(\"[\");\n        if (squareBracketIndex !== -1) {\n            if (part.indexOf(\"]\") !== part.length - 1) {\n                throw new EndpointError(`Path: '${path}' does not end with ']'`);\n            }\n            const arrayIndex = part.slice(squareBracketIndex + 1, -1);\n            if (Number.isNaN(parseInt(arrayIndex))) {\n                throw new EndpointError(`Invalid array index: '${arrayIndex}' in path: '${path}'`);\n            }\n            if (squareBracketIndex !== 0) {\n                pathList.push(part.slice(0, squareBracketIndex));\n            }\n            pathList.push(arrayIndex);\n        }\n        else {\n            pathList.push(part);\n        }\n    }\n    return pathList;\n};\n","import { EndpointURLScheme } from \"@smithy/types\";\nimport { isIpAddress } from \"./isIpAddress\";\nconst DEFAULT_PORTS = {\n    [EndpointURLScheme.HTTP]: 80,\n    [EndpointURLScheme.HTTPS]: 443,\n};\nexport const parseURL = (value) => {\n    const whatwgURL = (() => {\n        try {\n            if (value instanceof URL) {\n                return value;\n            }\n            if (typeof value === \"object\" && \"hostname\" in value) {\n                const { hostname, port, protocol = \"\", path = \"\", query = {} } = value;\n                const url = new URL(`${protocol}//${hostname}${port ? `:${port}` : \"\"}${path}`);\n                url.search = Object.entries(query)\n                    .map(([k, v]) => `${k}=${v}`)\n                    .join(\"&\");\n                return url;\n            }\n            return new URL(value);\n        }\n        catch (error) {\n            return null;\n        }\n    })();\n    if (!whatwgURL) {\n        console.error(`Unable to parse ${JSON.stringify(value)} as a whatwg URL.`);\n        return null;\n    }\n    const urlString = whatwgURL.href;\n    const { host, hostname, pathname, protocol, search } = whatwgURL;\n    if (search) {\n        return null;\n    }\n    const scheme = protocol.slice(0, -1);\n    if (!Object.values(EndpointURLScheme).includes(scheme)) {\n        return null;\n    }\n    const isIp = isIpAddress(hostname);\n    const inputContainsDefaultPort = urlString.includes(`${host}:${DEFAULT_PORTS[scheme]}`) ||\n        (typeof value === \"string\" && value.includes(`${host}:${DEFAULT_PORTS[scheme]}`));\n    const authority = `${host}${inputContainsDefaultPort ? `:${DEFAULT_PORTS[scheme]}` : ``}`;\n    return {\n        scheme,\n        authority,\n        path: pathname,\n        normalizedPath: pathname.endsWith(\"/\") ? pathname : `${pathname}/`,\n        isIp,\n    };\n};\n","import { booleanEquals, getAttr, isSet, isValidHostLabel, not, parseURL, stringEquals, substring, uriEncode, } from \"../lib\";\nexport const endpointFunctions = {\n    booleanEquals,\n    getAttr,\n    isSet,\n    isValidHostLabel,\n    not,\n    parseURL,\n    stringEquals,\n    substring,\n    uriEncode,\n};\n","export const isSet = (value) => value != null;\n","export const not = (value) => !value;\n","export const stringEquals = (value1, value2) => value1 === value2;\n","export const substring = (input, start, stop, reverse) => {\n    if (start >= stop || input.length < stop) {\n        return null;\n    }\n    if (!reverse) {\n        return input.substring(start, stop);\n    }\n    return input.substring(input.length - stop, input.length - start);\n};\n","export const uriEncode = (value) => encodeURIComponent(value).replace(/[!*'()]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);\n","import { getAttr } from \"../lib\";\nexport const evaluateTemplate = (template, options) => {\n    const evaluatedTemplateArr = [];\n    const templateContext = {\n        ...options.endpointParams,\n        ...options.referenceRecord,\n    };\n    let currentIndex = 0;\n    while (currentIndex < template.length) {\n        const openingBraceIndex = template.indexOf(\"{\", currentIndex);\n        if (openingBraceIndex === -1) {\n            evaluatedTemplateArr.push(template.slice(currentIndex));\n            break;\n        }\n        evaluatedTemplateArr.push(template.slice(currentIndex, openingBraceIndex));\n        const closingBraceIndex = template.indexOf(\"}\", openingBraceIndex);\n        if (closingBraceIndex === -1) {\n            evaluatedTemplateArr.push(template.slice(openingBraceIndex));\n            break;\n        }\n        if (template[openingBraceIndex + 1] === \"{\" && template[closingBraceIndex + 1] === \"}\") {\n            evaluatedTemplateArr.push(template.slice(openingBraceIndex + 1, closingBraceIndex));\n            currentIndex = closingBraceIndex + 2;\n        }\n        const parameterName = template.substring(openingBraceIndex + 1, closingBraceIndex);\n        if (parameterName.includes(\"#\")) {\n            const [refName, attrName] = parameterName.split(\"#\");\n            evaluatedTemplateArr.push(getAttr(templateContext[refName], attrName));\n        }\n        else {\n            evaluatedTemplateArr.push(templateContext[parameterName]);\n        }\n        currentIndex = closingBraceIndex + 1;\n    }\n    return evaluatedTemplateArr.join(\"\");\n};\n","import { EndpointError } from \"../types\";\nimport { callFunction } from \"./callFunction\";\nimport { evaluateTemplate } from \"./evaluateTemplate\";\nimport { getReferenceValue } from \"./getReferenceValue\";\nexport const evaluateExpression = (obj, keyName, options) => {\n    if (typeof obj === \"string\") {\n        return evaluateTemplate(obj, options);\n    }\n    else if (obj[\"fn\"]) {\n        return callFunction(obj, options);\n    }\n    else if (obj[\"ref\"]) {\n        return getReferenceValue(obj, options);\n    }\n    throw new EndpointError(`'${keyName}': ${String(obj)} is not a string, function or reference.`);\n};\n","export const getReferenceValue = ({ ref }, options) => {\n    const referenceRecord = {\n        ...options.endpointParams,\n        ...options.referenceRecord,\n    };\n    return referenceRecord[ref];\n};\n","import { customEndpointFunctions } from \"./customEndpointFunctions\";\nimport { endpointFunctions } from \"./endpointFunctions\";\nimport { evaluateExpression } from \"./evaluateExpression\";\nexport const callFunction = ({ fn, argv }, options) => {\n    const evaluatedArgs = argv.map((arg) => [\"boolean\", \"number\"].includes(typeof arg) ? arg : evaluateExpression(arg, \"arg\", options));\n    const fnSegments = fn.split(\".\");\n    if (fnSegments[0] in customEndpointFunctions && fnSegments[1] != null) {\n        return customEndpointFunctions[fnSegments[0]][fnSegments[1]](...evaluatedArgs);\n    }\n    return endpointFunctions[fn](...evaluatedArgs);\n};\n","import { debugId, toDebugString } from \"../debug\";\nimport { EndpointError } from \"../types\";\nimport { callFunction } from \"./callFunction\";\nexport const evaluateCondition = ({ assign, ...fnArgs }, options) => {\n    if (assign && assign in options.referenceRecord) {\n        throw new EndpointError(`'${assign}' is already defined in Reference Record.`);\n    }\n    const value = callFunction(fnArgs, options);\n    options.logger?.debug?.(`${debugId} evaluateCondition: ${toDebugString(fnArgs)} = ${toDebugString(value)}`);\n    return {\n        result: value === \"\" ? true : !!value,\n        ...(assign != null && { toAssign: { name: assign, value } }),\n    };\n};\n","import { debugId, toDebugString } from \"../debug\";\nimport { evaluateCondition } from \"./evaluateCondition\";\nexport const evaluateConditions = (conditions = [], options) => {\n    const conditionsReferenceRecord = {};\n    for (const condition of conditions) {\n        const { result, toAssign } = evaluateCondition(condition, {\n            ...options,\n            referenceRecord: {\n                ...options.referenceRecord,\n                ...conditionsReferenceRecord,\n            },\n        });\n        if (!result) {\n            return { result };\n        }\n        if (toAssign) {\n            conditionsReferenceRecord[toAssign.name] = toAssign.value;\n            options.logger?.debug?.(`${debugId} assign: ${toAssign.name} := ${toDebugString(toAssign.value)}`);\n        }\n    }\n    return { result: true, referenceRecord: conditionsReferenceRecord };\n};\n","import { EndpointError } from \"../types\";\nimport { evaluateExpression } from \"./evaluateExpression\";\nexport const getEndpointHeaders = (headers, options) => Object.entries(headers).reduce((acc, [headerKey, headerVal]) => ({\n    ...acc,\n    [headerKey]: headerVal.map((headerValEntry) => {\n        const processedExpr = evaluateExpression(headerValEntry, \"Header value entry\", options);\n        if (typeof processedExpr !== \"string\") {\n            throw new EndpointError(`Header '${headerKey}' value '${processedExpr}' is not a string`);\n        }\n        return processedExpr;\n    }),\n}), {});\n","import { EndpointError } from \"../types\";\nimport { evaluateTemplate } from \"./evaluateTemplate\";\nimport { getEndpointProperties } from \"./getEndpointProperties\";\nexport const getEndpointProperty = (property, options) => {\n    if (Array.isArray(property)) {\n        return property.map((propertyEntry) => getEndpointProperty(propertyEntry, options));\n    }\n    switch (typeof property) {\n        case \"string\":\n            return evaluateTemplate(property, options);\n        case \"object\":\n            if (property === null) {\n                throw new EndpointError(`Unexpected endpoint property: ${property}`);\n            }\n            return getEndpointProperties(property, options);\n        case \"boolean\":\n            return property;\n        default:\n            throw new EndpointError(`Unexpected endpoint property type: ${typeof property}`);\n    }\n};\n","import { getEndpointProperty } from \"./getEndpointProperty\";\nexport const getEndpointProperties = (properties, options) => Object.entries(properties).reduce((acc, [propertyKey, propertyVal]) => ({\n    ...acc,\n    [propertyKey]: getEndpointProperty(propertyVal, options),\n}), {});\n","import { EndpointError } from \"../types\";\nimport { evaluateExpression } from \"./evaluateExpression\";\nexport const getEndpointUrl = (endpointUrl, options) => {\n    const expression = evaluateExpression(endpointUrl, \"Endpoint URL\", options);\n    if (typeof expression === \"string\") {\n        try {\n            return new URL(expression);\n        }\n        catch (error) {\n            console.error(`Failed to construct URL with ${expression}`, error);\n            throw error;\n        }\n    }\n    throw new EndpointError(`Endpoint URL must be a string, got ${typeof expression}`);\n};\n","import { debugId, toDebugString } from \"../debug\";\nimport { evaluateConditions } from \"./evaluateConditions\";\nimport { getEndpointHeaders } from \"./getEndpointHeaders\";\nimport { getEndpointProperties } from \"./getEndpointProperties\";\nimport { getEndpointUrl } from \"./getEndpointUrl\";\nexport const evaluateEndpointRule = (endpointRule, options) => {\n    const { conditions, endpoint } = endpointRule;\n    const { result, referenceRecord } = evaluateConditions(conditions, options);\n    if (!result) {\n        return;\n    }\n    const endpointRuleOptions = {\n        ...options,\n        referenceRecord: { ...options.referenceRecord, ...referenceRecord },\n    };\n    const { url, properties, headers } = endpoint;\n    options.logger?.debug?.(`${debugId} Resolving endpoint from template: ${toDebugString(endpoint)}`);\n    return {\n        ...(headers != undefined && {\n            headers: getEndpointHeaders(headers, endpointRuleOptions),\n        }),\n        ...(properties != undefined && {\n            properties: getEndpointProperties(properties, endpointRuleOptions),\n        }),\n        url: getEndpointUrl(url, endpointRuleOptions),\n    };\n};\n","import { EndpointError } from \"../types\";\nimport { evaluateConditions } from \"./evaluateConditions\";\nimport { evaluateExpression } from \"./evaluateExpression\";\nexport const evaluateErrorRule = (errorRule, options) => {\n    const { conditions, error } = errorRule;\n    const { result, referenceRecord } = evaluateConditions(conditions, options);\n    if (!result) {\n        return;\n    }\n    throw new EndpointError(evaluateExpression(error, \"Error\", {\n        ...options,\n        referenceRecord: { ...options.referenceRecord, ...referenceRecord },\n    }));\n};\n","import { evaluateConditions } from \"./evaluateConditions\";\nimport { evaluateRules } from \"./evaluateRules\";\nexport const evaluateTreeRule = (treeRule, options) => {\n    const { conditions, rules } = treeRule;\n    const { result, referenceRecord } = evaluateConditions(conditions, options);\n    if (!result) {\n        return;\n    }\n    return evaluateRules(rules, {\n        ...options,\n        referenceRecord: { ...options.referenceRecord, ...referenceRecord },\n    });\n};\n","import { EndpointError } from \"../types\";\nimport { evaluateEndpointRule } from \"./evaluateEndpointRule\";\nimport { evaluateErrorRule } from \"./evaluateErrorRule\";\nimport { evaluateTreeRule } from \"./evaluateTreeRule\";\nexport const evaluateRules = (rules, options) => {\n    for (const rule of rules) {\n        if (rule.type === \"endpoint\") {\n            const endpointOrUndefined = evaluateEndpointRule(rule, options);\n            if (endpointOrUndefined) {\n                return endpointOrUndefined;\n            }\n        }\n        else if (rule.type === \"error\") {\n            evaluateErrorRule(rule, options);\n        }\n        else if (rule.type === \"tree\") {\n            const endpointOrUndefined = evaluateTreeRule(rule, options);\n            if (endpointOrUndefined) {\n                return endpointOrUndefined;\n            }\n        }\n        else {\n            throw new EndpointError(`Unknown endpoint rule: ${rule}`);\n        }\n    }\n    throw new EndpointError(`Rules evaluation failed`);\n};\n","import { debugId, toDebugString } from \"./debug\";\nimport { EndpointError } from \"./types\";\nimport { evaluateRules } from \"./utils\";\nexport const resolveEndpoint = (ruleSetObject, options) => {\n    const { endpointParams, logger } = options;\n    const { parameters, rules } = ruleSetObject;\n    options.logger?.debug?.(`${debugId} Initial EndpointParams: ${toDebugString(endpointParams)}`);\n    const paramsWithDefault = Object.entries(parameters)\n        .filter(([, v]) => v.default != null)\n        .map(([k, v]) => [k, v.default]);\n    if (paramsWithDefault.length > 0) {\n        for (const [paramKey, paramDefaultValue] of paramsWithDefault) {\n            endpointParams[paramKey] = endpointParams[paramKey] ?? paramDefaultValue;\n        }\n    }\n    const requiredParams = Object.entries(parameters)\n        .filter(([, v]) => v.required)\n        .map(([k]) => k);\n    for (const requiredParam of requiredParams) {\n        if (endpointParams[requiredParam] == null) {\n            throw new EndpointError(`Missing required parameter: '${requiredParam}'`);\n        }\n    }\n    const endpoint = evaluateRules(rules, { endpointParams, logger, referenceRecord: {} });\n    options.logger?.debug?.(`${debugId} Resolved endpoint: ${toDebugString(endpoint)}`);\n    return endpoint;\n};\n","const SHORT_TO_HEX = {};\nconst HEX_TO_SHORT = {};\nfor (let i = 0; i < 256; i++) {\n    let encodedByte = i.toString(16).toLowerCase();\n    if (encodedByte.length === 1) {\n        encodedByte = `0${encodedByte}`;\n    }\n    SHORT_TO_HEX[i] = encodedByte;\n    HEX_TO_SHORT[encodedByte] = i;\n}\nexport function fromHex(encoded) {\n    if (encoded.length % 2 !== 0) {\n        throw new Error(\"Hex encoded strings must have an even number length\");\n    }\n    const out = new Uint8Array(encoded.length / 2);\n    for (let i = 0; i < encoded.length; i += 2) {\n        const encodedByte = encoded.slice(i, i + 2).toLowerCase();\n        if (encodedByte in HEX_TO_SHORT) {\n            out[i / 2] = HEX_TO_SHORT[encodedByte];\n        }\n        else {\n            throw new Error(`Cannot decode unrecognized sequence ${encodedByte} as hexadecimal`);\n        }\n    }\n    return out;\n}\nexport function toHex(bytes) {\n    let out = \"\";\n    for (let i = 0; i < bytes.byteLength; i++) {\n        out += SHORT_TO_HEX[bytes[i]];\n    }\n    return out;\n}\n","import { SMITHY_CONTEXT_KEY } from \"@smithy/types\";\nexport const getSmithyContext = (context) => context[SMITHY_CONTEXT_KEY] || (context[SMITHY_CONTEXT_KEY] = {});\n","export const normalizeProvider = (input) => {\n    if (typeof input === \"function\")\n        return input;\n    const promisified = Promise.resolve(input);\n    return () => promisified;\n};\n","export var RETRY_MODES;\n(function (RETRY_MODES) {\n    RETRY_MODES[\"STANDARD\"] = \"standard\";\n    RETRY_MODES[\"ADAPTIVE\"] = \"adaptive\";\n})(RETRY_MODES || (RETRY_MODES = {}));\nexport const DEFAULT_MAX_ATTEMPTS = 3;\nexport const DEFAULT_RETRY_MODE = RETRY_MODES.STANDARD;\n","import { isThrottlingError } from \"@smithy/service-error-classification\";\nexport class DefaultRateLimiter {\n    constructor(options) {\n        this.currentCapacity = 0;\n        this.enabled = false;\n        this.lastMaxRate = 0;\n        this.measuredTxRate = 0;\n        this.requestCount = 0;\n        this.lastTimestamp = 0;\n        this.timeWindow = 0;\n        this.beta = options?.beta ?? 0.7;\n        this.minCapacity = options?.minCapacity ?? 1;\n        this.minFillRate = options?.minFillRate ?? 0.5;\n        this.scaleConstant = options?.scaleConstant ?? 0.4;\n        this.smooth = options?.smooth ?? 0.8;\n        const currentTimeInSeconds = this.getCurrentTimeInSeconds();\n        this.lastThrottleTime = currentTimeInSeconds;\n        this.lastTxRateBucket = Math.floor(this.getCurrentTimeInSeconds());\n        this.fillRate = this.minFillRate;\n        this.maxCapacity = this.minCapacity;\n    }\n    getCurrentTimeInSeconds() {\n        return Date.now() / 1000;\n    }\n    async getSendToken() {\n        return this.acquireTokenBucket(1);\n    }\n    async acquireTokenBucket(amount) {\n        if (!this.enabled) {\n            return;\n        }\n        this.refillTokenBucket();\n        if (amount > this.currentCapacity) {\n            const delay = ((amount - this.currentCapacity) / this.fillRate) * 1000;\n            await new Promise((resolve) => DefaultRateLimiter.setTimeoutFn(resolve, delay));\n        }\n        this.currentCapacity = this.currentCapacity - amount;\n    }\n    refillTokenBucket() {\n        const timestamp = this.getCurrentTimeInSeconds();\n        if (!this.lastTimestamp) {\n            this.lastTimestamp = timestamp;\n            return;\n        }\n        const fillAmount = (timestamp - this.lastTimestamp) * this.fillRate;\n        this.currentCapacity = Math.min(this.maxCapacity, this.currentCapacity + fillAmount);\n        this.lastTimestamp = timestamp;\n    }\n    updateClientSendingRate(response) {\n        let calculatedRate;\n        this.updateMeasuredRate();\n        if (isThrottlingError(response)) {\n            const rateToUse = !this.enabled ? this.measuredTxRate : Math.min(this.measuredTxRate, this.fillRate);\n            this.lastMaxRate = rateToUse;\n            this.calculateTimeWindow();\n            this.lastThrottleTime = this.getCurrentTimeInSeconds();\n            calculatedRate = this.cubicThrottle(rateToUse);\n            this.enableTokenBucket();\n        }\n        else {\n            this.calculateTimeWindow();\n            calculatedRate = this.cubicSuccess(this.getCurrentTimeInSeconds());\n        }\n        const newRate = Math.min(calculatedRate, 2 * this.measuredTxRate);\n        this.updateTokenBucketRate(newRate);\n    }\n    calculateTimeWindow() {\n        this.timeWindow = this.getPrecise(Math.pow((this.lastMaxRate * (1 - this.beta)) / this.scaleConstant, 1 / 3));\n    }\n    cubicThrottle(rateToUse) {\n        return this.getPrecise(rateToUse * this.beta);\n    }\n    cubicSuccess(timestamp) {\n        return this.getPrecise(this.scaleConstant * Math.pow(timestamp - this.lastThrottleTime - this.timeWindow, 3) + this.lastMaxRate);\n    }\n    enableTokenBucket() {\n        this.enabled = true;\n    }\n    updateTokenBucketRate(newRate) {\n        this.refillTokenBucket();\n        this.fillRate = Math.max(newRate, this.minFillRate);\n        this.maxCapacity = Math.max(newRate, this.minCapacity);\n        this.currentCapacity = Math.min(this.currentCapacity, this.maxCapacity);\n    }\n    updateMeasuredRate() {\n        const t = this.getCurrentTimeInSeconds();\n        const timeBucket = Math.floor(t * 2) / 2;\n        this.requestCount++;\n        if (timeBucket > this.lastTxRateBucket) {\n            const currentRate = this.requestCount / (timeBucket - this.lastTxRateBucket);\n            this.measuredTxRate = this.getPrecise(currentRate * this.smooth + this.measuredTxRate * (1 - this.smooth));\n            this.requestCount = 0;\n            this.lastTxRateBucket = timeBucket;\n        }\n    }\n    getPrecise(num) {\n        return parseFloat(num.toFixed(8));\n    }\n}\nDefaultRateLimiter.setTimeoutFn = setTimeout;\n","export const DEFAULT_RETRY_DELAY_BASE = 100;\nexport const MAXIMUM_RETRY_DELAY = 20 * 1000;\nexport const THROTTLING_RETRY_DELAY_BASE = 500;\nexport const INITIAL_RETRY_TOKENS = 500;\nexport const RETRY_COST = 5;\nexport const TIMEOUT_RETRY_COST = 10;\nexport const NO_RETRY_INCREMENT = 1;\nexport const INVOCATION_ID_HEADER = \"amz-sdk-invocation-id\";\nexport const REQUEST_HEADER = \"amz-sdk-request\";\n","import { MAXIMUM_RETRY_DELAY } from \"./constants\";\nexport const createDefaultRetryToken = ({ retryDelay, retryCount, retryCost, }) => {\n    const getRetryCount = () => retryCount;\n    const getRetryDelay = () => Math.min(MAXIMUM_RETRY_DELAY, retryDelay);\n    const getRetryCost = () => retryCost;\n    return {\n        getRetryCount,\n        getRetryDelay,\n        getRetryCost,\n    };\n};\n","import { DEFAULT_MAX_ATTEMPTS, RETRY_MODES } from \"./config\";\nimport { DEFAULT_RETRY_DELAY_BASE, INITIAL_RETRY_TOKENS, NO_RETRY_INCREMENT, RETRY_COST, THROTTLING_RETRY_DELAY_BASE, TIMEOUT_RETRY_COST, } from \"./constants\";\nimport { getDefaultRetryBackoffStrategy } from \"./defaultRetryBackoffStrategy\";\nimport { createDefaultRetryToken } from \"./defaultRetryToken\";\nexport class StandardRetryStrategy {\n    constructor(maxAttempts) {\n        this.maxAttempts = maxAttempts;\n        this.mode = RETRY_MODES.STANDARD;\n        this.capacity = INITIAL_RETRY_TOKENS;\n        this.retryBackoffStrategy = getDefaultRetryBackoffStrategy();\n        this.maxAttemptsProvider = typeof maxAttempts === \"function\" ? maxAttempts : async () => maxAttempts;\n    }\n    async acquireInitialRetryToken(retryTokenScope) {\n        return createDefaultRetryToken({\n            retryDelay: DEFAULT_RETRY_DELAY_BASE,\n            retryCount: 0,\n        });\n    }\n    async refreshRetryTokenForRetry(token, errorInfo) {\n        const maxAttempts = await this.getMaxAttempts();\n        if (this.shouldRetry(token, errorInfo, maxAttempts)) {\n            const errorType = errorInfo.errorType;\n            this.retryBackoffStrategy.setDelayBase(errorType === \"THROTTLING\" ? THROTTLING_RETRY_DELAY_BASE : DEFAULT_RETRY_DELAY_BASE);\n            const delayFromErrorType = this.retryBackoffStrategy.computeNextBackoffDelay(token.getRetryCount());\n            const retryDelay = errorInfo.retryAfterHint\n                ? Math.max(errorInfo.retryAfterHint.getTime() - Date.now() || 0, delayFromErrorType)\n                : delayFromErrorType;\n            const capacityCost = this.getCapacityCost(errorType);\n            this.capacity -= capacityCost;\n            return createDefaultRetryToken({\n                retryDelay,\n                retryCount: token.getRetryCount() + 1,\n                retryCost: capacityCost,\n            });\n        }\n        throw new Error(\"No retry token available\");\n    }\n    recordSuccess(token) {\n        this.capacity = Math.max(INITIAL_RETRY_TOKENS, this.capacity + (token.getRetryCost() ?? NO_RETRY_INCREMENT));\n    }\n    getCapacity() {\n        return this.capacity;\n    }\n    async getMaxAttempts() {\n        try {\n            return await this.maxAttemptsProvider();\n        }\n        catch (error) {\n            console.warn(`Max attempts provider could not resolve. Using default of ${DEFAULT_MAX_ATTEMPTS}`);\n            return DEFAULT_MAX_ATTEMPTS;\n        }\n    }\n    shouldRetry(tokenToRenew, errorInfo, maxAttempts) {\n        const attempts = tokenToRenew.getRetryCount() + 1;\n        return (attempts < maxAttempts &&\n            this.capacity >= this.getCapacityCost(errorInfo.errorType) &&\n            this.isRetryableError(errorInfo.errorType));\n    }\n    getCapacityCost(errorType) {\n        return errorType === \"TRANSIENT\" ? TIMEOUT_RETRY_COST : RETRY_COST;\n    }\n    isRetryableError(errorType) {\n        return errorType === \"THROTTLING\" || errorType === \"TRANSIENT\";\n    }\n}\n","import { DEFAULT_RETRY_DELAY_BASE, MAXIMUM_RETRY_DELAY } from \"./constants\";\nexport const getDefaultRetryBackoffStrategy = () => {\n    let delayBase = DEFAULT_RETRY_DELAY_BASE;\n    const computeNextBackoffDelay = (attempts) => {\n        return Math.floor(Math.min(MAXIMUM_RETRY_DELAY, Math.random() * 2 ** attempts * delayBase));\n    };\n    const setDelayBase = (delay) => {\n        delayBase = delay;\n    };\n    return {\n        computeNextBackoffDelay,\n        setDelayBase,\n    };\n};\n","import { RETRY_MODES } from \"./config\";\nimport { DefaultRateLimiter } from \"./DefaultRateLimiter\";\nimport { StandardRetryStrategy } from \"./StandardRetryStrategy\";\nexport class AdaptiveRetryStrategy {\n    constructor(maxAttemptsProvider, options) {\n        this.maxAttemptsProvider = maxAttemptsProvider;\n        this.mode = RETRY_MODES.ADAPTIVE;\n        const { rateLimiter } = options ?? {};\n        this.rateLimiter = rateLimiter ?? new DefaultRateLimiter();\n        this.standardRetryStrategy = new StandardRetryStrategy(maxAttemptsProvider);\n    }\n    async acquireInitialRetryToken(retryTokenScope) {\n        await this.rateLimiter.getSendToken();\n        return this.standardRetryStrategy.acquireInitialRetryToken(retryTokenScope);\n    }\n    async refreshRetryTokenForRetry(tokenToRenew, errorInfo) {\n        this.rateLimiter.updateClientSendingRate(errorInfo);\n        return this.standardRetryStrategy.refreshRetryTokenForRetry(tokenToRenew, errorInfo);\n    }\n    recordSuccess(token) {\n        this.rateLimiter.updateClientSendingRate({});\n        this.standardRetryStrategy.recordSuccess(token);\n    }\n}\n","import { transformFromString, transformToString } from \"./transforms\";\nexport class Uint8ArrayBlobAdapter extends Uint8Array {\n    static fromString(source, encoding = \"utf-8\") {\n        switch (typeof source) {\n            case \"string\":\n                return transformFromString(source, encoding);\n            default:\n                throw new Error(`Unsupported conversion from ${typeof source} to Uint8ArrayBlobAdapter.`);\n        }\n    }\n    static mutate(source) {\n        Object.setPrototypeOf(source, Uint8ArrayBlobAdapter.prototype);\n        return source;\n    }\n    transformToString(encoding = \"utf-8\") {\n        return transformToString(this, encoding);\n    }\n}\n","import { fromBase64, toBase64 } from \"@smithy/util-base64\";\nimport { fromUtf8, toUtf8 } from \"@smithy/util-utf8\";\nimport { Uint8ArrayBlobAdapter } from \"./Uint8ArrayBlobAdapter\";\nexport function transformToString(payload, encoding = \"utf-8\") {\n    if (encoding === \"base64\") {\n        return toBase64(payload);\n    }\n    return toUtf8(payload);\n}\nexport function transformFromString(str, encoding) {\n    if (encoding === \"base64\") {\n        return Uint8ArrayBlobAdapter.mutate(fromBase64(str));\n    }\n    return Uint8ArrayBlobAdapter.mutate(fromUtf8(str));\n}\n","export const getAwsChunkedEncodingStream = (readableStream, options) => {\n    const { base64Encoder, bodyLengthChecker, checksumAlgorithmFn, checksumLocationName, streamHasher } = options;\n    const checksumRequired = base64Encoder !== undefined &&\n        bodyLengthChecker !== undefined &&\n        checksumAlgorithmFn !== undefined &&\n        checksumLocationName !== undefined &&\n        streamHasher !== undefined;\n    const digest = checksumRequired ? streamHasher(checksumAlgorithmFn, readableStream) : undefined;\n    const reader = readableStream.getReader();\n    return new ReadableStream({\n        async pull(controller) {\n            const { value, done } = await reader.read();\n            if (done) {\n                controller.enqueue(`0\\r\\n`);\n                if (checksumRequired) {\n                    const checksum = base64Encoder(await digest);\n                    controller.enqueue(`${checksumLocationName}:${checksum}\\r\\n`);\n                    controller.enqueue(`\\r\\n`);\n                }\n                controller.close();\n            }\n            else {\n                controller.enqueue(`${(bodyLengthChecker(value) || 0).toString(16)}\\r\\n${value}\\r\\n`);\n            }\n        },\n    });\n};\n","export const isReadableStream = (stream) => typeof ReadableStream === \"function\" &&\n    (stream?.constructor?.name === ReadableStream.name || stream instanceof ReadableStream);\nexport const isBlob = (blob) => {\n    return typeof Blob === \"function\" && (blob?.constructor?.name === Blob.name || blob instanceof Blob);\n};\n","import { streamCollector } from \"@smithy/fetch-http-handler\";\nimport { toBase64 } from \"@smithy/util-base64\";\nimport { toHex } from \"@smithy/util-hex-encoding\";\nimport { toUtf8 } from \"@smithy/util-utf8\";\nimport { isReadableStream } from \"./stream-type-check\";\nconst ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED = \"The stream has already been transformed.\";\nexport const sdkStreamMixin = (stream) => {\n    if (!isBlobInstance(stream) && !isReadableStream(stream)) {\n        const name = stream?.__proto__?.constructor?.name || stream;\n        throw new Error(`Unexpected stream implementation, expect Blob or ReadableStream, got ${name}`);\n    }\n    let transformed = false;\n    const transformToByteArray = async () => {\n        if (transformed) {\n            throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED);\n        }\n        transformed = true;\n        return await streamCollector(stream);\n    };\n    const blobToWebStream = (blob) => {\n        if (typeof blob.stream !== \"function\") {\n            throw new Error(\"Cannot transform payload Blob to web stream. Please make sure the Blob.stream() is polyfilled.\\n\" +\n                \"If you are using React Native, this API is not yet supported, see: https://react-native.canny.io/feature-requests/p/fetch-streaming-body\");\n        }\n        return blob.stream();\n    };\n    return Object.assign(stream, {\n        transformToByteArray: transformToByteArray,\n        transformToString: async (encoding) => {\n            const buf = await transformToByteArray();\n            if (encoding === \"base64\") {\n                return toBase64(buf);\n            }\n            else if (encoding === \"hex\") {\n                return toHex(buf);\n            }\n            else if (encoding === undefined || encoding === \"utf8\" || encoding === \"utf-8\") {\n                return toUtf8(buf);\n            }\n            else if (typeof TextDecoder === \"function\") {\n                return new TextDecoder(encoding).decode(buf);\n            }\n            else {\n                throw new Error(\"TextDecoder is not available, please make sure polyfill is provided.\");\n            }\n        },\n        transformToWebStream: () => {\n            if (transformed) {\n                throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED);\n            }\n            transformed = true;\n            if (isBlobInstance(stream)) {\n                return blobToWebStream(stream);\n            }\n            else if (isReadableStream(stream)) {\n                return stream;\n            }\n            else {\n                throw new Error(`Cannot transform payload to web stream, got ${stream}`);\n            }\n        },\n    });\n};\nconst isBlobInstance = (stream) => typeof Blob === \"function\" && stream instanceof Blob;\n","export async function splitStream(stream) {\n    if (typeof stream.stream === \"function\") {\n        stream = stream.stream();\n    }\n    const readableStream = stream;\n    return readableStream.tee();\n}\n","export async function headStream(stream, bytes) {\n    let byteLengthCounter = 0;\n    const chunks = [];\n    const reader = stream.getReader();\n    let isDone = false;\n    while (!isDone) {\n        const { done, value } = await reader.read();\n        if (value) {\n            chunks.push(value);\n            byteLengthCounter += value?.byteLength ?? 0;\n        }\n        if (byteLengthCounter >= bytes) {\n            break;\n        }\n        isDone = done;\n    }\n    reader.releaseLock();\n    const collected = new Uint8Array(Math.min(bytes, byteLengthCounter));\n    let offset = 0;\n    for (const chunk of chunks) {\n        if (chunk.byteLength > collected.byteLength - offset) {\n            collected.set(chunk.subarray(0, collected.byteLength - offset), offset);\n            break;\n        }\n        else {\n            collected.set(chunk, offset);\n        }\n        offset += chunk.length;\n    }\n    return collected;\n}\n","const ReadableStreamRef = typeof ReadableStream === \"function\" ? ReadableStream : function () { };\nexport class ChecksumStream extends ReadableStreamRef {\n}\n","import { toBase64 } from \"@smithy/util-base64\";\nimport { isReadableStream } from \"../stream-type-check\";\nimport { ChecksumStream } from \"./ChecksumStream.browser\";\nexport const createChecksumStream = ({ expectedChecksum, checksum, source, checksumSourceLocation, base64Encoder, }) => {\n    if (!isReadableStream(source)) {\n        throw new Error(`@smithy/util-stream: unsupported source type ${source?.constructor?.name ?? source} in ChecksumStream.`);\n    }\n    const encoder = base64Encoder ?? toBase64;\n    if (typeof TransformStream !== \"function\") {\n        throw new Error(\"@smithy/util-stream: unable to instantiate ChecksumStream because API unavailable: ReadableStream/TransformStream.\");\n    }\n    const transform = new TransformStream({\n        start() { },\n        async transform(chunk, controller) {\n            checksum.update(chunk);\n            controller.enqueue(chunk);\n        },\n        async flush(controller) {\n            const digest = await checksum.digest();\n            const received = encoder(digest);\n            if (expectedChecksum !== received) {\n                const error = new Error(`Checksum mismatch: expected \"${expectedChecksum}\" but received \"${received}\"` +\n                    ` in response header \"${checksumSourceLocation}\".`);\n                controller.error(error);\n            }\n            else {\n                controller.terminate();\n            }\n        },\n    });\n    source.pipeThrough(transform);\n    const readable = transform.readable;\n    Object.setPrototypeOf(readable, ChecksumStream.prototype);\n    return readable;\n};\n","export const escapeUri = (uri) => encodeURIComponent(uri).replace(/[!'()*]/g, hexEncode);\nconst hexEncode = (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`;\n","export const fromUtf8 = (input) => new TextEncoder().encode(input);\n","import { fromUtf8 } from \"./fromUtf8\";\nexport const toUint8Array = (data) => {\n    if (typeof data === \"string\") {\n        return fromUtf8(data);\n    }\n    if (ArrayBuffer.isView(data)) {\n        return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);\n    }\n    return new Uint8Array(data);\n};\n","export const toUtf8 = (input) => {\n    if (typeof input === \"string\") {\n        return input;\n    }\n    if (typeof input !== \"object\" || typeof input.byteOffset !== \"number\" || typeof input.byteLength !== \"number\") {\n        throw new Error(\"@smithy/util-utf8: toUtf8 encoder function only accepts string | Uint8Array.\");\n    }\n    return new TextDecoder(\"utf-8\").decode(input);\n};\n","export const waiterServiceDefaults = {\n    minDelay: 2,\n    maxDelay: 120,\n};\nexport var WaiterState;\n(function (WaiterState) {\n    WaiterState[\"ABORTED\"] = \"ABORTED\";\n    WaiterState[\"FAILURE\"] = \"FAILURE\";\n    WaiterState[\"SUCCESS\"] = \"SUCCESS\";\n    WaiterState[\"RETRY\"] = \"RETRY\";\n    WaiterState[\"TIMEOUT\"] = \"TIMEOUT\";\n})(WaiterState || (WaiterState = {}));\nexport const checkExceptions = (result) => {\n    if (result.state === WaiterState.ABORTED) {\n        const abortError = new Error(`${JSON.stringify({\n            ...result,\n            reason: \"Request was aborted\",\n        })}`);\n        abortError.name = \"AbortError\";\n        throw abortError;\n    }\n    else if (result.state === WaiterState.TIMEOUT) {\n        const timeoutError = new Error(`${JSON.stringify({\n            ...result,\n            reason: \"Waiter has timed out\",\n        })}`);\n        timeoutError.name = \"TimeoutError\";\n        throw timeoutError;\n    }\n    else if (result.state !== WaiterState.SUCCESS) {\n        throw new Error(`${JSON.stringify(result)}`);\n    }\n    return result;\n};\n"],"names":["HttpAuthLocation","HttpApiKeyAuthLocation","EndpointURLScheme","AlgorithmId","FieldPosition","SMITHY_CONTEXT_KEY","IniSectionType","RequestHandlerProtocol","parseUrl","url","URL","hostname","pathname","port","protocol","search","query","parseQueryString","parseInt","undefined","path","alphabetByEncoding","alphabetByValue","Array","i","start","charCodeAt","limit","char","String","fromCharCode","index","toString","bitsPerLetter","bitsPerByte","maxLetterValue","fromBase64","input","totalByteLength","length","slice","out","ArrayBuffer","dataView","DataView","bits","bitLength","j","TypeError","concat","chunkOffset","byteLength","Math","floor","k","offset","setUint8","Uint8Array","toBase64","_input","fromUtf8","isArrayLike","isUint8Array","byteOffset","Error","str","min","bitClusterCount","ceil","TEXT_ENCODER","TextEncoder","calculateBodyLength","body","encode","len","code","size","booleanSelector","obj","key","type","SelectorType","DEFAULTS_MODE_OPTIONS","resolveDefaultsModeConfig","defaultsMode","arguments","memoize","async","mode","toLowerCase","Promise","resolve","isMobileBrowser","toLocaleLowerCase","join","_window","_parsedUA$platform","parsedUA","window","navigator","userAgent","bowser","platform","EndpointCache","constructor","_ref","params","this","data","Map","parameters","capacity","get","endpointParams","resolver","hash","has","keys","value","done","next","delete","set","buffer","param","_endpointParams$param","val","includes","IP_V4_REGEX","RegExp","isIpAddress","test","startsWith","endsWith","VALID_HOST_LABEL_REGEX","isValidHostLabel","labels","split","label","customEndpointFunctions","debugId","toDebugString","ref","fn","argv","map","JSON","stringify","EndpointError","message","super","name","getAttr","parts","pathList","part","squareBracketIndex","indexOf","arrayIndex","Number","isNaN","push","getAttrPathList","reduce","acc","isArray","DEFAULT_PORTS","HTTP","HTTPS","endpointFunctions","booleanEquals","value1","value2","isSet","not","parseURL","whatwgURL","Object","entries","v","error","urlString","href","host","scheme","values","isIp","inputContainsDefaultPort","authority","normalizedPath","stringEquals","substring","stop","reverse","uriEncode","encodeURIComponent","replace","c","toUpperCase","evaluateTemplate","template","options","evaluatedTemplateArr","templateContext","_objectSpread","referenceRecord","currentIndex","openingBraceIndex","closingBraceIndex","parameterName","refName","attrName","evaluateExpression","keyName","callFunction","getReferenceValue","evaluatedArgs","arg","fnSegments","evaluateCondition","_options$logger","_options$logger$debug","assign","fnArgs","_objectWithoutProperties","_excluded","logger","debug","call","result","toAssign","evaluateConditions","conditions","conditionsReferenceRecord","condition","_options$logger2","getEndpointHeaders","headers","headerKey","headerVal","headerValEntry","processedExpr","getEndpointProperty","property","propertyEntry","getEndpointProperties","properties","propertyKey","propertyVal","getEndpointUrl","endpointUrl","expression","evaluateEndpointRule","endpointRule","endpoint","endpointRuleOptions","evaluateErrorRule","errorRule","evaluateTreeRule","treeRule","rules","evaluateRules","rule","endpointOrUndefined","resolveEndpoint","ruleSetObject","_options$logger2$debu","paramsWithDefault","filter","default","_ref2","paramKey","paramDefaultValue","requiredParams","_ref3","required","_ref4","requiredParam","SHORT_TO_HEX","HEX_TO_SHORT","encodedByte","fromHex","encoded","toHex","bytes","getSmithyContext","context","normalizeProvider","promisified","RETRY_MODES","DEFAULT_MAX_ATTEMPTS","DEFAULT_RETRY_MODE","STANDARD","DefaultRateLimiter","_options$beta","_options$minCapacity","_options$minFillRate","_options$scaleConstan","_options$smooth","currentCapacity","enabled","lastMaxRate","measuredTxRate","requestCount","lastTimestamp","timeWindow","beta","minCapacity","minFillRate","scaleConstant","smooth","currentTimeInSeconds","getCurrentTimeInSeconds","lastThrottleTime","lastTxRateBucket","fillRate","maxCapacity","Date","now","getSendToken","acquireTokenBucket","amount","refillTokenBucket","delay","setTimeoutFn","timestamp","fillAmount","updateClientSendingRate","response","calculatedRate","updateMeasuredRate","isThrottlingError","rateToUse","calculateTimeWindow","cubicThrottle","enableTokenBucket","cubicSuccess","newRate","updateTokenBucketRate","getPrecise","pow","max","t","timeBucket","currentRate","num","parseFloat","toFixed","setTimeout","DEFAULT_RETRY_DELAY_BASE","MAXIMUM_RETRY_DELAY","THROTTLING_RETRY_DELAY_BASE","INITIAL_RETRY_TOKENS","RETRY_COST","TIMEOUT_RETRY_COST","NO_RETRY_INCREMENT","INVOCATION_ID_HEADER","REQUEST_HEADER","createDefaultRetryToken","retryDelay","retryCount","retryCost","getRetryCount","getRetryDelay","getRetryCost","StandardRetryStrategy","maxAttempts","retryBackoffStrategy","getDefaultRetryBackoffStrategy","delayBase","computeNextBackoffDelay","attempts","random","setDelayBase","maxAttemptsProvider","acquireInitialRetryToken","retryTokenScope","refreshRetryTokenForRetry","token","errorInfo","getMaxAttempts","shouldRetry","errorType","delayFromErrorType","retryAfterHint","getTime","capacityCost","getCapacityCost","recordSuccess","_token$getRetryCost","getCapacity","tokenToRenew","isRetryableError","AdaptiveRetryStrategy","ADAPTIVE","rateLimiter","standardRetryStrategy","Uint8ArrayBlobAdapter","fromString","source","encoding","mutate","transformFromString","setPrototypeOf","prototype","transformToString","payload","toUtf8","getAwsChunkedEncodingStream","readableStream","base64Encoder","bodyLengthChecker","checksumAlgorithmFn","checksumLocationName","streamHasher","checksumRequired","digest","reader","getReader","ReadableStream","pull","controller","read","enqueue","checksum","close","isReadableStream","stream","_stream$constructor","ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED","sdkStreamMixin","isBlobInstance","_stream$__proto__","__proto__","transformed","transformToByteArray","streamCollector","buf","TextDecoder","decode","transformToWebStream","blob","blobToWebStream","Blob","splitStream","tee","headStream","byteLengthCounter","chunks","isDone","_value$byteLength","releaseLock","collected","chunk","subarray","ReadableStreamRef","ChecksumStream","createChecksumStream","expectedChecksum","checksumSourceLocation","_source$constructor$n","_source$constructor","encoder","TransformStream","transform","update","flush","received","terminate","pipeThrough","readable","escapeUri","uri","hexEncode","toUint8Array","isView","BYTES_PER_ELEMENT","WaiterState"],"sourceRoot":""}