@alliander-opensource/aws-jwt-sts 0.3.5 → 0.3.7

package/node_modules/@smithy/core/dist-cjs/submodules/cbor/index.js

@@ -1,990 +1,1114 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+'use strict';
 
-// src/submodules/cbor/index.ts
-var cbor_exports = {};
-__export(cbor_exports, {
-  CborCodec: () => CborCodec,
-  CborShapeDeserializer: () => CborShapeDeserializer,
-  CborShapeSerializer: () => CborShapeSerializer,
-  SmithyRpcV2CborProtocol: () => SmithyRpcV2CborProtocol,
-  buildHttpRpcRequest: () => buildHttpRpcRequest,
-  cbor: () => cbor,
-  checkCborResponse: () => checkCborResponse,
-  dateToTag: () => dateToTag,
-  loadSmithyRpcV2CborErrorCode: () => loadSmithyRpcV2CborErrorCode,
-  parseCborBody: () => parseCborBody,
-  parseCborErrorBody: () => parseCborErrorBody,
-  tag: () => tag,
-  tagSymbol: () => tagSymbol
-});
-module.exports = __toCommonJS(cbor_exports);
+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');
 
-// src/submodules/cbor/cbor-decode.ts
-var import_serde = require("@smithy/core/serde");
-var import_util_utf8 = require("@smithy/util-utf8");
-
-// src/submodules/cbor/cbor-types.ts
-var majorUint64 = 0;
-var majorNegativeInt64 = 1;
-var majorUnstructuredByteString = 2;
-var majorUtf8String = 3;
-var majorList = 4;
-var majorMap = 5;
-var majorTag = 6;
-var majorSpecial = 7;
-var specialFalse = 20;
-var specialTrue = 21;
-var specialNull = 22;
-var specialUndefined = 23;
-var extendedOneByte = 24;
-var extendedFloat16 = 25;
-var extendedFloat32 = 26;
-var extendedFloat64 = 27;
-var minorIndefinite = 31;
+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);
+    return typeof Buffer !== "undefined" ? Buffer.alloc(size) : new Uint8Array(size);
 }
-var tagSymbol = Symbol("@smithy/core/cbor::tagSymbol");
-function tag(data2) {
-  data2[tagSymbol] = true;
-  return data2;
+const tagSymbol = Symbol("@smithy/core/cbor::tagSymbol");
+function tag(data) {
+    data[tagSymbol] = true;
+    return data;
 }
 
-// src/submodules/cbor/cbor-decode.ts
-var USE_TEXT_DECODER = typeof TextDecoder !== "undefined";
-var USE_BUFFER = typeof Buffer !== "undefined";
-var payload = alloc(0);
-var dataView = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
-var textDecoder = USE_TEXT_DECODER ? new TextDecoder() : null;
-var _offset = 0;
+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 = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+    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] & 224) >> 5;
-  const minor = payload[at] & 31;
-  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.getUint16(countIndex);
-            } else if (countLength === 4) {
-              unsignedInt = dataView.getUint32(countIndex);
-            } else {
-              unsignedInt = dataView.getBigUint64(countIndex);
+    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;
             }
-            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 + length;
-          return minor === 3 ? -b - BigInt(1) : b;
-        } else if (minor === 4) {
-          const decimalFraction = decode(at + offset, to);
-          const [exponent, mantissa] = decimalFraction;
-          const s = mantissa.toString();
-          const numericString = exponent === 0 ? s : s.slice(0, s.length + exponent) + "." + s.slice(exponent);
-          return new import_serde.NumericValue(numericString, "bigDecimal");
-        } 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);
-  }
+            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 && bytes.constructor?.name === "Buffer") {
-    return bytes.toString("utf-8", at, to);
-  }
-  if (textDecoder) {
-    return textDecoder.decode(bytes.subarray(at, to));
-  }
-  return (0, import_util_utf8.toUtf8)(bytes.subarray(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 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;
 }
-var minorValueToArgumentLength = {
-  [extendedOneByte]: 1,
-  [extendedFloat16]: 2,
-  [extendedFloat32]: 4,
-  [extendedFloat64]: 8
+const minorValueToArgumentLength = {
+    [extendedOneByte]: 1,
+    [extendedFloat16]: 2,
+    [extendedFloat32]: 4,
+    [extendedFloat64]: 8,
 };
 function bytesToFloat16(a, b) {
-  const sign = a >> 7;
-  const exponent = (a & 124) >> 2;
-  const fraction = (a & 3) << 8 | b;
-  const scalar = sign === 0 ? 1 : -1;
-  let exponentComponent;
-  let summation;
-  if (exponent === 0) {
-    if (fraction === 0) {
-      return 0;
-    } else {
-      exponentComponent = Math.pow(2, 1 - 15);
-      summation = 0;
-    }
-  } else if (exponent === 31) {
-    if (fraction === 0) {
-      return scalar * Infinity;
-    } else {
-      return NaN;
-    }
-  } else {
-    exponentComponent = Math.pow(2, exponent - 15);
-    summation = 1;
-  }
-  summation += fraction / 1024;
-  return scalar * (exponentComponent * summation);
+    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] & 31;
-  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.getUint16(countIndex);
-    } else if (countLength === 4) {
-      return dataView.getUint32(countIndex);
-    }
-    return demote(dataView.getBigUint64(countIndex));
-  }
-  throw new Error(`unexpected minor value ${minor}.`);
+    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;
+    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] === 255) {
-      const data2 = alloc(vector.length);
-      data2.set(vector, 0);
-      _offset = at - base + 2;
-      return bytesToUtf8(data2, 0, data2.length);
-    }
-    const major = (payload[at] & 224) >> 5;
-    const minor = payload[at] & 31;
-    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.");
+    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;
+    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] === 255) {
-      const data2 = alloc(vector.length);
-      data2.set(vector, 0);
-      _offset = at - base + 2;
-      return data2;
-    }
-    const major = (payload[at] & 224) >> 5;
-    const minor = payload[at] & 31;
-    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.");
+    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;
+    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] === 255) {
-      _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.");
+    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] & 224) >> 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;
+    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] === 255) {
-      _offset = at - base + 2;
-      return map;
-    }
-    const major = (payload[at] & 224) >> 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.");
+    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] & 31;
-  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.getFloat32(at + 1);
-    case extendedFloat64:
-      if (to - at < 9) {
-        throw new Error("incomplete float64 at end of buf.");
-      }
-      _offset = 9;
-      return dataView.getFloat64(at + 1);
-    default:
-      throw new Error(`unexpected minor value ${minor}.`);
-  }
+    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") {
+    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 num = Number(bigInt);
-  if (Number.MIN_SAFE_INTEGER <= num && num <= Number.MAX_SAFE_INTEGER) {
-    return num;
-  }
-  return bigInt;
 }
 
-// src/submodules/cbor/cbor-encode.ts
-var import_serde2 = require("@smithy/core/serde");
-var import_util_utf82 = require("@smithy/util-utf8");
-var USE_BUFFER2 = typeof Buffer !== "undefined";
-var initialSize = 2048;
-var data = alloc(initialSize);
-var dataView2 = new DataView(data.buffer, data.byteOffset, data.byteLength);
-var cursor = 0;
+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 < 16e6) {
-      resize(Math.max(data.byteLength * 4, data.byteLength + bytes));
-    } else {
-      resize(data.byteLength + bytes + 16e6);
-    }
-  }
+    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;
+    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);
-    }
-  }
-  dataView2 = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    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;
-    dataView2.setUint16(cursor, value);
-    cursor += 2;
-  } else if (value < 2 ** 32) {
-    data[cursor++] = major << 5 | extendedFloat32;
-    dataView2.setUint32(cursor, value);
-    cursor += 4;
-  } else {
-    data[cursor++] = major << 5 | extendedFloat64;
-    dataView2.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_BUFFER2) {
-        encodeHeader(majorUtf8String, Buffer.byteLength(input));
-        cursor += data.write(input, cursor);
-      } else {
-        const bytes = (0, import_util_utf82.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;
-          dataView2.setUint32(cursor, value);
-          cursor += 4;
-        } else {
-          data[cursor++] = major << 5 | extendedFloat64;
-          dataView2.setBigUint64(cursor, BigInt(value));
-          cursor += 8;
-        }
-        continue;
-      }
-      data[cursor++] = majorSpecial << 5 | extendedFloat64;
-      dataView2.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 & 255;
-      } else if (n < 4294967296) {
-        data[cursor++] = major << 5 | extendedFloat32;
-        dataView2.setUint32(cursor, n);
+    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 if (value < BigInt("18446744073709551616")) {
-        data[cursor++] = major << 5 | extendedFloat64;
-        dataView2.setBigUint64(cursor, value);
+    }
+    else {
+        data[cursor++] = (major << 5) | extendedFloat64;
+        dataView.setBigUint64(cursor, typeof value === "bigint" ? value : BigInt(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 ? 194 : 195;
-        if (USE_BUFFER2) {
-          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 import_serde2.NumericValue) {
-        const decimalIndex = input.string.indexOf(".");
-        const exponent = decimalIndex === -1 ? 0 : decimalIndex - input.string.length + 1;
-        const mantissa = BigInt(input.string.replace(".", ""));
-        data[cursor++] = 196;
-        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.`);
-  }
+    }
+}
+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.`);
+    }
 }
 
-// src/submodules/cbor/cbor.ts
-var cbor = {
-  deserialize(payload2) {
-    setPayload(payload2);
-    return decode(0, payload2.length);
-  },
-  serialize(input) {
-    try {
-      encode(input);
-      return toUint8Array();
-    } catch (e) {
-      toUint8Array();
-      throw e;
-    }
-  },
-  /**
-   * @public
-   * @param size - byte length to allocate.
-   *
-   * This may be used to garbage collect the CBOR
-   * shared encoding buffer space,
-   * e.g. resizeEncodingBuffer(0);
-   *
-   * This may also be used to pre-allocate more space for
-   * CBOR encoding, e.g. resizeEncodingBuffer(100_000_000);
-   */
-  resizeEncodingBuffer(size) {
-    resize(size);
-  }
+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);
+    },
 };
 
-// src/submodules/cbor/parseCborBody.ts
-var import_protocols = require("@smithy/core/protocols");
-var import_protocol_http = require("@smithy/protocol-http");
-var import_util_body_length_browser = require("@smithy/util-body-length-browser");
-var parseCborBody = (streamBody, context) => {
-  return (0, import_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 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 {};
+    });
 };
-var dateToTag = (date) => {
-  return tag({
-    tag: 1,
-    value: date.getTime() / 1e3
-  });
+const dateToTag = (date) => {
+    return tag({
+        tag: 1,
+        value: date.getTime() / 1000,
+    });
 };
-var parseCborErrorBody = async (errorBody, context) => {
-  const value = await parseCborBody(errorBody, context);
-  value.message = value.message ?? value.Message;
-  return value;
+const parseCborErrorBody = async (errorBody, context) => {
+    const value = await parseCborBody(errorBody, context);
+    value.message = value.message ?? value.Message;
+    return value;
 };
-var loadSmithyRpcV2CborErrorCode = (output, data2) => {
-  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 (data2["__type"] !== void 0) {
-    return sanitizeErrorCode(data2["__type"]);
-  }
-  const codeKey = Object.keys(data2).find((key) => key.toLowerCase() === "code");
-  if (codeKey && data2[codeKey] !== void 0) {
-    return sanitizeErrorCode(data2[codeKey]);
-  }
+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"]);
+    }
+    let codeKey;
+    for (const key in data) {
+        if (key.toLowerCase() === "code") {
+            codeKey = key;
+            break;
+        }
+    }
+    if (codeKey && data[codeKey] !== undefined) {
+        return sanitizeErrorCode(data[codeKey]);
+    }
 };
-var checkCborResponse = (response) => {
-  if (String(response.headers["smithy-protocol"]).toLowerCase() !== "rpc-v2-cbor") {
-    throw new Error("Malformed RPCv2 CBOR response, status: " + response.statusCode);
-  }
+const checkCborResponse = (response) => {
+    if (String(response.headers["smithy-protocol"]).toLowerCase() !== "rpc-v2-cbor") {
+        throw new Error("Malformed RPCv2 CBOR response, status: " + response.statusCode);
+    }
 };
-var 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: {
-      // intentional copy.
-      ...headers
-    }
-  };
-  if (resolvedHostname !== void 0) {
-    contents.hostname = resolvedHostname;
-  }
-  if (body !== void 0) {
-    contents.body = body;
-    try {
-      contents.headers["content-length"] = String((0, import_util_body_length_browser.calculateBodyLength)(body));
-    } catch (e) {
-    }
-  }
-  return new import_protocol_http.HttpRequest(contents);
+const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
+    const endpoint = await context.endpoint();
+    const { hostname, protocol = "https", port, path: basePath } = 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 (endpoint.headers) {
+        for (const name in endpoint.headers) {
+            contents.headers[name] = endpoint.headers[name];
+        }
+    }
+    if (body !== undefined) {
+        contents.body = body;
+        try {
+            contents.headers["content-length"] = String(utilBodyLengthBrowser.calculateBodyLength(body));
+        }
+        catch (e) { }
+    }
+    return new protocolHttp.HttpRequest(contents);
 };
 
-// src/submodules/cbor/SmithyRpcV2CborProtocol.ts
-var import_protocols2 = require("@smithy/core/protocols");
-var import_schema2 = require("@smithy/core/schema");
-var import_util_middleware = require("@smithy/util-middleware");
+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 in 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;
+                    }
+                }
+                const isUnion = ns.isUnionSchema();
+                if (isUnion && Array.isArray(sourceObject.$unknown)) {
+                    const [k, v] = sourceObject.$unknown;
+                    newObject[k] = v;
+                }
+                else if (typeof sourceObject.__type === "string") {
+                    for (const k in sourceObject) {
+                        if (!(k in newObject)) {
+                            newObject[k] = this.serialize(15, sourceObject[k]);
+                        }
+                    }
+                }
+            }
+            else if (ns.isDocumentSchema()) {
+                for (const key in sourceObject) {
+                    newObject[key] = this.serialize(ns.getValueSchema(), sourceObject[key]);
+                }
+            }
+            else if (ns.isBigDecimalSchema()) {
+                return sourceObject;
+            }
+            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()) {
+            if (typeof value === "number") {
+                return serde._parseEpochTimestamp(value);
+            }
+            if (typeof value === "object") {
+                if (value.tag === 1 && "value" in value) {
+                    return serde._parseEpochTimestamp(value.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 === "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();
+                for (const item of value) {
+                    const itemValue = this.readValue(memberSchema, item);
+                    newArray.push(itemValue);
+                }
+                return newArray;
+            }
+            const newObject = {};
+            if (ns.isMapSchema()) {
+                const targetSchema = ns.getValueSchema();
+                for (const key in value) {
+                    const itemValue = this.readValue(targetSchema, value[key]);
+                    newObject[key] = itemValue;
+                }
+            }
+            else if (ns.isStructSchema()) {
+                const isUnion = ns.isUnionSchema();
+                let keys;
+                if (isUnion) {
+                    keys = new Set();
+                    for (const k in value) {
+                        if (k !== "__type") {
+                            keys.add(k);
+                        }
+                    }
+                }
+                for (const [key, memberSchema] of ns.structIterator()) {
+                    if (isUnion) {
+                        keys.delete(key);
+                    }
+                    if (value[key] != null) {
+                        newObject[key] = this.readValue(memberSchema, value[key]);
+                    }
+                }
+                if (isUnion && keys?.size === 1) {
+                    let newObjectEmpty = true;
+                    for (const _ in newObject) {
+                        newObjectEmpty = false;
+                        break;
+                    }
+                    if (newObjectEmpty) {
+                        const k = keys.values().next().value;
+                        newObject.$unknown = [k, value[k]];
+                    }
+                }
+                else if (typeof value.__type === "string") {
+                    for (const k in value) {
+                        if (!(k in newObject)) {
+                            newObject[k] = value[k];
+                        }
+                    }
+                }
+            }
+            else if (value instanceof serde.NumericValue) {
+                return value;
+            }
+            return newObject;
+        }
+        else {
+            return value;
+        }
+    }
+}
 
-// src/submodules/cbor/CborCodec.ts
-var import_schema = require("@smithy/core/schema");
-var import_serde3 = require("@smithy/core/serde");
-var CborCodec = class {
-  createSerializer() {
-    const serializer = new CborShapeSerializer();
-    serializer.setSerdeContext(this.serdeContext);
-    return serializer;
-  }
-  createDeserializer() {
-    const deserializer = new CborShapeDeserializer();
-    deserializer.setSerdeContext(this.serdeContext);
-    return deserializer;
-  }
-  setSerdeContext(serdeContext) {
-    this.serdeContext = serdeContext;
-  }
-};
-var CborShapeSerializer = class {
-  setSerdeContext(serdeContext) {
-    this.serdeContext = serdeContext;
-  }
-  write(schema, value) {
-    this.value = (0, import_serde3.copyDocumentWithTransform)(value, schema, (_, schemaRef) => {
-      if (_ instanceof Date) {
-        return dateToTag(_);
-      }
-      if (_ instanceof Uint8Array) {
-        return _;
-      }
-      const ns = import_schema.NormalizedSchema.of(schemaRef);
-      const sparse = !!ns.getMergedTraits().sparse;
-      if (ns.isListSchema() && Array.isArray(_)) {
-        if (!sparse) {
-          return _.filter((item) => item != null);
-        }
-      } else if (_ && typeof _ === "object") {
-        const members = ns.getMemberSchemas();
-        const isStruct = ns.isStructSchema();
-        if (!sparse || isStruct) {
-          for (const [k, v] of Object.entries(_)) {
-            const filteredOutByNonSparse = !sparse && v == null;
-            const filteredOutByUnrecognizedMember = isStruct && !(k in members);
-            if (filteredOutByNonSparse || filteredOutByUnrecognizedMember) {
-              delete _[k];
-            }
-          }
-          return _;
-        }
-      }
-      return _;
-    });
-  }
-  flush() {
-    const buffer = cbor.serialize(this.value);
-    this.value = void 0;
-    return buffer;
-  }
-};
-var CborShapeDeserializer = class {
-  setSerdeContext(serdeContext) {
-    this.serdeContext = serdeContext;
-  }
-  read(schema, bytes) {
-    const data2 = cbor.deserialize(bytes);
-    return this.readValue(schema, data2);
-  }
-  readValue(_schema, value) {
-    const ns = import_schema.NormalizedSchema.of(_schema);
-    const schema = ns.getSchema();
-    if (typeof schema === "number") {
-      if (ns.isTimestampSchema()) {
-        return (0, import_serde3.parseEpochTimestamp)(value);
-      }
-      if (ns.isBlobSchema()) {
-        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.isListSchema() && !!ns.getMergedTraits().sparse;
-        for (const item of value) {
-          newArray.push(this.readValue(memberSchema, item));
-          if (!sparse && newArray[newArray.length - 1] == null) {
-            newArray.pop();
-          }
-        }
-        return newArray;
-      }
-      const newObject = {};
-      if (ns.isMapSchema()) {
-        const sparse = ns.getMergedTraits().sparse;
-        const targetSchema = ns.getValueSchema();
-        for (const key of Object.keys(value)) {
-          newObject[key] = this.readValue(targetSchema, value[key]);
-          if (newObject[key] == null && !sparse) {
-            delete newObject[key];
-          }
-        }
-      } 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, errorTypeRegistries, }) {
+        super({ defaultNamespace, errorTypeRegistries });
+    }
+    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";
+        const errorMetadata = {
+            $metadata: metadata,
+            $fault: response.statusCode <= 500 ? "client" : "server",
+        };
+        let namespace = this.options.defaultNamespace;
+        if (errorName.includes("#")) {
+            [namespace] = errorName.split("#");
+        }
+        const registry = this.compositeErrorRegistry;
+        const nsRegistry = schema.TypeRegistry.for(namespace);
+        registry.copyFrom(nsRegistry);
+        let errorSchema;
+        try {
+            errorSchema = registry.getSchema(errorName);
+        }
+        catch (e) {
+            if (dataObject.Message) {
+                dataObject.message = dataObject.Message;
+            }
+            const syntheticRegistry = schema.TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace);
+            registry.copyFrom(syntheticRegistry);
+            const baseExceptionSchema = registry.getBaseException();
+            if (baseExceptionSchema) {
+                const ErrorCtor = registry.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";
+    }
+}
 
-// src/submodules/cbor/SmithyRpcV2CborProtocol.ts
-var SmithyRpcV2CborProtocol = class extends import_protocols2.RpcProtocol {
-  constructor({ defaultNamespace }) {
-    super({ defaultNamespace });
-    this.codec = new CborCodec();
-    this.serializer = this.codec.createSerializer();
-    this.deserializer = this.codec.createDeserializer();
-  }
-  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": "application/cbor",
-      "smithy-protocol": "rpc-v2-cbor",
-      accept: "application/cbor"
-    });
-    if ((0, import_schema2.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 } = (0, import_util_middleware.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 error = loadSmithyRpcV2CborErrorCode(response, dataObject) ?? "Unknown";
-    let namespace = this.options.defaultNamespace;
-    if (error.includes("#")) {
-      [namespace] = error.split("#");
-    }
-    const registry = import_schema2.TypeRegistry.for(namespace);
-    const errorSchema = registry.getSchema(error);
-    if (!errorSchema) {
-      throw new Error("schema not found for " + error);
-    }
-    const message = dataObject.message ?? dataObject.Message ?? "Unknown";
-    const exception = new errorSchema.ctor(message);
-    Object.assign(exception, {
-      $metadata: metadata,
-      $response: response,
-      message,
-      ...dataObject
-    });
-    throw exception;
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CborCodec,
-  CborShapeDeserializer,
-  CborShapeSerializer,
-  SmithyRpcV2CborProtocol,
-  buildHttpRpcRequest,
-  cbor,
-  checkCborResponse,
-  dateToTag,
-  loadSmithyRpcV2CborErrorCode,
-  parseCborBody,
-  parseCborErrorBody,
-  tag,
-  tagSymbol
-});
+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;