@aws-sdk/util-endpoints 3.186.0 → 3.188.0

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [3.188.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.187.0...v3.188.0) (2022-10-13)
+
+
+### Bug Fixes
+
+* **endpoint:** misc endpoints 2.0 fixes for s3 ([#4031](https://github.com/aws/aws-sdk-js-v3/issues/4031)) ([f8926a5](https://github.com/aws/aws-sdk-js-v3/commit/f8926a56cf9a25c2e6a5c91089543094e32d5c4b))
+
+
+
+
+
 # [3.186.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.185.0...v3.186.0) (2022-10-06)
 
 **Note:** Version bump only for package @aws-sdk/util-endpoints

package/dist-cjs/resolveEndpoint.js

@@ -4,7 +4,7 @@ exports.resolveEndpoint = void 0;
 const types_1 = require("./types");
 const utils_1 = require("./utils");
 const resolveEndpoint = (ruleSetObject, options) => {
-    var _a;
+    var _a, _b;
     const { endpointParams, logger } = options;
     const { parameters, rules } = ruleSetObject;
     const paramsWithDefault = Object.entries(parameters)
@@ -23,6 +23,17 @@ const resolveEndpoint = (ruleSetObject, options) => {
             throw new types_1.EndpointError(`Missing required parameter: '${requiredParam}'`);
         }
     }
-    return (0, utils_1.evaluateRules)(rules, { endpointParams, logger, referenceRecord: {} });
+    const endpoint = (0, utils_1.evaluateRules)(rules, { endpointParams, logger, referenceRecord: {} });
+    if ((_b = options.endpointParams) === null || _b === void 0 ? void 0 : _b.Endpoint) {
+        try {
+            const givenEndpoint = new URL(options.endpointParams.Endpoint);
+            const { protocol, port } = givenEndpoint;
+            endpoint.url.protocol = protocol;
+            endpoint.url.port = port;
+        }
+        catch (e) {
+        }
+    }
+    return endpoint;
 };
 exports.resolveEndpoint = resolveEndpoint;

package/dist-es/lib/aws/isVirtualHostableS3Bucket.js

@@ -1,25 +1,12 @@
-import { __values } from "tslib";
 import { isIpAddress } from "../isIpAddress";
 import { isValidHostLabel } from "../isValidHostLabel";
-export var isVirtualHostableS3Bucket = function (value, allowSubDomains) {
-    var e_1, _a;
-    if (allowSubDomains === void 0) { allowSubDomains = false; }
+export const isVirtualHostableS3Bucket = (value, allowSubDomains = false) => {
     if (allowSubDomains) {
-        try {
-            for (var _b = __values(value.split(".")), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var label = _c.value;
-                if (!isVirtualHostableS3Bucket(label)) {
-                    return false;
-                }
+        for (const label of value.split(".")) {
+            if (!isVirtualHostableS3Bucket(label)) {
+                return false;
             }
         }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
         return true;
     }
     if (!isValidHostLabel(value)) {

package/dist-es/lib/aws/parseArn.js

@@ -1,16 +1,15 @@
-import { __read } from "tslib";
-export var parseArn = function (value) {
-    var segments = value.split(":");
+export const parseArn = (value) => {
+    const segments = value.split(":");
     if (segments.length < 6)
         return null;
-    var _a = __read(segments), arn = _a[0], partition = _a[1], service = _a[2], region = _a[3], accountId = _a[4], resourceId = _a.slice(5);
+    const [arn, partition, service, region, accountId, ...resourceId] = segments;
     if (arn !== "arn" || partition === "" || service === "" || resourceId[0] === "")
         return null;
     return {
-        partition: partition,
-        service: service,
-        region: region,
-        accountId: accountId,
+        partition,
+        service,
+        region,
+        accountId,
         resourceId: resourceId[0].includes("/") ? resourceId[0].split("/") : resourceId,
     };
 };

package/dist-es/lib/aws/partition.js

@@ -1,55 +1,33 @@
-import { __assign, __read, __values } from "tslib";
 import { partitions } from "./partitions.json";
-var DEFAULT_PARTITION = partitions.find(function (partition) { return partition.id === "aws"; });
-export var partition = function (value) {
-    var e_1, _a, e_2, _b, e_3, _c;
-    try {
-        for (var partitions_1 = __values(partitions), partitions_1_1 = partitions_1.next(); !partitions_1_1.done; partitions_1_1 = partitions_1.next()) {
-            var partition_1 = partitions_1_1.value;
-            var id = partition_1.id, regions = partition_1.regions, outputs = partition_1.outputs;
-            try {
-                for (var _d = (e_2 = void 0, __values(Object.entries(regions))), _e = _d.next(); !_e.done; _e = _d.next()) {
-                    var _f = __read(_e.value, 2), region = _f[0], regionData = _f[1];
-                    if (region === value) {
-                        return __assign(__assign({ name: id }, outputs), regionData);
-                    }
-                }
-            }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-            finally {
-                try {
-                    if (_e && !_e.done && (_b = _d.return)) _b.call(_d);
-                }
-                finally { if (e_2) throw e_2.error; }
-            }
-        }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (partitions_1_1 && !partitions_1_1.done && (_a = partitions_1.return)) _a.call(partitions_1);
-        }
-        finally { if (e_1) throw e_1.error; }
-    }
-    try {
-        for (var partitions_2 = __values(partitions), partitions_2_1 = partitions_2.next(); !partitions_2_1.done; partitions_2_1 = partitions_2.next()) {
-            var partition_2 = partitions_2_1.value;
-            var id = partition_2.id, regionRegex = partition_2.regionRegex, outputs = partition_2.outputs;
-            if (new RegExp(regionRegex).test(value)) {
-                return __assign({ name: id }, outputs);
+const DEFAULT_PARTITION = partitions.find((partition) => partition.id === "aws");
+export const partition = (value) => {
+    for (const partition of partitions) {
+        const { id, regions, outputs } = partition;
+        for (const [region, regionData] of Object.entries(regions)) {
+            if (region === value) {
+                return {
+                    name: id,
+                    ...outputs,
+                    ...regionData,
+                };
             }
         }
     }
-    catch (e_3_1) { e_3 = { error: e_3_1 }; }
-    finally {
-        try {
-            if (partitions_2_1 && !partitions_2_1.done && (_c = partitions_2.return)) _c.call(partitions_2);
+    for (const partition of partitions) {
+        const { id, regionRegex, outputs } = partition;
+        if (new RegExp(regionRegex).test(value)) {
+            return {
+                name: id,
+                ...outputs,
+            };
         }
-        finally { if (e_3) throw e_3.error; }
     }
     if (!DEFAULT_PARTITION) {
         throw new Error("Provided region was not found in the partition array or regex," +
             " and default partition with id 'aws' doesn't exist.");
     }
-    return __assign({ name: DEFAULT_PARTITION.id }, DEFAULT_PARTITION.outputs);
+    return {
+        name: DEFAULT_PARTITION.id,
+        ...DEFAULT_PARTITION.outputs,
+    };
 };

package/dist-es/lib/booleanEquals.js

@@ -1 +1 @@
-export var booleanEquals = function (value1, value2) { return value1 === value2; };
+export const booleanEquals = (value1, value2) => value1 === value2;

package/dist-es/lib/getAttr.js

@@ -1,13 +1,11 @@
 import { EndpointError } from "../types";
 import { getAttrPathList } from "./getAttrPathList";
-export var getAttr = function (value, path) {
-    return getAttrPathList(path).reduce(function (acc, index) {
-        if (typeof acc !== "object") {
-            throw new EndpointError("Index '".concat(index, "' in '").concat(path, "' not found in '").concat(JSON.stringify(value), "'"));
-        }
-        else if (Array.isArray(acc)) {
-            return acc[parseInt(index)];
-        }
-        return acc[index];
-    }, value);
-};
+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)) {
+        return acc[parseInt(index)];
+    }
+    return acc[index];
+}, value);

package/dist-es/lib/getAttrPathList.js

@@ -1,37 +1,25 @@
-import { __values } from "tslib";
 import { EndpointError } from "../types";
-export var getAttrPathList = function (path) {
-    var e_1, _a;
-    var parts = path.split(".");
-    var pathList = [];
-    try {
-        for (var parts_1 = __values(parts), parts_1_1 = parts_1.next(); !parts_1_1.done; parts_1_1 = parts_1.next()) {
-            var part = parts_1_1.value;
-            var squareBracketIndex = part.indexOf("[");
-            if (squareBracketIndex !== -1) {
-                if (part.indexOf("]") !== part.length - 1) {
-                    throw new EndpointError("Path: '".concat(path, "' does not end with ']'"));
-                }
-                var arrayIndex = part.slice(squareBracketIndex + 1, -1);
-                if (Number.isNaN(parseInt(arrayIndex))) {
-                    throw new EndpointError("Invalid array index: '".concat(arrayIndex, "' in path: '").concat(path, "'"));
-                }
-                if (squareBracketIndex !== 0) {
-                    pathList.push(part.slice(0, squareBracketIndex));
-                }
-                pathList.push(arrayIndex);
+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 ']'`);
             }
-            else {
-                pathList.push(part);
+            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);
         }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (parts_1_1 && !parts_1_1.done && (_a = parts_1.return)) _a.call(parts_1);
+        else {
+            pathList.push(part);
         }
-        finally { if (e_1) throw e_1.error; }
     }
     return pathList;
 };

package/dist-es/lib/isIpAddress.js

@@ -1,4 +1,2 @@
-var 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 var isIpAddress = function (value) {
-    return IP_V4_REGEX.test(value) || (value.startsWith("[") && value.endsWith("]"));
-};
+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/dist-es/lib/isSet.js

@@ -1 +1 @@
-export var isSet = function (value) { return value != null; };
+export const isSet = (value) => value != null;

package/dist-es/lib/isValidHostLabel.js

@@ -1,26 +1,13 @@
-import { __values } from "tslib";
-var VALID_HOST_LABEL_REGEX = new RegExp("^(?!.*-$)(?!-)[a-zA-Z0-9-]{1,63}$");
-export var isValidHostLabel = function (value, allowSubDomains) {
-    var e_1, _a;
-    if (allowSubDomains === void 0) { allowSubDomains = false; }
+const VALID_HOST_LABEL_REGEX = new RegExp(`^(?!.*-$)(?!-)[a-zA-Z0-9-]{1,63}$`);
+export const isValidHostLabel = (value, allowSubDomains = false) => {
     if (!allowSubDomains) {
         return VALID_HOST_LABEL_REGEX.test(value);
     }
-    var labels = value.split(".");
-    try {
-        for (var labels_1 = __values(labels), labels_1_1 = labels_1.next(); !labels_1_1.done; labels_1_1 = labels_1.next()) {
-            var label = labels_1_1.value;
-            if (!isValidHostLabel(label)) {
-                return false;
-            }
+    const labels = value.split(".");
+    for (const label of labels) {
+        if (!isValidHostLabel(label)) {
+            return false;
         }
     }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (labels_1_1 && !labels_1_1.done && (_a = labels_1.return)) _a.call(labels_1);
-        }
-        finally { if (e_1) throw e_1.error; }
-    }
     return true;
 };

package/dist-es/lib/not.js

@@ -1 +1 @@
-export var not = function (value) { return !value; };
+export const not = (value) => !value;

package/dist-es/lib/parseURL.js

@@ -1,12 +1,11 @@
-var _a;
 import { EndpointURLScheme } from "@aws-sdk/types";
 import { isIpAddress } from "./isIpAddress";
-var DEFAULT_PORTS = (_a = {},
-    _a[EndpointURLScheme.HTTP] = 80,
-    _a[EndpointURLScheme.HTTPS] = 443,
-    _a);
-export var parseURL = function (value) {
-    var whatwgURL = (function () {
+const DEFAULT_PORTS = {
+    [EndpointURLScheme.HTTP]: 80,
+    [EndpointURLScheme.HTTPS]: 443,
+};
+export const parseURL = (value) => {
+    const whatwgURL = (() => {
         try {
             return new URL(value);
         }
@@ -17,21 +16,21 @@ export var parseURL = function (value) {
     if (!whatwgURL) {
         return null;
     }
-    var host = whatwgURL.host, hostname = whatwgURL.hostname, pathname = whatwgURL.pathname, protocol = whatwgURL.protocol, search = whatwgURL.search;
+    const { host, hostname, pathname, protocol, search } = whatwgURL;
     if (search) {
         return null;
     }
-    var scheme = protocol.slice(0, -1);
+    const scheme = protocol.slice(0, -1);
     if (!Object.values(EndpointURLScheme).includes(scheme)) {
         return null;
     }
-    var isIp = isIpAddress(hostname);
-    var authority = "".concat(host).concat(value.includes("".concat(host, ":").concat(DEFAULT_PORTS[scheme])) ? ":".concat(DEFAULT_PORTS[scheme]) : "");
+    const isIp = isIpAddress(hostname);
+    const authority = `${host}${value.includes(`${host}:${DEFAULT_PORTS[scheme]}`) ? `:${DEFAULT_PORTS[scheme]}` : ``}`;
     return {
-        scheme: scheme,
-        authority: authority,
+        scheme,
+        authority,
         path: pathname,
-        normalizedPath: pathname.endsWith("/") ? pathname : "".concat(pathname, "/"),
-        isIp: isIp,
+        normalizedPath: pathname.endsWith("/") ? pathname : `${pathname}/`,
+        isIp,
     };
 };

package/dist-es/lib/stringEquals.js

@@ -1 +1 @@
-export var stringEquals = function (value1, value2) { return value1 === value2; };
+export const stringEquals = (value1, value2) => value1 === value2;

package/dist-es/lib/substring.js

@@ -1,4 +1,4 @@
-export var substring = function (input, start, stop, reverse) {
+export const substring = (input, start, stop, reverse) => {
     if (start >= stop || input.length < stop) {
         return null;
     }

package/dist-es/lib/uriEncode.js

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

package/dist-es/resolveEndpoint.js

@@ -1,58 +1,34 @@
-import { __read, __values } from "tslib";
 import { EndpointError } from "./types";
 import { evaluateRules } from "./utils";
-export var resolveEndpoint = function (ruleSetObject, options) {
-    var e_1, _a, e_2, _b;
-    var _c;
-    var endpointParams = options.endpointParams, logger = options.logger;
-    var parameters = ruleSetObject.parameters, rules = ruleSetObject.rules;
-    var paramsWithDefault = Object.entries(parameters)
-        .filter(function (_a) {
-        var _b = __read(_a, 2), v = _b[1];
-        return v.default != null;
-    })
-        .map(function (_a) {
-        var _b = __read(_a, 2), k = _b[0], v = _b[1];
-        return [k, v.default];
-    });
+export const resolveEndpoint = (ruleSetObject, options) => {
+    const { endpointParams, logger } = options;
+    const { parameters, rules } = ruleSetObject;
+    const paramsWithDefault = Object.entries(parameters)
+        .filter(([, v]) => v.default != null)
+        .map(([k, v]) => [k, v.default]);
     if (paramsWithDefault.length > 0) {
-        try {
-            for (var paramsWithDefault_1 = __values(paramsWithDefault), paramsWithDefault_1_1 = paramsWithDefault_1.next(); !paramsWithDefault_1_1.done; paramsWithDefault_1_1 = paramsWithDefault_1.next()) {
-                var _d = __read(paramsWithDefault_1_1.value, 2), paramKey = _d[0], paramDefaultValue = _d[1];
-                endpointParams[paramKey] = (_c = endpointParams[paramKey]) !== null && _c !== void 0 ? _c : paramDefaultValue;
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (paramsWithDefault_1_1 && !paramsWithDefault_1_1.done && (_a = paramsWithDefault_1.return)) _a.call(paramsWithDefault_1);
-            }
-            finally { if (e_1) throw e_1.error; }
+        for (const [paramKey, paramDefaultValue] of paramsWithDefault) {
+            endpointParams[paramKey] = endpointParams[paramKey] ?? paramDefaultValue;
         }
     }
-    var requiredParams = Object.entries(parameters)
-        .filter(function (_a) {
-        var _b = __read(_a, 2), v = _b[1];
-        return v.required;
-    })
-        .map(function (_a) {
-        var _b = __read(_a, 1), k = _b[0];
-        return k;
-    });
-    try {
-        for (var requiredParams_1 = __values(requiredParams), requiredParams_1_1 = requiredParams_1.next(); !requiredParams_1_1.done; requiredParams_1_1 = requiredParams_1.next()) {
-            var requiredParam = requiredParams_1_1.value;
-            if (endpointParams[requiredParam] == null) {
-                throw new EndpointError("Missing required parameter: '".concat(requiredParam, "'"));
-            }
+    const requiredParams = Object.entries(parameters)
+        .filter(([, v]) => v.required)
+        .map(([k]) => k);
+    for (const requiredParam of requiredParams) {
+        if (endpointParams[requiredParam] == null) {
+            throw new EndpointError(`Missing required parameter: '${requiredParam}'`);
         }
     }
-    catch (e_2_1) { e_2 = { error: e_2_1 }; }
-    finally {
+    const endpoint = evaluateRules(rules, { endpointParams, logger, referenceRecord: {} });
+    if (options.endpointParams?.Endpoint) {
         try {
-            if (requiredParams_1_1 && !requiredParams_1_1.done && (_b = requiredParams_1.return)) _b.call(requiredParams_1);
+            const givenEndpoint = new URL(options.endpointParams.Endpoint);
+            const { protocol, port } = givenEndpoint;
+            endpoint.url.protocol = protocol;
+            endpoint.url.port = port;
+        }
+        catch (e) {
         }
-        finally { if (e_2) throw e_2.error; }
     }
-    return evaluateRules(rules, { endpointParams: endpointParams, logger: logger, referenceRecord: {} });
+    return endpoint;
 };

package/dist-es/types/EndpointError.js

@@ -1,11 +1,6 @@
-import { __extends } from "tslib";
-var EndpointError = (function (_super) {
-    __extends(EndpointError, _super);
-    function EndpointError(message) {
-        var _this = _super.call(this, message) || this;
-        _this.name = "EndpointError";
-        return _this;
+export class EndpointError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "EndpointError";
     }
-    return EndpointError;
-}(Error));
-export { EndpointError };
+}

package/dist-es/utils/callFunction.js

@@ -1,10 +1,6 @@
-import { __read, __spreadArray } from "tslib";
 import * as lib from "../lib";
 import { evaluateExpression } from "./evaluateExpression";
-export var callFunction = function (_a, options) {
-    var fn = _a.fn, argv = _a.argv;
-    var evaluatedArgs = argv.map(function (arg) {
-        return ["boolean", "number"].includes(typeof arg) ? arg : evaluateExpression(arg, "arg", options);
-    });
-    return fn.split(".").reduce(function (acc, key) { return acc[key]; }, lib).apply(void 0, __spreadArray([], __read(evaluatedArgs), false));
+export const callFunction = ({ fn, argv }, options) => {
+    const evaluatedArgs = argv.map((arg) => ["boolean", "number"].includes(typeof arg) ? arg : evaluateExpression(arg, "arg", options));
+    return fn.split(".").reduce((acc, key) => acc[key], lib)(...evaluatedArgs);
 };

package/dist-es/utils/evaluateCondition.js

@@ -1,11 +1,12 @@
-import { __assign, __rest } from "tslib";
 import { EndpointError } from "../types";
 import { callFunction } from "./callFunction";
-export var evaluateCondition = function (_a, options) {
-    var assign = _a.assign, fnArgs = __rest(_a, ["assign"]);
+export const evaluateCondition = ({ assign, ...fnArgs }, options) => {
     if (assign && assign in options.referenceRecord) {
-        throw new EndpointError("'".concat(assign, "' is already defined in Reference Record."));
+        throw new EndpointError(`'${assign}' is already defined in Reference Record.`);
     }
-    var value = callFunction(fnArgs, options);
-    return __assign({ result: value === "" ? true : !!value }, (assign != null && { toAssign: { name: assign, value: value } }));
+    const value = callFunction(fnArgs, options);
+    return {
+        result: value === "" ? true : !!value,
+        ...(assign != null && { toAssign: { name: assign, value } }),
+    };
 };

package/dist-es/utils/evaluateConditions.js

@@ -1,27 +1,20 @@
-import { __assign, __values } from "tslib";
 import { evaluateCondition } from "./evaluateCondition";
-export var evaluateConditions = function (conditions, options) {
-    var e_1, _a;
-    if (conditions === void 0) { conditions = []; }
-    var conditionsReferenceRecord = {};
-    try {
-        for (var conditions_1 = __values(conditions), conditions_1_1 = conditions_1.next(); !conditions_1_1.done; conditions_1_1 = conditions_1.next()) {
-            var condition = conditions_1_1.value;
-            var _b = evaluateCondition(condition, __assign(__assign({}, options), { referenceRecord: __assign(__assign({}, options.referenceRecord), conditionsReferenceRecord) })), result = _b.result, toAssign = _b.toAssign;
-            if (!result) {
-                return { result: result };
-            }
-            if (toAssign) {
-                conditionsReferenceRecord[toAssign.name] = toAssign.value;
-            }
+export const evaluateConditions = (conditions = [], options) => {
+    const conditionsReferenceRecord = {};
+    for (const condition of conditions) {
+        const { result, toAssign } = evaluateCondition(condition, {
+            ...options,
+            referenceRecord: {
+                ...options.referenceRecord,
+                ...conditionsReferenceRecord,
+            },
+        });
+        if (!result) {
+            return { result };
         }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (conditions_1_1 && !conditions_1_1.done && (_a = conditions_1.return)) _a.call(conditions_1);
+        if (toAssign) {
+            conditionsReferenceRecord[toAssign.name] = toAssign.value;
         }
-        finally { if (e_1) throw e_1.error; }
     }
     return { result: true, referenceRecord: conditionsReferenceRecord };
 };

package/dist-es/utils/evaluateEndpointRule.js

@@ -1,19 +1,25 @@
-import { __assign } from "tslib";
 import { evaluateConditions } from "./evaluateConditions";
 import { getEndpointHeaders } from "./getEndpointHeaders";
 import { getEndpointProperties } from "./getEndpointProperties";
 import { getEndpointUrl } from "./getEndpointUrl";
-export var evaluateEndpointRule = function (endpointRule, options) {
-    var conditions = endpointRule.conditions, endpoint = endpointRule.endpoint;
-    var _a = evaluateConditions(conditions, options), result = _a.result, referenceRecord = _a.referenceRecord;
+export const evaluateEndpointRule = (endpointRule, options) => {
+    const { conditions, endpoint } = endpointRule;
+    const { result, referenceRecord } = evaluateConditions(conditions, options);
     if (!result) {
         return;
     }
-    var endpointRuleOptions = __assign(__assign({}, options), { referenceRecord: __assign(__assign({}, options.referenceRecord), referenceRecord) });
-    var url = endpoint.url, properties = endpoint.properties, headers = endpoint.headers;
-    return __assign(__assign(__assign({}, (headers != undefined && {
-        headers: getEndpointHeaders(headers, endpointRuleOptions),
-    })), (properties != undefined && {
-        properties: getEndpointProperties(properties, endpointRuleOptions),
-    })), { url: getEndpointUrl(url, endpointRuleOptions) });
+    const endpointRuleOptions = {
+        ...options,
+        referenceRecord: { ...options.referenceRecord, ...referenceRecord },
+    };
+    const { url, properties, headers } = endpoint;
+    return {
+        ...(headers != undefined && {
+            headers: getEndpointHeaders(headers, endpointRuleOptions),
+        }),
+        ...(properties != undefined && {
+            properties: getEndpointProperties(properties, endpointRuleOptions),
+        }),
+        url: getEndpointUrl(url, endpointRuleOptions),
+    };
 };

package/dist-es/utils/evaluateErrorRule.js

@@ -1,12 +1,14 @@
-import { __assign } from "tslib";
 import { EndpointError } from "../types";
 import { evaluateConditions } from "./evaluateConditions";
 import { evaluateExpression } from "./evaluateExpression";
-export var evaluateErrorRule = function (errorRule, options) {
-    var conditions = errorRule.conditions, error = errorRule.error;
-    var _a = evaluateConditions(conditions, options), result = _a.result, referenceRecord = _a.referenceRecord;
+export const evaluateErrorRule = (errorRule, options) => {
+    const { conditions, error } = errorRule;
+    const { result, referenceRecord } = evaluateConditions(conditions, options);
     if (!result) {
         return;
     }
-    throw new EndpointError(evaluateExpression(error, "Error", __assign(__assign({}, options), { referenceRecord: __assign(__assign({}, options.referenceRecord), referenceRecord) })));
+    throw new EndpointError(evaluateExpression(error, "Error", {
+        ...options,
+        referenceRecord: { ...options.referenceRecord, ...referenceRecord },
+    }));
 };

package/dist-es/utils/evaluateExpression.js

@@ -2,7 +2,7 @@ import { EndpointError } from "../types";
 import { callFunction } from "./callFunction";
 import { evaluateTemplate } from "./evaluateTemplate";
 import { getReferenceValue } from "./getReferenceValue";
-export var evaluateExpression = function (obj, keyName, options) {
+export const evaluateExpression = (obj, keyName, options) => {
     if (typeof obj === "string") {
         return evaluateTemplate(obj, options);
     }
@@ -12,5 +12,5 @@ export var evaluateExpression = function (obj, keyName, options) {
     else if (obj["ref"]) {
         return getReferenceValue(obj, options);
     }
-    throw new EndpointError("'".concat(keyName, "': ").concat(String(obj), " is not a string, function or reference."));
+    throw new EndpointError(`'${keyName}': ${String(obj)} is not a string, function or reference.`);
 };

package/dist-es/utils/evaluateRules.js

@@ -1,39 +1,27 @@
-import { __values } from "tslib";
 import { EndpointError } from "../types";
 import { evaluateEndpointRule } from "./evaluateEndpointRule";
 import { evaluateErrorRule } from "./evaluateErrorRule";
 import { evaluateTreeRule } from "./evaluateTreeRule";
-export var evaluateRules = function (rules, options) {
-    var e_1, _a;
-    try {
-        for (var rules_1 = __values(rules), rules_1_1 = rules_1.next(); !rules_1_1.done; rules_1_1 = rules_1.next()) {
-            var rule = rules_1_1.value;
-            if (rule.type === "endpoint") {
-                var endpointOrUndefined = evaluateEndpointRule(rule, options);
-                if (endpointOrUndefined) {
-                    return endpointOrUndefined;
-                }
+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") {
-                var endpointOrUndefined = evaluateTreeRule(rule, options);
-                if (endpointOrUndefined) {
-                    return endpointOrUndefined;
-                }
-            }
-            else {
-                throw new EndpointError("Unknown endpoint rule: ".concat(rule));
+        }
+        else if (rule.type === "error") {
+            evaluateErrorRule(rule, options);
+        }
+        else if (rule.type === "tree") {
+            const endpointOrUndefined = evaluateTreeRule(rule, options);
+            if (endpointOrUndefined) {
+                return endpointOrUndefined;
             }
         }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (rules_1_1 && !rules_1_1.done && (_a = rules_1.return)) _a.call(rules_1);
+        else {
+            throw new EndpointError(`Unknown endpoint rule: ${rule}`);
         }
-        finally { if (e_1) throw e_1.error; }
     }
-    throw new EndpointError("Rules evaluation failed");
+    throw new EndpointError(`Rules evaluation failed`);
 };

package/dist-es/utils/evaluateTemplate.js

@@ -1,25 +1,24 @@
-import { __assign, __read, __spreadArray } from "tslib";
 import { getAttr } from "../lib";
-var ATTR_SHORTHAND_REGEX = new RegExp("\\${([\\w]+)#([\\w]+)}", "g");
-export var evaluateTemplate = function (template, options) {
-    var templateToEvaluate = template
-        .replace(new RegExp("{([^{}]+)}", "g"), "${$1}")
-        .replace(new RegExp("{\\${([^{}]+)}}", "g"), "{$1}");
-    var templateContext = __assign(__assign({}, options.endpointParams), options.referenceRecord);
-    var attrShortHandList = templateToEvaluate.match(ATTR_SHORTHAND_REGEX) || [];
-    var attrShortHandMap = attrShortHandList.reduce(function (acc, attrShortHand) {
-        var indexOfHash = attrShortHand.indexOf("#");
-        var refName = attrShortHand.substring(2, indexOfHash);
-        var attrName = attrShortHand.substring(indexOfHash + 1, attrShortHand.length - 1);
+const ATTR_SHORTHAND_REGEX = new RegExp("\\${([\\w]+)#([\\w]+)}", "g");
+export const evaluateTemplate = (template, options) => {
+    const templateToEvaluate = template
+        .replace(new RegExp(`\{([^{}]+)\}`, "g"), "${$1}")
+        .replace(new RegExp(`\{\\$\{([^{}]+)\}\}`, "g"), "{$1}");
+    const templateContext = {
+        ...options.endpointParams,
+        ...options.referenceRecord,
+    };
+    const attrShortHandList = templateToEvaluate.match(ATTR_SHORTHAND_REGEX) || [];
+    const attrShortHandMap = attrShortHandList.reduce((acc, attrShortHand) => {
+        const indexOfHash = attrShortHand.indexOf("#");
+        const refName = attrShortHand.substring(2, indexOfHash);
+        const attrName = attrShortHand.substring(indexOfHash + 1, attrShortHand.length - 1);
         acc[attrShortHand] = getAttr(templateContext[refName], attrName);
         return acc;
     }, {});
-    var templateWithAttr = Object.entries(attrShortHandMap).reduce(function (acc, _a) {
-        var _b = __read(_a, 2), shortHand = _b[0], value = _b[1];
-        return acc.replace(shortHand, value);
-    }, templateToEvaluate);
-    var templateContextNames = Object.keys(templateContext);
-    var templateContextValues = Object.values(templateContext);
-    var templateWithTildeEscaped = templateWithAttr.replace(/\`/g, "\\`");
-    return new (Function.bind.apply(Function, __spreadArray(__spreadArray([void 0], __read(templateContextNames), false), ["return `".concat(templateWithTildeEscaped, "`")], false)))().apply(void 0, __spreadArray([], __read(templateContextValues), false));
+    const templateWithAttr = Object.entries(attrShortHandMap).reduce((acc, [shortHand, value]) => acc.replace(shortHand, value), templateToEvaluate);
+    const templateContextNames = Object.keys(templateContext);
+    const templateContextValues = Object.values(templateContext);
+    const templateWithTildeEscaped = templateWithAttr.replace(/\`/g, "\\`");
+    return new Function(...templateContextNames, `return \`${templateWithTildeEscaped}\``)(...templateContextValues);
 };

package/dist-es/utils/evaluateTreeRule.js

@@ -1,11 +1,13 @@
-import { __assign } from "tslib";
 import { evaluateConditions } from "./evaluateConditions";
 import { evaluateRules } from "./evaluateRules";
-export var evaluateTreeRule = function (treeRule, options) {
-    var conditions = treeRule.conditions, rules = treeRule.rules;
-    var _a = evaluateConditions(conditions, options), result = _a.result, referenceRecord = _a.referenceRecord;
+export const evaluateTreeRule = (treeRule, options) => {
+    const { conditions, rules } = treeRule;
+    const { result, referenceRecord } = evaluateConditions(conditions, options);
     if (!result) {
         return;
     }
-    return evaluateRules(rules, __assign(__assign({}, options), { referenceRecord: __assign(__assign({}, options.referenceRecord), referenceRecord) }));
+    return evaluateRules(rules, {
+        ...options,
+        referenceRecord: { ...options.referenceRecord, ...referenceRecord },
+    });
 };

package/dist-es/utils/getEndpointHeaders.js

@@ -1,16 +1,12 @@
-import { __assign, __read } from "tslib";
 import { EndpointError } from "../types";
 import { evaluateExpression } from "./evaluateExpression";
-export var getEndpointHeaders = function (headers, options) {
-    return Object.entries(headers).reduce(function (acc, _a) {
-        var _b;
-        var _c = __read(_a, 2), headerKey = _c[0], headerVal = _c[1];
-        return (__assign(__assign({}, acc), (_b = {}, _b[headerKey] = headerVal.map(function (headerValEntry) {
-            var processedExpr = evaluateExpression(headerValEntry, "Header value entry", options);
-            if (typeof processedExpr !== "string") {
-                throw new EndpointError("Header '".concat(headerKey, "' value '").concat(processedExpr, "' is not a string"));
-            }
-            return processedExpr;
-        }), _b)));
-    }, {});
-};
+export 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;
+    }),
+}), {});

package/dist-es/utils/getEndpointProperties.js

@@ -1,9 +1,5 @@
-import { __assign, __read } from "tslib";
 import { getEndpointProperty } from "./getEndpointProperty";
-export var getEndpointProperties = function (properties, options) {
-    return Object.entries(properties).reduce(function (acc, _a) {
-        var _b;
-        var _c = __read(_a, 2), propertyKey = _c[0], propertyVal = _c[1];
-        return (__assign(__assign({}, acc), (_b = {}, _b[propertyKey] = getEndpointProperty(propertyVal, options), _b)));
-    }, {});
-};
+export const getEndpointProperties = (properties, options) => Object.entries(properties).reduce((acc, [propertyKey, propertyVal]) => ({
+    ...acc,
+    [propertyKey]: getEndpointProperty(propertyVal, options),
+}), {});

package/dist-es/utils/getEndpointProperty.js

@@ -1,21 +1,21 @@
 import { EndpointError } from "../types";
 import { evaluateTemplate } from "./evaluateTemplate";
 import { getEndpointProperties } from "./getEndpointProperties";
-export var getEndpointProperty = function (property, options) {
+export const getEndpointProperty = (property, options) => {
     if (Array.isArray(property)) {
-        return property.map(function (propertyEntry) { return getEndpointProperty(propertyEntry, options); });
+        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: ".concat(property));
+                throw new EndpointError(`Unexpected endpoint property: ${property}`);
             }
             return getEndpointProperties(property, options);
         case "boolean":
             return property;
         default:
-            throw new EndpointError("Unexpected endpoint property type: ".concat(typeof property));
+            throw new EndpointError(`Unexpected endpoint property type: ${typeof property}`);
     }
 };

package/dist-es/utils/getEndpointUrl.js

@@ -1,15 +1,15 @@
 import { EndpointError } from "../types";
 import { evaluateExpression } from "./evaluateExpression";
-export var getEndpointUrl = function (endpointUrl, options) {
-    var expression = evaluateExpression(endpointUrl, "Endpoint URL", options);
+export 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 ".concat(expression), error);
+            console.error(`Failed to construct URL with ${expression}`, error);
             throw error;
         }
     }
-    throw new EndpointError("Endpoint URL must be a string, got ".concat(typeof expression));
+    throw new EndpointError(`Endpoint URL must be a string, got ${typeof expression}`);
 };

package/dist-es/utils/getReferenceValue.js

@@ -1,6 +1,7 @@
-import { __assign } from "tslib";
-export var getReferenceValue = function (_a, options) {
-    var ref = _a.ref;
-    var referenceRecord = __assign(__assign({}, options.endpointParams), options.referenceRecord);
+export const getReferenceValue = ({ ref }, options) => {
+    const referenceRecord = {
+        ...options.endpointParams,
+        ...options.referenceRecord,
+    };
     return referenceRecord[ref];
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/util-endpoints",
-  "version": "3.186.0",
+  "version": "3.188.0",
   "description": "Utilities to help with endpoint resolution",
   "main": "./dist-cjs/index.js",
   "module": "./dist-es/index.js",
@@ -21,7 +21,7 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@aws-sdk/types": "3.186.0",
+    "@aws-sdk/types": "3.188.0",
     "tslib": "^2.3.1"
   },
   "engines": {