@qqbrowser/openclaw-qbot 0.10.9 → 0.10.11

package/node_modules/@smithy/util-endpoints/dist-cjs/index.js

@@ -1,573 +1,12 @@
-'use strict';
-
-var types = require('@smithy/types');
-
-class BinaryDecisionDiagram {
-    nodes;
-    root;
-    conditions;
-    results;
-    constructor(bdd, root, conditions, results) {
-        this.nodes = bdd;
-        this.root = root;
-        this.conditions = conditions;
-        this.results = results;
-    }
-    static from(bdd, root, conditions, results) {
-        return new BinaryDecisionDiagram(bdd, root, conditions, results);
-    }
-}
-
-class EndpointCache {
-    capacity;
-    data = new Map();
-    parameters = [];
-    constructor({ size, params }) {
-        this.capacity = size ?? 50;
-        if (params) {
-            this.parameters = params;
-        }
-    }
-    get(endpointParams, resolver) {
-        const key = this.hash(endpointParams);
-        if (key === false) {
-            return resolver();
-        }
-        if (!this.data.has(key)) {
-            if (this.data.size > this.capacity + 10) {
-                const keys = this.data.keys();
-                let i = 0;
-                while (true) {
-                    const { value, done } = keys.next();
-                    this.data.delete(value);
-                    if (done || ++i > 10) {
-                        break;
-                    }
-                }
-            }
-            this.data.set(key, resolver());
-        }
-        return this.data.get(key);
-    }
-    size() {
-        return this.data.size;
-    }
-    hash(endpointParams) {
-        let buffer = "";
-        const { parameters } = this;
-        if (parameters.length === 0) {
-            return false;
-        }
-        for (const param of parameters) {
-            const val = String(endpointParams[param] ?? "");
-            if (val.includes("|;")) {
-                return false;
-            }
-            buffer += val + "|;";
-        }
-        return buffer;
-    }
-}
-
-class EndpointError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "EndpointError";
-    }
-}
-
-const debugId = "endpoints";
-
-function toDebugString(input) {
-    if (typeof input !== "object" || input == null) {
-        return input;
-    }
-    if ("ref" in input) {
-        return `$${toDebugString(input.ref)}`;
-    }
-    if ("fn" in input) {
-        return `${input.fn}(${(input.argv || []).map(toDebugString).join(", ")})`;
-    }
-    return JSON.stringify(input, null, 2);
-}
-
-const customEndpointFunctions = {};
-
-const booleanEquals = (value1, value2) => value1 === value2;
-
-function coalesce(...args) {
-    for (const arg of args) {
-        if (arg != null) {
-            return arg;
-        }
-    }
-    return undefined;
-}
-
-const getAttrPathList = (path) => {
-    const parts = path.split(".");
-    const pathList = [];
-    for (const part of parts) {
-        const squareBracketIndex = part.indexOf("[");
-        if (squareBracketIndex !== -1) {
-            if (part.indexOf("]") !== part.length - 1) {
-                throw new EndpointError(`Path: '${path}' does not end with ']'`);
-            }
-            const arrayIndex = part.slice(squareBracketIndex + 1, -1);
-            if (Number.isNaN(parseInt(arrayIndex))) {
-                throw new EndpointError(`Invalid array index: '${arrayIndex}' in path: '${path}'`);
-            }
-            if (squareBracketIndex !== 0) {
-                pathList.push(part.slice(0, squareBracketIndex));
-            }
-            pathList.push(arrayIndex);
-        }
-        else {
-            pathList.push(part);
-        }
-    }
-    return pathList;
-};
-
-const getAttr = (value, path) => getAttrPathList(path).reduce((acc, index) => {
-    if (typeof acc !== "object") {
-        throw new EndpointError(`Index '${index}' in '${path}' not found in '${JSON.stringify(value)}'`);
-    }
-    else if (Array.isArray(acc)) {
-        const i = parseInt(index);
-        return acc[i < 0 ? acc.length + i : i];
-    }
-    return acc[index];
-}, value);
-
-const isSet = (value) => value != null;
-
-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 ite(condition, trueValue, falseValue) {
-    return condition ? trueValue : falseValue;
-}
-
-const not = (value) => !value;
-
-const IP_V4_REGEX = new RegExp(`^(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}$`);
-const isIpAddress = (value) => IP_V4_REGEX.test(value) || (value.startsWith("[") && value.endsWith("]"));
-
-const DEFAULT_PORTS = {
-    [types.EndpointURLScheme.HTTP]: 80,
-    [types.EndpointURLScheme.HTTPS]: 443,
-};
-const parseURL = (value) => {
-    const whatwgURL = (() => {
-        try {
-            if (value instanceof URL) {
-                return value;
-            }
-            if (typeof value === "object" && "hostname" in value) {
-                const { hostname, port, protocol = "", path = "", query = {} } = value;
-                const url = new URL(`${protocol}//${hostname}${port ? `:${port}` : ""}${path}`);
-                url.search = Object.entries(query)
-                    .map(([k, v]) => `${k}=${v}`)
-                    .join("&");
-                return url;
-            }
-            return new URL(value);
-        }
-        catch (error) {
-            return null;
-        }
-    })();
-    if (!whatwgURL) {
-        console.error(`Unable to parse ${JSON.stringify(value)} as a whatwg URL.`);
-        return null;
-    }
-    const urlString = whatwgURL.href;
-    const { host, hostname, pathname, protocol, search } = whatwgURL;
-    if (search) {
-        return null;
-    }
-    const scheme = protocol.slice(0, -1);
-    if (!Object.values(types.EndpointURLScheme).includes(scheme)) {
-        return null;
-    }
-    const isIp = isIpAddress(hostname);
-    const inputContainsDefaultPort = urlString.includes(`${host}:${DEFAULT_PORTS[scheme]}`) ||
-        (typeof value === "string" && value.includes(`${host}:${DEFAULT_PORTS[scheme]}`));
-    const authority = `${host}${inputContainsDefaultPort ? `:${DEFAULT_PORTS[scheme]}` : ``}`;
-    return {
-        scheme,
-        authority,
-        path: pathname,
-        normalizedPath: pathname.endsWith("/") ? pathname : `${pathname}/`,
-        isIp,
-    };
-};
-
-function split(value, delimiter, limit) {
-    if (limit === 1) {
-        return [value];
-    }
-    if (value === "") {
-        return [""];
-    }
-    const parts = value.split(delimiter);
-    if (limit === 0) {
-        return parts;
-    }
-    return parts.slice(0, limit - 1).concat(parts.slice(1).join(delimiter));
-}
-
-const stringEquals = (value1, value2) => value1 === value2;
-
-const substring = (input, start, stop, reverse) => {
-    if (input == null || start >= stop || input.length < stop || /[^\u0000-\u007f]/.test(input)) {
-        return null;
-    }
-    if (!reverse) {
-        return input.substring(start, stop);
-    }
-    return input.substring(input.length - stop, input.length - start);
-};
-
-const uriEncode = (value) => encodeURIComponent(value).replace(/[!*'()]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
-
-const endpointFunctions = {
-    booleanEquals,
-    coalesce,
-    getAttr,
-    isSet,
-    isValidHostLabel,
-    ite,
-    not,
-    parseURL,
-    split,
-    stringEquals,
-    substring,
-    uriEncode,
-};
-
-const evaluateTemplate = (template, options) => {
-    const evaluatedTemplateArr = [];
-    const { referenceRecord, endpointParams } = options;
-    let currentIndex = 0;
-    while (currentIndex < template.length) {
-        const openingBraceIndex = template.indexOf("{", currentIndex);
-        if (openingBraceIndex === -1) {
-            evaluatedTemplateArr.push(template.slice(currentIndex));
-            break;
-        }
-        evaluatedTemplateArr.push(template.slice(currentIndex, openingBraceIndex));
-        const closingBraceIndex = template.indexOf("}", openingBraceIndex);
-        if (closingBraceIndex === -1) {
-            evaluatedTemplateArr.push(template.slice(openingBraceIndex));
-            break;
-        }
-        if (template[openingBraceIndex + 1] === "{" && template[closingBraceIndex + 1] === "}") {
-            evaluatedTemplateArr.push(template.slice(openingBraceIndex + 1, closingBraceIndex));
-            currentIndex = closingBraceIndex + 2;
-        }
-        const parameterName = template.substring(openingBraceIndex + 1, closingBraceIndex);
-        if (parameterName.includes("#")) {
-            const [refName, attrName] = parameterName.split("#");
-            evaluatedTemplateArr.push(getAttr((referenceRecord[refName] ?? endpointParams[refName]), attrName));
-        }
-        else {
-            evaluatedTemplateArr.push((referenceRecord[parameterName] ?? endpointParams[parameterName]));
-        }
-        currentIndex = closingBraceIndex + 1;
-    }
-    return evaluatedTemplateArr.join("");
-};
-
-const getReferenceValue = ({ ref }, options) => {
-    return options.referenceRecord[ref] ?? options.endpointParams[ref];
-};
-
-const evaluateExpression = (obj, keyName, options) => {
-    if (typeof obj === "string") {
-        return evaluateTemplate(obj, options);
-    }
-    else if (obj["fn"]) {
-        return group$2.callFunction(obj, options);
-    }
-    else if (obj["ref"]) {
-        return getReferenceValue(obj, options);
-    }
-    throw new EndpointError(`'${keyName}': ${String(obj)} is not a string, function or reference.`);
-};
-const callFunction = ({ fn, argv }, options) => {
-    const evaluatedArgs = Array(argv.length);
-    for (let i = 0; i < evaluatedArgs.length; ++i) {
-        const arg = argv[i];
-        if (typeof arg === "boolean" || typeof arg === "number") {
-            evaluatedArgs[i] = arg;
-        }
-        else {
-            evaluatedArgs[i] = group$2.evaluateExpression(arg, "arg", options);
-        }
-    }
-    const namespaceSeparatorIndex = fn.indexOf(".");
-    if (namespaceSeparatorIndex !== -1) {
-        const namespaceFunctions = customEndpointFunctions[fn.slice(0, namespaceSeparatorIndex)];
-        const customFunction = namespaceFunctions?.[fn.slice(namespaceSeparatorIndex + 1)];
-        if (typeof customFunction === "function") {
-            return customFunction(...evaluatedArgs);
-        }
-    }
-    const callable = endpointFunctions[fn];
-    if (typeof callable === "function") {
-        return callable(...evaluatedArgs);
-    }
-    throw new Error(`function ${fn} not loaded in endpointFunctions.`);
-};
-const group$2 = {
-    evaluateExpression,
-    callFunction,
-};
-
-const evaluateCondition = (condition, options) => {
-    const { assign } = condition;
-    if (assign && assign in options.referenceRecord) {
-        throw new EndpointError(`'${assign}' is already defined in Reference Record.`);
-    }
-    const value = callFunction(condition, options);
-    options.logger?.debug?.(`${debugId} evaluateCondition: ${toDebugString(condition)} = ${toDebugString(value)}`);
-    const result = value === "" ? true : !!value;
-    if (assign != null) {
-        return { result, toAssign: { name: assign, value } };
-    }
-    return { result };
-};
-
-const getEndpointHeaders = (headers, options) => Object.entries(headers ?? {}).reduce((acc, [headerKey, headerVal]) => {
-    acc[headerKey] = headerVal.map((headerValEntry) => {
-        const processedExpr = evaluateExpression(headerValEntry, "Header value entry", options);
-        if (typeof processedExpr !== "string") {
-            throw new EndpointError(`Header '${headerKey}' value '${processedExpr}' is not a string`);
-        }
-        return processedExpr;
-    });
-    return acc;
-}, {});
-
-const getEndpointProperties = (properties, options) => Object.entries(properties).reduce((acc, [propertyKey, propertyVal]) => {
-    acc[propertyKey] = group$1.getEndpointProperty(propertyVal, options);
-    return acc;
-}, {});
-const getEndpointProperty = (property, options) => {
-    if (Array.isArray(property)) {
-        return property.map((propertyEntry) => getEndpointProperty(propertyEntry, options));
-    }
-    switch (typeof property) {
-        case "string":
-            return evaluateTemplate(property, options);
-        case "object":
-            if (property === null) {
-                throw new EndpointError(`Unexpected endpoint property: ${property}`);
-            }
-            return group$1.getEndpointProperties(property, options);
-        case "boolean":
-            return property;
-        default:
-            throw new EndpointError(`Unexpected endpoint property type: ${typeof property}`);
-    }
-};
-const group$1 = {
-    getEndpointProperty,
-    getEndpointProperties,
-};
-
-const getEndpointUrl = (endpointUrl, options) => {
-    const expression = evaluateExpression(endpointUrl, "Endpoint URL", options);
-    if (typeof expression === "string") {
-        try {
-            return new URL(expression);
-        }
-        catch (error) {
-            console.error(`Failed to construct URL with ${expression}`, error);
-            throw error;
-        }
-    }
-    throw new EndpointError(`Endpoint URL must be a string, got ${typeof expression}`);
-};
-
-const RESULT = 100_000_000;
-const decideEndpoint = (bdd, options) => {
-    const { nodes, root, results, conditions } = bdd;
-    let ref = root;
-    const referenceRecord = {};
-    const closure = {
-        referenceRecord,
-        endpointParams: options.endpointParams,
-        logger: options.logger,
-    };
-    while (ref !== 1 && ref !== -1 && ref < RESULT) {
-        const node_i = 3 * (Math.abs(ref) - 1);
-        const [condition_i, highRef, lowRef] = [nodes[node_i], nodes[node_i + 1], nodes[node_i + 2]];
-        const [fn, argv, assign] = conditions[condition_i];
-        const evaluation = evaluateCondition({ fn, assign, argv }, closure);
-        if (evaluation.toAssign) {
-            const { name, value } = evaluation.toAssign;
-            referenceRecord[name] = value;
-        }
-        ref = ref >= 0 === evaluation.result ? highRef : lowRef;
-    }
-    if (ref >= RESULT) {
-        const result = results[ref - RESULT];
-        if (result[0] === -1) {
-            const [, errorExpression] = result;
-            throw new EndpointError(evaluateExpression(errorExpression, "Error", closure));
-        }
-        const [url, properties, headers] = result;
-        return {
-            url: getEndpointUrl(url, closure),
-            properties: getEndpointProperties(properties, closure),
-            headers: getEndpointHeaders(headers ?? {}, closure),
-        };
-    }
-    throw new EndpointError(`No matching endpoint.`);
-};
-
-const evaluateConditions = (conditions = [], options) => {
-    const conditionsReferenceRecord = {};
-    const conditionOptions = {
-        ...options,
-        referenceRecord: { ...options.referenceRecord },
-    };
-    let didAssign = false;
-    for (const condition of conditions) {
-        const { result, toAssign } = evaluateCondition(condition, conditionOptions);
-        if (!result) {
-            return { result };
-        }
-        if (toAssign) {
-            didAssign = true;
-            conditionsReferenceRecord[toAssign.name] = toAssign.value;
-            conditionOptions.referenceRecord[toAssign.name] = toAssign.value;
-            options.logger?.debug?.(`${debugId} assign: ${toAssign.name} := ${toDebugString(toAssign.value)}`);
-        }
-    }
-    if (didAssign) {
-        return { result: true, referenceRecord: conditionsReferenceRecord };
-    }
-    return { result: true };
-};
-
-const evaluateEndpointRule = (endpointRule, options) => {
-    const { conditions, endpoint } = endpointRule;
-    const { result, referenceRecord } = evaluateConditions(conditions, options);
-    if (!result) {
-        return;
-    }
-    const endpointRuleOptions = referenceRecord
-        ? {
-            ...options,
-            referenceRecord: { ...options.referenceRecord, ...referenceRecord },
-        }
-        : options;
-    const { url, properties, headers } = endpoint;
-    options.logger?.debug?.(`${debugId} Resolving endpoint from template: ${toDebugString(endpoint)}`);
-    const endpointToReturn = { url: getEndpointUrl(url, endpointRuleOptions) };
-    if (headers != null) {
-        endpointToReturn.headers = getEndpointHeaders(headers, endpointRuleOptions);
-    }
-    if (properties != null) {
-        endpointToReturn.properties = getEndpointProperties(properties, endpointRuleOptions);
-    }
-    return endpointToReturn;
-};
-
-const evaluateErrorRule = (errorRule, options) => {
-    const { conditions, error } = errorRule;
-    const { result, referenceRecord } = evaluateConditions(conditions, options);
-    if (!result) {
-        return;
-    }
-    const errorRuleOptions = referenceRecord
-        ? {
-            ...options,
-            referenceRecord: { ...options.referenceRecord, ...referenceRecord },
-        }
-        : options;
-    throw new EndpointError(evaluateExpression(error, "Error", errorRuleOptions));
-};
-
-const evaluateRules = (rules, options) => {
-    for (const rule of rules) {
-        if (rule.type === "endpoint") {
-            const endpointOrUndefined = evaluateEndpointRule(rule, options);
-            if (endpointOrUndefined) {
-                return endpointOrUndefined;
-            }
-        }
-        else if (rule.type === "error") {
-            evaluateErrorRule(rule, options);
-        }
-        else if (rule.type === "tree") {
-            const endpointOrUndefined = group.evaluateTreeRule(rule, options);
-            if (endpointOrUndefined) {
-                return endpointOrUndefined;
-            }
-        }
-        else {
-            throw new EndpointError(`Unknown endpoint rule: ${rule}`);
-        }
-    }
-    throw new EndpointError(`Rules evaluation failed`);
-};
-const evaluateTreeRule = (treeRule, options) => {
-    const { conditions, rules } = treeRule;
-    const { result, referenceRecord } = evaluateConditions(conditions, options);
-    if (!result) {
-        return;
-    }
-    const treeRuleOptions = referenceRecord
-        ? { ...options, referenceRecord: { ...options.referenceRecord, ...referenceRecord } }
-        : options;
-    return group.evaluateRules(rules, treeRuleOptions);
-};
-const group = {
-    evaluateRules,
-    evaluateTreeRule,
-};
-
-const resolveEndpoint = (ruleSetObject, options) => {
-    const { endpointParams, logger } = options;
-    const { parameters, rules } = ruleSetObject;
-    options.logger?.debug?.(`${debugId} Initial EndpointParams: ${toDebugString(endpointParams)}`);
-    for (const paramKey in parameters) {
-        const parameter = parameters[paramKey];
-        const endpointParam = endpointParams[paramKey];
-        if (endpointParam == null && parameter.default != null) {
-            endpointParams[paramKey] = parameter.default;
-            continue;
-        }
-        if (parameter.required && endpointParam == null) {
-            throw new EndpointError(`Missing required parameter: '${paramKey}'`);
-        }
-    }
-    const endpoint = evaluateRules(rules, { endpointParams, logger, referenceRecord: {} });
-    options.logger?.debug?.(`${debugId} Resolved endpoint: ${toDebugString(endpoint)}`);
-    return endpoint;
-};
-
-exports.BinaryDecisionDiagram = BinaryDecisionDiagram;
-exports.EndpointCache = EndpointCache;
-exports.EndpointError = EndpointError;
-exports.customEndpointFunctions = customEndpointFunctions;
-exports.decideEndpoint = decideEndpoint;
-exports.isIpAddress = isIpAddress;
-exports.isValidHostLabel = isValidHostLabel;
-exports.resolveEndpoint = resolveEndpoint;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EndpointError = exports.resolveEndpoint = exports.customEndpointFunctions = exports.isValidHostLabel = exports.isIpAddress = exports.decideEndpoint = exports.EndpointCache = exports.BinaryDecisionDiagram = void 0;
+var endpoints_1 = require("@smithy/core/endpoints");
+Object.defineProperty(exports, "BinaryDecisionDiagram", { enumerable: true, get: function () { return endpoints_1.BinaryDecisionDiagram; } });
+Object.defineProperty(exports, "EndpointCache", { enumerable: true, get: function () { return endpoints_1.EndpointCache; } });
+Object.defineProperty(exports, "decideEndpoint", { enumerable: true, get: function () { return endpoints_1.decideEndpoint; } });
+Object.defineProperty(exports, "isIpAddress", { enumerable: true, get: function () { return endpoints_1.isIpAddress; } });
+Object.defineProperty(exports, "isValidHostLabel", { enumerable: true, get: function () { return endpoints_1.isValidHostLabel; } });
+Object.defineProperty(exports, "customEndpointFunctions", { enumerable: true, get: function () { return endpoints_1.customEndpointFunctions; } });
+Object.defineProperty(exports, "resolveEndpoint", { enumerable: true, get: function () { return endpoints_1.resolveEndpoint; } });
+Object.defineProperty(exports, "EndpointError", { enumerable: true, get: function () { return endpoints_1.EndpointError; } });

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

@@ -1,8 +1 @@
-export { BinaryDecisionDiagram } from "./bdd/BinaryDecisionDiagram";
-export * from "./cache/EndpointCache";
-export { decideEndpoint } from "./decideEndpoint";
-export * from "./lib/isIpAddress";
-export * from "./lib/isValidHostLabel";
-export * from "./utils/customEndpointFunctions";
-export * from "./resolveEndpoint";
-export * from "./types";
+export { BinaryDecisionDiagram, EndpointCache, decideEndpoint, isIpAddress, isValidHostLabel, customEndpointFunctions, resolveEndpoint, EndpointError, } from "@smithy/core/endpoints";

package/node_modules/@smithy/util-endpoints/package.json

@@ -1,22 +1,14 @@
 {
   "name": "@smithy/util-endpoints",
-  "version": "3.4.2",
+  "version": "3.5.1",
   "description": "Utilities to help with endpoint resolution.",
   "main": "./dist-cjs/index.js",
   "module": "./dist-es/index.js",
   "scripts": {
-    "build": "concurrently 'yarn:build:types' 'yarn:build:es:cjs'",
-    "build:es:cjs": "yarn g:tsc -p tsconfig.es.json && node ../../scripts/inline util-endpoints",
+    "build": "yarn g:tsc -p tsconfig.cjs.json && yarn g:tsc -p tsconfig.es.json && yarn g:tsc -p tsconfig.types.json",
     "build:types": "yarn g:tsc -p tsconfig.types.json",
-    "build:types:downlevel": "premove dist-types/ts3.4 && downlevel-dts dist-types dist-types/ts3.4",
-    "clean": "premove dist-cjs dist-es dist-types tsconfig.cjs.tsbuildinfo tsconfig.es.tsbuildinfo tsconfig.types.tsbuildinfo",
-    "format": "prettier --config ../../prettier.config.js --ignore-path ../../.prettierignore --write \"**/*.{ts,md,json}\"",
-    "lint": "eslint -c ../../.eslintrc.js \"src/**/*.ts\"",
-    "stage-release": "premove .release && yarn pack && mkdir ./.release && tar zxvf ./package.tgz --directory ./.release && rm ./package.tgz",
-    "test": "yarn g:vitest run",
-    "test:integration": "yarn g:vitest run -c vitest.config.integ.mts",
-    "test:integration:watch": "yarn g:vitest watch -c vitest.config.integ.mts",
-    "test:watch": "yarn g:vitest watch"
+    "clean": "rm -rf dist-cjs dist-es dist-types",
+    "stage-release": "rm -rf .release && yarn pack && mkdir ./.release && tar zxvf ./package.tgz --directory ./.release && rm ./package.tgz"
   },
   "keywords": [
     "endpoint"
@@ -28,28 +20,13 @@
   "license": "Apache-2.0",
   "sideEffects": false,
   "dependencies": {
-    "@smithy/node-config-provider": "^4.3.14",
-    "@smithy/types": "^4.14.1",
+    "@smithy/core": "^3.24.1",
     "tslib": "^2.6.2"
   },
-  "devDependencies": {
-    "@types/node": "^18.11.9",
-    "concurrently": "7.0.0",
-    "downlevel-dts": "0.10.1",
-    "premove": "4.0.0",
-    "typedoc": "0.23.23"
-  },
   "types": "./dist-types/index.d.ts",
   "engines": {
     "node": ">=18.0.0"
   },
-  "typesVersions": {
-    "<4.5": {
-      "types/*": [
-        "types/ts3.4/*"
-      ]
-    }
-  },
   "files": [
     "dist-*/**"
   ],

package/node_modules/@smithy/util-hex-encoding/dist-cjs/index.js

@@ -1,38 +1,6 @@
-'use strict';
-
-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;
-}
-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;
-}
-
-exports.fromHex = fromHex;
-exports.toHex = toHex;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toHex = exports.fromHex = void 0;
+var serde_1 = require("@smithy/core/serde");
+Object.defineProperty(exports, "fromHex", { enumerable: true, get: function () { return serde_1.fromHex; } });
+Object.defineProperty(exports, "toHex", { enumerable: true, get: function () { return serde_1.toHex; } });