nowbackup 1.0.3

package/dist/chunk-APZ4HNNC.js

@@ -0,0 +1,1428 @@
+// ../../node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var getFilename = () => fileURLToPath(import.meta.url);
+var getDirname = () => path.dirname(getFilename());
+var __dirname = /* @__PURE__ */ getDirname();
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/is-array-buffer/is-array-buffer.js
+var isArrayBuffer = (arg) => typeof ArrayBuffer === "function" && arg instanceof ArrayBuffer || Object.prototype.toString.call(arg) === "[object ArrayBuffer]";
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/util-buffer-from/buffer-from.js
+var fromArrayBuffer = (input, offset = 0, length = input.byteLength - offset) => {
+  if (!isArrayBuffer(input)) {
+    throw new TypeError(`The "input" argument must be ArrayBuffer. Received type ${typeof input} (${input})`);
+  }
+  return Buffer.from(input, offset, length);
+};
+var fromString = (input, encoding) => {
+  if (typeof input !== "string") {
+    throw new TypeError(`The "input" argument must be of type string. Received type ${typeof input} (${input})`);
+  }
+  return encoding ? Buffer.from(input, encoding) : Buffer.from(input);
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/util-utf8/fromUtf8.js
+var fromUtf8 = (input) => {
+  const buf = fromString(input, "utf8");
+  return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength / Uint8Array.BYTES_PER_ELEMENT);
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/util-utf8/toUtf8.js
+var toUtf8 = (input) => {
+  if (typeof input === "string") {
+    return input;
+  }
+  if (typeof input !== "object" || typeof input.byteOffset !== "number" || typeof input.byteLength !== "number") {
+    throw new Error("@smithy/util-utf8: toUtf8 encoder function only accepts string | Uint8Array.");
+  }
+  return fromArrayBuffer(input.buffer, input.byteOffset, input.byteLength).toString("utf8");
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/util-hex-encoding/hex-encoding.js
+var SHORT_TO_HEX = {};
+var HEX_TO_SHORT = {};
+for (let i = 0; i < 256; i++) {
+  let encodedByte = i.toString(16).toLowerCase();
+  if (encodedByte.length === 1) {
+    encodedByte = `0${encodedByte}`;
+  }
+  SHORT_TO_HEX[i] = encodedByte;
+  HEX_TO_SHORT[encodedByte] = i;
+}
+function fromHex(encoded) {
+  if (encoded.length % 2 !== 0) {
+    throw new Error("Hex encoded strings must have an even number length");
+  }
+  const out = new Uint8Array(encoded.length / 2);
+  for (let i = 0; i < encoded.length; i += 2) {
+    const encodedByte = encoded.slice(i, i + 2).toLowerCase();
+    if (encodedByte in HEX_TO_SHORT) {
+      out[i / 2] = HEX_TO_SHORT[encodedByte];
+    } else {
+      throw new Error(`Cannot decode unrecognized sequence ${encodedByte} as hexadecimal`);
+    }
+  }
+  return out;
+}
+function toHex(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes.byteLength; i++) {
+    out += SHORT_TO_HEX[bytes[i]];
+  }
+  return out;
+}
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/index.js
+import { getRandomValues } from "crypto";
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/util-base64/fromBase64.js
+var BASE64_REGEX = /^[A-Za-z0-9+/]*={0,2}$/;
+var fromBase64 = (input) => {
+  if (input.length * 3 % 4 !== 0) {
+    throw new TypeError(`Incorrect padding on base64 string.`);
+  }
+  if (!BASE64_REGEX.exec(input)) {
+    throw new TypeError(`Invalid base64 string.`);
+  }
+  const buffer = fromString(input, "base64");
+  return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/util-base64/toBase64.js
+var toBase64 = (_input) => {
+  let input;
+  if (typeof _input === "string") {
+    input = fromUtf8(_input);
+  } else {
+    input = _input;
+  }
+  if (typeof input !== "object" || typeof input.byteOffset !== "number" || typeof input.byteLength !== "number") {
+    throw new Error("@smithy/util-base64: toBase64 encoder function only accepts string | Uint8Array.");
+  }
+  return fromArrayBuffer(input.buffer, input.byteOffset, input.byteLength).toString("base64");
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/util-stream/blob/Uint8ArrayBlobAdapter.js
+function bindUint8ArrayBlobAdapter(toUtf83, fromUtf83, toBase643, fromBase643) {
+  return class Uint8ArrayBlobAdapter2 extends Uint8Array {
+    static fromString(source, encoding = "utf-8") {
+      if (typeof source === "string") {
+        if (encoding === "base64") {
+          return Uint8ArrayBlobAdapter2.mutate(fromBase643(source));
+        }
+        return Uint8ArrayBlobAdapter2.mutate(fromUtf83(source));
+      }
+      throw new Error(`Unsupported conversion from ${typeof source} to Uint8ArrayBlobAdapter.`);
+    }
+    static mutate(source) {
+      Object.setPrototypeOf(source, Uint8ArrayBlobAdapter2.prototype);
+      return source;
+    }
+    transformToString(encoding = "utf-8") {
+      if (encoding === "base64") {
+        return toBase643(this);
+      }
+      return toUtf83(this);
+    }
+  };
+}
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/uuid/v4.js
+var decimalToHex = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bindV4(getRandomValues2) {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return () => crypto.randomUUID();
+  }
+  return () => {
+    const rnds = new Uint8Array(16);
+    getRandomValues2(rnds);
+    rnds[6] = rnds[6] & 15 | 64;
+    rnds[8] = rnds[8] & 63 | 128;
+    return decimalToHex[rnds[0]] + decimalToHex[rnds[1]] + decimalToHex[rnds[2]] + decimalToHex[rnds[3]] + "-" + decimalToHex[rnds[4]] + decimalToHex[rnds[5]] + "-" + decimalToHex[rnds[6]] + decimalToHex[rnds[7]] + "-" + decimalToHex[rnds[8]] + decimalToHex[rnds[9]] + "-" + decimalToHex[rnds[10]] + decimalToHex[rnds[11]] + decimalToHex[rnds[12]] + decimalToHex[rnds[13]] + decimalToHex[rnds[14]] + decimalToHex[rnds[15]];
+  };
+}
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/parse-utils.js
+var expectNumber = (value) => {
+  if (value === null || value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    const parsed = parseFloat(value);
+    if (!Number.isNaN(parsed)) {
+      if (String(parsed) !== String(value)) {
+        logger.warn(stackTraceWarning(`Expected number but observed string: ${value}`));
+      }
+      return parsed;
+    }
+  }
+  if (typeof value === "number") {
+    return value;
+  }
+  throw new TypeError(`Expected number, got ${typeof value}: ${value}`);
+};
+var MAX_FLOAT = Math.ceil(2 ** 127 * (2 - 2 ** -23));
+var expectFloat32 = (value) => {
+  const expected = expectNumber(value);
+  if (expected !== void 0 && !Number.isNaN(expected) && expected !== Infinity && expected !== -Infinity) {
+    if (Math.abs(expected) > MAX_FLOAT) {
+      throw new TypeError(`Expected 32-bit float, got ${value}`);
+    }
+  }
+  return expected;
+};
+var expectLong = (value) => {
+  if (value === null || value === void 0) {
+    return void 0;
+  }
+  if (Number.isInteger(value) && !Number.isNaN(value)) {
+    return value;
+  }
+  throw new TypeError(`Expected integer, got ${typeof value}: ${value}`);
+};
+var expectShort = (value) => expectSizedInt(value, 16);
+var expectByte = (value) => expectSizedInt(value, 8);
+var expectSizedInt = (value, size) => {
+  const expected = expectLong(value);
+  if (expected !== void 0 && castInt(expected, size) !== expected) {
+    throw new TypeError(`Expected ${size}-bit integer, got ${value}`);
+  }
+  return expected;
+};
+var castInt = (value, size) => {
+  switch (size) {
+    case 32:
+      return Int32Array.of(value)[0];
+    case 16:
+      return Int16Array.of(value)[0];
+    case 8:
+      return Int8Array.of(value)[0];
+  }
+};
+var strictParseDouble = (value) => {
+  if (typeof value == "string") {
+    return expectNumber(parseNumber(value));
+  }
+  return expectNumber(value);
+};
+var strictParseFloat32 = (value) => {
+  if (typeof value == "string") {
+    return expectFloat32(parseNumber(value));
+  }
+  return expectFloat32(value);
+};
+var NUMBER_REGEX = /(-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)|(-?Infinity)|(NaN)/g;
+var parseNumber = (value) => {
+  const matches = value.match(NUMBER_REGEX);
+  if (matches === null || matches[0].length !== value.length) {
+    throw new TypeError(`Expected real number, got implicit NaN`);
+  }
+  return parseFloat(value);
+};
+var strictParseShort = (value) => {
+  if (typeof value === "string") {
+    return expectShort(parseNumber(value));
+  }
+  return expectShort(value);
+};
+var strictParseByte = (value) => {
+  if (typeof value === "string") {
+    return expectByte(parseNumber(value));
+  }
+  return expectByte(value);
+};
+var stackTraceWarning = (message) => {
+  return String(new TypeError(message).stack || message).split("\n").slice(0, 5).filter((s) => !s.includes("stackTraceWarning")).join("\n");
+};
+var logger = {
+  warn: console.warn
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/date-utils.js
+var DAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+var MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+function dateToUtcString(date2) {
+  const year2 = date2.getUTCFullYear();
+  const month = date2.getUTCMonth();
+  const dayOfWeek = date2.getUTCDay();
+  const dayOfMonthInt = date2.getUTCDate();
+  const hoursInt = date2.getUTCHours();
+  const minutesInt = date2.getUTCMinutes();
+  const secondsInt = date2.getUTCSeconds();
+  const dayOfMonthString = dayOfMonthInt < 10 ? `0${dayOfMonthInt}` : `${dayOfMonthInt}`;
+  const hoursString = hoursInt < 10 ? `0${hoursInt}` : `${hoursInt}`;
+  const minutesString = minutesInt < 10 ? `0${minutesInt}` : `${minutesInt}`;
+  const secondsString = secondsInt < 10 ? `0${secondsInt}` : `${secondsInt}`;
+  return `${DAYS[dayOfWeek]}, ${dayOfMonthString} ${MONTHS[month]} ${year2} ${hoursString}:${minutesString}:${secondsString} GMT`;
+}
+var RFC3339 = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?[zZ]$/);
+var parseRfc3339DateTime = (value) => {
+  if (value === null || value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new TypeError("RFC-3339 date-times must be expressed as strings");
+  }
+  const match = RFC3339.exec(value);
+  if (!match) {
+    throw new TypeError("Invalid RFC-3339 date-time value");
+  }
+  const [_, yearStr, monthStr, dayStr, hours, minutes, seconds, fractionalMilliseconds] = match;
+  const year2 = strictParseShort(stripLeadingZeroes(yearStr));
+  const month = parseDateValue(monthStr, "month", 1, 12);
+  const day = parseDateValue(dayStr, "day", 1, 31);
+  return buildDate(year2, month, day, { hours, minutes, seconds, fractionalMilliseconds });
+};
+var RFC3339_WITH_OFFSET = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(([-+]\d{2}\:\d{2})|[zZ])$/);
+var parseRfc3339DateTimeWithOffset = (value) => {
+  if (value === null || value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new TypeError("RFC-3339 date-times must be expressed as strings");
+  }
+  const match = RFC3339_WITH_OFFSET.exec(value);
+  if (!match) {
+    throw new TypeError("Invalid RFC-3339 date-time value");
+  }
+  const [_, yearStr, monthStr, dayStr, hours, minutes, seconds, fractionalMilliseconds, offsetStr] = match;
+  const year2 = strictParseShort(stripLeadingZeroes(yearStr));
+  const month = parseDateValue(monthStr, "month", 1, 12);
+  const day = parseDateValue(dayStr, "day", 1, 31);
+  const date2 = buildDate(year2, month, day, { hours, minutes, seconds, fractionalMilliseconds });
+  if (offsetStr.toUpperCase() != "Z") {
+    date2.setTime(date2.getTime() - parseOffsetToMilliseconds(offsetStr));
+  }
+  return date2;
+};
+var IMF_FIXDATE = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\d{2}) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{4}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/);
+var RFC_850_DATE = new RegExp(/^(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (\d{2})-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/);
+var ASC_TIME = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ( [1-9]|\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? (\d{4})$/);
+var parseRfc7231DateTime = (value) => {
+  if (value === null || value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new TypeError("RFC-7231 date-times must be expressed as strings");
+  }
+  let match = IMF_FIXDATE.exec(value);
+  if (match) {
+    const [_, dayStr, monthStr, yearStr, hours, minutes, seconds, fractionalMilliseconds] = match;
+    return buildDate(strictParseShort(stripLeadingZeroes(yearStr)), parseMonthByShortName(monthStr), parseDateValue(dayStr, "day", 1, 31), { hours, minutes, seconds, fractionalMilliseconds });
+  }
+  match = RFC_850_DATE.exec(value);
+  if (match) {
+    const [_, dayStr, monthStr, yearStr, hours, minutes, seconds, fractionalMilliseconds] = match;
+    return adjustRfc850Year(buildDate(parseTwoDigitYear(yearStr), parseMonthByShortName(monthStr), parseDateValue(dayStr, "day", 1, 31), {
+      hours,
+      minutes,
+      seconds,
+      fractionalMilliseconds
+    }));
+  }
+  match = ASC_TIME.exec(value);
+  if (match) {
+    const [_, monthStr, dayStr, hours, minutes, seconds, fractionalMilliseconds, yearStr] = match;
+    return buildDate(strictParseShort(stripLeadingZeroes(yearStr)), parseMonthByShortName(monthStr), parseDateValue(dayStr.trimLeft(), "day", 1, 31), { hours, minutes, seconds, fractionalMilliseconds });
+  }
+  throw new TypeError("Invalid RFC-7231 date-time value");
+};
+var parseEpochTimestamp = (value) => {
+  if (value === null || value === void 0) {
+    return void 0;
+  }
+  let valueAsDouble;
+  if (typeof value === "number") {
+    valueAsDouble = value;
+  } else if (typeof value === "string") {
+    valueAsDouble = strictParseDouble(value);
+  } else if (typeof value === "object" && value.tag === 1) {
+    valueAsDouble = value.value;
+  } else {
+    throw new TypeError("Epoch timestamps must be expressed as floating point numbers or their string representation");
+  }
+  if (Number.isNaN(valueAsDouble) || valueAsDouble === Infinity || valueAsDouble === -Infinity) {
+    throw new TypeError("Epoch timestamps must be valid, non-Infinite, non-NaN numerics");
+  }
+  return new Date(Math.round(valueAsDouble * 1e3));
+};
+var buildDate = (year2, month, day, time2) => {
+  const adjustedMonth = month - 1;
+  validateDayOfMonth(year2, adjustedMonth, day);
+  return new Date(Date.UTC(year2, adjustedMonth, day, parseDateValue(time2.hours, "hour", 0, 23), parseDateValue(time2.minutes, "minute", 0, 59), parseDateValue(time2.seconds, "seconds", 0, 60), parseMilliseconds(time2.fractionalMilliseconds)));
+};
+var parseTwoDigitYear = (value) => {
+  const thisYear = (/* @__PURE__ */ new Date()).getUTCFullYear();
+  const valueInThisCentury = Math.floor(thisYear / 100) * 100 + strictParseShort(stripLeadingZeroes(value));
+  if (valueInThisCentury < thisYear) {
+    return valueInThisCentury + 100;
+  }
+  return valueInThisCentury;
+};
+var FIFTY_YEARS_IN_MILLIS = 50 * 365 * 24 * 60 * 60 * 1e3;
+var adjustRfc850Year = (input) => {
+  if (input.getTime() - (/* @__PURE__ */ new Date()).getTime() > FIFTY_YEARS_IN_MILLIS) {
+    return new Date(Date.UTC(input.getUTCFullYear() - 100, input.getUTCMonth(), input.getUTCDate(), input.getUTCHours(), input.getUTCMinutes(), input.getUTCSeconds(), input.getUTCMilliseconds()));
+  }
+  return input;
+};
+var parseMonthByShortName = (value) => {
+  const monthIdx = MONTHS.indexOf(value);
+  if (monthIdx < 0) {
+    throw new TypeError(`Invalid month: ${value}`);
+  }
+  return monthIdx + 1;
+};
+var DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+var validateDayOfMonth = (year2, month, day) => {
+  let maxDays = DAYS_IN_MONTH[month];
+  if (month === 1 && isLeapYear(year2)) {
+    maxDays = 29;
+  }
+  if (day > maxDays) {
+    throw new TypeError(`Invalid day for ${MONTHS[month]} in ${year2}: ${day}`);
+  }
+};
+var isLeapYear = (year2) => {
+  return year2 % 4 === 0 && (year2 % 100 !== 0 || year2 % 400 === 0);
+};
+var parseDateValue = (value, type, lower, upper) => {
+  const dateVal = strictParseByte(stripLeadingZeroes(value));
+  if (dateVal < lower || dateVal > upper) {
+    throw new TypeError(`${type} must be between ${lower} and ${upper}, inclusive`);
+  }
+  return dateVal;
+};
+var parseMilliseconds = (value) => {
+  if (value === null || value === void 0) {
+    return 0;
+  }
+  return strictParseFloat32("0." + value) * 1e3;
+};
+var parseOffsetToMilliseconds = (value) => {
+  const directionStr = value[0];
+  let direction = 1;
+  if (directionStr == "+") {
+    direction = 1;
+  } else if (directionStr == "-") {
+    direction = -1;
+  } else {
+    throw new TypeError(`Offset direction, ${directionStr}, must be "+" or "-"`);
+  }
+  const hour = Number(value.substring(1, 3));
+  const minute = Number(value.substring(4, 6));
+  return direction * (hour * 60 + minute) * 60 * 1e3;
+};
+var stripLeadingZeroes = (value) => {
+  let idx = 0;
+  while (idx < value.length - 1 && value.charAt(idx) === "0") {
+    idx++;
+  }
+  if (idx === 0) {
+    return value;
+  }
+  return value.slice(idx);
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/lazy-json.js
+var LazyJsonString = function LazyJsonString2(val) {
+  const str = Object.assign(new String(val), {
+    deserializeJSON() {
+      return JSON.parse(String(val));
+    },
+    toString() {
+      return String(val);
+    },
+    toJSON() {
+      return String(val);
+    }
+  });
+  return str;
+};
+LazyJsonString.from = (object) => {
+  if (object && typeof object === "object" && (object instanceof LazyJsonString || "deserializeJSON" in object)) {
+    return object;
+  } else if (typeof object === "string" || Object.getPrototypeOf(object) === String.prototype) {
+    return LazyJsonString(String(object));
+  }
+  return LazyJsonString(JSON.stringify(object));
+};
+LazyJsonString.fromObject = LazyJsonString.from;
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/quote-header.js
+function quoteHeader(part) {
+  if (part.includes(",") || part.includes('"')) {
+    part = `"${part.replace(/"/g, '\\"')}"`;
+  }
+  return part;
+}
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/schema-serde-lib/schema-date-utils.js
+var ddd = `(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)(?:[ne|u?r]?s?day)?`;
+var mmm = `(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)`;
+var time = `(\\d?\\d):(\\d{2}):(\\d{2})(?:\\.(\\d+))?`;
+var date = `(\\d?\\d)`;
+var year = `(\\d{4})`;
+var RFC3339_WITH_OFFSET2 = new RegExp(/^(\d{4})-(\d\d)-(\d\d)[tT](\d\d):(\d\d):(\d\d)(\.(\d+))?(([-+]\d\d:\d\d)|[zZ])$/);
+var IMF_FIXDATE2 = new RegExp(`^${ddd}, ${date} ${mmm} ${year} ${time} GMT$`);
+var RFC_850_DATE2 = new RegExp(`^${ddd}, ${date}-${mmm}-(\\d\\d) ${time} GMT$`);
+var ASC_TIME2 = new RegExp(`^${ddd} ${mmm} ( [1-9]|\\d\\d) ${time} ${year}$`);
+var months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+var _parseEpochTimestamp = (value) => {
+  if (value == null) {
+    return void 0;
+  }
+  let num = NaN;
+  if (typeof value === "number") {
+    num = value;
+  } else if (typeof value === "string") {
+    if (!/^-?\d*\.?\d+$/.test(value)) {
+      throw new TypeError(`parseEpochTimestamp - numeric string invalid.`);
+    }
+    num = Number.parseFloat(value);
+  } else if (typeof value === "object" && value.tag === 1) {
+    num = value.value;
+  }
+  if (isNaN(num) || Math.abs(num) === Infinity) {
+    throw new TypeError("Epoch timestamps must be valid finite numbers.");
+  }
+  return new Date(Math.round(num * 1e3));
+};
+var _parseRfc3339DateTimeWithOffset = (value) => {
+  if (value == null) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new TypeError("RFC3339 timestamps must be strings");
+  }
+  const matches = RFC3339_WITH_OFFSET2.exec(value);
+  if (!matches) {
+    throw new TypeError(`Invalid RFC3339 timestamp format ${value}`);
+  }
+  const [, yearStr, monthStr, dayStr, hours, minutes, seconds, , ms, offsetStr] = matches;
+  range(monthStr, 1, 12);
+  range(dayStr, 1, 31);
+  range(hours, 0, 23);
+  range(minutes, 0, 59);
+  range(seconds, 0, 60);
+  const date2 = new Date(Date.UTC(Number(yearStr), Number(monthStr) - 1, Number(dayStr), Number(hours), Number(minutes), Number(seconds), Number(ms) ? Math.round(parseFloat(`0.${ms}`) * 1e3) : 0));
+  date2.setUTCFullYear(Number(yearStr));
+  if (offsetStr.toUpperCase() != "Z") {
+    const [, sign, offsetH, offsetM] = /([+-])(\d\d):(\d\d)/.exec(offsetStr) || [void 0, "+", 0, 0];
+    const scalar = sign === "-" ? 1 : -1;
+    date2.setTime(date2.getTime() + scalar * (Number(offsetH) * 60 * 60 * 1e3 + Number(offsetM) * 60 * 1e3));
+  }
+  return date2;
+};
+var _parseRfc7231DateTime = (value) => {
+  if (value == null) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new TypeError("RFC7231 timestamps must be strings.");
+  }
+  let day;
+  let month;
+  let year2;
+  let hour;
+  let minute;
+  let second;
+  let fraction;
+  let matches;
+  if (matches = IMF_FIXDATE2.exec(value)) {
+    [, day, month, year2, hour, minute, second, fraction] = matches;
+  } else if (matches = RFC_850_DATE2.exec(value)) {
+    [, day, month, year2, hour, minute, second, fraction] = matches;
+    year2 = (Number(year2) + 1900).toString();
+  } else if (matches = ASC_TIME2.exec(value)) {
+    [, month, day, hour, minute, second, fraction, year2] = matches;
+  }
+  if (year2 && second) {
+    const timestamp = Date.UTC(Number(year2), months.indexOf(month), Number(day), Number(hour), Number(minute), Number(second), fraction ? Math.round(parseFloat(`0.${fraction}`) * 1e3) : 0);
+    range(day, 1, 31);
+    range(hour, 0, 23);
+    range(minute, 0, 59);
+    range(second, 0, 60);
+    const date2 = new Date(timestamp);
+    date2.setUTCFullYear(Number(year2));
+    return date2;
+  }
+  throw new TypeError(`Invalid RFC7231 date-time value ${value}.`);
+};
+function range(v, min, max) {
+  const _v = Number(v);
+  if (_v < min || _v > max) {
+    throw new Error(`Value ${_v} out of range [${min}, ${max}]`);
+  }
+}
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/split-every.js
+function splitEvery(value, delimiter, numDelimiters) {
+  if (numDelimiters <= 0 || !Number.isInteger(numDelimiters)) {
+    throw new Error("Invalid number of delimiters (" + numDelimiters + ") for splitEvery.");
+  }
+  const segments = value.split(delimiter);
+  if (numDelimiters === 1) {
+    return segments;
+  }
+  const compoundSegments = [];
+  let currentSegment = "";
+  for (let i = 0; i < segments.length; i++) {
+    if (currentSegment === "") {
+      currentSegment = segments[i];
+    } else {
+      currentSegment += delimiter + segments[i];
+    }
+    if ((i + 1) % numDelimiters === 0) {
+      compoundSegments.push(currentSegment);
+      currentSegment = "";
+    }
+  }
+  if (currentSegment !== "") {
+    compoundSegments.push(currentSegment);
+  }
+  return compoundSegments;
+}
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/split-header.js
+var splitHeader = (value) => {
+  const z = value.length;
+  const values = [];
+  let withinQuotes = false;
+  let prevChar = void 0;
+  let anchor = 0;
+  for (let i = 0; i < z; ++i) {
+    const char = value[i];
+    switch (char) {
+      case `"`:
+        if (prevChar !== "\\") {
+          withinQuotes = !withinQuotes;
+        }
+        break;
+      case ",":
+        if (!withinQuotes) {
+          values.push(value.slice(anchor, i));
+          anchor = i + 1;
+        }
+        break;
+      default:
+    }
+    prevChar = char;
+  }
+  values.push(value.slice(anchor));
+  return values.map((v) => {
+    v = v.trim();
+    const z2 = v.length;
+    if (z2 < 2) {
+      return v;
+    }
+    if (v[0] === `"` && v[z2 - 1] === `"`) {
+      v = v.slice(1, z2 - 1);
+    }
+    return v.replace(/\\"/g, '"');
+  });
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/value/NumericValue.js
+var format = /^-?\d*(\.\d+)?$/;
+var NumericValue = class _NumericValue {
+  string;
+  type;
+  constructor(string, type) {
+    this.string = string;
+    this.type = type;
+    if (!format.test(string)) {
+      throw new Error(`@smithy/core/serde - NumericValue must only contain [0-9], at most one decimal point ".", and an optional negation prefix "-".`);
+    }
+  }
+  toString() {
+    return this.string;
+  }
+  static [Symbol.hasInstance](object) {
+    if (!object || typeof object !== "object") {
+      return false;
+    }
+    const _nv = object;
+    return _NumericValue.prototype.isPrototypeOf(object) || _nv.type === "bigDecimal" && format.test(_nv.string);
+  }
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/util-body-length/calculateBodyLength.js
+import { ReadStream, fstatSync, lstatSync } from "fs";
+var calculateBodyLength = (body) => {
+  if (!body) {
+    return 0;
+  }
+  if (typeof body === "string") {
+    return Buffer.byteLength(body);
+  } else if (typeof body.byteLength === "number") {
+    return body.byteLength;
+  } else if (typeof body.size === "number") {
+    return body.size;
+  } else if (typeof body.start === "number" && typeof body.end === "number") {
+    return body.end + 1 - body.start;
+  } else if (body instanceof ReadStream) {
+    if (body.path != null) {
+      return lstatSync(body.path).size;
+    } else if (typeof body.fd === "number") {
+      return fstatSync(body.fd).size;
+    }
+  }
+  throw new Error(`Body Length computation failed for ${body}`);
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/util-utf8/toUint8Array.js
+var toUint8Array = (data) => {
+  if (typeof data === "string") {
+    return fromUtf8(data);
+  }
+  if (ArrayBuffer.isView(data)) {
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);
+  }
+  return new Uint8Array(data);
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/hash-node/hash-node.js
+import { createHash, createHmac } from "crypto";
+var Hash = class {
+  algorithmIdentifier;
+  secret;
+  hash;
+  constructor(algorithmIdentifier, secret) {
+    this.algorithmIdentifier = algorithmIdentifier;
+    this.secret = secret;
+    this.reset();
+  }
+  update(toHash, encoding) {
+    this.hash.update(toUint8Array(castSourceData(toHash, encoding)));
+  }
+  digest() {
+    return Promise.resolve(this.hash.digest());
+  }
+  reset() {
+    this.hash = this.secret ? createHmac(this.algorithmIdentifier, castSourceData(this.secret)) : createHash(this.algorithmIdentifier);
+  }
+};
+function castSourceData(toCast, encoding) {
+  if (Buffer.isBuffer(toCast)) {
+    return toCast;
+  }
+  if (typeof toCast === "string") {
+    return fromString(toCast, encoding);
+  }
+  if (ArrayBuffer.isView(toCast)) {
+    return fromArrayBuffer(toCast.buffer, toCast.byteOffset, toCast.byteLength);
+  }
+  return fromArrayBuffer(toCast);
+}
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/util-stream/checksum/ChecksumStream.js
+import { Duplex } from "stream";
+var ChecksumStream = class extends Duplex {
+  expectedChecksum;
+  checksumSourceLocation;
+  checksum;
+  source;
+  base64Encoder;
+  pendingCallback = null;
+  constructor({ expectedChecksum, checksum, source, checksumSourceLocation, base64Encoder }) {
+    var _a;
+    super();
+    if (typeof source.pipe === "function") {
+      this.source = source;
+    } else {
+      throw new Error(`@smithy/util-stream: unsupported source type ${((_a = source == null ? void 0 : source.constructor) == null ? void 0 : _a.name) ?? source} in ChecksumStream.`);
+    }
+    this.base64Encoder = base64Encoder ?? toBase64;
+    this.expectedChecksum = expectedChecksum;
+    this.checksum = checksum;
+    this.checksumSourceLocation = checksumSourceLocation;
+    this.source.pipe(this);
+  }
+  _read(size) {
+    if (this.pendingCallback) {
+      const callback = this.pendingCallback;
+      this.pendingCallback = null;
+      callback();
+    }
+  }
+  _write(chunk, encoding, callback) {
+    try {
+      this.checksum.update(chunk);
+      const canPushMore = this.push(chunk);
+      if (!canPushMore) {
+        this.pendingCallback = callback;
+        return;
+      }
+    } catch (e) {
+      return callback(e);
+    }
+    return callback();
+  }
+  async _final(callback) {
+    try {
+      const digest = await this.checksum.digest();
+      const received = this.base64Encoder(digest);
+      if (this.expectedChecksum !== received) {
+        return callback(new Error(`Checksum mismatch: expected "${this.expectedChecksum}" but received "${received}" in response header "${this.checksumSourceLocation}".`));
+      }
+    } catch (e) {
+      return callback(e);
+    }
+    this.push(null);
+    return callback();
+  }
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/util-stream/stream-type-check.js
+var isReadableStream = (stream) => {
+  var _a;
+  return typeof ReadableStream === "function" && (((_a = stream == null ? void 0 : stream.constructor) == null ? void 0 : _a.name) === ReadableStream.name || stream instanceof ReadableStream);
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/util-utf8/fromUtf8.browser.js
+var fromUtf82 = (input) => new TextEncoder().encode(input);
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/util-base64/constants-for-browser.js
+var chars = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/`;
+var alphabetByEncoding = Object.entries(chars).reduce((acc, [i, c]) => {
+  acc[c] = Number(i);
+  return acc;
+}, {});
+var alphabetByValue = chars.split("");
+var bitsPerLetter = 6;
+var bitsPerByte = 8;
+var maxLetterValue = 63;
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/util-base64/toBase64.browser.js
+function toBase642(_input) {
+  let input;
+  if (typeof _input === "string") {
+    input = fromUtf82(_input);
+  } else {
+    input = _input;
+  }
+  const isArrayLike = typeof input === "object" && typeof input.length === "number";
+  const isUint8Array = typeof input === "object" && typeof input.byteOffset === "number" && typeof input.byteLength === "number";
+  if (!isArrayLike && !isUint8Array) {
+    throw new Error("@smithy/util-base64: toBase64 encoder function only accepts string | Uint8Array.");
+  }
+  let str = "";
+  for (let i = 0; i < input.length; i += 3) {
+    let bits = 0;
+    let bitLength = 0;
+    for (let j = i, limit = Math.min(i + 3, input.length); j < limit; j++) {
+      bits |= input[j] << (limit - j - 1) * bitsPerByte;
+      bitLength += bitsPerByte;
+    }
+    const bitClusterCount = Math.ceil(bitLength / bitsPerLetter);
+    bits <<= bitClusterCount * bitsPerLetter - bitLength;
+    for (let k = 1; k <= bitClusterCount; k++) {
+      const offset = (bitClusterCount - k) * bitsPerLetter;
+      str += alphabetByValue[(bits & maxLetterValue << offset) >> offset];
+    }
+    str += "==".slice(0, 4 - bitClusterCount);
+  }
+  return str;
+}
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/util-stream/checksum/ChecksumStream.browser.js
+var ReadableStreamRef = typeof ReadableStream === "function" ? ReadableStream : function() {
+};
+var ChecksumStream2 = class extends ReadableStreamRef {
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/util-stream/checksum/createChecksumStream.browser.js
+var createChecksumStream = ({ expectedChecksum, checksum, source, checksumSourceLocation, base64Encoder }) => {
+  var _a;
+  if (!isReadableStream(source)) {
+    throw new Error(`@smithy/util-stream: unsupported source type ${((_a = source == null ? void 0 : source.constructor) == null ? void 0 : _a.name) ?? source} in ChecksumStream.`);
+  }
+  const encoder = base64Encoder ?? toBase642;
+  if (typeof TransformStream !== "function") {
+    throw new Error("@smithy/util-stream: unable to instantiate ChecksumStream because API unavailable: ReadableStream/TransformStream.");
+  }
+  const transform = new TransformStream({
+    start() {
+    },
+    async transform(chunk, controller) {
+      checksum.update(chunk);
+      controller.enqueue(chunk);
+    },
+    async flush(controller) {
+      const digest = await checksum.digest();
+      const received = encoder(digest);
+      if (expectedChecksum !== received) {
+        const error = new Error(`Checksum mismatch: expected "${expectedChecksum}" but received "${received}" in response header "${checksumSourceLocation}".`);
+        controller.error(error);
+      } else {
+        controller.terminate();
+      }
+    }
+  });
+  source.pipeThrough(transform);
+  const readable = transform.readable;
+  Object.setPrototypeOf(readable, ChecksumStream2.prototype);
+  return readable;
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/util-stream/checksum/createChecksumStream.js
+function createChecksumStream2(init) {
+  if (typeof ReadableStream === "function" && isReadableStream(init.source)) {
+    return createChecksumStream(init);
+  }
+  return new ChecksumStream(init);
+}
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/util-stream/createBufferedReadable.js
+import { Readable } from "stream";
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/util-stream/ByteArrayCollector.js
+var ByteArrayCollector = class {
+  allocByteArray;
+  byteLength = 0;
+  byteArrays = [];
+  constructor(allocByteArray) {
+    this.allocByteArray = allocByteArray;
+  }
+  push(byteArray) {
+    this.byteArrays.push(byteArray);
+    this.byteLength += byteArray.byteLength;
+  }
+  flush() {
+    if (this.byteArrays.length === 1) {
+      const bytes = this.byteArrays[0];
+      this.reset();
+      return bytes;
+    }
+    const aggregation = this.allocByteArray(this.byteLength);
+    let cursor = 0;
+    for (let i = 0; i < this.byteArrays.length; ++i) {
+      const bytes = this.byteArrays[i];
+      aggregation.set(bytes, cursor);
+      cursor += bytes.byteLength;
+    }
+    this.reset();
+    return aggregation;
+  }
+  reset() {
+    this.byteArrays = [];
+    this.byteLength = 0;
+  }
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/util-stream/createBufferedReadable.browser.js
+function createBufferedReadableStream(upstream, size, logger2) {
+  const reader = upstream.getReader();
+  let streamBufferingLoggedWarning = false;
+  let bytesSeen = 0;
+  const buffers = ["", new ByteArrayCollector((size2) => new Uint8Array(size2))];
+  let mode = -1;
+  const pull = async (controller) => {
+    const { value, done } = await reader.read();
+    const chunk = value;
+    if (done) {
+      if (mode !== -1) {
+        const remainder = flush(buffers, mode);
+        if (sizeOf(remainder) > 0) {
+          controller.enqueue(remainder);
+        }
+      }
+      controller.close();
+    } else {
+      const chunkMode = modeOf(chunk, false);
+      if (mode !== chunkMode) {
+        if (mode >= 0) {
+          controller.enqueue(flush(buffers, mode));
+        }
+        mode = chunkMode;
+      }
+      if (mode === -1) {
+        controller.enqueue(chunk);
+        return;
+      }
+      const chunkSize = sizeOf(chunk);
+      bytesSeen += chunkSize;
+      const bufferSize = sizeOf(buffers[mode]);
+      if (chunkSize >= size && bufferSize === 0) {
+        controller.enqueue(chunk);
+      } else {
+        const newSize = merge(buffers, mode, chunk);
+        if (!streamBufferingLoggedWarning && bytesSeen > size * 2) {
+          streamBufferingLoggedWarning = true;
+          logger2 == null ? void 0 : logger2.warn(`@smithy/util-stream - stream chunk size ${chunkSize} is below threshold of ${size}, automatically buffering.`);
+        }
+        if (newSize >= size) {
+          controller.enqueue(flush(buffers, mode));
+        } else {
+          await pull(controller);
+        }
+      }
+    }
+  };
+  return new ReadableStream({
+    pull
+  });
+}
+function merge(buffers, mode, chunk) {
+  switch (mode) {
+    case 0:
+      buffers[0] += chunk;
+      return sizeOf(buffers[0]);
+    case 1:
+    case 2:
+      buffers[mode].push(chunk);
+      return sizeOf(buffers[mode]);
+  }
+}
+function flush(buffers, mode) {
+  switch (mode) {
+    case 0:
+      const s = buffers[0];
+      buffers[0] = "";
+      return s;
+    case 1:
+    case 2:
+      return buffers[mode].flush();
+  }
+  throw new Error(`@smithy/util-stream - invalid index ${mode} given to flush()`);
+}
+function sizeOf(chunk) {
+  return (chunk == null ? void 0 : chunk.byteLength) ?? (chunk == null ? void 0 : chunk.length) ?? 0;
+}
+function modeOf(chunk, allowBuffer = true) {
+  if (allowBuffer && typeof Buffer !== "undefined" && chunk instanceof Buffer) {
+    return 2;
+  }
+  if (chunk instanceof Uint8Array) {
+    return 1;
+  }
+  if (typeof chunk === "string") {
+    return 0;
+  }
+  return -1;
+}
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/util-stream/createBufferedReadable.js
+function createBufferedReadable(upstream, size, logger2) {
+  if (isReadableStream(upstream)) {
+    return createBufferedReadableStream(upstream, size, logger2);
+  }
+  const downstream = new Readable({ read() {
+  } });
+  let streamBufferingLoggedWarning = false;
+  let bytesSeen = 0;
+  const buffers = [
+    "",
+    new ByteArrayCollector((size2) => new Uint8Array(size2)),
+    new ByteArrayCollector((size2) => Buffer.from(new Uint8Array(size2)))
+  ];
+  let mode = -1;
+  upstream.on("data", (chunk) => {
+    const chunkMode = modeOf(chunk, true);
+    if (mode !== chunkMode) {
+      if (mode >= 0) {
+        downstream.push(flush(buffers, mode));
+      }
+      mode = chunkMode;
+    }
+    if (mode === -1) {
+      downstream.push(chunk);
+      return;
+    }
+    const chunkSize = sizeOf(chunk);
+    bytesSeen += chunkSize;
+    const bufferSize = sizeOf(buffers[mode]);
+    if (chunkSize >= size && bufferSize === 0) {
+      downstream.push(chunk);
+    } else {
+      const newSize = merge(buffers, mode, chunk);
+      if (!streamBufferingLoggedWarning && bytesSeen > size * 2) {
+        streamBufferingLoggedWarning = true;
+        logger2 == null ? void 0 : logger2.warn(`@smithy/util-stream - stream chunk size ${chunkSize} is below threshold of ${size}, automatically buffering.`);
+      }
+      if (newSize >= size) {
+        downstream.push(flush(buffers, mode));
+      }
+    }
+  });
+  upstream.on("end", () => {
+    if (mode !== -1) {
+      const remainder = flush(buffers, mode);
+      if (sizeOf(remainder) > 0) {
+        downstream.push(remainder);
+      }
+    }
+    downstream.push(null);
+  });
+  return downstream;
+}
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/util-stream/getAwsChunkedEncodingStream.js
+import { Readable as Readable2 } from "stream";
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/util-stream/getAwsChunkedEncodingStream.browser.js
+var getAwsChunkedEncodingStream = (readableStream, options) => {
+  const { base64Encoder, bodyLengthChecker, checksumAlgorithmFn, checksumLocationName, streamHasher } = options;
+  const checksumRequired = base64Encoder !== void 0 && bodyLengthChecker !== void 0 && checksumAlgorithmFn !== void 0 && checksumLocationName !== void 0 && streamHasher !== void 0;
+  const digest = checksumRequired ? streamHasher(checksumAlgorithmFn, readableStream) : void 0;
+  const reader = readableStream.getReader();
+  return new ReadableStream({
+    async pull(controller) {
+      const { value, done } = await reader.read();
+      if (done) {
+        controller.enqueue(`0\r
+`);
+        if (checksumRequired) {
+          const checksum = base64Encoder(await digest);
+          controller.enqueue(`${checksumLocationName}:${checksum}\r
+`);
+          controller.enqueue(`\r
+`);
+        }
+        controller.close();
+      } else {
+        controller.enqueue(`${(bodyLengthChecker(value) || 0).toString(16)}\r
+${value}\r
+`);
+      }
+    }
+  });
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/util-stream/getAwsChunkedEncodingStream.js
+function getAwsChunkedEncodingStream2(stream, options) {
+  const readable = stream;
+  const readableStream = stream;
+  if (isReadableStream(readableStream)) {
+    return getAwsChunkedEncodingStream(readableStream, options);
+  }
+  const { base64Encoder, bodyLengthChecker, checksumAlgorithmFn, checksumLocationName, streamHasher } = options;
+  const checksumRequired = base64Encoder !== void 0 && checksumAlgorithmFn !== void 0 && checksumLocationName !== void 0 && streamHasher !== void 0;
+  const digest = checksumRequired ? streamHasher(checksumAlgorithmFn, readable) : void 0;
+  const awsChunkedEncodingStream = new Readable2({
+    read: () => {
+    }
+  });
+  readable.on("data", (data) => {
+    const length = bodyLengthChecker(data) || 0;
+    if (length === 0) {
+      return;
+    }
+    awsChunkedEncodingStream.push(`${length.toString(16)}\r
+`);
+    awsChunkedEncodingStream.push(data);
+    awsChunkedEncodingStream.push("\r\n");
+  });
+  readable.on("end", async () => {
+    awsChunkedEncodingStream.push(`0\r
+`);
+    if (checksumRequired) {
+      const checksum = base64Encoder(await digest);
+      awsChunkedEncodingStream.push(`${checksumLocationName}:${checksum}\r
+`);
+      awsChunkedEncodingStream.push(`\r
+`);
+    }
+    awsChunkedEncodingStream.push(null);
+  });
+  return awsChunkedEncodingStream;
+}
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/util-stream/sdk-stream-mixin.js
+import { Readable as Readable3 } from "stream";
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/util-utf8/toUtf8.browser.js
+var toUtf82 = (input) => {
+  if (typeof input === "string") {
+    return input;
+  }
+  if (typeof input !== "object" || typeof input.byteOffset !== "number" || typeof input.byteLength !== "number") {
+    throw new Error("@smithy/util-utf8: toUtf8 encoder function only accepts string | Uint8Array.");
+  }
+  return new TextDecoder("utf-8").decode(input);
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/util-base64/fromBase64.browser.js
+var fromBase642 = (input) => {
+  let totalByteLength = input.length / 4 * 3;
+  if (input.slice(-2) === "==") {
+    totalByteLength -= 2;
+  } else if (input.slice(-1) === "=") {
+    totalByteLength--;
+  }
+  const out = new ArrayBuffer(totalByteLength);
+  const dataView = new DataView(out);
+  for (let i = 0; i < input.length; i += 4) {
+    let bits = 0;
+    let bitLength = 0;
+    for (let j = i, limit = i + 3; j <= limit; j++) {
+      if (input[j] !== "=") {
+        if (!(input[j] in alphabetByEncoding)) {
+          throw new TypeError(`Invalid character ${input[j]} in base64 string.`);
+        }
+        bits |= alphabetByEncoding[input[j]] << (limit - j) * bitsPerLetter;
+        bitLength += bitsPerLetter;
+      } else {
+        bits >>= bitsPerLetter;
+      }
+    }
+    const chunkOffset = i / 4 * 3;
+    bits >>= bitLength % bitsPerByte;
+    const byteLength = Math.floor(bitLength / bitsPerByte);
+    for (let k = 0; k < byteLength; k++) {
+      const offset = (byteLength - k - 1) * bitsPerByte;
+      dataView.setUint8(chunkOffset + k, (bits & 255 << offset) >> offset);
+    }
+  }
+  return new Uint8Array(out);
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/util-stream/stream-collector.browser.js
+var streamCollector = async (stream) => {
+  var _a;
+  if (typeof Blob === "function" && stream instanceof Blob || ((_a = stream.constructor) == null ? void 0 : _a.name) === "Blob") {
+    if (Blob.prototype.arrayBuffer !== void 0) {
+      return new Uint8Array(await stream.arrayBuffer());
+    }
+    return collectBlob(stream);
+  }
+  return collectStream(stream);
+};
+async function collectBlob(blob) {
+  const base64 = await readToBase64(blob);
+  const arrayBuffer = fromBase642(base64);
+  return new Uint8Array(arrayBuffer);
+}
+async function collectStream(stream) {
+  const chunks = [];
+  const reader = stream.getReader();
+  let isDone = false;
+  let length = 0;
+  while (!isDone) {
+    const { done, value } = await reader.read();
+    if (value) {
+      chunks.push(value);
+      length += value.length;
+    }
+    isDone = done;
+  }
+  const collected = new Uint8Array(length);
+  let offset = 0;
+  for (const chunk of chunks) {
+    collected.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return collected;
+}
+function readToBase64(blob) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onloadend = () => {
+      if (reader.readyState !== 2) {
+        return reject(new Error("Reader aborted too early"));
+      }
+      const result = reader.result ?? "";
+      const commaIndex = result.indexOf(",");
+      const dataOffset = commaIndex > -1 ? commaIndex + 1 : result.length;
+      resolve(result.substring(dataOffset));
+    };
+    reader.onabort = () => reject(new Error("Read aborted"));
+    reader.onerror = () => reject(reader.error);
+    reader.readAsDataURL(blob);
+  });
+}
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/util-stream/sdk-stream-mixin.browser.js
+var ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED = "The stream has already been transformed.";
+var sdkStreamMixin = (stream) => {
+  var _a, _b;
+  if (!isBlobInstance(stream) && !isReadableStream(stream)) {
+    const name = ((_b = (_a = stream == null ? void 0 : stream.__proto__) == null ? void 0 : _a.constructor) == null ? void 0 : _b.name) || stream;
+    throw new Error(`Unexpected stream implementation, expect Blob or ReadableStream, got ${name}`);
+  }
+  let transformed = false;
+  const transformToByteArray = async () => {
+    if (transformed) {
+      throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED);
+    }
+    transformed = true;
+    return await streamCollector(stream);
+  };
+  const blobToWebStream = (blob) => {
+    if (typeof blob.stream !== "function") {
+      throw new Error("Cannot transform payload Blob to web stream. Please make sure the Blob.stream() is polyfilled.\nIf you are using React Native, this API is not yet supported, see: https://react-native.canny.io/feature-requests/p/fetch-streaming-body");
+    }
+    return blob.stream();
+  };
+  return Object.assign(stream, {
+    transformToByteArray,
+    transformToString: async (encoding) => {
+      const buf = await transformToByteArray();
+      if (encoding === "base64") {
+        return toBase642(buf);
+      } else if (encoding === "hex") {
+        return toHex(buf);
+      } else if (encoding === void 0 || encoding === "utf8" || encoding === "utf-8") {
+        return toUtf82(buf);
+      } else if (typeof TextDecoder === "function") {
+        return new TextDecoder(encoding).decode(buf);
+      } else {
+        throw new Error("TextDecoder is not available, please make sure polyfill is provided.");
+      }
+    },
+    transformToWebStream: () => {
+      if (transformed) {
+        throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED);
+      }
+      transformed = true;
+      if (isBlobInstance(stream)) {
+        return blobToWebStream(stream);
+      } else if (isReadableStream(stream)) {
+        return stream;
+      } else {
+        throw new Error(`Cannot transform payload to web stream, got ${stream}`);
+      }
+    }
+  });
+};
+var isBlobInstance = (stream) => typeof Blob === "function" && stream instanceof Blob;
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/util-stream/stream-collector.js
+import { Writable } from "stream";
+var Collector = class extends Writable {
+  bufferedBytes = [];
+  _write(chunk, encoding, callback) {
+    this.bufferedBytes.push(chunk);
+    callback();
+  }
+};
+var isReadableStreamInstance = (stream) => typeof ReadableStream === "function" && stream instanceof ReadableStream;
+async function collectReadableStream(stream) {
+  const chunks = [];
+  const reader = stream.getReader();
+  let isDone = false;
+  let length = 0;
+  while (!isDone) {
+    const { done, value } = await reader.read();
+    if (value) {
+      chunks.push(value);
+      length += value.length;
+    }
+    isDone = done;
+  }
+  const collected = new Uint8Array(length);
+  let offset = 0;
+  for (const chunk of chunks) {
+    collected.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return collected;
+}
+var streamCollector2 = (stream) => {
+  if (isReadableStreamInstance(stream)) {
+    return collectReadableStream(stream);
+  }
+  return new Promise((resolve, reject) => {
+    const collector = new Collector();
+    stream.pipe(collector);
+    stream.on("error", (err) => {
+      collector.end();
+      reject(err);
+    });
+    collector.on("error", reject);
+    collector.on("finish", function() {
+      const bytes = new Uint8Array(Buffer.concat(this.bufferedBytes));
+      resolve(bytes);
+    });
+  });
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/util-stream/sdk-stream-mixin.js
+var ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED2 = "The stream has already been transformed.";
+var sdkStreamMixin2 = (stream) => {
+  var _a, _b;
+  if (!(stream instanceof Readable3)) {
+    try {
+      return sdkStreamMixin(stream);
+    } catch (e) {
+      const name = ((_b = (_a = stream == null ? void 0 : stream.__proto__) == null ? void 0 : _a.constructor) == null ? void 0 : _b.name) || stream;
+      throw new Error(`Unexpected stream implementation, expect Stream.Readable instance, got ${name}`);
+    }
+  }
+  let transformed = false;
+  const transformToByteArray = async () => {
+    if (transformed) {
+      throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED2);
+    }
+    transformed = true;
+    return await streamCollector2(stream);
+  };
+  return Object.assign(stream, {
+    transformToByteArray,
+    transformToString: async (encoding) => {
+      const buf = await transformToByteArray();
+      if (encoding === void 0 || Buffer.isEncoding(encoding)) {
+        return fromArrayBuffer(buf.buffer, buf.byteOffset, buf.byteLength).toString(encoding);
+      } else {
+        const decoder = new TextDecoder(encoding);
+        return decoder.decode(buf);
+      }
+    },
+    transformToWebStream: () => {
+      if (transformed) {
+        throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED2);
+      }
+      if (stream.readableFlowing !== null) {
+        throw new Error("The stream has been consumed by other callbacks.");
+      }
+      if (typeof Readable3.toWeb !== "function") {
+        throw new Error("Readable.toWeb() is not supported. Please ensure a polyfill is available.");
+      }
+      transformed = true;
+      return Readable3.toWeb(stream);
+    }
+  });
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/serde/index.js
+var Uint8ArrayBlobAdapter = class extends bindUint8ArrayBlobAdapter(toUtf8, fromUtf8, toBase64, fromBase64) {
+};
+var _getRandomValues = getRandomValues;
+var v4 = bindV4(_getRandomValues);
+var generateIdempotencyToken = v4;
+
+export {
+  __dirname,
+  isArrayBuffer,
+  fromBase64,
+  fromUtf8,
+  toBase64,
+  toUtf8,
+  dateToUtcString,
+  parseRfc3339DateTime,
+  parseRfc3339DateTimeWithOffset,
+  parseRfc7231DateTime,
+  parseEpochTimestamp,
+  LazyJsonString,
+  quoteHeader,
+  _parseEpochTimestamp,
+  _parseRfc3339DateTimeWithOffset,
+  _parseRfc7231DateTime,
+  splitEvery,
+  splitHeader,
+  NumericValue,
+  fromHex,
+  toHex,
+  calculateBodyLength,
+  toUint8Array,
+  Hash,
+  createChecksumStream2 as createChecksumStream,
+  createBufferedReadable,
+  getAwsChunkedEncodingStream2 as getAwsChunkedEncodingStream,
+  sdkStreamMixin2 as sdkStreamMixin,
+  Uint8ArrayBlobAdapter,
+  v4,
+  generateIdempotencyToken
+};