p6-cdk-namer 1.3.45 → 1.3.46

package/node_modules/@aws-sdk/token-providers/node_modules/@smithy/core/dist-cjs/submodules/cbor/index.js

@@ -1,1048 +0,0 @@
-'use strict';
-
-var serde = require('@smithy/core/serde');
-var utilUtf8 = require('@smithy/util-utf8');
-var protocols = require('@smithy/core/protocols');
-var protocolHttp = require('@smithy/protocol-http');
-var utilBodyLengthBrowser = require('@smithy/util-body-length-browser');
-var schema = require('@smithy/core/schema');
-var utilMiddleware = require('@smithy/util-middleware');
-var utilBase64 = require('@smithy/util-base64');
-
-const majorUint64 = 0;
-const majorNegativeInt64 = 1;
-const majorUnstructuredByteString = 2;
-const majorUtf8String = 3;
-const majorList = 4;
-const majorMap = 5;
-const majorTag = 6;
-const majorSpecial = 7;
-const specialFalse = 20;
-const specialTrue = 21;
-const specialNull = 22;
-const specialUndefined = 23;
-const extendedOneByte = 24;
-const extendedFloat16 = 25;
-const extendedFloat32 = 26;
-const extendedFloat64 = 27;
-const minorIndefinite = 31;
-function alloc(size) {
-    return typeof Buffer !== "undefined" ? Buffer.alloc(size) : new Uint8Array(size);
-}
-const tagSymbol = Symbol("@smithy/core/cbor::tagSymbol");
-function tag(data) {
-    data[tagSymbol] = true;
-    return data;
-}
-
-const USE_TEXT_DECODER = typeof TextDecoder !== "undefined";
-const USE_BUFFER$1 = typeof Buffer !== "undefined";
-let payload = alloc(0);
-let dataView$1 = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
-const textDecoder = USE_TEXT_DECODER ? new TextDecoder() : null;
-let _offset = 0;
-function setPayload(bytes) {
-    payload = bytes;
-    dataView$1 = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
-}
-function decode(at, to) {
-    if (at >= to) {
-        throw new Error("unexpected end of (decode) payload.");
-    }
-    const major = (payload[at] & 0b1110_0000) >> 5;
-    const minor = payload[at] & 0b0001_1111;
-    switch (major) {
-        case majorUint64:
-        case majorNegativeInt64:
-        case majorTag:
-            let unsignedInt;
-            let offset;
-            if (minor < 24) {
-                unsignedInt = minor;
-                offset = 1;
-            }
-            else {
-                switch (minor) {
-                    case extendedOneByte:
-                    case extendedFloat16:
-                    case extendedFloat32:
-                    case extendedFloat64:
-                        const countLength = minorValueToArgumentLength[minor];
-                        const countOffset = (countLength + 1);
-                        offset = countOffset;
-                        if (to - at < countOffset) {
-                            throw new Error(`countLength ${countLength} greater than remaining buf len.`);
-                        }
-                        const countIndex = at + 1;
-                        if (countLength === 1) {
-                            unsignedInt = payload[countIndex];
-                        }
-                        else if (countLength === 2) {
-                            unsignedInt = dataView$1.getUint16(countIndex);
-                        }
-                        else if (countLength === 4) {
-                            unsignedInt = dataView$1.getUint32(countIndex);
-                        }
-                        else {
-                            unsignedInt = dataView$1.getBigUint64(countIndex);
-                        }
-                        break;
-                    default:
-                        throw new Error(`unexpected minor value ${minor}.`);
-                }
-            }
-            if (major === majorUint64) {
-                _offset = offset;
-                return castBigInt(unsignedInt);
-            }
-            else if (major === majorNegativeInt64) {
-                let negativeInt;
-                if (typeof unsignedInt === "bigint") {
-                    negativeInt = BigInt(-1) - unsignedInt;
-                }
-                else {
-                    negativeInt = -1 - unsignedInt;
-                }
-                _offset = offset;
-                return castBigInt(negativeInt);
-            }
-            else {
-                if (minor === 2 || minor === 3) {
-                    const length = decodeCount(at + offset, to);
-                    let b = BigInt(0);
-                    const start = at + offset + _offset;
-                    for (let i = start; i < start + length; ++i) {
-                        b = (b << BigInt(8)) | BigInt(payload[i]);
-                    }
-                    _offset = offset + _offset + length;
-                    return minor === 3 ? -b - BigInt(1) : b;
-                }
-                else if (minor === 4) {
-                    const decimalFraction = decode(at + offset, to);
-                    const [exponent, mantissa] = decimalFraction;
-                    const normalizer = mantissa < 0 ? -1 : 1;
-                    const mantissaStr = "0".repeat(Math.abs(exponent) + 1) + String(BigInt(normalizer) * BigInt(mantissa));
-                    let numericString;
-                    const sign = mantissa < 0 ? "-" : "";
-                    numericString =
-                        exponent === 0
-                            ? mantissaStr
-                            : mantissaStr.slice(0, mantissaStr.length + exponent) + "." + mantissaStr.slice(exponent);
-                    numericString = numericString.replace(/^0+/g, "");
-                    if (numericString === "") {
-                        numericString = "0";
-                    }
-                    if (numericString[0] === ".") {
-                        numericString = "0" + numericString;
-                    }
-                    numericString = sign + numericString;
-                    _offset = offset + _offset;
-                    return serde.nv(numericString);
-                }
-                else {
-                    const value = decode(at + offset, to);
-                    const valueOffset = _offset;
-                    _offset = offset + valueOffset;
-                    return tag({ tag: castBigInt(unsignedInt), value });
-                }
-            }
-        case majorUtf8String:
-        case majorMap:
-        case majorList:
-        case majorUnstructuredByteString:
-            if (minor === minorIndefinite) {
-                switch (major) {
-                    case majorUtf8String:
-                        return decodeUtf8StringIndefinite(at, to);
-                    case majorMap:
-                        return decodeMapIndefinite(at, to);
-                    case majorList:
-                        return decodeListIndefinite(at, to);
-                    case majorUnstructuredByteString:
-                        return decodeUnstructuredByteStringIndefinite(at, to);
-                }
-            }
-            else {
-                switch (major) {
-                    case majorUtf8String:
-                        return decodeUtf8String(at, to);
-                    case majorMap:
-                        return decodeMap(at, to);
-                    case majorList:
-                        return decodeList(at, to);
-                    case majorUnstructuredByteString:
-                        return decodeUnstructuredByteString(at, to);
-                }
-            }
-        default:
-            return decodeSpecial(at, to);
-    }
-}
-function bytesToUtf8(bytes, at, to) {
-    if (USE_BUFFER$1 && bytes.constructor?.name === "Buffer") {
-        return bytes.toString("utf-8", at, to);
-    }
-    if (textDecoder) {
-        return textDecoder.decode(bytes.subarray(at, to));
-    }
-    return utilUtf8.toUtf8(bytes.subarray(at, to));
-}
-function demote(bigInteger) {
-    const num = Number(bigInteger);
-    if (num < Number.MIN_SAFE_INTEGER || Number.MAX_SAFE_INTEGER < num) {
-        console.warn(new Error(`@smithy/core/cbor - truncating BigInt(${bigInteger}) to ${num} with loss of precision.`));
-    }
-    return num;
-}
-const minorValueToArgumentLength = {
-    [extendedOneByte]: 1,
-    [extendedFloat16]: 2,
-    [extendedFloat32]: 4,
-    [extendedFloat64]: 8,
-};
-function bytesToFloat16(a, b) {
-    const sign = a >> 7;
-    const exponent = (a & 0b0111_1100) >> 2;
-    const fraction = ((a & 0b0000_0011) << 8) | b;
-    const scalar = sign === 0 ? 1 : -1;
-    let exponentComponent;
-    let summation;
-    if (exponent === 0b00000) {
-        if (fraction === 0b00000_00000) {
-            return 0;
-        }
-        else {
-            exponentComponent = Math.pow(2, 1 - 15);
-            summation = 0;
-        }
-    }
-    else if (exponent === 0b11111) {
-        if (fraction === 0b00000_00000) {
-            return scalar * Infinity;
-        }
-        else {
-            return NaN;
-        }
-    }
-    else {
-        exponentComponent = Math.pow(2, exponent - 15);
-        summation = 1;
-    }
-    summation += fraction / 1024;
-    return scalar * (exponentComponent * summation);
-}
-function decodeCount(at, to) {
-    const minor = payload[at] & 0b0001_1111;
-    if (minor < 24) {
-        _offset = 1;
-        return minor;
-    }
-    if (minor === extendedOneByte ||
-        minor === extendedFloat16 ||
-        minor === extendedFloat32 ||
-        minor === extendedFloat64) {
-        const countLength = minorValueToArgumentLength[minor];
-        _offset = (countLength + 1);
-        if (to - at < _offset) {
-            throw new Error(`countLength ${countLength} greater than remaining buf len.`);
-        }
-        const countIndex = at + 1;
-        if (countLength === 1) {
-            return payload[countIndex];
-        }
-        else if (countLength === 2) {
-            return dataView$1.getUint16(countIndex);
-        }
-        else if (countLength === 4) {
-            return dataView$1.getUint32(countIndex);
-        }
-        return demote(dataView$1.getBigUint64(countIndex));
-    }
-    throw new Error(`unexpected minor value ${minor}.`);
-}
-function decodeUtf8String(at, to) {
-    const length = decodeCount(at, to);
-    const offset = _offset;
-    at += offset;
-    if (to - at < length) {
-        throw new Error(`string len ${length} greater than remaining buf len.`);
-    }
-    const value = bytesToUtf8(payload, at, at + length);
-    _offset = offset + length;
-    return value;
-}
-function decodeUtf8StringIndefinite(at, to) {
-    at += 1;
-    const vector = [];
-    for (const base = at; at < to;) {
-        if (payload[at] === 0b1111_1111) {
-            const data = alloc(vector.length);
-            data.set(vector, 0);
-            _offset = at - base + 2;
-            return bytesToUtf8(data, 0, data.length);
-        }
-        const major = (payload[at] & 0b1110_0000) >> 5;
-        const minor = payload[at] & 0b0001_1111;
-        if (major !== majorUtf8String) {
-            throw new Error(`unexpected major type ${major} in indefinite string.`);
-        }
-        if (minor === minorIndefinite) {
-            throw new Error("nested indefinite string.");
-        }
-        const bytes = decodeUnstructuredByteString(at, to);
-        const length = _offset;
-        at += length;
-        for (let i = 0; i < bytes.length; ++i) {
-            vector.push(bytes[i]);
-        }
-    }
-    throw new Error("expected break marker.");
-}
-function decodeUnstructuredByteString(at, to) {
-    const length = decodeCount(at, to);
-    const offset = _offset;
-    at += offset;
-    if (to - at < length) {
-        throw new Error(`unstructured byte string len ${length} greater than remaining buf len.`);
-    }
-    const value = payload.subarray(at, at + length);
-    _offset = offset + length;
-    return value;
-}
-function decodeUnstructuredByteStringIndefinite(at, to) {
-    at += 1;
-    const vector = [];
-    for (const base = at; at < to;) {
-        if (payload[at] === 0b1111_1111) {
-            const data = alloc(vector.length);
-            data.set(vector, 0);
-            _offset = at - base + 2;
-            return data;
-        }
-        const major = (payload[at] & 0b1110_0000) >> 5;
-        const minor = payload[at] & 0b0001_1111;
-        if (major !== majorUnstructuredByteString) {
-            throw new Error(`unexpected major type ${major} in indefinite string.`);
-        }
-        if (minor === minorIndefinite) {
-            throw new Error("nested indefinite string.");
-        }
-        const bytes = decodeUnstructuredByteString(at, to);
-        const length = _offset;
-        at += length;
-        for (let i = 0; i < bytes.length; ++i) {
-            vector.push(bytes[i]);
-        }
-    }
-    throw new Error("expected break marker.");
-}
-function decodeList(at, to) {
-    const listDataLength = decodeCount(at, to);
-    const offset = _offset;
-    at += offset;
-    const base = at;
-    const list = Array(listDataLength);
-    for (let i = 0; i < listDataLength; ++i) {
-        const item = decode(at, to);
-        const itemOffset = _offset;
-        list[i] = item;
-        at += itemOffset;
-    }
-    _offset = offset + (at - base);
-    return list;
-}
-function decodeListIndefinite(at, to) {
-    at += 1;
-    const list = [];
-    for (const base = at; at < to;) {
-        if (payload[at] === 0b1111_1111) {
-            _offset = at - base + 2;
-            return list;
-        }
-        const item = decode(at, to);
-        const n = _offset;
-        at += n;
-        list.push(item);
-    }
-    throw new Error("expected break marker.");
-}
-function decodeMap(at, to) {
-    const mapDataLength = decodeCount(at, to);
-    const offset = _offset;
-    at += offset;
-    const base = at;
-    const map = {};
-    for (let i = 0; i < mapDataLength; ++i) {
-        if (at >= to) {
-            throw new Error("unexpected end of map payload.");
-        }
-        const major = (payload[at] & 0b1110_0000) >> 5;
-        if (major !== majorUtf8String) {
-            throw new Error(`unexpected major type ${major} for map key at index ${at}.`);
-        }
-        const key = decode(at, to);
-        at += _offset;
-        const value = decode(at, to);
-        at += _offset;
-        map[key] = value;
-    }
-    _offset = offset + (at - base);
-    return map;
-}
-function decodeMapIndefinite(at, to) {
-    at += 1;
-    const base = at;
-    const map = {};
-    for (; at < to;) {
-        if (at >= to) {
-            throw new Error("unexpected end of map payload.");
-        }
-        if (payload[at] === 0b1111_1111) {
-            _offset = at - base + 2;
-            return map;
-        }
-        const major = (payload[at] & 0b1110_0000) >> 5;
-        if (major !== majorUtf8String) {
-            throw new Error(`unexpected major type ${major} for map key.`);
-        }
-        const key = decode(at, to);
-        at += _offset;
-        const value = decode(at, to);
-        at += _offset;
-        map[key] = value;
-    }
-    throw new Error("expected break marker.");
-}
-function decodeSpecial(at, to) {
-    const minor = payload[at] & 0b0001_1111;
-    switch (minor) {
-        case specialTrue:
-        case specialFalse:
-            _offset = 1;
-            return minor === specialTrue;
-        case specialNull:
-            _offset = 1;
-            return null;
-        case specialUndefined:
-            _offset = 1;
-            return null;
-        case extendedFloat16:
-            if (to - at < 3) {
-                throw new Error("incomplete float16 at end of buf.");
-            }
-            _offset = 3;
-            return bytesToFloat16(payload[at + 1], payload[at + 2]);
-        case extendedFloat32:
-            if (to - at < 5) {
-                throw new Error("incomplete float32 at end of buf.");
-            }
-            _offset = 5;
-            return dataView$1.getFloat32(at + 1);
-        case extendedFloat64:
-            if (to - at < 9) {
-                throw new Error("incomplete float64 at end of buf.");
-            }
-            _offset = 9;
-            return dataView$1.getFloat64(at + 1);
-        default:
-            throw new Error(`unexpected minor value ${minor}.`);
-    }
-}
-function castBigInt(bigInt) {
-    if (typeof bigInt === "number") {
-        return bigInt;
-    }
-    const num = Number(bigInt);
-    if (Number.MIN_SAFE_INTEGER <= num && num <= Number.MAX_SAFE_INTEGER) {
-        return num;
-    }
-    return bigInt;
-}
-
-const USE_BUFFER = typeof Buffer !== "undefined";
-const initialSize = 2048;
-let data = alloc(initialSize);
-let dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
-let cursor = 0;
-function ensureSpace(bytes) {
-    const remaining = data.byteLength - cursor;
-    if (remaining < bytes) {
-        if (cursor < 16_000_000) {
-            resize(Math.max(data.byteLength * 4, data.byteLength + bytes));
-        }
-        else {
-            resize(data.byteLength + bytes + 16_000_000);
-        }
-    }
-}
-function toUint8Array() {
-    const out = alloc(cursor);
-    out.set(data.subarray(0, cursor), 0);
-    cursor = 0;
-    return out;
-}
-function resize(size) {
-    const old = data;
-    data = alloc(size);
-    if (old) {
-        if (old.copy) {
-            old.copy(data, 0, 0, old.byteLength);
-        }
-        else {
-            data.set(old, 0);
-        }
-    }
-    dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
-}
-function encodeHeader(major, value) {
-    if (value < 24) {
-        data[cursor++] = (major << 5) | value;
-    }
-    else if (value < 1 << 8) {
-        data[cursor++] = (major << 5) | 24;
-        data[cursor++] = value;
-    }
-    else if (value < 1 << 16) {
-        data[cursor++] = (major << 5) | extendedFloat16;
-        dataView.setUint16(cursor, value);
-        cursor += 2;
-    }
-    else if (value < 2 ** 32) {
-        data[cursor++] = (major << 5) | extendedFloat32;
-        dataView.setUint32(cursor, value);
-        cursor += 4;
-    }
-    else {
-        data[cursor++] = (major << 5) | extendedFloat64;
-        dataView.setBigUint64(cursor, typeof value === "bigint" ? value : BigInt(value));
-        cursor += 8;
-    }
-}
-function encode(_input) {
-    const encodeStack = [_input];
-    while (encodeStack.length) {
-        const input = encodeStack.pop();
-        ensureSpace(typeof input === "string" ? input.length * 4 : 64);
-        if (typeof input === "string") {
-            if (USE_BUFFER) {
-                encodeHeader(majorUtf8String, Buffer.byteLength(input));
-                cursor += data.write(input, cursor);
-            }
-            else {
-                const bytes = utilUtf8.fromUtf8(input);
-                encodeHeader(majorUtf8String, bytes.byteLength);
-                data.set(bytes, cursor);
-                cursor += bytes.byteLength;
-            }
-            continue;
-        }
-        else if (typeof input === "number") {
-            if (Number.isInteger(input)) {
-                const nonNegative = input >= 0;
-                const major = nonNegative ? majorUint64 : majorNegativeInt64;
-                const value = nonNegative ? input : -input - 1;
-                if (value < 24) {
-                    data[cursor++] = (major << 5) | value;
-                }
-                else if (value < 256) {
-                    data[cursor++] = (major << 5) | 24;
-                    data[cursor++] = value;
-                }
-                else if (value < 65536) {
-                    data[cursor++] = (major << 5) | extendedFloat16;
-                    data[cursor++] = value >> 8;
-                    data[cursor++] = value;
-                }
-                else if (value < 4294967296) {
-                    data[cursor++] = (major << 5) | extendedFloat32;
-                    dataView.setUint32(cursor, value);
-                    cursor += 4;
-                }
-                else {
-                    data[cursor++] = (major << 5) | extendedFloat64;
-                    dataView.setBigUint64(cursor, BigInt(value));
-                    cursor += 8;
-                }
-                continue;
-            }
-            data[cursor++] = (majorSpecial << 5) | extendedFloat64;
-            dataView.setFloat64(cursor, input);
-            cursor += 8;
-            continue;
-        }
-        else if (typeof input === "bigint") {
-            const nonNegative = input >= 0;
-            const major = nonNegative ? majorUint64 : majorNegativeInt64;
-            const value = nonNegative ? input : -input - BigInt(1);
-            const n = Number(value);
-            if (n < 24) {
-                data[cursor++] = (major << 5) | n;
-            }
-            else if (n < 256) {
-                data[cursor++] = (major << 5) | 24;
-                data[cursor++] = n;
-            }
-            else if (n < 65536) {
-                data[cursor++] = (major << 5) | extendedFloat16;
-                data[cursor++] = n >> 8;
-                data[cursor++] = n & 0b1111_1111;
-            }
-            else if (n < 4294967296) {
-                data[cursor++] = (major << 5) | extendedFloat32;
-                dataView.setUint32(cursor, n);
-                cursor += 4;
-            }
-            else if (value < BigInt("18446744073709551616")) {
-                data[cursor++] = (major << 5) | extendedFloat64;
-                dataView.setBigUint64(cursor, value);
-                cursor += 8;
-            }
-            else {
-                const binaryBigInt = value.toString(2);
-                const bigIntBytes = new Uint8Array(Math.ceil(binaryBigInt.length / 8));
-                let b = value;
-                let i = 0;
-                while (bigIntBytes.byteLength - ++i >= 0) {
-                    bigIntBytes[bigIntBytes.byteLength - i] = Number(b & BigInt(255));
-                    b >>= BigInt(8);
-                }
-                ensureSpace(bigIntBytes.byteLength * 2);
-                data[cursor++] = nonNegative ? 0b110_00010 : 0b110_00011;
-                if (USE_BUFFER) {
-                    encodeHeader(majorUnstructuredByteString, Buffer.byteLength(bigIntBytes));
-                }
-                else {
-                    encodeHeader(majorUnstructuredByteString, bigIntBytes.byteLength);
-                }
-                data.set(bigIntBytes, cursor);
-                cursor += bigIntBytes.byteLength;
-            }
-            continue;
-        }
-        else if (input === null) {
-            data[cursor++] = (majorSpecial << 5) | specialNull;
-            continue;
-        }
-        else if (typeof input === "boolean") {
-            data[cursor++] = (majorSpecial << 5) | (input ? specialTrue : specialFalse);
-            continue;
-        }
-        else if (typeof input === "undefined") {
-            throw new Error("@smithy/core/cbor: client may not serialize undefined value.");
-        }
-        else if (Array.isArray(input)) {
-            for (let i = input.length - 1; i >= 0; --i) {
-                encodeStack.push(input[i]);
-            }
-            encodeHeader(majorList, input.length);
-            continue;
-        }
-        else if (typeof input.byteLength === "number") {
-            ensureSpace(input.length * 2);
-            encodeHeader(majorUnstructuredByteString, input.length);
-            data.set(input, cursor);
-            cursor += input.byteLength;
-            continue;
-        }
-        else if (typeof input === "object") {
-            if (input instanceof serde.NumericValue) {
-                const decimalIndex = input.string.indexOf(".");
-                const exponent = decimalIndex === -1 ? 0 : decimalIndex - input.string.length + 1;
-                const mantissa = BigInt(input.string.replace(".", ""));
-                data[cursor++] = 0b110_00100;
-                encodeStack.push(mantissa);
-                encodeStack.push(exponent);
-                encodeHeader(majorList, 2);
-                continue;
-            }
-            if (input[tagSymbol]) {
-                if ("tag" in input && "value" in input) {
-                    encodeStack.push(input.value);
-                    encodeHeader(majorTag, input.tag);
-                    continue;
-                }
-                else {
-                    throw new Error("tag encountered with missing fields, need 'tag' and 'value', found: " + JSON.stringify(input));
-                }
-            }
-            const keys = Object.keys(input);
-            for (let i = keys.length - 1; i >= 0; --i) {
-                const key = keys[i];
-                encodeStack.push(input[key]);
-                encodeStack.push(key);
-            }
-            encodeHeader(majorMap, keys.length);
-            continue;
-        }
-        throw new Error(`data type ${input?.constructor?.name ?? typeof input} not compatible for encoding.`);
-    }
-}
-
-const cbor = {
-    deserialize(payload) {
-        setPayload(payload);
-        return decode(0, payload.length);
-    },
-    serialize(input) {
-        try {
-            encode(input);
-            return toUint8Array();
-        }
-        catch (e) {
-            toUint8Array();
-            throw e;
-        }
-    },
-    resizeEncodingBuffer(size) {
-        resize(size);
-    },
-};
-
-const parseCborBody = (streamBody, context) => {
-    return protocols.collectBody(streamBody, context).then(async (bytes) => {
-        if (bytes.length) {
-            try {
-                return cbor.deserialize(bytes);
-            }
-            catch (e) {
-                Object.defineProperty(e, "$responseBodyText", {
-                    value: context.utf8Encoder(bytes),
-                });
-                throw e;
-            }
-        }
-        return {};
-    });
-};
-const dateToTag = (date) => {
-    return tag({
-        tag: 1,
-        value: date.getTime() / 1000,
-    });
-};
-const parseCborErrorBody = async (errorBody, context) => {
-    const value = await parseCborBody(errorBody, context);
-    value.message = value.message ?? value.Message;
-    return value;
-};
-const loadSmithyRpcV2CborErrorCode = (output, data) => {
-    const sanitizeErrorCode = (rawValue) => {
-        let cleanValue = rawValue;
-        if (typeof cleanValue === "number") {
-            cleanValue = cleanValue.toString();
-        }
-        if (cleanValue.indexOf(",") >= 0) {
-            cleanValue = cleanValue.split(",")[0];
-        }
-        if (cleanValue.indexOf(":") >= 0) {
-            cleanValue = cleanValue.split(":")[0];
-        }
-        if (cleanValue.indexOf("#") >= 0) {
-            cleanValue = cleanValue.split("#")[1];
-        }
-        return cleanValue;
-    };
-    if (data["__type"] !== undefined) {
-        return sanitizeErrorCode(data["__type"]);
-    }
-    const codeKey = Object.keys(data).find((key) => key.toLowerCase() === "code");
-    if (codeKey && data[codeKey] !== undefined) {
-        return sanitizeErrorCode(data[codeKey]);
-    }
-};
-const checkCborResponse = (response) => {
-    if (String(response.headers["smithy-protocol"]).toLowerCase() !== "rpc-v2-cbor") {
-        throw new Error("Malformed RPCv2 CBOR response, status: " + response.statusCode);
-    }
-};
-const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const contents = {
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
-        headers: {
-            ...headers,
-        },
-    };
-    if (resolvedHostname !== undefined) {
-        contents.hostname = resolvedHostname;
-    }
-    if (body !== undefined) {
-        contents.body = body;
-        try {
-            contents.headers["content-length"] = String(utilBodyLengthBrowser.calculateBodyLength(body));
-        }
-        catch (e) { }
-    }
-    return new protocolHttp.HttpRequest(contents);
-};
-
-class CborCodec extends protocols.SerdeContext {
-    createSerializer() {
-        const serializer = new CborShapeSerializer();
-        serializer.setSerdeContext(this.serdeContext);
-        return serializer;
-    }
-    createDeserializer() {
-        const deserializer = new CborShapeDeserializer();
-        deserializer.setSerdeContext(this.serdeContext);
-        return deserializer;
-    }
-}
-class CborShapeSerializer extends protocols.SerdeContext {
-    value;
-    write(schema, value) {
-        this.value = this.serialize(schema, value);
-    }
-    serialize(schema$1, source) {
-        const ns = schema.NormalizedSchema.of(schema$1);
-        if (source == null) {
-            if (ns.isIdempotencyToken()) {
-                return serde.generateIdempotencyToken();
-            }
-            return source;
-        }
-        if (ns.isBlobSchema()) {
-            if (typeof source === "string") {
-                return (this.serdeContext?.base64Decoder ?? utilBase64.fromBase64)(source);
-            }
-            return source;
-        }
-        if (ns.isTimestampSchema()) {
-            if (typeof source === "number" || typeof source === "bigint") {
-                return dateToTag(new Date((Number(source) / 1000) | 0));
-            }
-            return dateToTag(source);
-        }
-        if (typeof source === "function" || typeof source === "object") {
-            const sourceObject = source;
-            if (ns.isListSchema() && Array.isArray(sourceObject)) {
-                const sparse = !!ns.getMergedTraits().sparse;
-                const newArray = [];
-                let i = 0;
-                for (const item of sourceObject) {
-                    const value = this.serialize(ns.getValueSchema(), item);
-                    if (value != null || sparse) {
-                        newArray[i++] = value;
-                    }
-                }
-                return newArray;
-            }
-            if (sourceObject instanceof Date) {
-                return dateToTag(sourceObject);
-            }
-            const newObject = {};
-            if (ns.isMapSchema()) {
-                const sparse = !!ns.getMergedTraits().sparse;
-                for (const key of Object.keys(sourceObject)) {
-                    const value = this.serialize(ns.getValueSchema(), sourceObject[key]);
-                    if (value != null || sparse) {
-                        newObject[key] = value;
-                    }
-                }
-            }
-            else if (ns.isStructSchema()) {
-                for (const [key, memberSchema] of ns.structIterator()) {
-                    const value = this.serialize(memberSchema, sourceObject[key]);
-                    if (value != null) {
-                        newObject[key] = value;
-                    }
-                }
-            }
-            else if (ns.isDocumentSchema()) {
-                for (const key of Object.keys(sourceObject)) {
-                    newObject[key] = this.serialize(ns.getValueSchema(), sourceObject[key]);
-                }
-            }
-            return newObject;
-        }
-        return source;
-    }
-    flush() {
-        const buffer = cbor.serialize(this.value);
-        this.value = undefined;
-        return buffer;
-    }
-}
-class CborShapeDeserializer extends protocols.SerdeContext {
-    read(schema, bytes) {
-        const data = cbor.deserialize(bytes);
-        return this.readValue(schema, data);
-    }
-    readValue(_schema, value) {
-        const ns = schema.NormalizedSchema.of(_schema);
-        if (ns.isTimestampSchema() && typeof value === "number") {
-            return serde._parseEpochTimestamp(value);
-        }
-        if (ns.isBlobSchema()) {
-            if (typeof value === "string") {
-                return (this.serdeContext?.base64Decoder ?? utilBase64.fromBase64)(value);
-            }
-            return value;
-        }
-        if (typeof value === "undefined" ||
-            typeof value === "boolean" ||
-            typeof value === "number" ||
-            typeof value === "string" ||
-            typeof value === "bigint" ||
-            typeof value === "symbol") {
-            return value;
-        }
-        else if (typeof value === "function" || typeof value === "object") {
-            if (value === null) {
-                return null;
-            }
-            if ("byteLength" in value) {
-                return value;
-            }
-            if (value instanceof Date) {
-                return value;
-            }
-            if (ns.isDocumentSchema()) {
-                return value;
-            }
-            if (ns.isListSchema()) {
-                const newArray = [];
-                const memberSchema = ns.getValueSchema();
-                const sparse = !!ns.getMergedTraits().sparse;
-                for (const item of value) {
-                    const itemValue = this.readValue(memberSchema, item);
-                    if (itemValue != null || sparse) {
-                        newArray.push(itemValue);
-                    }
-                }
-                return newArray;
-            }
-            const newObject = {};
-            if (ns.isMapSchema()) {
-                const sparse = !!ns.getMergedTraits().sparse;
-                const targetSchema = ns.getValueSchema();
-                for (const key of Object.keys(value)) {
-                    const itemValue = this.readValue(targetSchema, value[key]);
-                    if (itemValue != null || sparse) {
-                        newObject[key] = itemValue;
-                    }
-                }
-            }
-            else if (ns.isStructSchema()) {
-                for (const [key, memberSchema] of ns.structIterator()) {
-                    newObject[key] = this.readValue(memberSchema, value[key]);
-                }
-            }
-            return newObject;
-        }
-        else {
-            return value;
-        }
-    }
-}
-
-class SmithyRpcV2CborProtocol extends protocols.RpcProtocol {
-    codec = new CborCodec();
-    serializer = this.codec.createSerializer();
-    deserializer = this.codec.createDeserializer();
-    constructor({ defaultNamespace }) {
-        super({ defaultNamespace });
-    }
-    getShapeId() {
-        return "smithy.protocols#rpcv2Cbor";
-    }
-    getPayloadCodec() {
-        return this.codec;
-    }
-    async serializeRequest(operationSchema, input, context) {
-        const request = await super.serializeRequest(operationSchema, input, context);
-        Object.assign(request.headers, {
-            "content-type": this.getDefaultContentType(),
-            "smithy-protocol": "rpc-v2-cbor",
-            accept: this.getDefaultContentType(),
-        });
-        if (schema.deref(operationSchema.input) === "unit") {
-            delete request.body;
-            delete request.headers["content-type"];
-        }
-        else {
-            if (!request.body) {
-                this.serializer.write(15, {});
-                request.body = this.serializer.flush();
-            }
-            try {
-                request.headers["content-length"] = String(request.body.byteLength);
-            }
-            catch (e) { }
-        }
-        const { service, operation } = utilMiddleware.getSmithyContext(context);
-        const path = `/service/${service}/operation/${operation}`;
-        if (request.path.endsWith("/")) {
-            request.path += path.slice(1);
-        }
-        else {
-            request.path += path;
-        }
-        return request;
-    }
-    async deserializeResponse(operationSchema, context, response) {
-        return super.deserializeResponse(operationSchema, context, response);
-    }
-    async handleError(operationSchema, context, response, dataObject, metadata) {
-        const errorName = loadSmithyRpcV2CborErrorCode(response, dataObject) ?? "Unknown";
-        let namespace = this.options.defaultNamespace;
-        if (errorName.includes("#")) {
-            [namespace] = errorName.split("#");
-        }
-        const errorMetadata = {
-            $metadata: metadata,
-            $response: response,
-            $fault: response.statusCode <= 500 ? "client" : "server",
-        };
-        const registry = schema.TypeRegistry.for(namespace);
-        let errorSchema;
-        try {
-            errorSchema = registry.getSchema(errorName);
-        }
-        catch (e) {
-            if (dataObject.Message) {
-                dataObject.message = dataObject.Message;
-            }
-            const synthetic = schema.TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace);
-            const baseExceptionSchema = synthetic.getBaseException();
-            if (baseExceptionSchema) {
-                const ErrorCtor = synthetic.getErrorCtor(baseExceptionSchema);
-                throw Object.assign(new ErrorCtor({ name: errorName }), errorMetadata, dataObject);
-            }
-            throw Object.assign(new Error(errorName), errorMetadata, dataObject);
-        }
-        const ns = schema.NormalizedSchema.of(errorSchema);
-        const ErrorCtor = registry.getErrorCtor(errorSchema);
-        const message = dataObject.message ?? dataObject.Message ?? "Unknown";
-        const exception = new ErrorCtor(message);
-        const output = {};
-        for (const [name, member] of ns.structIterator()) {
-            output[name] = this.deserializer.readValue(member, dataObject[name]);
-        }
-        throw Object.assign(exception, errorMetadata, {
-            $fault: ns.getMergedTraits().error,
-            message,
-        }, output);
-    }
-    getDefaultContentType() {
-        return "application/cbor";
-    }
-}
-
-exports.CborCodec = CborCodec;
-exports.CborShapeDeserializer = CborShapeDeserializer;
-exports.CborShapeSerializer = CborShapeSerializer;
-exports.SmithyRpcV2CborProtocol = SmithyRpcV2CborProtocol;
-exports.buildHttpRpcRequest = buildHttpRpcRequest;
-exports.cbor = cbor;
-exports.checkCborResponse = checkCborResponse;
-exports.dateToTag = dateToTag;
-exports.loadSmithyRpcV2CborErrorCode = loadSmithyRpcV2CborErrorCode;
-exports.parseCborBody = parseCborBody;
-exports.parseCborErrorBody = parseCborErrorBody;
-exports.tag = tag;
-exports.tagSymbol = tagSymbol;