@openclaw/amazon-bedrock-provider 2026.9.8 → 2026.10.1-beta.2

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/serde/parse-utils.js

@@ -1,236 +0,0 @@
-import { hasOwn } from "@smithy/core/transport";
-export const parseBoolean = (value) => {
-    switch (value) {
-        case "true":
-            return true;
-        case "false":
-            return false;
-        default:
-            throw new Error(`Unable to parse boolean value "${value}"`);
-    }
-};
-export const expectBoolean = (value) => {
-    if (value === null || value === undefined) {
-        return undefined;
-    }
-    if (typeof value === "number") {
-        if (value === 0 || value === 1) {
-            logger.warn(stackTraceWarning(`Expected boolean, got ${typeof value}: ${value}`));
-        }
-        if (value === 0) {
-            return false;
-        }
-        if (value === 1) {
-            return true;
-        }
-    }
-    if (typeof value === "string") {
-        const lower = value.toLowerCase();
-        if (lower === "false" || lower === "true") {
-            logger.warn(stackTraceWarning(`Expected boolean, got ${typeof value}: ${value}`));
-        }
-        if (lower === "false") {
-            return false;
-        }
-        if (lower === "true") {
-            return true;
-        }
-    }
-    if (typeof value === "boolean") {
-        return value;
-    }
-    throw new TypeError(`Expected boolean, got ${typeof value}: ${value}`);
-};
-export const expectNumber = (value) => {
-    if (value === null || value === undefined) {
-        return undefined;
-    }
-    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}`);
-};
-const MAX_FLOAT = Math.ceil(2 ** 127 * (2 - 2 ** -23));
-export const expectFloat32 = (value) => {
-    const expected = expectNumber(value);
-    if (expected !== undefined && !Number.isNaN(expected) && expected !== Infinity && expected !== -Infinity) {
-        if (Math.abs(expected) > MAX_FLOAT) {
-            throw new TypeError(`Expected 32-bit float, got ${value}`);
-        }
-    }
-    return expected;
-};
-export const expectLong = (value) => {
-    if (value === null || value === undefined) {
-        return undefined;
-    }
-    if (Number.isInteger(value) && !Number.isNaN(value)) {
-        return value;
-    }
-    throw new TypeError(`Expected integer, got ${typeof value}: ${value}`);
-};
-export const expectInt = expectLong;
-export const expectInt32 = (value) => expectSizedInt(value, 32);
-export const expectShort = (value) => expectSizedInt(value, 16);
-export const expectByte = (value) => expectSizedInt(value, 8);
-const expectSizedInt = (value, size) => {
-    const expected = expectLong(value);
-    if (expected !== undefined && castInt(expected, size) !== expected) {
-        throw new TypeError(`Expected ${size}-bit integer, got ${value}`);
-    }
-    return expected;
-};
-const 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];
-    }
-};
-export const expectNonNull = (value, location) => {
-    if (value === null || value === undefined) {
-        if (location) {
-            throw new TypeError(`Expected a non-null value for ${location}`);
-        }
-        throw new TypeError("Expected a non-null value");
-    }
-    return value;
-};
-export const expectObject = (value) => {
-    if (value === null || value === undefined) {
-        return undefined;
-    }
-    if (typeof value === "object" && !Array.isArray(value)) {
-        return value;
-    }
-    const receivedType = Array.isArray(value) ? "array" : typeof value;
-    throw new TypeError(`Expected object, got ${receivedType}: ${value}`);
-};
-export const expectString = (value) => {
-    if (value === null || value === undefined) {
-        return undefined;
-    }
-    if (typeof value === "string") {
-        return value;
-    }
-    if (["boolean", "number", "bigint"].includes(typeof value)) {
-        logger.warn(stackTraceWarning(`Expected string, got ${typeof value}: ${value}`));
-        return String(value);
-    }
-    throw new TypeError(`Expected string, got ${typeof value}: ${value}`);
-};
-export const expectUnion = (value) => {
-    if (value === null || value === undefined) {
-        return undefined;
-    }
-    const asObject = expectObject(value);
-    const setKeys = [];
-    for (const k in asObject) {
-        if (!hasOwn(asObject, k))
-            continue;
-        if (asObject[k] != null) {
-            setKeys.push(k);
-        }
-    }
-    if (setKeys.length === 0) {
-        throw new TypeError(`Unions must have exactly one non-null member. None were found.`);
-    }
-    if (setKeys.length > 1) {
-        throw new TypeError(`Unions must have exactly one non-null member. Keys ${setKeys} were not null.`);
-    }
-    return asObject;
-};
-export const strictParseDouble = (value) => {
-    if (typeof value == "string") {
-        return expectNumber(parseNumber(value));
-    }
-    return expectNumber(value);
-};
-export const strictParseFloat = strictParseDouble;
-export const strictParseFloat32 = (value) => {
-    if (typeof value == "string") {
-        return expectFloat32(parseNumber(value));
-    }
-    return expectFloat32(value);
-};
-const NUMBER_REGEX = /(-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)|(-?Infinity)|(NaN)/g;
-const 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);
-};
-export const limitedParseDouble = (value) => {
-    if (typeof value == "string") {
-        return parseFloatString(value);
-    }
-    return expectNumber(value);
-};
-export const handleFloat = limitedParseDouble;
-export const limitedParseFloat = limitedParseDouble;
-export const limitedParseFloat32 = (value) => {
-    if (typeof value == "string") {
-        return parseFloatString(value);
-    }
-    return expectFloat32(value);
-};
-const parseFloatString = (value) => {
-    switch (value) {
-        case "NaN":
-            return NaN;
-        case "Infinity":
-            return Infinity;
-        case "-Infinity":
-            return -Infinity;
-        default:
-            throw new Error(`Unable to parse float value: ${value}`);
-    }
-};
-export const strictParseLong = (value) => {
-    if (typeof value === "string") {
-        return expectLong(parseNumber(value));
-    }
-    return expectLong(value);
-};
-export const strictParseInt = strictParseLong;
-export const strictParseInt32 = (value) => {
-    if (typeof value === "string") {
-        return expectInt32(parseNumber(value));
-    }
-    return expectInt32(value);
-};
-export const strictParseShort = (value) => {
-    if (typeof value === "string") {
-        return expectShort(parseNumber(value));
-    }
-    return expectShort(value);
-};
-export const strictParseByte = (value) => {
-    if (typeof value === "string") {
-        return expectByte(parseNumber(value));
-    }
-    return expectByte(value);
-};
-const stackTraceWarning = (message) => {
-    return String(new TypeError(message).stack || message)
-        .split("\n")
-        .slice(0, 5)
-        .filter((s) => !s.includes("stackTraceWarning"))
-        .join("\n");
-};
-export const logger = {
-    warn: console.warn,
-};

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/serde/quote-header.js

@@ -1,6 +0,0 @@
-export function quoteHeader(part) {
-    if (part.includes(",") || part.includes('"')) {
-        part = `"${part.replace(/"/g, '\\"')}"`;
-    }
-    return part;
-}

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/serde/schema-serde-lib/schema-date-utils.js

@@ -1,101 +0,0 @@
-const ddd = `(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)(?:[ne|u?r]?s?day)?`;
-const mmm = `(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)`;
-const time = `(\\d?\\d):(\\d{2}):(\\d{2})(?:\\.(\\d+))?`;
-const date = `(\\d?\\d)`;
-const year = `(\\d{4})`;
-const RFC3339_WITH_OFFSET = new RegExp(/^(\d{4})-(\d\d)-(\d\d)[tT](\d\d):(\d\d):(\d\d)(\.(\d+))?(([-+]\d\d:\d\d)|[zZ])$/);
-const IMF_FIXDATE = new RegExp(`^${ddd}, ${date} ${mmm} ${year} ${time} GMT$`);
-const RFC_850_DATE = new RegExp(`^${ddd}, ${date}-${mmm}-(\\d\\d) ${time} GMT$`);
-const ASC_TIME = new RegExp(`^${ddd} ${mmm} ( [1-9]|\\d\\d) ${time} ${year}$`);
-const months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
-export const _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 * 1000));
-};
-export const _parseRfc3339DateTimeWithOffset = (value) => {
-    if (value == null) {
-        return void 0;
-    }
-    if (typeof value !== "string") {
-        throw new TypeError("RFC3339 timestamps must be strings");
-    }
-    const matches = RFC3339_WITH_OFFSET.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 date = new Date(Date.UTC(Number(yearStr), Number(monthStr) - 1, Number(dayStr), Number(hours), Number(minutes), Number(seconds), Number(ms) ? Math.round(parseFloat(`0.${ms}`) * 1000) : 0));
-    date.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;
-        date.setTime(date.getTime() + scalar * (Number(offsetH) * 60 * 60 * 1000 + Number(offsetM) * 60 * 1000));
-    }
-    return date;
-};
-export const _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 year;
-    let hour;
-    let minute;
-    let second;
-    let fraction;
-    let matches;
-    if ((matches = IMF_FIXDATE.exec(value))) {
-        [, day, month, year, hour, minute, second, fraction] = matches;
-    }
-    else if ((matches = RFC_850_DATE.exec(value))) {
-        [, day, month, year, hour, minute, second, fraction] = matches;
-        year = (Number(year) + 1900).toString();
-    }
-    else if ((matches = ASC_TIME.exec(value))) {
-        [, month, day, hour, minute, second, fraction, year] = matches;
-    }
-    if (year && second) {
-        const timestamp = Date.UTC(Number(year), months.indexOf(month), Number(day), Number(hour), Number(minute), Number(second), fraction ? Math.round(parseFloat(`0.${fraction}`) * 1000) : 0);
-        range(day, 1, 31);
-        range(hour, 0, 23);
-        range(minute, 0, 59);
-        range(second, 0, 60);
-        const date = new Date(timestamp);
-        date.setUTCFullYear(Number(year));
-        return date;
-    }
-    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}]`);
-    }
-}

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/serde/split-every.js

@@ -1,27 +0,0 @@
-export 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;
-}

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/serde/split-header.js

@@ -1,37 +0,0 @@
-export const splitHeader = (value) => {
-    const z = value.length;
-    const values = [];
-    let withinQuotes = false;
-    let prevChar = undefined;
-    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 z = v.length;
-        if (z < 2) {
-            return v;
-        }
-        if (v[0] === `"` && v[z - 1] === `"`) {
-            v = v.slice(1, z - 1);
-        }
-        return v.replace(/\\"/g, '"');
-    });
-};

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/serde/util-base64/constants-for-browser.js

@@ -1,9 +0,0 @@
-const chars = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/`;
-export const alphabetByEncoding = Object.entries(chars).reduce((acc, [i, c]) => {
-    acc[c] = Number(i);
-    return acc;
-}, {});
-export const alphabetByValue = chars.split("");
-export const bitsPerLetter = 6;
-export const bitsPerByte = 8;
-export const maxLetterValue = 0b111111;

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/serde/util-base64/fromBase64.browser.js

@@ -1,36 +0,0 @@
-import { alphabetByEncoding, bitsPerByte, bitsPerLetter } from "./constants-for-browser";
-export const fromBase64 = (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);
-};

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/serde/util-base64/fromBase64.js

@@ -1,12 +0,0 @@
-import { fromString } from "../util-buffer-from/buffer-from";
-const BASE64_REGEX = /^[A-Za-z0-9+/]*={0,2}$/;
-export const 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);
-};

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/serde/util-base64/toBase64.browser.js

@@ -1,35 +0,0 @@
-import { fromUtf8 } from "../util-utf8/fromUtf8.browser";
-import { alphabetByValue, bitsPerByte, bitsPerLetter, maxLetterValue } from "./constants-for-browser";
-export function toBase64(_input) {
-    let input;
-    if (typeof _input === "string") {
-        input = fromUtf8(_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;
-}

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/serde/util-base64/toBase64.js

@@ -1,15 +0,0 @@
-import { fromArrayBuffer } from "../util-buffer-from/buffer-from";
-import { fromUtf8 } from "../util-utf8/fromUtf8";
-export const 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");
-};

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/serde/util-body-length/calculateBodyLength.browser.js

@@ -1,26 +0,0 @@
-const TEXT_ENCODER = typeof TextEncoder == "function" ? new TextEncoder() : null;
-export const calculateBodyLength = (body) => {
-    if (typeof body === "string") {
-        if (TEXT_ENCODER) {
-            return TEXT_ENCODER.encode(body).byteLength;
-        }
-        let len = body.length;
-        for (let i = len - 1; i >= 0; i--) {
-            const code = body.charCodeAt(i);
-            if (code > 0x7f && code <= 0x7ff)
-                len++;
-            else if (code > 0x7ff && code <= 0xffff)
-                len += 2;
-            if (code >= 0xdc00 && code <= 0xdfff)
-                i--;
-        }
-        return len;
-    }
-    else if (typeof body.byteLength === "number") {
-        return body.byteLength;
-    }
-    else if (typeof body.size === "number") {
-        return body.size;
-    }
-    throw new Error(`Body Length computation failed for ${body}`);
-};

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/serde/util-body-length/calculateBodyLength.js

@@ -1,27 +0,0 @@
-import { ReadStream, fstatSync, lstatSync } from "node:fs";
-export const 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}`);
-};

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/serde/util-buffer-from/buffer-from.js

@@ -1,13 +0,0 @@
-import { isArrayBuffer } from "../is-array-buffer/is-array-buffer";
-export const 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);
-};
-export const 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);
-};

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/serde/util-hex-encoding/hex-encoding.js

@@ -1,33 +0,0 @@
-const SHORT_TO_HEX = {};
-const 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;
-}
-export 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;
-}
-export function toHex(bytes) {
-    let out = "";
-    for (let i = 0; i < bytes.byteLength; i++) {
-        out += SHORT_TO_HEX[bytes[i]];
-    }
-    return out;
-}

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/ByteArrayCollector.js

@@ -1,32 +0,0 @@
-export class ByteArrayCollector {
-    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;
-    }
-}