@senpiper/sp-agent 0.1.6 → 0.1.7

package/node_modules/@smithy/core/dist-cjs/submodules/serde/index.js

@@ -1,9 +1,10 @@
-const { createHmac, createHash, getRandomValues } = require("node:crypto");
-const { hasOwn, HttpResponse } = require("@smithy/core/transport");
-exports.hasOwn = hasOwn;
-const { ReadStream, lstatSync, fstatSync } = require("node:fs");
-const { toEndpointV1 } = require("@smithy/core/endpoints");
-const { Readable, Writable, PassThrough } = require("node:stream");
+'use strict';
+
+var node_crypto = require('node:crypto');
+var node_fs = require('node:fs');
+var protocols = require('@smithy/core/protocols');
+var endpoints = require('@smithy/core/endpoints');
+var node_stream = require('node:stream');
 
 const isArrayBuffer = (arg) => (typeof ArrayBuffer === "function" && arg instanceof ArrayBuffer) ||
     Object.prototype.toString.call(arg) === "[object ArrayBuffer]";
@@ -22,7 +23,7 @@ const fromString = (input, encoding) => {
 };
 
 const BASE64_REGEX = /^[A-Za-z0-9+/]*={0,2}$/;
-const fromBase64 = (input) => {
+const fromBase64$1 = (input) => {
     if ((input.length * 3) % 4 !== 0) {
         throw new TypeError(`Incorrect padding on base64 string.`);
     }
@@ -119,7 +120,7 @@ function bindV4(getRandomValues) {
     };
 }
 
-const copyDocumentWithTransform = (source, _schemaRef, _transform = (_) => _) => source;
+const copyDocumentWithTransform = (source, schemaRef, transform = (_) => _) => source;
 
 const parseBoolean = (value) => {
     switch (value) {
@@ -260,8 +261,6 @@ const expectUnion = (value) => {
     const asObject = expectObject(value);
     const setKeys = [];
     for (const k in asObject) {
-        if (!hasOwn(asObject, k))
-            continue;
         if (asObject[k] != null) {
             setKeys.push(k);
         }
@@ -391,7 +390,7 @@ const parseRfc3339DateTime = (value) => {
     const day = parseDateValue(dayStr, "day", 1, 31);
     return buildDate(year, month, day, { hours, minutes, seconds, fractionalMilliseconds });
 };
-const RFC3339_WITH_OFFSET$1 = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(([-+]\d{2}:\d{2})|[zZ])$/);
+const RFC3339_WITH_OFFSET$1 = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(([-+]\d{2}\:\d{2})|[zZ])$/);
 const parseRfc3339DateTimeWithOffset = (value) => {
     if (value === null || value === undefined) {
         return undefined;
@@ -746,7 +745,7 @@ const splitHeader = (value) => {
     });
 };
 
-const format = /^-?((0|[1-9]\d*)(\.\d+)?|\.\d+)([eE][+-]?\d+)?$/;
+const format = /^-?\d*(\.\d+)?$/;
 class NumericValue {
     string;
     type;
@@ -754,7 +753,7 @@ class NumericValue {
         this.string = string;
         this.type = type;
         if (!format.test(string)) {
-            throw new Error(`@smithy/core/serde - NumericValue string must conform to the Smithy bigDecimal format. Received: "${string}"`);
+            throw new Error(`@smithy/core/serde - NumericValue must only contain [0-9], at most one decimal point ".", and an optional negation prefix "-".`);
         }
     }
     toString() {
@@ -822,21 +821,18 @@ const calculateBodyLength = (body) => {
     else if (typeof body.start === "number" && typeof body.end === "number") {
         return body.end + 1 - body.start;
     }
-    else if (body instanceof ReadStream) {
+    else if (body instanceof node_fs.ReadStream) {
         if (body.path != null) {
-            return lstatSync(body.path).size;
+            return node_fs.lstatSync(body.path).size;
         }
         else if (typeof body.fd === "number") {
-            return fstatSync(body.fd).size;
+            return node_fs.fstatSync(body.fd).size;
         }
     }
     throw new Error(`Body Length computation failed for ${body}`);
 };
 
 const toUint8Array = (data) => {
-    if (data instanceof Uint8Array) {
-        return data;
-    }
     if (typeof data === "string") {
         return fromUtf8$1(data);
     }
@@ -846,22 +842,6 @@ const toUint8Array = (data) => {
     return new Uint8Array(data);
 };
 
-function concatBytes(arrays, length) {
-    if (length === undefined) {
-        length = 0;
-        for (const bytes of arrays) {
-            length += bytes.byteLength;
-        }
-    }
-    const result = new Uint8Array(length);
-    let offset = 0;
-    for (const buf of arrays) {
-        result.set(buf, offset);
-        offset += buf.byteLength;
-    }
-    return result;
-}
-
 const deserializerMiddleware = (options, deserializer) => (next, context) => async (args) => {
     const { response } = await next(args);
     try {
@@ -883,7 +863,7 @@ const deserializerMiddleware = (options, deserializer) => (next, context) => asy
             try {
                 error.message += "\n  " + hint;
             }
-            catch (ignored) {
+            catch (e) {
                 if (!context.logger || context.logger?.constructor?.name === "NoOpLogger") {
                     console.warn(hint);
                 }
@@ -897,7 +877,7 @@ const deserializerMiddleware = (options, deserializer) => (next, context) => asy
                 }
             }
             try {
-                if (HttpResponse.isInstance(response)) {
+                if (protocols.HttpResponse.isInstance(response)) {
                     const { headers = {} } = response;
                     const headerEntries = Object.entries(headers);
                     error.$metadata = {
@@ -908,7 +888,7 @@ const deserializerMiddleware = (options, deserializer) => (next, context) => asy
                     };
                 }
             }
-            catch (ignored) {
+            catch (e) {
             }
         }
         throw error;
@@ -923,7 +903,7 @@ const findHeader = (pattern, headers) => {
 const serializerMiddleware = (options, serializer) => (next, context) => async (args) => {
     const endpointConfig = options;
     const endpoint = context.endpointV2
-        ? async () => toEndpointV1(context.endpointV2)
+        ? async () => endpoints.toEndpointV1(context.endpointV2)
         : endpointConfig.endpoint;
     if (!endpoint) {
         throw new Error("No valid endpoint provider available.");
@@ -973,8 +953,8 @@ class Hash {
     }
     reset() {
         this.hash = this.secret
-            ? createHmac(this.algorithmIdentifier, castSourceData(this.secret))
-            : createHash(this.algorithmIdentifier);
+            ? node_crypto.createHmac(this.algorithmIdentifier, castSourceData(this.secret))
+            : node_crypto.createHash(this.algorithmIdentifier);
     }
 }
 function castSourceData(toCast, encoding) {
@@ -990,80 +970,62 @@ function castSourceData(toCast, encoding) {
     return fromArrayBuffer(toCast);
 }
 
-let ChecksumStream$1 = class ChecksumStream extends Readable {
+let ChecksumStream$1 = class ChecksumStream extends node_stream.Duplex {
     expectedChecksum;
     checksumSourceLocation;
     checksum;
     source;
     base64Encoder;
+    pendingCallback = null;
     constructor({ expectedChecksum, checksum, source, checksumSourceLocation, base64Encoder, }) {
         super();
-        if (typeof source.pipe !== "function") {
+        if (typeof source.pipe === "function") {
+            this.source = source;
+        }
+        else {
             throw new Error(`@smithy/util-stream: unsupported source type ${source?.constructor?.name ?? source} in ChecksumStream.`);
         }
-        this.source = source;
         this.base64Encoder = base64Encoder ?? toBase64$1;
         this.expectedChecksum = expectedChecksum;
         this.checksum = checksum;
         this.checksumSourceLocation = checksumSourceLocation;
-        this.source.on("data", this.onSourceData);
-        this.source.on("end", this.onSourceEnd);
-        this.source.on("error", this.onSourceError);
-        this.source.on("close", this.onSourceClose);
-        this.source.pause();
-    }
-    onSourceData = (chunk) => {
-        if (this.destroyed) {
-            return;
+        this.source.pipe(this);
+    }
+    _read(size) {
+        if (this.pendingCallback) {
+            const callback = this.pendingCallback;
+            this.pendingCallback = null;
+            callback();
         }
+    }
+    _write(chunk, encoding, callback) {
         try {
             this.checksum.update(chunk);
+            const canPushMore = this.push(chunk);
+            if (!canPushMore) {
+                this.pendingCallback = callback;
+                return;
+            }
         }
         catch (e) {
-            this.destroy(e);
-            return;
-        }
-        if (!this.push(chunk)) {
-            this.source.pause();
-        }
-    };
-    onSourceEnd = async () => {
-        if (this.destroyed) {
-            return;
+            return callback(e);
         }
+        return callback();
+    }
+    async _final(callback) {
         try {
             const digest = await this.checksum.digest();
             const received = this.base64Encoder(digest);
             if (this.expectedChecksum !== received) {
-                this.destroy(new Error(`Checksum mismatch: expected "${this.expectedChecksum}" but received "${received}"` +
+                return callback(new Error(`Checksum mismatch: expected "${this.expectedChecksum}" but received "${received}"` +
                     ` in response header "${this.checksumSourceLocation}".`));
-                return;
             }
         }
         catch (e) {
-            this.destroy(e);
-            return;
+            return callback(e);
         }
         this.push(null);
-    };
-    onSourceError = (error) => {
-        this.destroy(error);
-    };
-    onSourceClose = () => {
-        if (!this.destroyed && !this.source.readableEnded) {
-            this.destroy(new Error("Connection lost or stream closed before all data was received."));
-        }
-    };
-    _read(_size) {
-        this.source.resume();
-    }
-    _destroy(error, callback) {
-        this.source?.removeListener("data", this.onSourceData);
-        this.source?.removeListener("end", this.onSourceEnd);
-        this.source?.removeListener("error", this.onSourceError);
-        this.source?.removeListener("close", this.onSourceClose);
-        this.source?.destroy();
-        callback(error);
+        return callback();
     }
 };
 
@@ -1076,7 +1038,7 @@ const isBlob = (blob) => {
 const fromUtf8 = (input) => new TextEncoder().encode(input);
 
 const chars = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/`;
-Object.entries(chars).reduce((acc, [i, c]) => {
+const alphabetByEncoding = Object.entries(chars).reduce((acc, [i, c]) => {
     acc[c] = Number(i);
     return acc;
 }, {});
@@ -1294,7 +1256,7 @@ function createBufferedReadable(upstream, size, logger) {
     if (isReadableStream(upstream)) {
         return createBufferedReadableStream(upstream, size, logger);
     }
-    const downstream = new Readable({ read() { } });
+    const downstream = new node_stream.Readable({ read() { } });
     let streamBufferingLoggedWarning = false;
     let bytesSeen = 0;
     const buffers = [
@@ -1384,7 +1346,7 @@ function getAwsChunkedEncodingStream(stream, options) {
         checksumLocationName !== undefined &&
         streamHasher !== undefined;
     const digest = checksumRequired ? streamHasher(checksumAlgorithmFn, readable) : undefined;
-    const awsChunkedEncodingStream = new Readable({
+    const awsChunkedEncodingStream = new node_stream.Readable({
         read: () => { },
     });
     readable.on("data", (data) => {
@@ -1454,12 +1416,12 @@ const headStream = (stream, bytes) => {
         });
         collector.on("error", reject);
         collector.on("finish", function () {
-            const bytes = concatBytes(this.buffers);
+            const bytes = new Uint8Array(Buffer.concat(this.buffers));
             resolve(bytes);
         });
     });
 };
-let Collector$1 = class Collector extends Writable {
+let Collector$1 = class Collector extends node_stream.Writable {
     buffers = [];
     limit = Infinity;
     bytesBuffered = 0;
@@ -1486,30 +1448,93 @@ const toUtf8 = (input) => {
     return new TextDecoder("utf-8").decode(input);
 };
 
+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 alphabetByEncoding)) {
+                    throw new TypeError(`Invalid character ${input[j]} in base64 string.`);
+                }
+                bits |= alphabetByEncoding[input[j]] << ((limit - j) * bitsPerLetter);
+                bitLength += bitsPerLetter;
+            }
+            else {
+                bits >>= bitsPerLetter;
+            }
+        }
+        const chunkOffset = (i / 4) * 3;
+        bits >>= bitLength % bitsPerByte;
+        const byteLength = Math.floor(bitLength / bitsPerByte);
+        for (let k = 0; k < byteLength; k++) {
+            const offset = (byteLength - k - 1) * bitsPerByte;
+            dataView.setUint8(chunkOffset + k, (bits & (255 << offset)) >> offset);
+        }
+    }
+    return new Uint8Array(out);
+};
+
 const streamCollector$1 = async (stream) => {
-    if (isBlob(stream)) {
+    if ((typeof Blob === "function" && stream instanceof Blob) || stream.constructor?.name === "Blob") {
+        if (Blob.prototype.arrayBuffer !== undefined) {
+            return new Uint8Array(await stream.arrayBuffer());
+        }
         return collectBlob(stream);
     }
-    return collectReadableStream(stream);
+    return collectStream(stream);
 };
 async function collectBlob(blob) {
-    return blob.arrayBuffer().then((ab) => new Uint8Array(ab));
+    const base64 = await readToBase64(blob);
+    const arrayBuffer = fromBase64(base64);
+    return new Uint8Array(arrayBuffer);
 }
-async function collectReadableStream(stream) {
+async function collectStream(stream) {
     const chunks = [];
     const reader = stream.getReader();
+    let isDone = false;
     let length = 0;
-    while (true) {
+    while (!isDone) {
         const { done, value } = await reader.read();
         if (value) {
             chunks.push(value);
             length += value.length;
         }
-        if (done) {
-            break;
-        }
+        isDone = done;
     }
-    return concatBytes(chunks, length);
+    const collected = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+        collected.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return collected;
+}
+function readToBase64(blob) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onloadend = () => {
+            if (reader.readyState !== 2) {
+                return reject(new Error("Reader aborted too early"));
+            }
+            const result = (reader.result ?? "");
+            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.readAsDataURL(blob);
+    });
 }
 
 const ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED$1 = "The stream has already been transformed.";
@@ -1572,43 +1597,61 @@ const sdkStreamMixin$1 = (stream) => {
 };
 const isBlobInstance = (stream) => typeof Blob === "function" && stream instanceof Blob;
 
-const streamCollector = (stream) => {
-    if (isBlob(stream)) {
-        return collectBlob(stream);
+class Collector extends node_stream.Writable {
+    bufferedBytes = [];
+    _write(chunk, encoding, callback) {
+        this.bufferedBytes.push(chunk);
+        callback();
     }
-    if (isReadableStream(stream)) {
+}
+const isReadableStreamInstance = (stream) => typeof ReadableStream === "function" && stream instanceof ReadableStream;
+async function collectReadableStream(stream) {
+    const chunks = [];
+    const reader = stream.getReader();
+    let isDone = false;
+    let length = 0;
+    while (!isDone) {
+        const { done, value } = await reader.read();
+        if (value) {
+            chunks.push(value);
+            length += value.length;
+        }
+        isDone = done;
+    }
+    const collected = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+        collected.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return collected;
+}
+const streamCollector = (stream) => {
+    if (isReadableStreamInstance(stream)) {
         return collectReadableStream(stream);
     }
     return new Promise((resolve, reject) => {
         const collector = new Collector();
-        const nodeStream = stream;
-        nodeStream.pipe(collector);
-        nodeStream.on("error", (err) => {
+        stream.pipe(collector);
+        stream.on("error", (err) => {
             collector.end();
             reject(err);
         });
         collector.on("error", reject);
         collector.on("finish", function () {
-            const bytes = concatBytes(this.bufferedBytes);
+            const bytes = new Uint8Array(Buffer.concat(this.bufferedBytes));
             resolve(bytes);
         });
     });
 };
-class Collector extends Writable {
-    bufferedBytes = [];
-    _write(chunk, encoding, callback) {
-        this.bufferedBytes.push(chunk);
-        callback();
-    }
-}
 
 const ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED = "The stream has already been transformed.";
 const sdkStreamMixin = (stream) => {
-    if (!(stream instanceof Readable)) {
+    if (!(stream instanceof node_stream.Readable)) {
         try {
             return sdkStreamMixin$1(stream);
         }
-        catch (ignored) {
+        catch (e) {
             const name = stream?.__proto__?.constructor?.name || stream;
             throw new Error(`Unexpected stream implementation, expect Stream.Readable instance, got ${name}`);
         }
@@ -1640,11 +1683,11 @@ const sdkStreamMixin = (stream) => {
             if (stream.readableFlowing !== null) {
                 throw new Error("The stream has been consumed by other callbacks.");
             }
-            if (typeof Readable.toWeb !== "function") {
+            if (typeof node_stream.Readable.toWeb !== "function") {
                 throw new Error("Readable.toWeb() is not supported. Please ensure a polyfill is available.");
             }
             transformed = true;
-            return Readable.toWeb(stream);
+            return node_stream.Readable.toWeb(stream);
         },
     });
 };
@@ -1661,16 +1704,16 @@ async function splitStream(stream) {
     if (isReadableStream(stream) || isBlob(stream)) {
         return splitStream$1(stream);
     }
-    const stream1 = new PassThrough();
-    const stream2 = new PassThrough();
+    const stream1 = new node_stream.PassThrough();
+    const stream2 = new node_stream.PassThrough();
     stream.pipe(stream1);
     stream.pipe(stream2);
     return [stream1, stream2];
 }
 
-class Uint8ArrayBlobAdapter extends bindUint8ArrayBlobAdapter(toUtf8$1, fromUtf8$1, toBase64$1, fromBase64) {
+class Uint8ArrayBlobAdapter extends bindUint8ArrayBlobAdapter(toUtf8$1, fromUtf8$1, toBase64$1, fromBase64$1) {
 }
-const _getRandomValues = getRandomValues;
+const _getRandomValues = node_crypto.getRandomValues;
 const v4 = bindV4(_getRandomValues);
 const generateIdempotencyToken = v4;
 
@@ -1683,7 +1726,6 @@ exports._parseEpochTimestamp = _parseEpochTimestamp;
 exports._parseRfc3339DateTimeWithOffset = _parseRfc3339DateTimeWithOffset;
 exports._parseRfc7231DateTime = _parseRfc7231DateTime;
 exports.calculateBodyLength = calculateBodyLength;
-exports.concatBytes = concatBytes;
 exports.copyDocumentWithTransform = copyDocumentWithTransform;
 exports.createBufferedReadable = createBufferedReadable;
 exports.createChecksumStream = createChecksumStream;
@@ -1703,7 +1745,7 @@ exports.expectShort = expectShort;
 exports.expectString = expectString;
 exports.expectUnion = expectUnion;
 exports.fromArrayBuffer = fromArrayBuffer;
-exports.fromBase64 = fromBase64;
+exports.fromBase64 = fromBase64$1;
 exports.fromHex = fromHex;
 exports.fromString = fromString;
 exports.fromUtf8 = fromUtf8$1;
@@ -1732,7 +1774,6 @@ exports.serializerMiddlewareOption = serializerMiddlewareOption;
 exports.splitEvery = splitEvery;
 exports.splitHeader = splitHeader;
 exports.splitStream = splitStream;
-exports.streamCollector = streamCollector;
 exports.strictParseByte = strictParseByte;
 exports.strictParseDouble = strictParseDouble;
 exports.strictParseFloat = strictParseFloat;