include node_modules so release .zip is deployable

node_modules/@smithy/util-waiter/dist-cjs/createWaiter.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWaiter = void 0;
+const poller_1 = require("./poller");
+const utils_1 = require("./utils");
+const waiter_1 = require("./waiter");
+const abortTimeout = async (abortSignal) => {
+    return new Promise((resolve) => {
+        abortSignal.onabort = () => resolve({ state: waiter_1.WaiterState.ABORTED });
+    });
+};
+const createWaiter = async (options, input, acceptorChecks) => {
+    const params = {
+        ...waiter_1.waiterServiceDefaults,
+        ...options,
+    };
+    (0, utils_1.validateWaiterOptions)(params);
+    const exitConditions = [(0, poller_1.runPolling)(params, input, acceptorChecks)];
+    if (options.abortController) {
+        exitConditions.push(abortTimeout(options.abortController.signal));
+    }
+    if (options.abortSignal) {
+        exitConditions.push(abortTimeout(options.abortSignal));
+    }
+    return Promise.race(exitConditions);
+};
+exports.createWaiter = createWaiter;

node_modules/@smithy/util-waiter/dist-cjs/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./createWaiter"), exports);
+tslib_1.__exportStar(require("./waiter"), exports);

node_modules/@smithy/util-waiter/dist-cjs/poller.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPolling = void 0;
+const sleep_1 = require("./utils/sleep");
+const waiter_1 = require("./waiter");
+const exponentialBackoffWithJitter = (minDelay, maxDelay, attemptCeiling, attempt) => {
+    if (attempt > attemptCeiling)
+        return maxDelay;
+    const delay = minDelay * 2 ** (attempt - 1);
+    return randomInRange(minDelay, delay);
+};
+const randomInRange = (min, max) => min + Math.random() * (max - min);
+const runPolling = async ({ minDelay, maxDelay, maxWaitTime, abortController, client, abortSignal }, input, acceptorChecks) => {
+    var _a;
+    const { state, reason } = await acceptorChecks(client, input);
+    if (state !== waiter_1.WaiterState.RETRY) {
+        return { state, reason };
+    }
+    let currentAttempt = 1;
+    const waitUntil = Date.now() + maxWaitTime * 1000;
+    const attemptCeiling = Math.log(maxDelay / minDelay) / Math.log(2) + 1;
+    while (true) {
+        if (((_a = abortController === null || abortController === void 0 ? void 0 : abortController.signal) === null || _a === void 0 ? void 0 : _a.aborted) || (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted)) {
+            return { state: waiter_1.WaiterState.ABORTED };
+        }
+        const delay = exponentialBackoffWithJitter(minDelay, maxDelay, attemptCeiling, currentAttempt);
+        if (Date.now() + delay * 1000 > waitUntil) {
+            return { state: waiter_1.WaiterState.TIMEOUT };
+        }
+        await (0, sleep_1.sleep)(delay);
+        const { state, reason } = await acceptorChecks(client, input);
+        if (state !== waiter_1.WaiterState.RETRY) {
+            return { state, reason };
+        }
+        currentAttempt += 1;
+    }
+};
+exports.runPolling = runPolling;

node_modules/@smithy/util-waiter/dist-cjs/utils/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./sleep"), exports);
+tslib_1.__exportStar(require("./validate"), exports);

node_modules/@smithy/util-waiter/dist-cjs/utils/sleep.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = void 0;
+const sleep = (seconds) => {
+    return new Promise((resolve) => setTimeout(resolve, seconds * 1000));
+};
+exports.sleep = sleep;

node_modules/@smithy/util-waiter/dist-cjs/utils/validate.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateWaiterOptions = void 0;
+const validateWaiterOptions = (options) => {
+    if (options.maxWaitTime < 1) {
+        throw new Error(`WaiterConfiguration.maxWaitTime must be greater than 0`);
+    }
+    else if (options.minDelay < 1) {
+        throw new Error(`WaiterConfiguration.minDelay must be greater than 0`);
+    }
+    else if (options.maxDelay < 1) {
+        throw new Error(`WaiterConfiguration.maxDelay must be greater than 0`);
+    }
+    else if (options.maxWaitTime <= options.minDelay) {
+        throw new Error(`WaiterConfiguration.maxWaitTime [${options.maxWaitTime}] must be greater than WaiterConfiguration.minDelay [${options.minDelay}] for this waiter`);
+    }
+    else if (options.maxDelay < options.minDelay) {
+        throw new Error(`WaiterConfiguration.maxDelay [${options.maxDelay}] must be greater than WaiterConfiguration.minDelay [${options.minDelay}] for this waiter`);
+    }
+};
+exports.validateWaiterOptions = validateWaiterOptions;

node_modules/@smithy/util-waiter/dist-cjs/waiter.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkExceptions = exports.WaiterState = exports.waiterServiceDefaults = void 0;
+exports.waiterServiceDefaults = {
+    minDelay: 2,
+    maxDelay: 120,
+};
+var WaiterState;
+(function (WaiterState) {
+    WaiterState["ABORTED"] = "ABORTED";
+    WaiterState["FAILURE"] = "FAILURE";
+    WaiterState["SUCCESS"] = "SUCCESS";
+    WaiterState["RETRY"] = "RETRY";
+    WaiterState["TIMEOUT"] = "TIMEOUT";
+})(WaiterState = exports.WaiterState || (exports.WaiterState = {}));
+const checkExceptions = (result) => {
+    if (result.state === WaiterState.ABORTED) {
+        const abortError = new Error(`${JSON.stringify({
+            ...result,
+            reason: "Request was aborted",
+        })}`);
+        abortError.name = "AbortError";
+        throw abortError;
+    }
+    else if (result.state === WaiterState.TIMEOUT) {
+        const timeoutError = new Error(`${JSON.stringify({
+            ...result,
+            reason: "Waiter has timed out",
+        })}`);
+        timeoutError.name = "TimeoutError";
+        throw timeoutError;
+    }
+    else if (result.state !== WaiterState.SUCCESS) {
+        throw new Error(`${JSON.stringify({ result })}`);
+    }
+    return result;
+};
+exports.checkExceptions = checkExceptions;