@ndlib/ndlib-cdk2 1.0.0

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/fetch-http-handler/LICENSE

@@ -0,0 +1,201 @@
+Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2018-2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/fetch-http-handler/README.md

@@ -0,0 +1,4 @@
+# @aws-sdk/fetch-http-handler
+
+[![NPM version](https://img.shields.io/npm/v/@aws-sdk/fetch-http-handler/latest.svg)](https://www.npmjs.com/package/@aws-sdk/fetch-http-handler)
+[![NPM downloads](https://img.shields.io/npm/dm/@aws-sdk/fetch-http-handler.svg)](https://www.npmjs.com/package/@aws-sdk/fetch-http-handler)

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/fetch-http-handler/dist/cjs/fetch-http-handler.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchHttpHandler = void 0;
+const protocol_http_1 = require("@aws-sdk/protocol-http");
+const querystring_builder_1 = require("@aws-sdk/querystring-builder");
+const request_timeout_1 = require("./request-timeout");
+class FetchHttpHandler {
+    constructor({ requestTimeout } = {}) {
+        this.requestTimeout = requestTimeout;
+    }
+    destroy() {
+        // Do nothing. TLS and HTTP/2 connection pooling is handled by the browser.
+    }
+    handle(request, { abortSignal } = {}) {
+        const requestTimeoutInMs = this.requestTimeout;
+        // if the request was already aborted, prevent doing extra work
+        if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
+            const abortError = new Error("Request aborted");
+            abortError.name = "AbortError";
+            return Promise.reject(abortError);
+        }
+        let path = request.path;
+        if (request.query) {
+            const queryString = querystring_builder_1.buildQueryString(request.query);
+            if (queryString) {
+                path += `?${queryString}`;
+            }
+        }
+        const { port, method } = request;
+        const url = `${request.protocol}//${request.hostname}${port ? `:${port}` : ""}${path}`;
+        // Request constructor doesn't allow GET/HEAD request with body
+        // ref: https://github.com/whatwg/fetch/issues/551
+        const body = method === "GET" || method === "HEAD" ? undefined : request.body;
+        const requestOptions = {
+            body,
+            headers: new Headers(request.headers),
+            method: method,
+        };
+        // some browsers support abort signal
+        if (typeof AbortController !== "undefined") {
+            requestOptions["signal"] = abortSignal;
+        }
+        const fetchRequest = new Request(url, requestOptions);
+        const raceOfPromises = [
+            fetch(fetchRequest).then((response) => {
+                const fetchHeaders = response.headers;
+                const transformedHeaders = {};
+                for (const pair of fetchHeaders.entries()) {
+                    transformedHeaders[pair[0]] = pair[1];
+                }
+                const hasReadableStream = response.body !== undefined;
+                // Return the response with buffered body
+                if (!hasReadableStream) {
+                    return response.blob().then((body) => ({
+                        response: new protocol_http_1.HttpResponse({
+                            headers: transformedHeaders,
+                            statusCode: response.status,
+                            body,
+                        }),
+                    }));
+                }
+                // Return the response with streaming body
+                return {
+                    response: new protocol_http_1.HttpResponse({
+                        headers: transformedHeaders,
+                        statusCode: response.status,
+                        body: response.body,
+                    }),
+                };
+            }),
+            request_timeout_1.requestTimeout(requestTimeoutInMs),
+        ];
+        if (abortSignal) {
+            raceOfPromises.push(new Promise((resolve, reject) => {
+                abortSignal.onabort = () => {
+                    const abortError = new Error("Request aborted");
+                    abortError.name = "AbortError";
+                    reject(abortError);
+                };
+            }));
+        }
+        return Promise.race(raceOfPromises);
+    }
+}
+exports.FetchHttpHandler = FetchHttpHandler;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fetch-http-handler.js","sourceRoot":"","sources":["../../src/fetch-http-handler.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpHandler, HttpRequest, HttpResponse } from \"@aws-sdk/protocol-http\";\nimport { buildQueryString } from \"@aws-sdk/querystring-builder\";\nimport { HeaderBag, HttpHandlerOptions } from \"@aws-sdk/types\";\n\nimport { requestTimeout } from \"./request-timeout\";\n\ndeclare let AbortController: any;\n\n/**\n * Represents the http options that can be passed to a browser http client.\n */\nexport interface FetchHttpHandlerOptions {\n  /**\n   * The number of milliseconds a request can take before being automatically\n   * terminated.\n   */\n  requestTimeout?: number;\n}\n\nexport class FetchHttpHandler implements HttpHandler {\n  private readonly requestTimeout?: number;\n\n  constructor({ requestTimeout }: FetchHttpHandlerOptions = {}) {\n    this.requestTimeout = requestTimeout;\n  }\n\n  destroy(): void {\n    // Do nothing. TLS and HTTP/2 connection pooling is handled by the browser.\n  }\n\n  handle(request: HttpRequest, { abortSignal }: HttpHandlerOptions = {}): Promise<{ response: HttpResponse }> {\n    const requestTimeoutInMs = this.requestTimeout;\n\n    // if the request was already aborted, prevent doing extra work\n    if (abortSignal?.aborted) {\n      const abortError = new Error(\"Request aborted\");\n      abortError.name = \"AbortError\";\n      return Promise.reject(abortError);\n    }\n\n    let path = request.path;\n    if (request.query) {\n      const queryString = buildQueryString(request.query);\n      if (queryString) {\n        path += `?${queryString}`;\n      }\n    }\n\n    const { port, method } = request;\n    const url = `${request.protocol}//${request.hostname}${port ? `:${port}` : \"\"}${path}`;\n    // Request constructor doesn't allow GET/HEAD request with body\n    // ref: https://github.com/whatwg/fetch/issues/551\n    const body = method === \"GET\" || method === \"HEAD\" ? undefined : request.body;\n    const requestOptions: RequestInit = {\n      body,\n      headers: new Headers(request.headers),\n      method: method,\n    };\n\n    // some browsers support abort signal\n    if (typeof AbortController !== \"undefined\") {\n      (requestOptions as any)[\"signal\"] = abortSignal;\n    }\n\n    const fetchRequest = new Request(url, requestOptions);\n    const raceOfPromises = [\n      fetch(fetchRequest).then((response) => {\n        const fetchHeaders: any = response.headers;\n        const transformedHeaders: HeaderBag = {};\n\n        for (const pair of <Array<string[]>>fetchHeaders.entries()) {\n          transformedHeaders[pair[0]] = pair[1];\n        }\n\n        const hasReadableStream = response.body !== undefined;\n\n        // Return the response with buffered body\n        if (!hasReadableStream) {\n          return response.blob().then((body) => ({\n            response: new HttpResponse({\n              headers: transformedHeaders,\n              statusCode: response.status,\n              body,\n            }),\n          }));\n        }\n        // Return the response with streaming body\n        return {\n          response: new HttpResponse({\n            headers: transformedHeaders,\n            statusCode: response.status,\n            body: response.body,\n          }),\n        };\n      }),\n      requestTimeout(requestTimeoutInMs),\n    ];\n    if (abortSignal) {\n      raceOfPromises.push(\n        new Promise<never>((resolve, reject) => {\n          abortSignal.onabort = () => {\n            const abortError = new Error(\"Request aborted\");\n            abortError.name = \"AbortError\";\n            reject(abortError);\n          };\n        })\n      );\n    }\n    return Promise.race(raceOfPromises);\n  }\n}\n"]}

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/fetch-http-handler/dist/cjs/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./fetch-http-handler"), exports);
+tslib_1.__exportStar(require("./stream-collector"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsK0RBQXFDO0FBQ3JDLDZEQUFtQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2ZldGNoLWh0dHAtaGFuZGxlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vc3RyZWFtLWNvbGxlY3RvclwiO1xuIl19

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/fetch-http-handler/dist/cjs/request-timeout.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestTimeout = void 0;
+function requestTimeout(timeoutInMs = 0) {
+    return new Promise((resolve, reject) => {
+        if (timeoutInMs) {
+            setTimeout(() => {
+                const timeoutError = new Error(`Request did not complete within ${timeoutInMs} ms`);
+                timeoutError.name = "TimeoutError";
+                reject(timeoutError);
+            }, timeoutInMs);
+        }
+    });
+}
+exports.requestTimeout = requestTimeout;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVxdWVzdC10aW1lb3V0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3JlcXVlc3QtdGltZW91dC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxTQUFnQixjQUFjLENBQUMsV0FBVyxHQUFHLENBQUM7SUFDNUMsT0FBTyxJQUFJLE9BQU8sQ0FBQyxDQUFDLE9BQU8sRUFBRSxNQUFNLEVBQUUsRUFBRTtRQUNyQyxJQUFJLFdBQVcsRUFBRTtZQUNmLFVBQVUsQ0FBQyxHQUFHLEVBQUU7Z0JBQ2QsTUFBTSxZQUFZLEdBQUcsSUFBSSxLQUFLLENBQUMsbUNBQW1DLFdBQVcsS0FBSyxDQUFDLENBQUM7Z0JBQ3BGLFlBQVksQ0FBQyxJQUFJLEdBQUcsY0FBYyxDQUFDO2dCQUNuQyxNQUFNLENBQUMsWUFBWSxDQUFDLENBQUM7WUFDdkIsQ0FBQyxFQUFFLFdBQVcsQ0FBQyxDQUFDO1NBQ2pCO0lBQ0gsQ0FBQyxDQUFDLENBQUM7QUFDTCxDQUFDO0FBVkQsd0NBVUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZnVuY3Rpb24gcmVxdWVzdFRpbWVvdXQodGltZW91dEluTXMgPSAwKTogUHJvbWlzZTxuZXZlcj4ge1xuICByZXR1cm4gbmV3IFByb21pc2UoKHJlc29sdmUsIHJlamVjdCkgPT4ge1xuICAgIGlmICh0aW1lb3V0SW5Ncykge1xuICAgICAgc2V0VGltZW91dCgoKSA9PiB7XG4gICAgICAgIGNvbnN0IHRpbWVvdXRFcnJvciA9IG5ldyBFcnJvcihgUmVxdWVzdCBkaWQgbm90IGNvbXBsZXRlIHdpdGhpbiAke3RpbWVvdXRJbk1zfSBtc2ApO1xuICAgICAgICB0aW1lb3V0RXJyb3IubmFtZSA9IFwiVGltZW91dEVycm9yXCI7XG4gICAgICAgIHJlamVjdCh0aW1lb3V0RXJyb3IpO1xuICAgICAgfSwgdGltZW91dEluTXMpO1xuICAgIH1cbiAgfSk7XG59XG4iXX0=

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/fetch-http-handler/dist/cjs/stream-collector.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamCollector = void 0;
+const util_base64_browser_1 = require("@aws-sdk/util-base64-browser");
+//reference: https://snack.expo.io/r1JCSWRGU
+const streamCollector = (stream) => {
+    if (typeof Blob === "function" && stream instanceof Blob) {
+        return collectBlob(stream);
+    }
+    return collectStream(stream);
+};
+exports.streamCollector = streamCollector;
+async function collectBlob(blob) {
+    const base64 = await readToBase64(blob);
+    const arrayBuffer = util_base64_browser_1.fromBase64(base64);
+    return new Uint8Array(arrayBuffer);
+}
+async function collectStream(stream) {
+    let res = new Uint8Array(0);
+    const reader = stream.getReader();
+    let isDone = false;
+    while (!isDone) {
+        const { done, value } = await reader.read();
+        if (value) {
+            const prior = res;
+            res = new Uint8Array(prior.length + value.length);
+            res.set(prior);
+            res.set(value, prior.length);
+        }
+        isDone = done;
+    }
+    return res;
+}
+function readToBase64(blob) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onloadend = () => {
+            var _a;
+            // reference: https://developer.mozilla.org/en-US/docs/Web/API/FileReader/readAsDataURL
+            // response from readAsDataURL is always prepended with "data:*/*;base64,"
+            if (reader.readyState !== 2) {
+                return reject(new Error("Reader aborted too early"));
+            }
+            const result = ((_a = reader.result) !== null && _a !== void 0 ? _a : "");
+            // Response can include only 'data:' for empty blob, return empty string in this case.
+            // Otherwise, return the string after ','
+            const commaIndex = result.indexOf(",");
+            const dataOffset = commaIndex > -1 ? commaIndex + 1 : result.length;
+            resolve(result.substring(dataOffset));
+        };
+        reader.onabort = () => reject(new Error("Read aborted"));
+        reader.onerror = () => reject(reader.error);
+        // reader.readAsArrayBuffer is not always available
+        reader.readAsDataURL(blob);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/fetch-http-handler/dist/es/fetch-http-handler.js

@@ -0,0 +1,98 @@
+import { __values } from "tslib";
+import { HttpResponse } from "@aws-sdk/protocol-http";
+import { buildQueryString } from "@aws-sdk/querystring-builder";
+import { requestTimeout } from "./request-timeout";
+var FetchHttpHandler = /** @class */ (function () {
+    function FetchHttpHandler(_a) {
+        var _b = _a === void 0 ? {} : _a, requestTimeout = _b.requestTimeout;
+        this.requestTimeout = requestTimeout;
+    }
+    FetchHttpHandler.prototype.destroy = function () {
+        // Do nothing. TLS and HTTP/2 connection pooling is handled by the browser.
+    };
+    FetchHttpHandler.prototype.handle = function (request, _a) {
+        var _b = _a === void 0 ? {} : _a, abortSignal = _b.abortSignal;
+        var requestTimeoutInMs = this.requestTimeout;
+        // if the request was already aborted, prevent doing extra work
+        if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
+            var abortError = new Error("Request aborted");
+            abortError.name = "AbortError";
+            return Promise.reject(abortError);
+        }
+        var path = request.path;
+        if (request.query) {
+            var queryString = buildQueryString(request.query);
+            if (queryString) {
+                path += "?" + queryString;
+            }
+        }
+        var port = request.port, method = request.method;
+        var url = request.protocol + "//" + request.hostname + (port ? ":" + port : "") + path;
+        // Request constructor doesn't allow GET/HEAD request with body
+        // ref: https://github.com/whatwg/fetch/issues/551
+        var body = method === "GET" || method === "HEAD" ? undefined : request.body;
+        var requestOptions = {
+            body: body,
+            headers: new Headers(request.headers),
+            method: method,
+        };
+        // some browsers support abort signal
+        if (typeof AbortController !== "undefined") {
+            requestOptions["signal"] = abortSignal;
+        }
+        var fetchRequest = new Request(url, requestOptions);
+        var raceOfPromises = [
+            fetch(fetchRequest).then(function (response) {
+                var e_1, _a;
+                var fetchHeaders = response.headers;
+                var transformedHeaders = {};
+                try {
+                    for (var _b = __values(fetchHeaders.entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var pair = _c.value;
+                        transformedHeaders[pair[0]] = pair[1];
+                    }
+                }
+                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; }
+                }
+                var hasReadableStream = response.body !== undefined;
+                // Return the response with buffered body
+                if (!hasReadableStream) {
+                    return response.blob().then(function (body) { return ({
+                        response: new HttpResponse({
+                            headers: transformedHeaders,
+                            statusCode: response.status,
+                            body: body,
+                        }),
+                    }); });
+                }
+                // Return the response with streaming body
+                return {
+                    response: new HttpResponse({
+                        headers: transformedHeaders,
+                        statusCode: response.status,
+                        body: response.body,
+                    }),
+                };
+            }),
+            requestTimeout(requestTimeoutInMs),
+        ];
+        if (abortSignal) {
+            raceOfPromises.push(new Promise(function (resolve, reject) {
+                abortSignal.onabort = function () {
+                    var abortError = new Error("Request aborted");
+                    abortError.name = "AbortError";
+                    reject(abortError);
+                };
+            }));
+        }
+        return Promise.race(raceOfPromises);
+    };
+    return FetchHttpHandler;
+}());
+export { FetchHttpHandler };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fetch-http-handler.js","sourceRoot":"","sources":["../../src/fetch-http-handler.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpHandler, HttpRequest, HttpResponse } from \"@aws-sdk/protocol-http\";\nimport { buildQueryString } from \"@aws-sdk/querystring-builder\";\nimport { HeaderBag, HttpHandlerOptions } from \"@aws-sdk/types\";\n\nimport { requestTimeout } from \"./request-timeout\";\n\ndeclare let AbortController: any;\n\n/**\n * Represents the http options that can be passed to a browser http client.\n */\nexport interface FetchHttpHandlerOptions {\n  /**\n   * The number of milliseconds a request can take before being automatically\n   * terminated.\n   */\n  requestTimeout?: number;\n}\n\nexport class FetchHttpHandler implements HttpHandler {\n  private readonly requestTimeout?: number;\n\n  constructor({ requestTimeout }: FetchHttpHandlerOptions = {}) {\n    this.requestTimeout = requestTimeout;\n  }\n\n  destroy(): void {\n    // Do nothing. TLS and HTTP/2 connection pooling is handled by the browser.\n  }\n\n  handle(request: HttpRequest, { abortSignal }: HttpHandlerOptions = {}): Promise<{ response: HttpResponse }> {\n    const requestTimeoutInMs = this.requestTimeout;\n\n    // if the request was already aborted, prevent doing extra work\n    if (abortSignal?.aborted) {\n      const abortError = new Error(\"Request aborted\");\n      abortError.name = \"AbortError\";\n      return Promise.reject(abortError);\n    }\n\n    let path = request.path;\n    if (request.query) {\n      const queryString = buildQueryString(request.query);\n      if (queryString) {\n        path += `?${queryString}`;\n      }\n    }\n\n    const { port, method } = request;\n    const url = `${request.protocol}//${request.hostname}${port ? `:${port}` : \"\"}${path}`;\n    // Request constructor doesn't allow GET/HEAD request with body\n    // ref: https://github.com/whatwg/fetch/issues/551\n    const body = method === \"GET\" || method === \"HEAD\" ? undefined : request.body;\n    const requestOptions: RequestInit = {\n      body,\n      headers: new Headers(request.headers),\n      method: method,\n    };\n\n    // some browsers support abort signal\n    if (typeof AbortController !== \"undefined\") {\n      (requestOptions as any)[\"signal\"] = abortSignal;\n    }\n\n    const fetchRequest = new Request(url, requestOptions);\n    const raceOfPromises = [\n      fetch(fetchRequest).then((response) => {\n        const fetchHeaders: any = response.headers;\n        const transformedHeaders: HeaderBag = {};\n\n        for (const pair of <Array<string[]>>fetchHeaders.entries()) {\n          transformedHeaders[pair[0]] = pair[1];\n        }\n\n        const hasReadableStream = response.body !== undefined;\n\n        // Return the response with buffered body\n        if (!hasReadableStream) {\n          return response.blob().then((body) => ({\n            response: new HttpResponse({\n              headers: transformedHeaders,\n              statusCode: response.status,\n              body,\n            }),\n          }));\n        }\n        // Return the response with streaming body\n        return {\n          response: new HttpResponse({\n            headers: transformedHeaders,\n            statusCode: response.status,\n            body: response.body,\n          }),\n        };\n      }),\n      requestTimeout(requestTimeoutInMs),\n    ];\n    if (abortSignal) {\n      raceOfPromises.push(\n        new Promise<never>((resolve, reject) => {\n          abortSignal.onabort = () => {\n            const abortError = new Error(\"Request aborted\");\n            abortError.name = \"AbortError\";\n            reject(abortError);\n          };\n        })\n      );\n    }\n    return Promise.race(raceOfPromises);\n  }\n}\n"]}

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/fetch-http-handler/dist/es/index.js

@@ -0,0 +1,3 @@
+export * from "./fetch-http-handler";
+export * from "./stream-collector";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLG9CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vZmV0Y2gtaHR0cC1oYW5kbGVyXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zdHJlYW0tY29sbGVjdG9yXCI7XG4iXX0=

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/fetch-http-handler/dist/es/request-timeout.js

@@ -0,0 +1,13 @@
+export function requestTimeout(timeoutInMs) {
+    if (timeoutInMs === void 0) { timeoutInMs = 0; }
+    return new Promise(function (resolve, reject) {
+        if (timeoutInMs) {
+            setTimeout(function () {
+                var timeoutError = new Error("Request did not complete within " + timeoutInMs + " ms");
+                timeoutError.name = "TimeoutError";
+                reject(timeoutError);
+            }, timeoutInMs);
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVxdWVzdC10aW1lb3V0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3JlcXVlc3QtdGltZW91dC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLFVBQVUsY0FBYyxDQUFDLFdBQWU7SUFBZiw0QkFBQSxFQUFBLGVBQWU7SUFDNUMsT0FBTyxJQUFJLE9BQU8sQ0FBQyxVQUFDLE9BQU8sRUFBRSxNQUFNO1FBQ2pDLElBQUksV0FBVyxFQUFFO1lBQ2YsVUFBVSxDQUFDO2dCQUNULElBQU0sWUFBWSxHQUFHLElBQUksS0FBSyxDQUFDLHFDQUFtQyxXQUFXLFFBQUssQ0FBQyxDQUFDO2dCQUNwRixZQUFZLENBQUMsSUFBSSxHQUFHLGNBQWMsQ0FBQztnQkFDbkMsTUFBTSxDQUFDLFlBQVksQ0FBQyxDQUFDO1lBQ3ZCLENBQUMsRUFBRSxXQUFXLENBQUMsQ0FBQztTQUNqQjtJQUNILENBQUMsQ0FBQyxDQUFDO0FBQ0wsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBmdW5jdGlvbiByZXF1ZXN0VGltZW91dCh0aW1lb3V0SW5NcyA9IDApOiBQcm9taXNlPG5ldmVyPiB7XG4gIHJldHVybiBuZXcgUHJvbWlzZSgocmVzb2x2ZSwgcmVqZWN0KSA9PiB7XG4gICAgaWYgKHRpbWVvdXRJbk1zKSB7XG4gICAgICBzZXRUaW1lb3V0KCgpID0+IHtcbiAgICAgICAgY29uc3QgdGltZW91dEVycm9yID0gbmV3IEVycm9yKGBSZXF1ZXN0IGRpZCBub3QgY29tcGxldGUgd2l0aGluICR7dGltZW91dEluTXN9IG1zYCk7XG4gICAgICAgIHRpbWVvdXRFcnJvci5uYW1lID0gXCJUaW1lb3V0RXJyb3JcIjtcbiAgICAgICAgcmVqZWN0KHRpbWVvdXRFcnJvcik7XG4gICAgICB9LCB0aW1lb3V0SW5Ncyk7XG4gICAgfVxuICB9KTtcbn1cbiJdfQ==

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/fetch-http-handler/dist/es/stream-collector.js

@@ -0,0 +1,75 @@
+import { __awaiter, __generator } from "tslib";
+import { fromBase64 } from "@aws-sdk/util-base64-browser";
+//reference: https://snack.expo.io/r1JCSWRGU
+export var streamCollector = function (stream) {
+    if (typeof Blob === "function" && stream instanceof Blob) {
+        return collectBlob(stream);
+    }
+    return collectStream(stream);
+};
+function collectBlob(blob) {
+    return __awaiter(this, void 0, void 0, function () {
+        var base64, arrayBuffer;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, readToBase64(blob)];
+                case 1:
+                    base64 = _a.sent();
+                    arrayBuffer = fromBase64(base64);
+                    return [2 /*return*/, new Uint8Array(arrayBuffer)];
+            }
+        });
+    });
+}
+function collectStream(stream) {
+    return __awaiter(this, void 0, void 0, function () {
+        var res, reader, isDone, _a, done, value, prior;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    res = new Uint8Array(0);
+                    reader = stream.getReader();
+                    isDone = false;
+                    _b.label = 1;
+                case 1:
+                    if (!!isDone) return [3 /*break*/, 3];
+                    return [4 /*yield*/, reader.read()];
+                case 2:
+                    _a = _b.sent(), done = _a.done, value = _a.value;
+                    if (value) {
+                        prior = res;
+                        res = new Uint8Array(prior.length + value.length);
+                        res.set(prior);
+                        res.set(value, prior.length);
+                    }
+                    isDone = done;
+                    return [3 /*break*/, 1];
+                case 3: return [2 /*return*/, res];
+            }
+        });
+    });
+}
+function readToBase64(blob) {
+    return new Promise(function (resolve, reject) {
+        var reader = new FileReader();
+        reader.onloadend = function () {
+            var _a;
+            // reference: https://developer.mozilla.org/en-US/docs/Web/API/FileReader/readAsDataURL
+            // response from readAsDataURL is always prepended with "data:*/*;base64,"
+            if (reader.readyState !== 2) {
+                return reject(new Error("Reader aborted too early"));
+            }
+            var result = ((_a = reader.result) !== null && _a !== void 0 ? _a : "");
+            // Response can include only 'data:' for empty blob, return empty string in this case.
+            // Otherwise, return the string after ','
+            var commaIndex = result.indexOf(",");
+            var dataOffset = commaIndex > -1 ? commaIndex + 1 : result.length;
+            resolve(result.substring(dataOffset));
+        };
+        reader.onabort = function () { return reject(new Error("Read aborted")); };
+        reader.onerror = function () { return reject(reader.error); };
+        // reader.readAsArrayBuffer is not always available
+        reader.readAsDataURL(blob);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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