@openclaw/amazon-bedrock-provider 2026.7.2-beta.4 → 2026.7.2-beta.7

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/middleware-endpoint/service-customizations/s3.js

@@ -0,0 +1,37 @@
+export const resolveParamsForS3 = async (endpointParams) => {
+    const bucket = endpointParams?.Bucket || "";
+    if (typeof endpointParams.Bucket === "string") {
+        endpointParams.Bucket = bucket.replace(/#/g, encodeURIComponent("#")).replace(/\?/g, encodeURIComponent("?"));
+    }
+    if (isArnBucketName(bucket)) {
+        if (endpointParams.ForcePathStyle === true) {
+            throw new Error("Path-style addressing cannot be used with ARN buckets");
+        }
+    }
+    else if (!isDnsCompatibleBucketName(bucket) ||
+        (bucket.indexOf(".") !== -1 && !String(endpointParams.Endpoint).startsWith("http:")) ||
+        bucket.toLowerCase() !== bucket ||
+        bucket.length < 3) {
+        endpointParams.ForcePathStyle = true;
+    }
+    if (endpointParams.DisableMultiRegionAccessPoints) {
+        endpointParams.disableMultiRegionAccessPoints = true;
+        endpointParams.DisableMRAP = true;
+    }
+    return endpointParams;
+};
+const DOMAIN_PATTERN = /^[a-z0-9][a-z0-9.-]{1,61}[a-z0-9]$/;
+const IP_ADDRESS_PATTERN = /(\d+\.){3}\d+/;
+const DOTS_PATTERN = /\.\./;
+export const DOT_PATTERN = /\./;
+export const S3_HOSTNAME_PATTERN = /^(.+\.)?s3(-fips)?(\.dualstack)?[.-]([a-z0-9-]+)\./;
+export const isDnsCompatibleBucketName = (bucketName) => DOMAIN_PATTERN.test(bucketName) && !IP_ADDRESS_PATTERN.test(bucketName) && !DOTS_PATTERN.test(bucketName);
+export const isArnBucketName = (bucketName) => {
+    const [arn, partition, service, , , bucket] = bucketName.split(":");
+    const isArn = arn === "arn" && bucketName.split(":").length >= 6;
+    const isValidArn = Boolean(isArn && partition && service && bucket);
+    if (isArn && !isValidArn) {
+        throw new Error(`Invalid ARN: ${bucketName} was an invalid ARN.`);
+    }
+    return isValidArn;
+};

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/bdd/BinaryDecisionDiagram.js

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

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/cache/EndpointCache.js

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

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/debug/debugId.js

@@ -0,0 +1 @@
+export const debugId = "endpoints";

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/debug/index.js

@@ -0,0 +1,2 @@
+export { debugId } from "./debugId";
+export { toDebugString } from "./toDebugString";

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/debug/toDebugString.js

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

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/decideEndpoint.js

@@ -0,0 +1,42 @@
+import { EndpointError } from "./types";
+import { evaluateCondition } from "./utils/evaluateCondition";
+import { evaluateExpression } from "./utils/evaluateExpression";
+import { getEndpointHeaders } from "./utils/getEndpointHeaders";
+import { getEndpointProperties } from "./utils/getEndpointProperties";
+import { getEndpointUrl } from "./utils/getEndpointUrl";
+const RESULT = 100_000_000;
+export 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.`);
+};

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/lib/booleanEquals.js

@@ -0,0 +1 @@
+export const booleanEquals = (value1, value2) => value1 === value2;

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/lib/coalesce.js

@@ -0,0 +1,8 @@
+export function coalesce(...args) {
+    for (const arg of args) {
+        if (arg != null) {
+            return arg;
+        }
+    }
+    return undefined;
+}

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/lib/getAttr.js

@@ -0,0 +1,12 @@
+import { EndpointError } from "../types";
+import { getAttrPathList } from "./getAttrPathList";
+export 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);

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/lib/getAttrPathList.js

@@ -0,0 +1,25 @@
+import { EndpointError } from "../types";
+export 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;
+};

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/lib/index.js

@@ -0,0 +1,12 @@
+export { booleanEquals } from "./booleanEquals";
+export { coalesce } from "./coalesce";
+export { getAttr } from "./getAttr";
+export { isSet } from "./isSet";
+export { isValidHostLabel } from "@smithy/core/transport";
+export { ite } from "./ite";
+export { not } from "./not";
+export { parseURL } from "./parseURL";
+export { split } from "./split";
+export { stringEquals } from "./stringEquals";
+export { substring } from "./substring";
+export { uriEncode } from "./uriEncode";

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/lib/isIpAddress.js

@@ -0,0 +1,2 @@
+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}$`);
+export const isIpAddress = (value) => IP_V4_REGEX.test(value) || (value.startsWith("[") && value.endsWith("]"));

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/lib/isSet.js

@@ -0,0 +1 @@
+export const isSet = (value) => value != null;

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/lib/ite.js

@@ -0,0 +1,3 @@
+export function ite(condition, trueValue, falseValue) {
+    return condition ? trueValue : falseValue;
+}

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/lib/not.js

@@ -0,0 +1 @@
+export const not = (value) => !value;

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/lib/parseURL.js

@@ -0,0 +1,51 @@
+import { EndpointURLScheme } from "@smithy/types";
+import { isIpAddress } from "./isIpAddress";
+const DEFAULT_PORTS = {
+    [EndpointURLScheme.HTTP]: 80,
+    [EndpointURLScheme.HTTPS]: 443,
+};
+export 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 (ignored) {
+            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(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,
+    };
+};

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/lib/split.js

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

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/lib/stringEquals.js

@@ -0,0 +1 @@
+export const stringEquals = (value1, value2) => value1 === value2;

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/lib/substring.js

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

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/lib/uriEncode.js

@@ -0,0 +1 @@
+export const uriEncode = (value) => encodeURIComponent(value).replace(/[!*'()]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/resolveEndpoint.js

@@ -0,0 +1,22 @@
+import { debugId, toDebugString } from "./debug";
+import { EndpointError } from "./types";
+import { evaluateRules } from "./utils";
+export 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;
+};

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/types/EndpointError.js

@@ -0,0 +1,6 @@
+export class EndpointError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "EndpointError";
+    }
+}

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/types/EndpointFunctions.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/types/EndpointRuleObject.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/types/ErrorRuleObject.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/types/RuleSetObject.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/types/TreeRuleObject.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/types/index.js

@@ -0,0 +1 @@
+export { EndpointError } from "./EndpointError";

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/types/shared.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/utils/callFunction.js

@@ -0,0 +1 @@
+export { callFunction } from "./evaluateExpression";

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/utils/customEndpointFunctions.js

@@ -0,0 +1 @@
+export const customEndpointFunctions = {};

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/utils/endpointFunctions.js

@@ -0,0 +1,15 @@
+import { booleanEquals, coalesce, getAttr, isSet, isValidHostLabel, ite, not, parseURL, split, stringEquals, substring, uriEncode, } from "../lib";
+export const endpointFunctions = {
+    booleanEquals,
+    coalesce,
+    getAttr,
+    isSet,
+    isValidHostLabel,
+    ite,
+    not,
+    parseURL,
+    split,
+    stringEquals,
+    substring,
+    uriEncode,
+};

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/utils/evaluateCondition.js

@@ -0,0 +1,16 @@
+import { debugId, toDebugString } from "../debug";
+import { EndpointError } from "../types";
+import { callFunction } from "./callFunction";
+export 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 };
+};

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/utils/evaluateConditions.js

@@ -0,0 +1,26 @@
+import { debugId, toDebugString } from "../debug";
+import { evaluateCondition } from "./evaluateCondition";
+export 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 };
+};

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/utils/evaluateEndpointRule.js

@@ -0,0 +1,28 @@
+import { debugId, toDebugString } from "../debug";
+import { evaluateConditions } from "./evaluateConditions";
+import { getEndpointHeaders } from "./getEndpointHeaders";
+import { getEndpointProperties } from "./getEndpointProperties";
+import { getEndpointUrl } from "./getEndpointUrl";
+export 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;
+};

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/utils/evaluateErrorRule.js

@@ -0,0 +1,17 @@
+import { EndpointError } from "../types";
+import { evaluateConditions } from "./evaluateConditions";
+import { evaluateExpression } from "./evaluateExpression";
+export 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));
+};

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/utils/evaluateExpression.js

@@ -0,0 +1,46 @@
+import { EndpointError, } from "../types";
+import { customEndpointFunctions } from "./customEndpointFunctions";
+import { endpointFunctions } from "./endpointFunctions";
+import { evaluateTemplate } from "./evaluateTemplate";
+import { getReferenceValue } from "./getReferenceValue";
+export const evaluateExpression = (obj, keyName, options) => {
+    if (typeof obj === "string") {
+        return evaluateTemplate(obj, options);
+    }
+    else if (obj["fn"]) {
+        return group.callFunction(obj, options);
+    }
+    else if (obj["ref"]) {
+        return getReferenceValue(obj, options);
+    }
+    throw new EndpointError(`'${keyName}': ${String(obj)} is not a string, function or reference.`);
+};
+export 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.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.`);
+};
+export const group = {
+    evaluateExpression,
+    callFunction,
+};

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/utils/evaluateRules.js

@@ -0,0 +1,42 @@
+import { EndpointError } from "../types";
+import { evaluateConditions } from "./evaluateConditions";
+import { evaluateEndpointRule } from "./evaluateEndpointRule";
+import { evaluateErrorRule } from "./evaluateErrorRule";
+export 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`);
+};
+export 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);
+};
+export const group = {
+    evaluateRules,
+    evaluateTreeRule,
+};

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/utils/evaluateTemplate.js

@@ -0,0 +1,33 @@
+import { getAttr } from "../lib";
+export 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("");
+};

package/node_modules/@aws-sdk/credential-provider-node/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/utils/evaluateTreeRule.js

@@ -0,0 +1 @@
+export { evaluateTreeRule } from "./evaluateRules";