@aws-sdk/middleware-bucket-endpoint 3.171.0 → 3.183.0

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [3.183.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.182.0...v3.183.0) (2022-10-03)
+
+**Note:** Version bump only for package @aws-sdk/middleware-bucket-endpoint
+
+
+
+
+
+# [3.178.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.177.0...v3.178.0) (2022-09-23)
+
+**Note:** Version bump only for package @aws-sdk/middleware-bucket-endpoint
+
+
+
+
+
 # [3.171.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.170.0...v3.171.0) (2022-09-14)
 
 **Note:** Version bump only for package @aws-sdk/middleware-bucket-endpoint

package/dist-es/NodeDisableMultiregionAccessPointConfigOptions.js

@@ -1,12 +1,8 @@
 import { booleanSelector, SelectorType } from "@aws-sdk/util-config-provider";
-export var NODE_DISABLE_MULTIREGION_ACCESS_POINT_ENV_NAME = "AWS_S3_DISABLE_MULTIREGION_ACCESS_POINTS";
-export var NODE_DISABLE_MULTIREGION_ACCESS_POINT_INI_NAME = "s3_disable_multiregion_access_points";
-export var NODE_DISABLE_MULTIREGION_ACCESS_POINT_CONFIG_OPTIONS = {
-    environmentVariableSelector: function (env) {
-        return booleanSelector(env, NODE_DISABLE_MULTIREGION_ACCESS_POINT_ENV_NAME, SelectorType.ENV);
-    },
-    configFileSelector: function (profile) {
-        return booleanSelector(profile, NODE_DISABLE_MULTIREGION_ACCESS_POINT_INI_NAME, SelectorType.CONFIG);
-    },
+export const NODE_DISABLE_MULTIREGION_ACCESS_POINT_ENV_NAME = "AWS_S3_DISABLE_MULTIREGION_ACCESS_POINTS";
+export const NODE_DISABLE_MULTIREGION_ACCESS_POINT_INI_NAME = "s3_disable_multiregion_access_points";
+export const NODE_DISABLE_MULTIREGION_ACCESS_POINT_CONFIG_OPTIONS = {
+    environmentVariableSelector: (env) => booleanSelector(env, NODE_DISABLE_MULTIREGION_ACCESS_POINT_ENV_NAME, SelectorType.ENV),
+    configFileSelector: (profile) => booleanSelector(profile, NODE_DISABLE_MULTIREGION_ACCESS_POINT_INI_NAME, SelectorType.CONFIG),
     default: false,
 };

package/dist-es/NodeUseArnRegionConfigOptions.js

@@ -1,10 +1,8 @@
 import { booleanSelector, SelectorType } from "@aws-sdk/util-config-provider";
-export var NODE_USE_ARN_REGION_ENV_NAME = "AWS_S3_USE_ARN_REGION";
-export var NODE_USE_ARN_REGION_INI_NAME = "s3_use_arn_region";
-export var NODE_USE_ARN_REGION_CONFIG_OPTIONS = {
-    environmentVariableSelector: function (env) {
-        return booleanSelector(env, NODE_USE_ARN_REGION_ENV_NAME, SelectorType.ENV);
-    },
-    configFileSelector: function (profile) { return booleanSelector(profile, NODE_USE_ARN_REGION_INI_NAME, SelectorType.CONFIG); },
+export const NODE_USE_ARN_REGION_ENV_NAME = "AWS_S3_USE_ARN_REGION";
+export const NODE_USE_ARN_REGION_INI_NAME = "s3_use_arn_region";
+export const NODE_USE_ARN_REGION_CONFIG_OPTIONS = {
+    environmentVariableSelector: (env) => booleanSelector(env, NODE_USE_ARN_REGION_ENV_NAME, SelectorType.ENV),
+    configFileSelector: (profile) => booleanSelector(profile, NODE_USE_ARN_REGION_INI_NAME, SelectorType.CONFIG),
     default: false,
 };

package/dist-es/bucketEndpointMiddleware.js

@@ -1,114 +1,81 @@
-import { __assign, __awaiter, __generator } from "tslib";
 import { HttpRequest } from "@aws-sdk/protocol-http";
 import { parse as parseArn, validate as validateArn } from "@aws-sdk/util-arn-parser";
 import { bucketHostname } from "./bucketHostname";
-export var bucketEndpointMiddleware = function (options) {
-    return function (next, context) {
-        return function (args) { return __awaiter(void 0, void 0, void 0, function () {
-            var bucketName, replaceBucketInPath, request, bucketArn, clientRegion, useDualstackEndpoint, useFipsEndpoint, _a, partition, _b, signingRegion, useArnRegion, _c, hostname, bucketEndpoint, modifiedSigningRegion, signingService, _d, clientRegion, dualstackEndpoint, fipsEndpoint, _e, hostname, bucketEndpoint;
-            var _f;
-            return __generator(this, function (_g) {
-                switch (_g.label) {
-                    case 0:
-                        bucketName = args.input.Bucket;
-                        replaceBucketInPath = options.bucketEndpoint;
-                        request = args.request;
-                        if (!HttpRequest.isInstance(request)) return [3, 13];
-                        if (!options.bucketEndpoint) return [3, 1];
-                        request.hostname = bucketName;
-                        return [3, 12];
-                    case 1:
-                        if (!validateArn(bucketName)) return [3, 8];
-                        bucketArn = parseArn(bucketName);
-                        return [4, options.region()];
-                    case 2:
-                        clientRegion = _g.sent();
-                        return [4, options.useDualstackEndpoint()];
-                    case 3:
-                        useDualstackEndpoint = _g.sent();
-                        return [4, options.useFipsEndpoint()];
-                    case 4:
-                        useFipsEndpoint = _g.sent();
-                        return [4, options.regionInfoProvider(clientRegion, { useDualstackEndpoint: useDualstackEndpoint, useFipsEndpoint: useFipsEndpoint })];
-                    case 5:
-                        _a = (_g.sent()) || {}, partition = _a.partition, _b = _a.signingRegion, signingRegion = _b === void 0 ? clientRegion : _b;
-                        return [4, options.useArnRegion()];
-                    case 6:
-                        useArnRegion = _g.sent();
-                        _d = bucketHostname;
-                        _f = {
-                            bucketName: bucketArn,
-                            baseHostname: request.hostname,
-                            accelerateEndpoint: options.useAccelerateEndpoint,
-                            dualstackEndpoint: useDualstackEndpoint,
-                            fipsEndpoint: useFipsEndpoint,
-                            pathStyleEndpoint: options.forcePathStyle,
-                            tlsCompatible: request.protocol === "https:",
-                            useArnRegion: useArnRegion,
-                            clientPartition: partition,
-                            clientSigningRegion: signingRegion,
-                            clientRegion: clientRegion,
-                            isCustomEndpoint: options.isCustomEndpoint
-                        };
-                        return [4, options.disableMultiregionAccessPoints()];
-                    case 7:
-                        _c = _d.apply(void 0, [(_f.disableMultiregionAccessPoints = _g.sent(),
-                                _f)]), hostname = _c.hostname, bucketEndpoint = _c.bucketEndpoint, modifiedSigningRegion = _c.signingRegion, signingService = _c.signingService;
-                        if (modifiedSigningRegion && modifiedSigningRegion !== signingRegion) {
-                            context["signing_region"] = modifiedSigningRegion;
-                        }
-                        if (signingService && signingService !== "s3") {
-                            context["signing_service"] = signingService;
-                        }
-                        request.hostname = hostname;
-                        replaceBucketInPath = bucketEndpoint;
-                        return [3, 12];
-                    case 8: return [4, options.region()];
-                    case 9:
-                        clientRegion = _g.sent();
-                        return [4, options.useDualstackEndpoint()];
-                    case 10:
-                        dualstackEndpoint = _g.sent();
-                        return [4, options.useFipsEndpoint()];
-                    case 11:
-                        fipsEndpoint = _g.sent();
-                        _e = bucketHostname({
-                            bucketName: bucketName,
-                            clientRegion: clientRegion,
-                            baseHostname: request.hostname,
-                            accelerateEndpoint: options.useAccelerateEndpoint,
-                            dualstackEndpoint: dualstackEndpoint,
-                            fipsEndpoint: fipsEndpoint,
-                            pathStyleEndpoint: options.forcePathStyle,
-                            tlsCompatible: request.protocol === "https:",
-                            isCustomEndpoint: options.isCustomEndpoint,
-                        }), hostname = _e.hostname, bucketEndpoint = _e.bucketEndpoint;
-                        request.hostname = hostname;
-                        replaceBucketInPath = bucketEndpoint;
-                        _g.label = 12;
-                    case 12:
-                        if (replaceBucketInPath) {
-                            request.path = request.path.replace(/^(\/)?[^\/]+/, "");
-                            if (request.path === "") {
-                                request.path = "/";
-                            }
-                        }
-                        _g.label = 13;
-                    case 13: return [2, next(__assign(__assign({}, args), { request: request }))];
-                }
+export const bucketEndpointMiddleware = (options) => (next, context) => async (args) => {
+    const { Bucket: bucketName } = args.input;
+    let replaceBucketInPath = options.bucketEndpoint;
+    const request = args.request;
+    if (HttpRequest.isInstance(request)) {
+        if (options.bucketEndpoint) {
+            request.hostname = bucketName;
+        }
+        else if (validateArn(bucketName)) {
+            const bucketArn = parseArn(bucketName);
+            const clientRegion = await options.region();
+            const useDualstackEndpoint = await options.useDualstackEndpoint();
+            const useFipsEndpoint = await options.useFipsEndpoint();
+            const { partition, signingRegion = clientRegion } = (await options.regionInfoProvider(clientRegion, { useDualstackEndpoint, useFipsEndpoint })) || {};
+            const useArnRegion = await options.useArnRegion();
+            const { hostname, bucketEndpoint, signingRegion: modifiedSigningRegion, signingService, } = bucketHostname({
+                bucketName: bucketArn,
+                baseHostname: request.hostname,
+                accelerateEndpoint: options.useAccelerateEndpoint,
+                dualstackEndpoint: useDualstackEndpoint,
+                fipsEndpoint: useFipsEndpoint,
+                pathStyleEndpoint: options.forcePathStyle,
+                tlsCompatible: request.protocol === "https:",
+                useArnRegion,
+                clientPartition: partition,
+                clientSigningRegion: signingRegion,
+                clientRegion: clientRegion,
+                isCustomEndpoint: options.isCustomEndpoint,
+                disableMultiregionAccessPoints: await options.disableMultiregionAccessPoints(),
             });
-        }); };
-    };
+            if (modifiedSigningRegion && modifiedSigningRegion !== signingRegion) {
+                context["signing_region"] = modifiedSigningRegion;
+            }
+            if (signingService && signingService !== "s3") {
+                context["signing_service"] = signingService;
+            }
+            request.hostname = hostname;
+            replaceBucketInPath = bucketEndpoint;
+        }
+        else {
+            const clientRegion = await options.region();
+            const dualstackEndpoint = await options.useDualstackEndpoint();
+            const fipsEndpoint = await options.useFipsEndpoint();
+            const { hostname, bucketEndpoint } = bucketHostname({
+                bucketName,
+                clientRegion,
+                baseHostname: request.hostname,
+                accelerateEndpoint: options.useAccelerateEndpoint,
+                dualstackEndpoint,
+                fipsEndpoint,
+                pathStyleEndpoint: options.forcePathStyle,
+                tlsCompatible: request.protocol === "https:",
+                isCustomEndpoint: options.isCustomEndpoint,
+            });
+            request.hostname = hostname;
+            replaceBucketInPath = bucketEndpoint;
+        }
+        if (replaceBucketInPath) {
+            request.path = request.path.replace(/^(\/)?[^\/]+/, "");
+            if (request.path === "") {
+                request.path = "/";
+            }
+        }
+    }
+    return next({ ...args, request });
 };
-export var bucketEndpointMiddlewareOptions = {
+export const bucketEndpointMiddlewareOptions = {
     tags: ["BUCKET_ENDPOINT"],
     name: "bucketEndpointMiddleware",
     relation: "before",
     toMiddleware: "hostHeaderMiddleware",
     override: true,
 };
-export var getBucketEndpointPlugin = function (options) { return ({
-    applyToStack: function (clientStack) {
+export const getBucketEndpointPlugin = (options) => ({
+    applyToStack: (clientStack) => {
         clientStack.addRelativeTo(bucketEndpointMiddleware(options), bucketEndpointMiddlewareOptions);
     },
-}); };
+});

package/dist-es/bucketHostname.js

@@ -1,6 +1,5 @@
-import { __assign, __read } from "tslib";
 import { DOT_PATTERN, getArnResources, getSuffix, getSuffixForArnEndpoint, isBucketNameOptions, isDnsCompatibleBucketName, validateAccountId, validateArnEndpointOptions, validateCustomEndpoint, validateDNSHostLabel, validateMrapAlias, validateNoDualstack, validateNoFIPS, validateOutpostService, validatePartition, validateRegion, validateRegionalClient, validateS3Service, validateService, } from "./bucketHostnameUtils";
-export var bucketHostname = function (options) {
+export const bucketHostname = (options) => {
     validateCustomEndpoint(options);
     return isBucketNameOptions(options)
         ?
@@ -8,72 +7,69 @@ export var bucketHostname = function (options) {
         :
             getEndpointFromArn(options);
 };
-var getEndpointFromBucketName = function (_a) {
-    var _b = _a.accelerateEndpoint, accelerateEndpoint = _b === void 0 ? false : _b, region = _a.clientRegion, baseHostname = _a.baseHostname, bucketName = _a.bucketName, _c = _a.dualstackEndpoint, dualstackEndpoint = _c === void 0 ? false : _c, _d = _a.fipsEndpoint, fipsEndpoint = _d === void 0 ? false : _d, _e = _a.pathStyleEndpoint, pathStyleEndpoint = _e === void 0 ? false : _e, _f = _a.tlsCompatible, tlsCompatible = _f === void 0 ? true : _f, _g = _a.isCustomEndpoint, isCustomEndpoint = _g === void 0 ? false : _g;
-    var _h = __read(isCustomEndpoint ? [region, baseHostname] : getSuffix(baseHostname), 2), clientRegion = _h[0], hostnameSuffix = _h[1];
+const getEndpointFromBucketName = ({ accelerateEndpoint = false, clientRegion: region, baseHostname, bucketName, dualstackEndpoint = false, fipsEndpoint = false, pathStyleEndpoint = false, tlsCompatible = true, isCustomEndpoint = false, }) => {
+    const [clientRegion, hostnameSuffix] = isCustomEndpoint ? [region, baseHostname] : getSuffix(baseHostname);
     if (pathStyleEndpoint || !isDnsCompatibleBucketName(bucketName) || (tlsCompatible && DOT_PATTERN.test(bucketName))) {
         return {
             bucketEndpoint: false,
-            hostname: dualstackEndpoint ? "s3.dualstack.".concat(clientRegion, ".").concat(hostnameSuffix) : baseHostname,
+            hostname: dualstackEndpoint ? `s3.dualstack.${clientRegion}.${hostnameSuffix}` : baseHostname,
         };
     }
     if (accelerateEndpoint) {
-        baseHostname = "s3-accelerate".concat(dualstackEndpoint ? ".dualstack" : "", ".").concat(hostnameSuffix);
+        baseHostname = `s3-accelerate${dualstackEndpoint ? ".dualstack" : ""}.${hostnameSuffix}`;
     }
     else if (dualstackEndpoint) {
-        baseHostname = "s3.dualstack.".concat(clientRegion, ".").concat(hostnameSuffix);
+        baseHostname = `s3.dualstack.${clientRegion}.${hostnameSuffix}`;
     }
     return {
         bucketEndpoint: true,
-        hostname: "".concat(bucketName, ".").concat(baseHostname),
+        hostname: `${bucketName}.${baseHostname}`,
     };
 };
-var getEndpointFromArn = function (options) {
-    var isCustomEndpoint = options.isCustomEndpoint, baseHostname = options.baseHostname, clientRegion = options.clientRegion;
-    var hostnameSuffix = isCustomEndpoint ? baseHostname : getSuffixForArnEndpoint(baseHostname)[1];
-    var pathStyleEndpoint = options.pathStyleEndpoint, _a = options.accelerateEndpoint, accelerateEndpoint = _a === void 0 ? false : _a, _b = options.fipsEndpoint, fipsEndpoint = _b === void 0 ? false : _b, _c = options.tlsCompatible, tlsCompatible = _c === void 0 ? true : _c, bucketName = options.bucketName, _d = options.clientPartition, clientPartition = _d === void 0 ? "aws" : _d;
-    validateArnEndpointOptions({ pathStyleEndpoint: pathStyleEndpoint, accelerateEndpoint: accelerateEndpoint, tlsCompatible: tlsCompatible });
-    var service = bucketName.service, partition = bucketName.partition, accountId = bucketName.accountId, region = bucketName.region, resource = bucketName.resource;
+const getEndpointFromArn = (options) => {
+    const { isCustomEndpoint, baseHostname, clientRegion } = options;
+    const hostnameSuffix = isCustomEndpoint ? baseHostname : getSuffixForArnEndpoint(baseHostname)[1];
+    const { pathStyleEndpoint, accelerateEndpoint = false, fipsEndpoint = false, tlsCompatible = true, bucketName, clientPartition = "aws", } = options;
+    validateArnEndpointOptions({ pathStyleEndpoint, accelerateEndpoint, tlsCompatible });
+    const { service, partition, accountId, region, resource } = bucketName;
     validateService(service);
-    validatePartition(partition, { clientPartition: clientPartition });
+    validatePartition(partition, { clientPartition });
     validateAccountId(accountId);
-    var _e = getArnResources(resource), accesspointName = _e.accesspointName, outpostId = _e.outpostId;
+    const { accesspointName, outpostId } = getArnResources(resource);
     if (service === "s3-object-lambda") {
-        return getEndpointFromObjectLambdaArn(__assign(__assign({}, options), { tlsCompatible: tlsCompatible, bucketName: bucketName, accesspointName: accesspointName, hostnameSuffix: hostnameSuffix }));
+        return getEndpointFromObjectLambdaArn({ ...options, tlsCompatible, bucketName, accesspointName, hostnameSuffix });
     }
     if (region === "") {
-        return getEndpointFromMRAPArn(__assign(__assign({}, options), { clientRegion: clientRegion, mrapAlias: accesspointName, hostnameSuffix: hostnameSuffix }));
+        return getEndpointFromMRAPArn({ ...options, clientRegion, mrapAlias: accesspointName, hostnameSuffix });
     }
     if (outpostId) {
-        return getEndpointFromOutpostArn(__assign(__assign({}, options), { clientRegion: clientRegion, outpostId: outpostId, accesspointName: accesspointName, hostnameSuffix: hostnameSuffix }));
+        return getEndpointFromOutpostArn({ ...options, clientRegion, outpostId, accesspointName, hostnameSuffix });
     }
-    return getEndpointFromAccessPointArn(__assign(__assign({}, options), { clientRegion: clientRegion, accesspointName: accesspointName, hostnameSuffix: hostnameSuffix }));
+    return getEndpointFromAccessPointArn({ ...options, clientRegion, accesspointName, hostnameSuffix });
 };
-var getEndpointFromObjectLambdaArn = function (_a) {
-    var _b = _a.dualstackEndpoint, dualstackEndpoint = _b === void 0 ? false : _b, _c = _a.fipsEndpoint, fipsEndpoint = _c === void 0 ? false : _c, _d = _a.tlsCompatible, tlsCompatible = _d === void 0 ? true : _d, useArnRegion = _a.useArnRegion, clientRegion = _a.clientRegion, _e = _a.clientSigningRegion, clientSigningRegion = _e === void 0 ? clientRegion : _e, accesspointName = _a.accesspointName, bucketName = _a.bucketName, hostnameSuffix = _a.hostnameSuffix;
-    var accountId = bucketName.accountId, region = bucketName.region, service = bucketName.service;
+const getEndpointFromObjectLambdaArn = ({ dualstackEndpoint = false, fipsEndpoint = false, tlsCompatible = true, useArnRegion, clientRegion, clientSigningRegion = clientRegion, accesspointName, bucketName, hostnameSuffix, }) => {
+    const { accountId, region, service } = bucketName;
     validateRegionalClient(clientRegion);
     validateRegion(region, {
-        useArnRegion: useArnRegion,
-        clientRegion: clientRegion,
-        clientSigningRegion: clientSigningRegion,
+        useArnRegion,
+        clientRegion,
+        clientSigningRegion,
         allowFipsRegion: true,
         useFipsEndpoint: fipsEndpoint,
     });
     validateNoDualstack(dualstackEndpoint);
-    var DNSHostLabel = "".concat(accesspointName, "-").concat(accountId);
-    validateDNSHostLabel(DNSHostLabel, { tlsCompatible: tlsCompatible });
-    var endpointRegion = useArnRegion ? region : clientRegion;
-    var signingRegion = useArnRegion ? region : clientSigningRegion;
+    const DNSHostLabel = `${accesspointName}-${accountId}`;
+    validateDNSHostLabel(DNSHostLabel, { tlsCompatible });
+    const endpointRegion = useArnRegion ? region : clientRegion;
+    const signingRegion = useArnRegion ? region : clientSigningRegion;
     return {
         bucketEndpoint: true,
-        hostname: "".concat(DNSHostLabel, ".").concat(service).concat(fipsEndpoint ? "-fips" : "", ".").concat(endpointRegion, ".").concat(hostnameSuffix),
-        signingRegion: signingRegion,
+        hostname: `${DNSHostLabel}.${service}${fipsEndpoint ? "-fips" : ""}.${endpointRegion}.${hostnameSuffix}`,
+        signingRegion,
         signingService: service,
     };
 };
-var getEndpointFromMRAPArn = function (_a) {
-    var disableMultiregionAccessPoints = _a.disableMultiregionAccessPoints, _b = _a.dualstackEndpoint, dualstackEndpoint = _b === void 0 ? false : _b, isCustomEndpoint = _a.isCustomEndpoint, mrapAlias = _a.mrapAlias, hostnameSuffix = _a.hostnameSuffix;
+const getEndpointFromMRAPArn = ({ disableMultiregionAccessPoints, dualstackEndpoint = false, isCustomEndpoint, mrapAlias, hostnameSuffix, }) => {
     if (disableMultiregionAccessPoints === true) {
         throw new Error("SDK is attempting to use a MRAP ARN. Please enable to feature.");
     }
@@ -81,50 +77,48 @@ var getEndpointFromMRAPArn = function (_a) {
     validateNoDualstack(dualstackEndpoint);
     return {
         bucketEndpoint: true,
-        hostname: "".concat(mrapAlias).concat(isCustomEndpoint ? "" : ".accesspoint.s3-global", ".").concat(hostnameSuffix),
+        hostname: `${mrapAlias}${isCustomEndpoint ? "" : `.accesspoint.s3-global`}.${hostnameSuffix}`,
         signingRegion: "*",
     };
 };
-var getEndpointFromOutpostArn = function (_a) {
-    var useArnRegion = _a.useArnRegion, clientRegion = _a.clientRegion, _b = _a.clientSigningRegion, clientSigningRegion = _b === void 0 ? clientRegion : _b, bucketName = _a.bucketName, outpostId = _a.outpostId, _c = _a.dualstackEndpoint, dualstackEndpoint = _c === void 0 ? false : _c, _d = _a.fipsEndpoint, fipsEndpoint = _d === void 0 ? false : _d, _e = _a.tlsCompatible, tlsCompatible = _e === void 0 ? true : _e, accesspointName = _a.accesspointName, isCustomEndpoint = _a.isCustomEndpoint, hostnameSuffix = _a.hostnameSuffix;
+const getEndpointFromOutpostArn = ({ useArnRegion, clientRegion, clientSigningRegion = clientRegion, bucketName, outpostId, dualstackEndpoint = false, fipsEndpoint = false, tlsCompatible = true, accesspointName, isCustomEndpoint, hostnameSuffix, }) => {
     validateRegionalClient(clientRegion);
-    validateRegion(bucketName.region, { useArnRegion: useArnRegion, clientRegion: clientRegion, clientSigningRegion: clientSigningRegion, useFipsEndpoint: fipsEndpoint });
-    var DNSHostLabel = "".concat(accesspointName, "-").concat(bucketName.accountId);
-    validateDNSHostLabel(DNSHostLabel, { tlsCompatible: tlsCompatible });
-    var endpointRegion = useArnRegion ? bucketName.region : clientRegion;
-    var signingRegion = useArnRegion ? bucketName.region : clientSigningRegion;
+    validateRegion(bucketName.region, { useArnRegion, clientRegion, clientSigningRegion, useFipsEndpoint: fipsEndpoint });
+    const DNSHostLabel = `${accesspointName}-${bucketName.accountId}`;
+    validateDNSHostLabel(DNSHostLabel, { tlsCompatible });
+    const endpointRegion = useArnRegion ? bucketName.region : clientRegion;
+    const signingRegion = useArnRegion ? bucketName.region : clientSigningRegion;
     validateOutpostService(bucketName.service);
-    validateDNSHostLabel(outpostId, { tlsCompatible: tlsCompatible });
+    validateDNSHostLabel(outpostId, { tlsCompatible });
     validateNoDualstack(dualstackEndpoint);
     validateNoFIPS(fipsEndpoint);
-    var hostnamePrefix = "".concat(DNSHostLabel, ".").concat(outpostId);
+    const hostnamePrefix = `${DNSHostLabel}.${outpostId}`;
     return {
         bucketEndpoint: true,
-        hostname: "".concat(hostnamePrefix).concat(isCustomEndpoint ? "" : ".s3-outposts.".concat(endpointRegion), ".").concat(hostnameSuffix),
-        signingRegion: signingRegion,
+        hostname: `${hostnamePrefix}${isCustomEndpoint ? "" : `.s3-outposts.${endpointRegion}`}.${hostnameSuffix}`,
+        signingRegion,
         signingService: "s3-outposts",
     };
 };
-var getEndpointFromAccessPointArn = function (_a) {
-    var useArnRegion = _a.useArnRegion, clientRegion = _a.clientRegion, _b = _a.clientSigningRegion, clientSigningRegion = _b === void 0 ? clientRegion : _b, bucketName = _a.bucketName, _c = _a.dualstackEndpoint, dualstackEndpoint = _c === void 0 ? false : _c, _d = _a.fipsEndpoint, fipsEndpoint = _d === void 0 ? false : _d, _e = _a.tlsCompatible, tlsCompatible = _e === void 0 ? true : _e, accesspointName = _a.accesspointName, isCustomEndpoint = _a.isCustomEndpoint, hostnameSuffix = _a.hostnameSuffix;
+const getEndpointFromAccessPointArn = ({ useArnRegion, clientRegion, clientSigningRegion = clientRegion, bucketName, dualstackEndpoint = false, fipsEndpoint = false, tlsCompatible = true, accesspointName, isCustomEndpoint, hostnameSuffix, }) => {
     validateRegionalClient(clientRegion);
     validateRegion(bucketName.region, {
-        useArnRegion: useArnRegion,
-        clientRegion: clientRegion,
-        clientSigningRegion: clientSigningRegion,
+        useArnRegion,
+        clientRegion,
+        clientSigningRegion,
         allowFipsRegion: true,
         useFipsEndpoint: fipsEndpoint,
     });
-    var hostnamePrefix = "".concat(accesspointName, "-").concat(bucketName.accountId);
-    validateDNSHostLabel(hostnamePrefix, { tlsCompatible: tlsCompatible });
-    var endpointRegion = useArnRegion ? bucketName.region : clientRegion;
-    var signingRegion = useArnRegion ? bucketName.region : clientSigningRegion;
+    const hostnamePrefix = `${accesspointName}-${bucketName.accountId}`;
+    validateDNSHostLabel(hostnamePrefix, { tlsCompatible });
+    const endpointRegion = useArnRegion ? bucketName.region : clientRegion;
+    const signingRegion = useArnRegion ? bucketName.region : clientSigningRegion;
     validateS3Service(bucketName.service);
     return {
         bucketEndpoint: true,
-        hostname: "".concat(hostnamePrefix).concat(isCustomEndpoint
+        hostname: `${hostnamePrefix}${isCustomEndpoint
             ? ""
-            : ".s3-accesspoint".concat(fipsEndpoint ? "-fips" : "").concat(dualstackEndpoint ? ".dualstack" : "", ".").concat(endpointRegion), ".").concat(hostnameSuffix),
-        signingRegion: signingRegion,
+            : `.s3-accesspoint${fipsEndpoint ? "-fips" : ""}${dualstackEndpoint ? ".dualstack" : ""}.${endpointRegion}`}.${hostnameSuffix}`,
+        signingRegion,
     };
 };

package/dist-es/bucketHostnameUtils.js

@@ -1,28 +1,21 @@
-import { __read } from "tslib";
-var DOMAIN_PATTERN = /^[a-z0-9][a-z0-9\.\-]{1,61}[a-z0-9]$/;
-var IP_ADDRESS_PATTERN = /(\d+\.){3}\d+/;
-var DOTS_PATTERN = /\.\./;
-export var DOT_PATTERN = /\./;
-export var S3_HOSTNAME_PATTERN = /^(.+\.)?s3(-fips)?(\.dualstack)?[.-]([a-z0-9-]+)\./;
-var S3_US_EAST_1_ALTNAME_PATTERN = /^s3(-external-1)?\.amazonaws\.com$/;
-var AWS_PARTITION_SUFFIX = "amazonaws.com";
-export var isBucketNameOptions = function (options) { return typeof options.bucketName === "string"; };
-export var isDnsCompatibleBucketName = function (bucketName) {
-    return DOMAIN_PATTERN.test(bucketName) && !IP_ADDRESS_PATTERN.test(bucketName) && !DOTS_PATTERN.test(bucketName);
-};
-var getRegionalSuffix = function (hostname) {
-    var parts = hostname.match(S3_HOSTNAME_PATTERN);
-    return [parts[4], hostname.replace(new RegExp("^".concat(parts[0])), "")];
-};
-export var getSuffix = function (hostname) {
-    return S3_US_EAST_1_ALTNAME_PATTERN.test(hostname) ? ["us-east-1", AWS_PARTITION_SUFFIX] : getRegionalSuffix(hostname);
-};
-export var getSuffixForArnEndpoint = function (hostname) {
-    return S3_US_EAST_1_ALTNAME_PATTERN.test(hostname)
-        ? [hostname.replace(".".concat(AWS_PARTITION_SUFFIX), ""), AWS_PARTITION_SUFFIX]
-        : getRegionalSuffix(hostname);
-};
-export var validateArnEndpointOptions = function (options) {
+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-]+)\./;
+const S3_US_EAST_1_ALTNAME_PATTERN = /^s3(-external-1)?\.amazonaws\.com$/;
+const AWS_PARTITION_SUFFIX = "amazonaws.com";
+export const isBucketNameOptions = (options) => typeof options.bucketName === "string";
+export const isDnsCompatibleBucketName = (bucketName) => DOMAIN_PATTERN.test(bucketName) && !IP_ADDRESS_PATTERN.test(bucketName) && !DOTS_PATTERN.test(bucketName);
+const getRegionalSuffix = (hostname) => {
+    const parts = hostname.match(S3_HOSTNAME_PATTERN);
+    return [parts[4], hostname.replace(new RegExp(`^${parts[0]}`), "")];
+};
+export const getSuffix = (hostname) => S3_US_EAST_1_ALTNAME_PATTERN.test(hostname) ? ["us-east-1", AWS_PARTITION_SUFFIX] : getRegionalSuffix(hostname);
+export const getSuffixForArnEndpoint = (hostname) => S3_US_EAST_1_ALTNAME_PATTERN.test(hostname)
+    ? [hostname.replace(`.${AWS_PARTITION_SUFFIX}`, ""), AWS_PARTITION_SUFFIX]
+    : getRegionalSuffix(hostname);
+export const validateArnEndpointOptions = (options) => {
     if (options.pathStyleEndpoint) {
         throw new Error("Path-style S3 endpoint is not supported when bucket is an ARN");
     }
@@ -33,27 +26,27 @@ export var validateArnEndpointOptions = function (options) {
         throw new Error("HTTPS is required when bucket is an ARN");
     }
 };
-export var validateService = function (service) {
+export const validateService = (service) => {
     if (service !== "s3" && service !== "s3-outposts" && service !== "s3-object-lambda") {
         throw new Error("Expect 's3' or 's3-outposts' or 's3-object-lambda' in ARN service component");
     }
 };
-export var validateS3Service = function (service) {
+export const validateS3Service = (service) => {
     if (service !== "s3") {
         throw new Error("Expect 's3' in Accesspoint ARN service component");
     }
 };
-export var validateOutpostService = function (service) {
+export const validateOutpostService = (service) => {
     if (service !== "s3-outposts") {
         throw new Error("Expect 's3-posts' in Outpost ARN service component");
     }
 };
-export var validatePartition = function (partition, options) {
+export const validatePartition = (partition, options) => {
     if (partition !== options.clientPartition) {
-        throw new Error("Partition in ARN is incompatible, got \"".concat(partition, "\" but expected \"").concat(options.clientPartition, "\""));
+        throw new Error(`Partition in ARN is incompatible, got "${partition}" but expected "${options.clientPartition}"`);
     }
 };
-export var validateRegion = function (region, options) {
+export const validateRegion = (region, options) => {
     if (region === "") {
         throw new Error("ARN region is empty");
     }
@@ -62,37 +55,36 @@ export var validateRegion = function (region, options) {
             throw new Error("FIPS region is not supported");
         }
         else if (!isEqualRegions(region, options.clientRegion)) {
-            throw new Error("Client FIPS region ".concat(options.clientRegion, " doesn't match region ").concat(region, " in ARN"));
+            throw new Error(`Client FIPS region ${options.clientRegion} doesn't match region ${region} in ARN`);
         }
     }
     if (!options.useArnRegion &&
         !isEqualRegions(region, options.clientRegion || "") &&
         !isEqualRegions(region, options.clientSigningRegion || "")) {
-        throw new Error("Region in ARN is incompatible, got ".concat(region, " but expected ").concat(options.clientRegion));
+        throw new Error(`Region in ARN is incompatible, got ${region} but expected ${options.clientRegion}`);
     }
 };
-export var validateRegionalClient = function (region) {
+export const validateRegionalClient = (region) => {
     if (["s3-external-1", "aws-global"].includes(region)) {
-        throw new Error("Client region ".concat(region, " is not regional"));
+        throw new Error(`Client region ${region} is not regional`);
     }
 };
-var isEqualRegions = function (regionA, regionB) { return regionA === regionB; };
-export var validateAccountId = function (accountId) {
+const isEqualRegions = (regionA, regionB) => regionA === regionB;
+export const validateAccountId = (accountId) => {
     if (!/[0-9]{12}/.exec(accountId)) {
         throw new Error("Access point ARN accountID does not match regex '[0-9]{12}'");
     }
 };
-export var validateDNSHostLabel = function (label, options) {
-    if (options === void 0) { options = { tlsCompatible: true }; }
+export const validateDNSHostLabel = (label, options = { tlsCompatible: true }) => {
     if (label.length >= 64 ||
         !/^[a-z0-9][a-z0-9.-]*[a-z0-9]$/.test(label) ||
         /(\d+\.){3}\d+/.test(label) ||
         /[.-]{2}/.test(label) ||
-        ((options === null || options === void 0 ? void 0 : options.tlsCompatible) && DOT_PATTERN.test(label))) {
-        throw new Error("Invalid DNS label ".concat(label));
+        (options?.tlsCompatible && DOT_PATTERN.test(label))) {
+        throw new Error(`Invalid DNS label ${label}`);
     }
 };
-export var validateCustomEndpoint = function (options) {
+export const validateCustomEndpoint = (options) => {
     if (options.isCustomEndpoint) {
         if (options.dualstackEndpoint)
             throw new Error("Dualstack endpoint is not supported with custom endpoint");
@@ -100,41 +92,41 @@ export var validateCustomEndpoint = function (options) {
             throw new Error("Accelerate endpoint is not supported with custom endpoint");
     }
 };
-export var getArnResources = function (resource) {
-    var delimiter = resource.includes(":") ? ":" : "/";
-    var _a = __read(resource.split(delimiter)), resourceType = _a[0], rest = _a.slice(1);
+export const getArnResources = (resource) => {
+    const delimiter = resource.includes(":") ? ":" : "/";
+    const [resourceType, ...rest] = resource.split(delimiter);
     if (resourceType === "accesspoint") {
         if (rest.length !== 1 || rest[0] === "") {
-            throw new Error("Access Point ARN should have one resource accesspoint".concat(delimiter, "{accesspointname}"));
+            throw new Error(`Access Point ARN should have one resource accesspoint${delimiter}{accesspointname}`);
         }
         return { accesspointName: rest[0] };
     }
     else if (resourceType === "outpost") {
         if (!rest[0] || rest[1] !== "accesspoint" || !rest[2] || rest.length !== 3) {
-            throw new Error("Outpost ARN should have resource outpost".concat(delimiter, "{outpostId}").concat(delimiter, "accesspoint").concat(delimiter, "{accesspointName}"));
+            throw new Error(`Outpost ARN should have resource outpost${delimiter}{outpostId}${delimiter}accesspoint${delimiter}{accesspointName}`);
         }
-        var _b = __read(rest, 3), outpostId = _b[0], _1 = _b[1], accesspointName = _b[2];
-        return { outpostId: outpostId, accesspointName: accesspointName };
+        const [outpostId, _, accesspointName] = rest;
+        return { outpostId, accesspointName };
     }
     else {
-        throw new Error("ARN resource should begin with 'accesspoint".concat(delimiter, "' or 'outpost").concat(delimiter, "'"));
+        throw new Error(`ARN resource should begin with 'accesspoint${delimiter}' or 'outpost${delimiter}'`);
     }
 };
-export var validateNoDualstack = function (dualstackEndpoint) {
+export const validateNoDualstack = (dualstackEndpoint) => {
     if (dualstackEndpoint)
         throw new Error("Dualstack endpoint is not supported with Outpost or Multi-region Access Point ARN.");
 };
-export var validateNoFIPS = function (useFipsEndpoint) {
+export const validateNoFIPS = (useFipsEndpoint) => {
     if (useFipsEndpoint)
-        throw new Error("FIPS region is not supported with Outpost.");
+        throw new Error(`FIPS region is not supported with Outpost.`);
 };
-export var validateMrapAlias = function (name) {
+export const validateMrapAlias = (name) => {
     try {
-        name.split(".").forEach(function (label) {
+        name.split(".").forEach((label) => {
             validateDNSHostLabel(label);
         });
     }
     catch (e) {
-        throw new Error("\"".concat(name, "\" is not a DNS compatible name."));
+        throw new Error(`"${name}" is not a DNS compatible name.`);
     }
 };

package/dist-es/configurations.js

@@ -1,7 +1,13 @@
-import { __assign } from "tslib";
 export function resolveBucketEndpointConfig(input) {
-    var _a = input.bucketEndpoint, bucketEndpoint = _a === void 0 ? false : _a, _b = input.forcePathStyle, forcePathStyle = _b === void 0 ? false : _b, _c = input.useAccelerateEndpoint, useAccelerateEndpoint = _c === void 0 ? false : _c, _d = input.useArnRegion, useArnRegion = _d === void 0 ? false : _d, _e = input.disableMultiregionAccessPoints, disableMultiregionAccessPoints = _e === void 0 ? false : _e;
-    return __assign(__assign({}, input), { bucketEndpoint: bucketEndpoint, forcePathStyle: forcePathStyle, useAccelerateEndpoint: useAccelerateEndpoint, useArnRegion: typeof useArnRegion === "function" ? useArnRegion : function () { return Promise.resolve(useArnRegion); }, disableMultiregionAccessPoints: typeof disableMultiregionAccessPoints === "function"
+    const { bucketEndpoint = false, forcePathStyle = false, useAccelerateEndpoint = false, useArnRegion = false, disableMultiregionAccessPoints = false, } = input;
+    return {
+        ...input,
+        bucketEndpoint,
+        forcePathStyle,
+        useAccelerateEndpoint,
+        useArnRegion: typeof useArnRegion === "function" ? useArnRegion : () => Promise.resolve(useArnRegion),
+        disableMultiregionAccessPoints: typeof disableMultiregionAccessPoints === "function"
             ? disableMultiregionAccessPoints
-            : function () { return Promise.resolve(disableMultiregionAccessPoints); } });
+            : () => Promise.resolve(disableMultiregionAccessPoints),
+    };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/middleware-bucket-endpoint",
-  "version": "3.171.0",
+  "version": "3.183.0",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
     "build:cjs": "tsc -p tsconfig.cjs.json",
@@ -20,15 +20,15 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@aws-sdk/protocol-http": "3.171.0",
-    "@aws-sdk/types": "3.171.0",
-    "@aws-sdk/util-arn-parser": "3.170.0",
-    "@aws-sdk/util-config-provider": "3.170.0",
+    "@aws-sdk/protocol-http": "3.183.0",
+    "@aws-sdk/types": "3.183.0",
+    "@aws-sdk/util-arn-parser": "3.183.0",
+    "@aws-sdk/util-config-provider": "3.183.0",
     "tslib": "^2.3.1"
   },
   "devDependencies": {
-    "@aws-sdk/middleware-stack": "3.171.0",
-    "@aws-sdk/node-config-provider": "3.171.0",
+    "@aws-sdk/middleware-stack": "3.183.0",
+    "@aws-sdk/node-config-provider": "3.183.0",
     "@tsconfig/recommended": "1.0.1",
     "concurrently": "7.0.0",
     "downlevel-dts": "0.10.1",