初始化环境文件

node_modules/@smithy/util-base64/dist-cjs/constants.browser.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maxLetterValue = exports.bitsPerByte = exports.bitsPerLetter = exports.alphabetByValue = exports.alphabetByEncoding = void 0;
+const chars = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/`;
+exports.alphabetByEncoding = Object.entries(chars).reduce((acc, [i, c]) => {
+    acc[c] = Number(i);
+    return acc;
+}, {});
+exports.alphabetByValue = chars.split("");
+exports.bitsPerLetter = 6;
+exports.bitsPerByte = 8;
+exports.maxLetterValue = 0b111111;

node_modules/@smithy/util-base64/dist-cjs/fromBase64.browser.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromBase64 = void 0;
+const constants_browser_1 = require("./constants.browser");
+const fromBase64 = (input) => {
+    let totalByteLength = (input.length / 4) * 3;
+    if (input.slice(-2) === "==") {
+        totalByteLength -= 2;
+    }
+    else if (input.slice(-1) === "=") {
+        totalByteLength--;
+    }
+    const out = new ArrayBuffer(totalByteLength);
+    const dataView = new DataView(out);
+    for (let i = 0; i < input.length; i += 4) {
+        let bits = 0;
+        let bitLength = 0;
+        for (let j = i, limit = i + 3; j <= limit; j++) {
+            if (input[j] !== "=") {
+                if (!(input[j] in constants_browser_1.alphabetByEncoding)) {
+                    throw new TypeError(`Invalid character ${input[j]} in base64 string.`);
+                }
+                bits |= constants_browser_1.alphabetByEncoding[input[j]] << ((limit - j) * constants_browser_1.bitsPerLetter);
+                bitLength += constants_browser_1.bitsPerLetter;
+            }
+            else {
+                bits >>= constants_browser_1.bitsPerLetter;
+            }
+        }
+        const chunkOffset = (i / 4) * 3;
+        bits >>= bitLength % constants_browser_1.bitsPerByte;
+        const byteLength = Math.floor(bitLength / constants_browser_1.bitsPerByte);
+        for (let k = 0; k < byteLength; k++) {
+            const offset = (byteLength - k - 1) * constants_browser_1.bitsPerByte;
+            dataView.setUint8(chunkOffset + k, (bits & (255 << offset)) >> offset);
+        }
+    }
+    return new Uint8Array(out);
+};
+exports.fromBase64 = fromBase64;

node_modules/@smithy/util-base64/dist-cjs/fromBase64.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromBase64 = void 0;
+const util_buffer_from_1 = require("@smithy/util-buffer-from");
+const BASE64_REGEX = /^[A-Za-z0-9+/]*={0,2}$/;
+const fromBase64 = (input) => {
+    if ((input.length * 3) % 4 !== 0) {
+        throw new TypeError(`Incorrect padding on base64 string.`);
+    }
+    if (!BASE64_REGEX.exec(input)) {
+        throw new TypeError(`Invalid base64 string.`);
+    }
+    const buffer = (0, util_buffer_from_1.fromString)(input, "base64");
+    return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+};
+exports.fromBase64 = fromBase64;

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

@@ -0,0 +1,27 @@
+'use strict';
+
+var fromBase64 = require('./fromBase64');
+var toBase64 = require('./toBase64');
+
+
+
+Object.prototype.hasOwnProperty.call(fromBase64, '__proto__') &&
+	!Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
+	Object.defineProperty(exports, '__proto__', {
+		enumerable: true,
+		value: fromBase64['__proto__']
+	});
+
+Object.keys(fromBase64).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = fromBase64[k];
+});
+Object.prototype.hasOwnProperty.call(toBase64, '__proto__') &&
+	!Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
+	Object.defineProperty(exports, '__proto__', {
+		enumerable: true,
+		value: toBase64['__proto__']
+	});
+
+Object.keys(toBase64).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = toBase64[k];
+});

node_modules/@smithy/util-base64/dist-cjs/toBase64.browser.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBase64 = toBase64;
+const util_utf8_1 = require("@smithy/util-utf8");
+const constants_browser_1 = require("./constants.browser");
+function toBase64(_input) {
+    let input;
+    if (typeof _input === "string") {
+        input = (0, util_utf8_1.fromUtf8)(_input);
+    }
+    else {
+        input = _input;
+    }
+    const isArrayLike = typeof input === "object" && typeof input.length === "number";
+    const isUint8Array = typeof input === "object" &&
+        typeof input.byteOffset === "number" &&
+        typeof input.byteLength === "number";
+    if (!isArrayLike && !isUint8Array) {
+        throw new Error("@smithy/util-base64: toBase64 encoder function only accepts string | Uint8Array.");
+    }
+    let str = "";
+    for (let i = 0; i < input.length; i += 3) {
+        let bits = 0;
+        let bitLength = 0;
+        for (let j = i, limit = Math.min(i + 3, input.length); j < limit; j++) {
+            bits |= input[j] << ((limit - j - 1) * constants_browser_1.bitsPerByte);
+            bitLength += constants_browser_1.bitsPerByte;
+        }
+        const bitClusterCount = Math.ceil(bitLength / constants_browser_1.bitsPerLetter);
+        bits <<= bitClusterCount * constants_browser_1.bitsPerLetter - bitLength;
+        for (let k = 1; k <= bitClusterCount; k++) {
+            const offset = (bitClusterCount - k) * constants_browser_1.bitsPerLetter;
+            str += constants_browser_1.alphabetByValue[(bits & (constants_browser_1.maxLetterValue << offset)) >> offset];
+        }
+        str += "==".slice(0, 4 - bitClusterCount);
+    }
+    return str;
+}

node_modules/@smithy/util-base64/dist-cjs/toBase64.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBase64 = void 0;
+const util_buffer_from_1 = require("@smithy/util-buffer-from");
+const util_utf8_1 = require("@smithy/util-utf8");
+const toBase64 = (_input) => {
+    let input;
+    if (typeof _input === "string") {
+        input = (0, util_utf8_1.fromUtf8)(_input);
+    }
+    else {
+        input = _input;
+    }
+    if (typeof input !== "object" || typeof input.byteOffset !== "number" || typeof input.byteLength !== "number") {
+        throw new Error("@smithy/util-base64: toBase64 encoder function only accepts string | Uint8Array.");
+    }
+    return (0, util_buffer_from_1.fromArrayBuffer)(input.buffer, input.byteOffset, input.byteLength).toString("base64");
+};
+exports.toBase64 = toBase64;