@qqbrowser/openclaw-qbot 0.10.11 → 0.10.15

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

@@ -1,8 +1,124 @@
 'use strict';
 
-var protocols = require('@smithy/core/protocols');
+var transport = require('@smithy/core/transport');
 var endpoints = require('@smithy/core/endpoints');
 
+const chars = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/`;
+const alphabetByEncoding = Object.entries(chars).reduce((acc, [i, c]) => {
+    acc[c] = Number(i);
+    return acc;
+}, {});
+const alphabetByValue = chars.split("");
+const bitsPerLetter = 6;
+const bitsPerByte = 8;
+const maxLetterValue = 0b111111;
+
+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);
+};
+
+const fromUtf8 = (input) => new TextEncoder().encode(input);
+
+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;
+}
+
+function bindUint8ArrayBlobAdapter(toUtf8, fromUtf8, toBase64, fromBase64) {
+    return class Uint8ArrayBlobAdapter extends Uint8Array {
+        static fromString(source, encoding = "utf-8") {
+            if (typeof source === "string") {
+                if (encoding === "base64") {
+                    return Uint8ArrayBlobAdapter.mutate(fromBase64(source));
+                }
+                return Uint8ArrayBlobAdapter.mutate(fromUtf8(source));
+            }
+            throw new Error(`Unsupported conversion from ${typeof source} to Uint8ArrayBlobAdapter.`);
+        }
+        static mutate(source) {
+            Object.setPrototypeOf(source, Uint8ArrayBlobAdapter.prototype);
+            return source;
+        }
+        transformToString(encoding = "utf-8") {
+            if (encoding === "base64") {
+                return toBase64(this);
+            }
+            return toUtf8(this);
+        }
+    };
+}
+
+const 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 new TextDecoder("utf-8").decode(input);
+};
+
 const decimalToHex = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
 function bindV4(getRandomValues) {
     if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
@@ -721,107 +837,6 @@ function toHex(bytes) {
     return out;
 }
 
-const chars = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/`;
-const alphabetByEncoding = Object.entries(chars).reduce((acc, [i, c]) => {
-    acc[c] = Number(i);
-    return acc;
-}, {});
-const alphabetByValue = chars.split("");
-const bitsPerLetter = 6;
-const bitsPerByte = 8;
-const maxLetterValue = 0b111111;
-
-const fromBase64$1 = (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);
-};
-
-const isArrayBuffer = (arg) => (typeof ArrayBuffer === "function" && arg instanceof ArrayBuffer) ||
-    Object.prototype.toString.call(arg) === "[object ArrayBuffer]";
-
-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);
-};
-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);
-};
-
-const fromUtf8$1 = (input) => {
-    const buf = fromString(input, "utf8");
-    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength / Uint8Array.BYTES_PER_ELEMENT);
-};
-
-function toBase64$1(_input) {
-    let input;
-    if (typeof _input === "string") {
-        input = fromUtf8$1(_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;
-}
-
 const TEXT_ENCODER = typeof TextEncoder == "function" ? new TextEncoder() : null;
 const calculateBodyLength = (body) => {
     if (typeof body === "string") {
@@ -849,11 +864,9 @@ const calculateBodyLength = (body) => {
     throw new Error(`Body Length computation failed for ${body}`);
 };
 
-const fromUtf8 = (input) => new TextEncoder().encode(input);
-
 const toUint8Array = (data) => {
     if (typeof data === "string") {
-        return fromUtf8$1(data);
+        return fromUtf8(data);
     }
     if (ArrayBuffer.isView(data)) {
         return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);
@@ -861,15 +874,8 @@ const toUint8Array = (data) => {
     return new Uint8Array(data);
 };
 
-const toUtf8$1 = (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);
-};
+const isArrayBuffer = (arg) => (typeof ArrayBuffer === "function" && arg instanceof ArrayBuffer) ||
+    Object.prototype.toString.call(arg) === "[object ArrayBuffer]";
 
 const deserializerMiddleware = (options, deserializer) => (next, context) => async (args) => {
     const { response } = await next(args);
@@ -906,7 +912,7 @@ const deserializerMiddleware = (options, deserializer) => (next, context) => asy
                 }
             }
             try {
-                if (protocols.HttpResponse.isInstance(response)) {
+                if (transport.HttpResponse.isInstance(response)) {
                     const { headers = {} } = response;
                     const headerEntries = Object.entries(headers);
                     error.$metadata = {
@@ -965,64 +971,6 @@ function getSerdePlugin(config, serializer, deserializer) {
     };
 }
 
-const BASE64_REGEX = /^[A-Za-z0-9+/]*={0,2}$/;
-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);
-};
-
-const toBase64 = (_input) => {
-    let input;
-    if (typeof _input === "string") {
-        input = fromUtf8$1(_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");
-};
-
-const 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");
-};
-
-class Uint8ArrayBlobAdapter extends Uint8Array {
-    static fromString(source, encoding = "utf-8") {
-        if (typeof source === "string") {
-            if (encoding === "base64") {
-                return Uint8ArrayBlobAdapter.mutate(fromBase64(source));
-            }
-            return Uint8ArrayBlobAdapter.mutate(fromUtf8$1(source));
-        }
-        throw new Error(`Unsupported conversion from ${typeof source} to Uint8ArrayBlobAdapter.`);
-    }
-    static mutate(source) {
-        Object.setPrototypeOf(source, Uint8ArrayBlobAdapter.prototype);
-        return source;
-    }
-    transformToString(encoding = "utf-8") {
-        if (encoding === "base64") {
-            return toBase64(this);
-        }
-        return toUtf8(this);
-    }
-}
-
 const ReadableStreamRef = typeof ReadableStream === "function" ? ReadableStream : function () { };
 class ChecksumStream extends ReadableStreamRef {
 }
@@ -1376,7 +1324,11 @@ async function splitStream(stream) {
 }
 
 const no = Symbol.for("node-only");
+const fromArrayBuffer = no;
+const fromString = no;
 const Hash = no;
+class Uint8ArrayBlobAdapter extends bindUint8ArrayBlobAdapter(toUtf8, fromUtf8, toBase64, fromBase64) {
+}
 const _getRandomValues = (array) => crypto.getRandomValues(array);
 const v4 = bindV4(_getRandomValues);
 const generateIdempotencyToken = v4;
@@ -1409,7 +1361,7 @@ exports.expectShort = expectShort;
 exports.expectString = expectString;
 exports.expectUnion = expectUnion;
 exports.fromArrayBuffer = fromArrayBuffer;
-exports.fromBase64 = fromBase64$1;
+exports.fromBase64 = fromBase64;
 exports.fromHex = fromHex;
 exports.fromString = fromString;
 exports.fromUtf8 = fromUtf8;
@@ -1446,8 +1398,8 @@ exports.strictParseInt = strictParseInt;
 exports.strictParseInt32 = strictParseInt32;
 exports.strictParseLong = strictParseLong;
 exports.strictParseShort = strictParseShort;
-exports.toBase64 = toBase64$1;
+exports.toBase64 = toBase64;
 exports.toHex = toHex;
 exports.toUint8Array = toUint8Array;
-exports.toUtf8 = toUtf8$1;
+exports.toUtf8 = toUtf8;
 exports.v4 = v4;

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

@@ -0,0 +1,184 @@
+'use strict';
+
+var types = require('@smithy/types');
+
+const getSmithyContext = (context) => context[types.SMITHY_CONTEXT_KEY] || (context[types.SMITHY_CONTEXT_KEY] = {});
+
+class HttpRequest {
+    method;
+    protocol;
+    hostname;
+    port;
+    path;
+    query;
+    headers;
+    username;
+    password;
+    fragment;
+    body;
+    constructor(options) {
+        this.method = options.method || "GET";
+        this.hostname = options.hostname || "localhost";
+        this.port = options.port;
+        this.query = options.query || {};
+        this.headers = options.headers || {};
+        this.body = options.body;
+        this.protocol = options.protocol
+            ? options.protocol.slice(-1) !== ":"
+                ? `${options.protocol}:`
+                : options.protocol
+            : "https:";
+        this.path = options.path ? (options.path.charAt(0) !== "/" ? `/${options.path}` : options.path) : "/";
+        this.username = options.username;
+        this.password = options.password;
+        this.fragment = options.fragment;
+    }
+    static clone(request) {
+        const cloned = new HttpRequest({
+            ...request,
+            headers: { ...request.headers },
+        });
+        if (cloned.query) {
+            cloned.query = cloneQuery(cloned.query);
+        }
+        return cloned;
+    }
+    static isInstance(request) {
+        if (!request) {
+            return false;
+        }
+        const req = request;
+        return ("method" in req &&
+            "protocol" in req &&
+            "hostname" in req &&
+            "path" in req &&
+            typeof req["query"] === "object" &&
+            typeof req["headers"] === "object");
+    }
+    clone() {
+        return HttpRequest.clone(this);
+    }
+}
+function cloneQuery(query) {
+    return Object.keys(query).reduce((carry, paramName) => {
+        const param = query[paramName];
+        return {
+            ...carry,
+            [paramName]: Array.isArray(param) ? [...param] : param,
+        };
+    }, {});
+}
+
+class HttpResponse {
+    statusCode;
+    reason;
+    headers;
+    body;
+    constructor(options) {
+        this.statusCode = options.statusCode;
+        this.reason = options.reason;
+        this.headers = options.headers || {};
+        this.body = options.body;
+    }
+    static isInstance(response) {
+        if (!response)
+            return false;
+        const resp = response;
+        return typeof resp.statusCode === "number" && typeof resp.headers === "object";
+    }
+}
+
+const VALID_HOST_LABEL_REGEX = new RegExp(`^(?!.*-$)(?!-)[a-zA-Z0-9-]{1,63}$`);
+const isValidHostLabel = (value, allowSubDomains = false) => {
+    if (!allowSubDomains) {
+        return VALID_HOST_LABEL_REGEX.test(value);
+    }
+    const labels = value.split(".");
+    for (const label of labels) {
+        if (!isValidHostLabel(label)) {
+            return false;
+        }
+    }
+    return true;
+};
+
+function isValidHostname(hostname) {
+    const hostPattern = /^[a-z0-9][a-z0-9\.\-]*[a-z0-9]$/;
+    return hostPattern.test(hostname);
+}
+
+const normalizeProvider = (input) => {
+    if (typeof input === "function")
+        return input;
+    const promisified = Promise.resolve(input);
+    return () => promisified;
+};
+
+function parseQueryString(querystring) {
+    const query = {};
+    querystring = querystring.replace(/^\?/, "");
+    if (querystring) {
+        for (const pair of querystring.split("&")) {
+            let [key, value = null] = pair.split("=");
+            key = decodeURIComponent(key);
+            if (value) {
+                value = decodeURIComponent(value);
+            }
+            if (!(key in query)) {
+                query[key] = value;
+            }
+            else if (Array.isArray(query[key])) {
+                query[key].push(value);
+            }
+            else {
+                query[key] = [query[key], value];
+            }
+        }
+    }
+    return query;
+}
+
+const parseUrl = (url) => {
+    if (typeof url === "string") {
+        return parseUrl(new URL(url));
+    }
+    const { hostname, pathname, port, protocol, search } = url;
+    let query;
+    if (search) {
+        query = parseQueryString(search);
+    }
+    return {
+        hostname,
+        port: port ? parseInt(port) : undefined,
+        protocol,
+        path: pathname,
+        query,
+    };
+};
+
+const toEndpointV1 = (endpoint) => {
+    if (typeof endpoint === "object") {
+        if ("url" in endpoint) {
+            const v1Endpoint = parseUrl(endpoint.url);
+            if (endpoint.headers) {
+                v1Endpoint.headers = {};
+                for (const name in endpoint.headers) {
+                    v1Endpoint.headers[name.toLowerCase()] = endpoint.headers[name].join(", ");
+                }
+            }
+            return v1Endpoint;
+        }
+        return endpoint;
+    }
+    return parseUrl(endpoint);
+};
+
+exports.HttpRequest = HttpRequest;
+exports.HttpResponse = HttpResponse;
+exports.getSmithyContext = getSmithyContext;
+exports.isValidHostLabel = isValidHostLabel;
+exports.isValidHostname = isValidHostname;
+exports.normalizeProvider = normalizeProvider;
+exports.parseQueryString = parseQueryString;
+exports.parseUrl = parseUrl;
+exports.toEndpointV1 = toEndpointV1;

package/node_modules/@smithy/core/dist-es/index.js

@@ -1,8 +1,8 @@
-export * from "./getSmithyContext";
-export * from "./middleware-http-auth-scheme";
-export * from "./middleware-http-signing";
+export { getSmithyContext } from "@smithy/core/transport";
+export * from "./legacy-root-exports/middleware-http-auth-scheme";
+export * from "./legacy-root-exports/middleware-http-signing";
 export * from "./normalizeProvider";
-export { createPaginator } from "./pagination/createPaginator";
-export * from "./request-builder/requestBuilder";
+export { createPaginator } from "./legacy-root-exports/pagination/createPaginator";
+export { requestBuilder } from "@smithy/core/protocols";
 export * from "./setFeature";
-export * from "./util-identity-and-auth";
+export * from "./legacy-root-exports/util-identity-and-auth";

package/node_modules/@smithy/core/dist-es/submodules/cbor/SmithyRpcV2CborProtocol.js

@@ -83,7 +83,7 @@ export class SmithyRpcV2CborProtocol extends RpcProtocol {
         const ns = NormalizedSchema.of(errorSchema);
         const ErrorCtor = registry.getErrorCtor(errorSchema);
         const message = dataObject.message ?? dataObject.Message ?? "Unknown";
-        const exception = new ErrorCtor(message);
+        const exception = new ErrorCtor({});
         const output = {};
         for (const [name, member] of ns.structIterator()) {
             output[name] = this.deserializer.readValue(member, dataObject[name]);

package/node_modules/@smithy/core/dist-es/submodules/client/index.js

@@ -1,6 +1,6 @@
 export { constructStack } from "./middleware-stack/MiddlewareStack";
-export { getSmithyContext } from "./util-middleware/getSmithyContext";
-export { normalizeProvider } from "./util-middleware/normalizeProvider";
+export { getSmithyContext } from "@smithy/core/transport";
+export { normalizeProvider } from "@smithy/core/transport";
 export { invalidFunction } from "./invalid-dependency/invalidFunction";
 export { invalidProvider } from "./invalid-dependency/invalidProvider";
 export { createWaiter } from "./util-waiter/createWaiter";

package/node_modules/@smithy/core/dist-es/submodules/config/config-resolver/regionConfig/checkRegion.js

@@ -1,4 +1,4 @@
-import { isValidHostLabel } from "@smithy/core/endpoints";
+import { isValidHostLabel } from "@smithy/core/transport";
 const validRegions = new Set();
 export const checkRegion = (region, check = isValidHostLabel) => {
     if (!validRegions.has(region) && !check(region)) {

package/node_modules/@smithy/core/dist-es/submodules/endpoints/index.browser.js

@@ -3,12 +3,12 @@ import { bindGetEndpointFromInstructions } from "./middleware-endpoint/adaptors/
 import { bindEndpointMiddleware } from "./middleware-endpoint/endpointMiddleware";
 import { bindGetEndpointPlugin } from "./middleware-endpoint/getEndpointPlugin";
 import { bindResolveEndpointConfig } from "./middleware-endpoint/resolveEndpointConfig";
-export * from "./toEndpointV1";
+export { toEndpointV1 } from "@smithy/core/transport";
 export { BinaryDecisionDiagram } from "./util-endpoints/bdd/BinaryDecisionDiagram";
 export { EndpointCache } from "./util-endpoints/cache/EndpointCache";
 export { decideEndpoint } from "./util-endpoints/decideEndpoint";
 export { isIpAddress } from "./util-endpoints/lib/isIpAddress";
-export { isValidHostLabel } from "./util-endpoints/lib/isValidHostLabel";
+export { isValidHostLabel } from "@smithy/core/transport";
 export { customEndpointFunctions } from "./util-endpoints/utils/customEndpointFunctions";
 export { resolveEndpoint } from "./util-endpoints/resolveEndpoint";
 export * from "./util-endpoints/types";

package/node_modules/@smithy/core/dist-es/submodules/endpoints/index.js

@@ -3,12 +3,12 @@ import { bindGetEndpointFromInstructions } from "./middleware-endpoint/adaptors/
 import { bindEndpointMiddleware } from "./middleware-endpoint/endpointMiddleware";
 import { bindGetEndpointPlugin } from "./middleware-endpoint/getEndpointPlugin";
 import { bindResolveEndpointConfig } from "./middleware-endpoint/resolveEndpointConfig";
-export * from "./toEndpointV1";
+export { toEndpointV1 } from "@smithy/core/transport";
 export { BinaryDecisionDiagram } from "./util-endpoints/bdd/BinaryDecisionDiagram";
 export { EndpointCache } from "./util-endpoints/cache/EndpointCache";
 export { decideEndpoint } from "./util-endpoints/decideEndpoint";
 export { isIpAddress } from "./util-endpoints/lib/isIpAddress";
-export { isValidHostLabel } from "./util-endpoints/lib/isValidHostLabel";
+export { isValidHostLabel } from "@smithy/core/transport";
 export { customEndpointFunctions } from "./util-endpoints/utils/customEndpointFunctions";
 export { resolveEndpoint } from "./util-endpoints/resolveEndpoint";
 export * from "./util-endpoints/types";

package/node_modules/@smithy/core/dist-es/submodules/endpoints/middleware-endpoint/adaptors/toEndpointV1.js

@@ -1 +1 @@
-export { toEndpointV1 } from "../../toEndpointV1";
+export { toEndpointV1 } from "@smithy/core/transport";

package/node_modules/@smithy/core/dist-es/submodules/endpoints/middleware-endpoint/resolveEndpointConfig.js

@@ -1,4 +1,4 @@
-import { normalizeProvider } from "@smithy/core/client";
+import { normalizeProvider } from "@smithy/core/transport";
 import { toEndpointV1 } from "./adaptors/toEndpointV1";
 export function bindResolveEndpointConfig(getEndpointFromConfig) {
     return (input) => {

package/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/lib/index.js

@@ -2,7 +2,7 @@ export * from "./booleanEquals";
 export * from "./coalesce";
 export * from "./getAttr";
 export * from "./isSet";
-export * from "./isValidHostLabel";
+export { isValidHostLabel } from "@smithy/core/transport";
 export * from "./ite";
 export * from "./not";
 export * from "./parseURL";

package/node_modules/@smithy/core/dist-es/submodules/protocols/HttpBindingProtocol.js

@@ -1,9 +1,9 @@
 import { NormalizedSchema, translateTraits } from "@smithy/core/schema";
 import { sdkStreamMixin, splitEvery, splitHeader } from "@smithy/core/serde";
+import { HttpRequest } from "@smithy/core/transport";
 import { HttpProtocol } from "./HttpProtocol";
 import { collectBody } from "./collect-stream-body";
 import { extendedEncodeURIComponent } from "./extended-encode-uri-component";
-import { HttpRequest } from "./protocol-http/httpRequest";
 export class HttpBindingProtocol extends HttpProtocol {
     async serializeRequest(operationSchema, _input, context) {
         const input = _input && typeof _input === "object" ? _input : {};

package/node_modules/@smithy/core/dist-es/submodules/protocols/HttpProtocol.js

@@ -1,7 +1,6 @@
 import { NormalizedSchema, TypeRegistry, translateTraits } from "@smithy/core/schema";
+import { HttpRequest, HttpResponse } from "@smithy/core/transport";
 import { SerdeContext } from "./SerdeContext";
-import { HttpRequest } from "./protocol-http/httpRequest";
-import { HttpResponse } from "./protocol-http/httpResponse";
 export class HttpProtocol extends SerdeContext {
     options;
     compositeErrorRegistry;

package/node_modules/@smithy/core/dist-es/submodules/protocols/RpcProtocol.js

@@ -1,7 +1,7 @@
 import { NormalizedSchema } from "@smithy/core/schema";
+import { HttpRequest } from "@smithy/core/transport";
 import { HttpProtocol } from "./HttpProtocol";
 import { collectBody } from "./collect-stream-body";
-import { HttpRequest } from "./protocol-http/httpRequest";
 export class RpcProtocol extends HttpProtocol {
     async serializeRequest(operationSchema, _input, context) {
         const serializer = this.serializer;