@ndlib/ndlib-cdk2 1.0.8 → 1.0.9

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/middleware-signing/dist-es/configurations.js

@@ -0,0 +1,103 @@
+import { memoize } from "@aws-sdk/property-provider";
+import { SignatureV4 } from "@aws-sdk/signature-v4";
+import { normalizeProvider } from "@aws-sdk/util-middleware";
+const CREDENTIAL_EXPIRE_WINDOW = 300000;
+export const resolveAwsAuthConfig = (input) => {
+    const normalizedCreds = input.credentials
+        ? normalizeCredentialProvider(input.credentials)
+        : input.credentialDefaultProvider(input);
+    const { signingEscapePath = true, systemClockOffset = input.systemClockOffset || 0, sha256 } = input;
+    let signer;
+    if (input.signer) {
+        signer = normalizeProvider(input.signer);
+    }
+    else if (input.regionInfoProvider) {
+        signer = () => normalizeProvider(input.region)()
+            .then(async (region) => [
+            (await input.regionInfoProvider(region, {
+                useFipsEndpoint: await input.useFipsEndpoint(),
+                useDualstackEndpoint: await input.useDualstackEndpoint(),
+            })) || {},
+            region,
+        ])
+            .then(([regionInfo, region]) => {
+            const { signingRegion, signingService } = regionInfo;
+            input.signingRegion = input.signingRegion || signingRegion || region;
+            input.signingName = input.signingName || signingService || input.serviceId;
+            const params = {
+                ...input,
+                credentials: normalizedCreds,
+                region: input.signingRegion,
+                service: input.signingName,
+                sha256,
+                uriEscapePath: signingEscapePath,
+            };
+            const SignerCtor = input.signerConstructor || SignatureV4;
+            return new SignerCtor(params);
+        });
+    }
+    else {
+        signer = async (authScheme) => {
+            authScheme = Object.assign({}, {
+                name: "sigv4",
+                signingName: input.signingName || input.defaultSigningName,
+                signingRegion: await normalizeProvider(input.region)(),
+                properties: {},
+            }, authScheme);
+            const signingRegion = authScheme.signingRegion;
+            const signingService = authScheme.signingName;
+            input.signingRegion = input.signingRegion || signingRegion;
+            input.signingName = input.signingName || signingService || input.serviceId;
+            const params = {
+                ...input,
+                credentials: normalizedCreds,
+                region: input.signingRegion,
+                service: input.signingName,
+                sha256,
+                uriEscapePath: signingEscapePath,
+            };
+            const SignerCtor = input.signerConstructor || SignatureV4;
+            return new SignerCtor(params);
+        };
+    }
+    return {
+        ...input,
+        systemClockOffset,
+        signingEscapePath,
+        credentials: normalizedCreds,
+        signer,
+    };
+};
+export const resolveSigV4AuthConfig = (input) => {
+    const normalizedCreds = input.credentials
+        ? normalizeCredentialProvider(input.credentials)
+        : input.credentialDefaultProvider(input);
+    const { signingEscapePath = true, systemClockOffset = input.systemClockOffset || 0, sha256 } = input;
+    let signer;
+    if (input.signer) {
+        signer = normalizeProvider(input.signer);
+    }
+    else {
+        signer = normalizeProvider(new SignatureV4({
+            credentials: normalizedCreds,
+            region: input.region,
+            service: input.signingName,
+            sha256,
+            uriEscapePath: signingEscapePath,
+        }));
+    }
+    return {
+        ...input,
+        systemClockOffset,
+        signingEscapePath,
+        credentials: normalizedCreds,
+        signer,
+    };
+};
+const normalizeCredentialProvider = (credentials) => {
+    if (typeof credentials === "function") {
+        return memoize(credentials, (credentials) => credentials.expiration !== undefined &&
+            credentials.expiration.getTime() - Date.now() < CREDENTIAL_EXPIRE_WINDOW, (credentials) => credentials.expiration !== undefined);
+    }
+    return normalizeProvider(credentials);
+};

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/middleware-signing/dist-es/index.js

@@ -0,0 +1,2 @@
+export * from "./configurations";
+export * from "./middleware";

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/middleware-signing/dist-es/middleware.js

@@ -0,0 +1,43 @@
+import { HttpRequest, HttpResponse } from "@aws-sdk/protocol-http";
+import { getSkewCorrectedDate } from "./utils/getSkewCorrectedDate";
+import { getUpdatedSystemClockOffset } from "./utils/getUpdatedSystemClockOffset";
+export const awsAuthMiddleware = (options) => (next, context) => async function (args) {
+    if (!HttpRequest.isInstance(args.request))
+        return next(args);
+    const authScheme = context.endpointV2?.properties?.authSchemes?.[0];
+    const multiRegionOverride = authScheme?.name === "sigv4a" ? authScheme?.signingRegionSet?.join(",") : undefined;
+    const signer = await options.signer(authScheme);
+    const output = await next({
+        ...args,
+        request: await signer.sign(args.request, {
+            signingDate: getSkewCorrectedDate(options.systemClockOffset),
+            signingRegion: multiRegionOverride || context["signing_region"],
+            signingService: context["signing_service"],
+        }),
+    }).catch((error) => {
+        const serverTime = error.ServerTime ?? getDateHeader(error.$response);
+        if (serverTime) {
+            options.systemClockOffset = getUpdatedSystemClockOffset(serverTime, options.systemClockOffset);
+        }
+        throw error;
+    });
+    const dateHeader = getDateHeader(output.response);
+    if (dateHeader) {
+        options.systemClockOffset = getUpdatedSystemClockOffset(dateHeader, options.systemClockOffset);
+    }
+    return output;
+};
+const getDateHeader = (response) => HttpResponse.isInstance(response) ? response.headers?.date ?? response.headers?.Date : undefined;
+export const awsAuthMiddlewareOptions = {
+    name: "awsAuthMiddleware",
+    tags: ["SIGNATURE", "AWSAUTH"],
+    relation: "after",
+    toMiddleware: "retryMiddleware",
+    override: true,
+};
+export const getAwsAuthPlugin = (options) => ({
+    applyToStack: (clientStack) => {
+        clientStack.addRelativeTo(awsAuthMiddleware(options), awsAuthMiddlewareOptions);
+    },
+});
+export const getSigV4AuthPlugin = getAwsAuthPlugin;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/middleware-signing/dist-es/utils/getSkewCorrectedDate.js

@@ -0,0 +1 @@
+export const getSkewCorrectedDate = (systemClockOffset) => new Date(Date.now() + systemClockOffset);

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/middleware-signing/dist-es/utils/getUpdatedSystemClockOffset.js

@@ -0,0 +1,8 @@
+import { isClockSkewed } from "./isClockSkewed";
+export const getUpdatedSystemClockOffset = (clockTime, currentSystemClockOffset) => {
+    const clockTimeInMs = Date.parse(clockTime);
+    if (isClockSkewed(clockTimeInMs, currentSystemClockOffset)) {
+        return clockTimeInMs - Date.now();
+    }
+    return currentSystemClockOffset;
+};

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/middleware-signing/dist-es/utils/isClockSkewed.js

@@ -0,0 +1,2 @@
+import { getSkewCorrectedDate } from "./getSkewCorrectedDate";
+export const isClockSkewed = (clockTime, systemClockOffset) => Math.abs(getSkewCorrectedDate(systemClockOffset).getTime() - clockTime) >= 300000;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/middleware-signing/dist-types/configurations.d.ts

@@ -0,0 +1,92 @@
+import { SignatureV4CryptoInit, SignatureV4Init } from "@aws-sdk/signature-v4";
+import { AuthScheme, AwsCredentialIdentity, ChecksumConstructor, HashConstructor, Logger, MemoizedProvider, Provider, RegionInfoProvider, RequestSigner } from "@aws-sdk/types";
+export interface AwsAuthInputConfig {
+    /**
+     * The credentials used to sign requests.
+     */
+    credentials?: AwsCredentialIdentity | Provider<AwsCredentialIdentity>;
+    /**
+     * The signer to use when signing requests.
+     */
+    signer?: RequestSigner | ((authScheme?: AuthScheme) => Promise<RequestSigner>);
+    /**
+     * Whether to escape request path when signing the request.
+     */
+    signingEscapePath?: boolean;
+    /**
+     * An offset value in milliseconds to apply to all signing times.
+     */
+    systemClockOffset?: number;
+    /**
+     * The region where you want to sign your request against. This
+     * can be different to the region in the endpoint.
+     */
+    signingRegion?: string;
+    /**
+     * The injectable SigV4-compatible signer class constructor. If not supplied,
+     * regular SignatureV4 constructor will be used.
+     * @private
+     */
+    signerConstructor?: new (options: SignatureV4Init & SignatureV4CryptoInit) => RequestSigner;
+}
+export interface SigV4AuthInputConfig {
+    /**
+     * The credentials used to sign requests.
+     */
+    credentials?: AwsCredentialIdentity | Provider<AwsCredentialIdentity>;
+    /**
+     * The signer to use when signing requests.
+     */
+    signer?: RequestSigner | ((authScheme?: AuthScheme) => Promise<RequestSigner>);
+    /**
+     * Whether to escape request path when signing the request.
+     */
+    signingEscapePath?: boolean;
+    /**
+     * An offset value in milliseconds to apply to all signing times.
+     */
+    systemClockOffset?: number;
+}
+interface PreviouslyResolved {
+    credentialDefaultProvider: (input: any) => MemoizedProvider<AwsCredentialIdentity>;
+    region: string | Provider<string>;
+    regionInfoProvider?: RegionInfoProvider;
+    signingName?: string;
+    defaultSigningName?: string;
+    serviceId: string;
+    sha256: ChecksumConstructor | HashConstructor;
+    useFipsEndpoint: Provider<boolean>;
+    useDualstackEndpoint: Provider<boolean>;
+}
+interface SigV4PreviouslyResolved {
+    credentialDefaultProvider: (input: any) => MemoizedProvider<AwsCredentialIdentity>;
+    region: string | Provider<string>;
+    signingName: string;
+    sha256: ChecksumConstructor | HashConstructor;
+    logger?: Logger;
+}
+export interface AwsAuthResolvedConfig {
+    /**
+     * Resolved value for input config {@link AwsAuthInputConfig.credentials}
+     * This provider MAY memoize the loaded credentials for certain period.
+     * See {@link MemoizedProvider} for more information.
+     */
+    credentials: MemoizedProvider<AwsCredentialIdentity>;
+    /**
+     * Resolved value for input config {@link AwsAuthInputConfig.signer}
+     */
+    signer: (authScheme?: AuthScheme) => Promise<RequestSigner>;
+    /**
+     * Resolved value for input config {@link AwsAuthInputConfig.signingEscapePath}
+     */
+    signingEscapePath: boolean;
+    /**
+     * Resolved value for input config {@link AwsAuthInputConfig.systemClockOffset}
+     */
+    systemClockOffset: number;
+}
+export interface SigV4AuthResolvedConfig extends AwsAuthResolvedConfig {
+}
+export declare const resolveAwsAuthConfig: <T>(input: T & AwsAuthInputConfig & PreviouslyResolved) => T & AwsAuthResolvedConfig;
+export declare const resolveSigV4AuthConfig: <T>(input: T & SigV4AuthInputConfig & SigV4PreviouslyResolved) => T & SigV4AuthResolvedConfig;
+export {};

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/middleware-signing/dist-types/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./configurations";
+export * from "./middleware";

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/middleware-signing/dist-types/middleware.d.ts

@@ -0,0 +1,6 @@
+import { FinalizeRequestMiddleware, Pluggable, RelativeMiddlewareOptions } from "@aws-sdk/types";
+import { AwsAuthResolvedConfig } from "./configurations";
+export declare const awsAuthMiddleware: <Input extends object, Output extends object>(options: AwsAuthResolvedConfig) => FinalizeRequestMiddleware<Input, Output>;
+export declare const awsAuthMiddlewareOptions: RelativeMiddlewareOptions;
+export declare const getAwsAuthPlugin: (options: AwsAuthResolvedConfig) => Pluggable<any, any>;
+export declare const getSigV4AuthPlugin: (options: AwsAuthResolvedConfig) => Pluggable<any, any>;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/middleware-signing/dist-types/ts3.4/configurations.d.ts

@@ -0,0 +1,68 @@
+import { SignatureV4CryptoInit, SignatureV4Init } from "@aws-sdk/signature-v4";
+import {
+  AuthScheme,
+  AwsCredentialIdentity,
+  ChecksumConstructor,
+  HashConstructor,
+  Logger,
+  MemoizedProvider,
+  Provider,
+  RegionInfoProvider,
+  RequestSigner,
+} from "@aws-sdk/types";
+export interface AwsAuthInputConfig {
+  credentials?: AwsCredentialIdentity | Provider<AwsCredentialIdentity>;
+  signer?:
+    | RequestSigner
+    | ((authScheme?: AuthScheme) => Promise<RequestSigner>);
+  signingEscapePath?: boolean;
+  systemClockOffset?: number;
+  signingRegion?: string;
+  signerConstructor?: new (
+    options: SignatureV4Init & SignatureV4CryptoInit
+  ) => RequestSigner;
+}
+export interface SigV4AuthInputConfig {
+  credentials?: AwsCredentialIdentity | Provider<AwsCredentialIdentity>;
+  signer?:
+    | RequestSigner
+    | ((authScheme?: AuthScheme) => Promise<RequestSigner>);
+  signingEscapePath?: boolean;
+  systemClockOffset?: number;
+}
+interface PreviouslyResolved {
+  credentialDefaultProvider: (
+    input: any
+  ) => MemoizedProvider<AwsCredentialIdentity>;
+  region: string | Provider<string>;
+  regionInfoProvider?: RegionInfoProvider;
+  signingName?: string;
+  defaultSigningName?: string;
+  serviceId: string;
+  sha256: ChecksumConstructor | HashConstructor;
+  useFipsEndpoint: Provider<boolean>;
+  useDualstackEndpoint: Provider<boolean>;
+}
+interface SigV4PreviouslyResolved {
+  credentialDefaultProvider: (
+    input: any
+  ) => MemoizedProvider<AwsCredentialIdentity>;
+  region: string | Provider<string>;
+  signingName: string;
+  sha256: ChecksumConstructor | HashConstructor;
+  logger?: Logger;
+}
+export interface AwsAuthResolvedConfig {
+  credentials: MemoizedProvider<AwsCredentialIdentity>;
+  signer: (authScheme?: AuthScheme) => Promise<RequestSigner>;
+  signingEscapePath: boolean;
+  systemClockOffset: number;
+}
+export interface SigV4AuthResolvedConfig extends AwsAuthResolvedConfig {}
+export declare const resolveAwsAuthConfig: <T>(
+  input: T & AwsAuthInputConfig & PreviouslyResolved
+) => T & AwsAuthResolvedConfig;
+export declare const resolveSigV4AuthConfig: <T>(
+  input: T & SigV4AuthInputConfig & SigV4PreviouslyResolved
+) => T & SigV4AuthResolvedConfig;
+export {};

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/middleware-signing/dist-types/ts3.4/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./configurations";
+export * from "./middleware";

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/middleware-signing/dist-types/ts3.4/middleware.d.ts

@@ -0,0 +1,19 @@
+import {
+  FinalizeRequestMiddleware,
+  Pluggable,
+  RelativeMiddlewareOptions,
+} from "@aws-sdk/types";
+import { AwsAuthResolvedConfig } from "./configurations";
+export declare const awsAuthMiddleware: <
+  Input extends object,
+  Output extends object
+>(
+  options: AwsAuthResolvedConfig
+) => FinalizeRequestMiddleware<Input, Output>;
+export declare const awsAuthMiddlewareOptions: RelativeMiddlewareOptions;
+export declare const getAwsAuthPlugin: (
+  options: AwsAuthResolvedConfig
+) => Pluggable<any, any>;
+export declare const getSigV4AuthPlugin: (
+  options: AwsAuthResolvedConfig
+) => Pluggable<any, any>;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/middleware-signing/dist-types/ts3.4/utils/getSkewCorrectedDate.d.ts

@@ -0,0 +1 @@
+export declare const getSkewCorrectedDate: (systemClockOffset: number) => Date;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/middleware-signing/dist-types/ts3.4/utils/getUpdatedSystemClockOffset.d.ts

@@ -0,0 +1,4 @@
+export declare const getUpdatedSystemClockOffset: (
+  clockTime: string,
+  currentSystemClockOffset: number
+) => number;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/middleware-signing/dist-types/ts3.4/utils/isClockSkewed.d.ts

@@ -0,0 +1,4 @@
+export declare const isClockSkewed: (
+  clockTime: number,
+  systemClockOffset: number
+) => boolean;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/middleware-signing/dist-types/utils/getSkewCorrectedDate.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns a date that is corrected for clock skew.
+ *
+ * @param systemClockOffset The offset of the system clock in milliseconds.
+ */
+export declare const getSkewCorrectedDate: (systemClockOffset: number) => Date;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/middleware-signing/dist-types/utils/getUpdatedSystemClockOffset.d.ts

@@ -0,0 +1,8 @@
+/**
+ * If clock is skewed, it returns the difference between serverTime and current time.
+ * If clock is not skewed, it returns currentSystemClockOffset.
+ *
+ * @param clockTime The string value of the server time.
+ * @param currentSystemClockOffset The current system clock offset.
+ */
+export declare const getUpdatedSystemClockOffset: (clockTime: string, currentSystemClockOffset: number) => number;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/middleware-signing/dist-types/utils/isClockSkewed.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Checks if the provided date is within the skew window of 300000ms.
+ *
+ * @param clockTime - The time to check for skew in milliseconds.
+ * @param systemClockOffset - The offset of the system clock in milliseconds.
+ */
+export declare const isClockSkewed: (clockTime: number, systemClockOffset: number) => boolean;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/middleware-stack/dist-cjs/MiddlewareStack.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constructStack = void 0;
+const constructStack = () => {
+    let absoluteEntries = [];
+    let relativeEntries = [];
+    const entriesNameSet = new Set();
+    const sort = (entries) => entries.sort((a, b) => stepWeights[b.step] - stepWeights[a.step] ||
+        priorityWeights[b.priority || "normal"] - priorityWeights[a.priority || "normal"]);
+    const removeByName = (toRemove) => {
+        let isRemoved = false;
+        const filterCb = (entry) => {
+            if (entry.name && entry.name === toRemove) {
+                isRemoved = true;
+                entriesNameSet.delete(toRemove);
+                return false;
+            }
+            return true;
+        };
+        absoluteEntries = absoluteEntries.filter(filterCb);
+        relativeEntries = relativeEntries.filter(filterCb);
+        return isRemoved;
+    };
+    const removeByReference = (toRemove) => {
+        let isRemoved = false;
+        const filterCb = (entry) => {
+            if (entry.middleware === toRemove) {
+                isRemoved = true;
+                if (entry.name)
+                    entriesNameSet.delete(entry.name);
+                return false;
+            }
+            return true;
+        };
+        absoluteEntries = absoluteEntries.filter(filterCb);
+        relativeEntries = relativeEntries.filter(filterCb);
+        return isRemoved;
+    };
+    const cloneTo = (toStack) => {
+        absoluteEntries.forEach((entry) => {
+            toStack.add(entry.middleware, { ...entry });
+        });
+        relativeEntries.forEach((entry) => {
+            toStack.addRelativeTo(entry.middleware, { ...entry });
+        });
+        return toStack;
+    };
+    const expandRelativeMiddlewareList = (from) => {
+        const expandedMiddlewareList = [];
+        from.before.forEach((entry) => {
+            if (entry.before.length === 0 && entry.after.length === 0) {
+                expandedMiddlewareList.push(entry);
+            }
+            else {
+                expandedMiddlewareList.push(...expandRelativeMiddlewareList(entry));
+            }
+        });
+        expandedMiddlewareList.push(from);
+        from.after.reverse().forEach((entry) => {
+            if (entry.before.length === 0 && entry.after.length === 0) {
+                expandedMiddlewareList.push(entry);
+            }
+            else {
+                expandedMiddlewareList.push(...expandRelativeMiddlewareList(entry));
+            }
+        });
+        return expandedMiddlewareList;
+    };
+    const getMiddlewareList = (debug = false) => {
+        const normalizedAbsoluteEntries = [];
+        const normalizedRelativeEntries = [];
+        const normalizedEntriesNameMap = {};
+        absoluteEntries.forEach((entry) => {
+            const normalizedEntry = {
+                ...entry,
+                before: [],
+                after: [],
+            };
+            if (normalizedEntry.name)
+                normalizedEntriesNameMap[normalizedEntry.name] = normalizedEntry;
+            normalizedAbsoluteEntries.push(normalizedEntry);
+        });
+        relativeEntries.forEach((entry) => {
+            const normalizedEntry = {
+                ...entry,
+                before: [],
+                after: [],
+            };
+            if (normalizedEntry.name)
+                normalizedEntriesNameMap[normalizedEntry.name] = normalizedEntry;
+            normalizedRelativeEntries.push(normalizedEntry);
+        });
+        normalizedRelativeEntries.forEach((entry) => {
+            if (entry.toMiddleware) {
+                const toMiddleware = normalizedEntriesNameMap[entry.toMiddleware];
+                if (toMiddleware === undefined) {
+                    if (debug) {
+                        return;
+                    }
+                    throw new Error(`${entry.toMiddleware} is not found when adding ${entry.name || "anonymous"} middleware ${entry.relation} ${entry.toMiddleware}`);
+                }
+                if (entry.relation === "after") {
+                    toMiddleware.after.push(entry);
+                }
+                if (entry.relation === "before") {
+                    toMiddleware.before.push(entry);
+                }
+            }
+        });
+        const mainChain = sort(normalizedAbsoluteEntries)
+            .map(expandRelativeMiddlewareList)
+            .reduce((wholeList, expendedMiddlewareList) => {
+            wholeList.push(...expendedMiddlewareList);
+            return wholeList;
+        }, []);
+        return mainChain;
+    };
+    const stack = {
+        add: (middleware, options = {}) => {
+            const { name, override } = options;
+            const entry = {
+                step: "initialize",
+                priority: "normal",
+                middleware,
+                ...options,
+            };
+            if (name) {
+                if (entriesNameSet.has(name)) {
+                    if (!override)
+                        throw new Error(`Duplicate middleware name '${name}'`);
+                    const toOverrideIndex = absoluteEntries.findIndex((entry) => entry.name === name);
+                    const toOverride = absoluteEntries[toOverrideIndex];
+                    if (toOverride.step !== entry.step || toOverride.priority !== entry.priority) {
+                        throw new Error(`"${name}" middleware with ${toOverride.priority} priority in ${toOverride.step} step cannot be ` +
+                            `overridden by same-name middleware with ${entry.priority} priority in ${entry.step} step.`);
+                    }
+                    absoluteEntries.splice(toOverrideIndex, 1);
+                }
+                entriesNameSet.add(name);
+            }
+            absoluteEntries.push(entry);
+        },
+        addRelativeTo: (middleware, options) => {
+            const { name, override } = options;
+            const entry = {
+                middleware,
+                ...options,
+            };
+            if (name) {
+                if (entriesNameSet.has(name)) {
+                    if (!override)
+                        throw new Error(`Duplicate middleware name '${name}'`);
+                    const toOverrideIndex = relativeEntries.findIndex((entry) => entry.name === name);
+                    const toOverride = relativeEntries[toOverrideIndex];
+                    if (toOverride.toMiddleware !== entry.toMiddleware || toOverride.relation !== entry.relation) {
+                        throw new Error(`"${name}" middleware ${toOverride.relation} "${toOverride.toMiddleware}" middleware cannot be overridden ` +
+                            `by same-name middleware ${entry.relation} "${entry.toMiddleware}" middleware.`);
+                    }
+                    relativeEntries.splice(toOverrideIndex, 1);
+                }
+                entriesNameSet.add(name);
+            }
+            relativeEntries.push(entry);
+        },
+        clone: () => cloneTo((0, exports.constructStack)()),
+        use: (plugin) => {
+            plugin.applyToStack(stack);
+        },
+        remove: (toRemove) => {
+            if (typeof toRemove === "string")
+                return removeByName(toRemove);
+            else
+                return removeByReference(toRemove);
+        },
+        removeByTag: (toRemove) => {
+            let isRemoved = false;
+            const filterCb = (entry) => {
+                const { tags, name } = entry;
+                if (tags && tags.includes(toRemove)) {
+                    if (name)
+                        entriesNameSet.delete(name);
+                    isRemoved = true;
+                    return false;
+                }
+                return true;
+            };
+            absoluteEntries = absoluteEntries.filter(filterCb);
+            relativeEntries = relativeEntries.filter(filterCb);
+            return isRemoved;
+        },
+        concat: (from) => {
+            const cloned = cloneTo((0, exports.constructStack)());
+            cloned.use(from);
+            return cloned;
+        },
+        applyToStack: cloneTo,
+        identify: () => {
+            return getMiddlewareList(true).map((mw) => {
+                return mw.name + ": " + (mw.tags || []).join(",");
+            });
+        },
+        resolve: (handler, context) => {
+            for (const middleware of getMiddlewareList()
+                .map((entry) => entry.middleware)
+                .reverse()) {
+                handler = middleware(handler, context);
+            }
+            return handler;
+        },
+    };
+    return stack;
+};
+exports.constructStack = constructStack;
+const stepWeights = {
+    initialize: 5,
+    serialize: 4,
+    build: 3,
+    finalizeRequest: 2,
+    deserialize: 1,
+};
+const priorityWeights = {
+    high: 3,
+    normal: 2,
+    low: 1,
+};

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/middleware-stack/dist-cjs/index.js

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

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/middleware-stack/dist-cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });