Backend half

SerpentRace_Backend/node_modules/@smithy/property-provider/dist-es/CredentialsProviderError.js

@@ -0,0 +1,8 @@
+import { ProviderError } from "./ProviderError";
+export class CredentialsProviderError extends ProviderError {
+    constructor(message, options = true) {
+        super(message, options);
+        this.name = "CredentialsProviderError";
+        Object.setPrototypeOf(this, CredentialsProviderError.prototype);
+    }
+}

SerpentRace_Backend/node_modules/@smithy/property-provider/dist-es/ProviderError.js

@@ -0,0 +1,22 @@
+export class ProviderError extends Error {
+    constructor(message, options = true) {
+        let logger;
+        let tryNextLink = true;
+        if (typeof options === "boolean") {
+            logger = undefined;
+            tryNextLink = options;
+        }
+        else if (options != null && typeof options === "object") {
+            logger = options.logger;
+            tryNextLink = options.tryNextLink ?? true;
+        }
+        super(message);
+        this.name = "ProviderError";
+        this.tryNextLink = tryNextLink;
+        Object.setPrototypeOf(this, ProviderError.prototype);
+        logger?.debug?.(`@smithy/property-provider ${tryNextLink ? "->" : "(!)"} ${message}`);
+    }
+    static from(error, options = true) {
+        return Object.assign(new this(error.message, options), error);
+    }
+}

SerpentRace_Backend/node_modules/@smithy/property-provider/dist-es/TokenProviderError.js

@@ -0,0 +1,8 @@
+import { ProviderError } from "./ProviderError";
+export class TokenProviderError extends ProviderError {
+    constructor(message, options = true) {
+        super(message, options);
+        this.name = "TokenProviderError";
+        Object.setPrototypeOf(this, TokenProviderError.prototype);
+    }
+}

SerpentRace_Backend/node_modules/@smithy/property-provider/dist-es/chain.js

@@ -0,0 +1,21 @@
+import { ProviderError } from "./ProviderError";
+export const chain = (...providers) => async () => {
+    if (providers.length === 0) {
+        throw new ProviderError("No providers in chain");
+    }
+    let lastProviderError;
+    for (const provider of providers) {
+        try {
+            const credentials = await provider();
+            return credentials;
+        }
+        catch (err) {
+            lastProviderError = err;
+            if (err?.tryNextLink) {
+                continue;
+            }
+            throw err;
+        }
+    }
+    throw lastProviderError;
+};

SerpentRace_Backend/node_modules/@smithy/property-provider/dist-es/fromStatic.js

@@ -0,0 +1 @@
+export const fromStatic = (staticValue) => () => Promise.resolve(staticValue);

SerpentRace_Backend/node_modules/@smithy/property-provider/dist-es/index.js

@@ -0,0 +1,6 @@
+export * from "./CredentialsProviderError";
+export * from "./ProviderError";
+export * from "./TokenProviderError";
+export * from "./chain";
+export * from "./fromStatic";
+export * from "./memoize";

SerpentRace_Backend/node_modules/@smithy/property-provider/dist-es/memoize.js

@@ -0,0 +1,45 @@
+export const memoize = (provider, isExpired, requiresRefresh) => {
+    let resolved;
+    let pending;
+    let hasResult;
+    let isConstant = false;
+    const coalesceProvider = async () => {
+        if (!pending) {
+            pending = provider();
+        }
+        try {
+            resolved = await pending;
+            hasResult = true;
+            isConstant = false;
+        }
+        finally {
+            pending = undefined;
+        }
+        return resolved;
+    };
+    if (isExpired === undefined) {
+        return async (options) => {
+            if (!hasResult || options?.forceRefresh) {
+                resolved = await coalesceProvider();
+            }
+            return resolved;
+        };
+    }
+    return async (options) => {
+        if (!hasResult || options?.forceRefresh) {
+            resolved = await coalesceProvider();
+        }
+        if (isConstant) {
+            return resolved;
+        }
+        if (requiresRefresh && !requiresRefresh(resolved)) {
+            isConstant = true;
+            return resolved;
+        }
+        if (isExpired(resolved)) {
+            await coalesceProvider();
+            return resolved;
+        }
+        return resolved;
+    };
+};