@aws-sdk/lib-storage 3.903.0 → 3.906.0

package/dist-cjs/index.js

@@ -1,572 +1,512 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  Upload: () => Upload
-});
-module.exports = __toCommonJS(index_exports);
+'use strict';
 
-// src/Upload.ts
-var import_client_s3 = require("@aws-sdk/client-s3");
-var import_abort_controller = require("@smithy/abort-controller");
-var import_middleware_endpoint = require("@smithy/middleware-endpoint");
-var import_smithy_client = require("@smithy/smithy-client");
-var import_events = require("events");
+var clientS3 = require('@aws-sdk/client-s3');
+var abortController = require('@smithy/abort-controller');
+var middlewareEndpoint = require('@smithy/middleware-endpoint');
+var smithyClient = require('@smithy/smithy-client');
+var events = require('events');
+var buffer = require('buffer');
+var runtimeConfig = require('./runtimeConfig');
+var stream = require('stream');
 
-// src/byteLength.ts
-var import_buffer = require("buffer");
-var import_runtimeConfig = require("././runtimeConfig");
-var byteLength = /* @__PURE__ */ __name((input) => {
-  if (input == null) {
-    return 0;
-  }
-  if (typeof input === "string") {
-    return import_buffer.Buffer.byteLength(input);
-  }
-  if (typeof input.byteLength === "number") {
-    return input.byteLength;
-  } else if (typeof input.length === "number") {
-    return input.length;
-  } else if (typeof input.size === "number") {
-    return input.size;
-  } else if (typeof input.start === "number" && typeof input.end === "number") {
-    return input.end + 1 - input.start;
-  } else if (typeof input.path === "string") {
-    try {
-      return import_runtimeConfig.runtimeConfig.lstatSync(input.path).size;
-    } catch (error) {
-      return void 0;
+const byteLength = (input) => {
+    if (input == null) {
+        return 0;
     }
-  }
-  return void 0;
-}, "byteLength");
-
-// src/byteLengthSource.ts
-var import_runtimeConfig2 = require("././runtimeConfig");
-var byteLengthSource = /* @__PURE__ */ __name((input, override) => {
-  if (override != null) {
-    return "the ContentLength property of the params set by the caller" /* CONTENT_LENGTH */;
-  }
-  if (input == null) {
-    return "a null or undefined Body" /* EMPTY_INPUT */;
-  }
-  if (typeof input === "string") {
-    return "the encoded byte length of the Body string" /* STRING_LENGTH */;
-  }
-  if (typeof input.byteLength === "number") {
-    return "the byteLength of a typed byte array such as Uint8Array" /* TYPED_ARRAY */;
-  } else if (typeof input.length === "number") {
-    return "the value of Body.length" /* LENGTH */;
-  } else if (typeof input.size === "number") {
-    return "the value of Body.size" /* SIZE */;
-  } else if (typeof input.start === "number" && typeof input.end === "number") {
-    return "the numeric difference between Body.start and Body.end" /* START_END_DIFF */;
-  } else if (typeof input.path === "string") {
-    try {
-      import_runtimeConfig2.runtimeConfig.lstatSync(input.path).size;
-      return "the size of the file given by Body.path on disk as reported by lstatSync" /* LSTAT */;
-    } catch (error) {
-      return void 0;
-    }
-  }
-  return void 0;
-}, "byteLengthSource");
-
-// src/chunker.ts
-
-var import_stream = require("stream");
+    if (typeof input === "string") {
+        return buffer.Buffer.byteLength(input);
+    }
+    if (typeof input.byteLength === "number") {
+        return input.byteLength;
+    }
+    else if (typeof input.length === "number") {
+        return input.length;
+    }
+    else if (typeof input.size === "number") {
+        return input.size;
+    }
+    else if (typeof input.start === "number" && typeof input.end === "number") {
+        return input.end + 1 - input.start;
+    }
+    else if (runtimeConfig.runtimeConfig.isFileReadStream(input)) {
+        try {
+            return runtimeConfig.runtimeConfig.lstatSync(input.path).size;
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+    return undefined;
+};
 
-// src/chunks/getChunkStream.ts
+var BYTE_LENGTH_SOURCE;
+(function (BYTE_LENGTH_SOURCE) {
+    BYTE_LENGTH_SOURCE["EMPTY_INPUT"] = "a null or undefined Body";
+    BYTE_LENGTH_SOURCE["CONTENT_LENGTH"] = "the ContentLength property of the params set by the caller";
+    BYTE_LENGTH_SOURCE["STRING_LENGTH"] = "the encoded byte length of the Body string";
+    BYTE_LENGTH_SOURCE["TYPED_ARRAY"] = "the byteLength of a typed byte array such as Uint8Array";
+    BYTE_LENGTH_SOURCE["LENGTH"] = "the value of Body.length";
+    BYTE_LENGTH_SOURCE["SIZE"] = "the value of Body.size";
+    BYTE_LENGTH_SOURCE["START_END_DIFF"] = "the numeric difference between Body.start and Body.end";
+    BYTE_LENGTH_SOURCE["LSTAT"] = "the size of the file given by Body.path on disk as reported by lstatSync";
+})(BYTE_LENGTH_SOURCE || (BYTE_LENGTH_SOURCE = {}));
+const byteLengthSource = (input, override) => {
+    if (override != null) {
+        return BYTE_LENGTH_SOURCE.CONTENT_LENGTH;
+    }
+    if (input == null) {
+        return BYTE_LENGTH_SOURCE.EMPTY_INPUT;
+    }
+    if (typeof input === "string") {
+        return BYTE_LENGTH_SOURCE.STRING_LENGTH;
+    }
+    if (typeof input.byteLength === "number") {
+        return BYTE_LENGTH_SOURCE.TYPED_ARRAY;
+    }
+    else if (typeof input.length === "number") {
+        return BYTE_LENGTH_SOURCE.LENGTH;
+    }
+    else if (typeof input.size === "number") {
+        return BYTE_LENGTH_SOURCE.SIZE;
+    }
+    else if (typeof input.start === "number" && typeof input.end === "number") {
+        return BYTE_LENGTH_SOURCE.START_END_DIFF;
+    }
+    else if (runtimeConfig.runtimeConfig.isFileReadStream(input)) {
+        try {
+            runtimeConfig.runtimeConfig.lstatSync(input.path).size;
+            return BYTE_LENGTH_SOURCE.LSTAT;
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+    return undefined;
+};
 
 async function* getChunkStream(data, partSize, getNextData) {
-  let partNumber = 1;
-  const currentBuffer = { chunks: [], length: 0 };
-  for await (const datum of getNextData(data)) {
-    currentBuffer.chunks.push(datum);
-    currentBuffer.length += datum.byteLength;
-    while (currentBuffer.length > partSize) {
-      const dataChunk = currentBuffer.chunks.length > 1 ? import_buffer.Buffer.concat(currentBuffer.chunks) : currentBuffer.chunks[0];
-      yield {
+    let partNumber = 1;
+    const currentBuffer = { chunks: [], length: 0 };
+    for await (const datum of getNextData(data)) {
+        currentBuffer.chunks.push(datum);
+        currentBuffer.length += datum.byteLength;
+        while (currentBuffer.length > partSize) {
+            const dataChunk = currentBuffer.chunks.length > 1 ? buffer.Buffer.concat(currentBuffer.chunks) : currentBuffer.chunks[0];
+            yield {
+                partNumber,
+                data: dataChunk.subarray(0, partSize),
+            };
+            currentBuffer.chunks = [dataChunk.subarray(partSize)];
+            currentBuffer.length = currentBuffer.chunks[0].byteLength;
+            partNumber += 1;
+        }
+    }
+    yield {
         partNumber,
-        data: dataChunk.subarray(0, partSize)
-      };
-      currentBuffer.chunks = [dataChunk.subarray(partSize)];
-      currentBuffer.length = currentBuffer.chunks[0].byteLength;
-      partNumber += 1;
-    }
-  }
-  yield {
-    partNumber,
-    data: currentBuffer.chunks.length !== 1 ? import_buffer.Buffer.concat(currentBuffer.chunks) : currentBuffer.chunks[0],
-    lastPart: true
-  };
+        data: currentBuffer.chunks.length !== 1 ? buffer.Buffer.concat(currentBuffer.chunks) : currentBuffer.chunks[0],
+        lastPart: true,
+    };
 }
-__name(getChunkStream, "getChunkStream");
 
-// src/chunks/getChunkUint8Array.ts
 async function* getChunkUint8Array(data, partSize) {
-  let partNumber = 1;
-  let startByte = 0;
-  let endByte = partSize;
-  while (endByte < data.byteLength) {
+    let partNumber = 1;
+    let startByte = 0;
+    let endByte = partSize;
+    while (endByte < data.byteLength) {
+        yield {
+            partNumber,
+            data: data.subarray(startByte, endByte),
+        };
+        partNumber += 1;
+        startByte = endByte;
+        endByte = startByte + partSize;
+    }
     yield {
-      partNumber,
-      data: data.subarray(startByte, endByte)
+        partNumber,
+        data: data.subarray(startByte),
+        lastPart: true,
     };
-    partNumber += 1;
-    startByte = endByte;
-    endByte = startByte + partSize;
-  }
-  yield {
-    partNumber,
-    data: data.subarray(startByte),
-    lastPart: true
-  };
 }
-__name(getChunkUint8Array, "getChunkUint8Array");
-
-// src/chunks/getDataReadable.ts
 
 async function* getDataReadable(data) {
-  for await (const chunk of data) {
-    if (import_buffer.Buffer.isBuffer(chunk) || chunk instanceof Uint8Array) {
-      yield chunk;
-    } else {
-      yield import_buffer.Buffer.from(chunk);
+    for await (const chunk of data) {
+        if (buffer.Buffer.isBuffer(chunk) || chunk instanceof Uint8Array) {
+            yield chunk;
+        }
+        else {
+            yield buffer.Buffer.from(chunk);
+        }
     }
-  }
 }
-__name(getDataReadable, "getDataReadable");
-
-// src/chunks/getDataReadableStream.ts
 
 async function* getDataReadableStream(data) {
-  const reader = data.getReader();
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) {
-        return;
-      }
-      if (import_buffer.Buffer.isBuffer(value) || value instanceof Uint8Array) {
-        yield value;
-      } else {
-        yield import_buffer.Buffer.from(value);
-      }
-    }
-  } catch (e) {
-    throw e;
-  } finally {
-    reader.releaseLock();
-  }
+    const reader = data.getReader();
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                return;
+            }
+            if (buffer.Buffer.isBuffer(value) || value instanceof Uint8Array) {
+                yield value;
+            }
+            else {
+                yield buffer.Buffer.from(value);
+            }
+        }
+    }
+    catch (e) {
+        throw e;
+    }
+    finally {
+        reader.releaseLock();
+    }
 }
-__name(getDataReadableStream, "getDataReadableStream");
 
-// src/chunker.ts
-var getChunk = /* @__PURE__ */ __name((data, partSize) => {
-  if (data instanceof Uint8Array) {
-    return getChunkUint8Array(data, partSize);
-  }
-  if (data instanceof import_stream.Readable) {
-    return getChunkStream(data, partSize, getDataReadable);
-  }
-  if (data instanceof String || typeof data === "string") {
-    return getChunkUint8Array(import_buffer.Buffer.from(data), partSize);
-  }
-  if (typeof data.stream === "function") {
-    return getChunkStream(data.stream(), partSize, getDataReadableStream);
-  }
-  if (data instanceof ReadableStream) {
-    return getChunkStream(data, partSize, getDataReadableStream);
-  }
-  throw new Error(
-    "Body Data is unsupported format, expected data to be one of: string | Uint8Array | Buffer | Readable | ReadableStream | Blob;."
-  );
-}, "getChunk");
+const getChunk = (data, partSize) => {
+    if (data instanceof Uint8Array) {
+        return getChunkUint8Array(data, partSize);
+    }
+    if (data instanceof stream.Readable) {
+        return getChunkStream(data, partSize, getDataReadable);
+    }
+    if (data instanceof String || typeof data === "string") {
+        return getChunkUint8Array(buffer.Buffer.from(data), partSize);
+    }
+    if (typeof data.stream === "function") {
+        return getChunkStream(data.stream(), partSize, getDataReadableStream);
+    }
+    if (data instanceof ReadableStream) {
+        return getChunkStream(data, partSize, getDataReadableStream);
+    }
+    throw new Error("Body Data is unsupported format, expected data to be one of: string | Uint8Array | Buffer | Readable | ReadableStream | Blob;.");
+};
 
-// src/Upload.ts
-var Upload = class _Upload extends import_events.EventEmitter {
-  static {
-    __name(this, "Upload");
-  }
-  /**
-   * @internal
-   * modified in testing only.
-   */
-  static MIN_PART_SIZE = 1024 * 1024 * 5;
-  /**
-   * S3 multipart upload does not allow more than 10,000 parts.
-   */
-  MAX_PARTS = 1e4;
-  // Defaults.
-  queueSize = 4;
-  partSize;
-  leavePartsOnError = false;
-  tags = [];
-  client;
-  params;
-  // used for reporting progress.
-  totalBytes;
-  totalBytesSource;
-  bytesUploadedSoFar;
-  // used in the upload.
-  abortController;
-  concurrentUploaders = [];
-  createMultiPartPromise;
-  abortMultipartUploadCommand = null;
-  uploadedParts = [];
-  uploadEnqueuedPartsCount = 0;
-  expectedPartsCount;
-  /**
-   * Last UploadId if the upload was done with MultipartUpload and not PutObject.
-   */
-  uploadId;
-  uploadEvent;
-  isMultiPart = true;
-  singleUploadResult;
-  sent = false;
-  constructor(options) {
-    super();
-    this.queueSize = options.queueSize || this.queueSize;
-    this.leavePartsOnError = options.leavePartsOnError || this.leavePartsOnError;
-    this.tags = options.tags || this.tags;
-    this.client = options.client;
-    this.params = options.params;
-    if (!this.params) {
-      throw new Error(`InputError: Upload requires params to be passed to upload.`);
-    }
-    this.totalBytes = this.params.ContentLength ?? byteLength(this.params.Body);
-    this.totalBytesSource = byteLengthSource(this.params.Body, this.params.ContentLength);
-    this.bytesUploadedSoFar = 0;
-    this.abortController = options.abortController ?? new import_abort_controller.AbortController();
-    this.partSize = options.partSize || Math.max(_Upload.MIN_PART_SIZE, Math.floor((this.totalBytes || 0) / this.MAX_PARTS));
-    if (this.totalBytes !== void 0) {
-      this.expectedPartsCount = Math.ceil(this.totalBytes / this.partSize);
-    }
-    this.__validateInput();
-  }
-  async abort() {
-    this.abortController.abort();
-  }
-  async done() {
-    if (this.sent) {
-      throw new Error(
-        "@aws-sdk/lib-storage: this instance of Upload has already executed .done(). Create a new instance."
-      );
-    }
-    this.sent = true;
-    return await Promise.race([this.__doMultipartUpload(), this.__abortTimeout(this.abortController.signal)]);
-  }
-  on(event, listener) {
-    this.uploadEvent = event;
-    return super.on(event, listener);
-  }
-  async __uploadUsingPut(dataPart) {
-    this.isMultiPart = false;
-    const params = { ...this.params, Body: dataPart.data };
-    const clientConfig = this.client.config;
-    const requestHandler = clientConfig.requestHandler;
-    const eventEmitter = requestHandler instanceof import_events.EventEmitter ? requestHandler : null;
-    const uploadEventListener = /* @__PURE__ */ __name((event) => {
-      this.bytesUploadedSoFar = event.loaded;
-      this.totalBytes = event.total;
-      this.__notifyProgress({
-        loaded: this.bytesUploadedSoFar,
-        total: this.totalBytes,
-        part: dataPart.partNumber,
-        Key: this.params.Key,
-        Bucket: this.params.Bucket
-      });
-    }, "uploadEventListener");
-    if (eventEmitter !== null) {
-      eventEmitter.on("xhr.upload.progress", uploadEventListener);
-    }
-    const resolved = await Promise.all([this.client.send(new import_client_s3.PutObjectCommand(params)), clientConfig?.endpoint?.()]);
-    const putResult = resolved[0];
-    let endpoint = resolved[1];
-    if (!endpoint) {
-      endpoint = (0, import_middleware_endpoint.toEndpointV1)(
-        await (0, import_middleware_endpoint.getEndpointFromInstructions)(params, import_client_s3.PutObjectCommand, {
-          ...clientConfig
-        })
-      );
-    }
-    if (!endpoint) {
-      throw new Error('Could not resolve endpoint from S3 "client.config.endpoint()" nor EndpointsV2.');
-    }
-    if (eventEmitter !== null) {
-      eventEmitter.off("xhr.upload.progress", uploadEventListener);
-    }
-    const locationKey = this.params.Key.split("/").map((segment) => (0, import_smithy_client.extendedEncodeURIComponent)(segment)).join("/");
-    const locationBucket = (0, import_smithy_client.extendedEncodeURIComponent)(this.params.Bucket);
-    const Location = (() => {
-      const endpointHostnameIncludesBucket = endpoint.hostname.startsWith(`${locationBucket}.`);
-      const forcePathStyle = this.client.config.forcePathStyle;
-      const optionalPort = endpoint.port ? `:${endpoint.port}` : ``;
-      if (forcePathStyle) {
-        return `${endpoint.protocol}//${endpoint.hostname}${optionalPort}/${locationBucket}/${locationKey}`;
-      }
-      if (endpointHostnameIncludesBucket) {
-        return `${endpoint.protocol}//${endpoint.hostname}${optionalPort}/${locationKey}`;
-      }
-      return `${endpoint.protocol}//${locationBucket}.${endpoint.hostname}${optionalPort}/${locationKey}`;
-    })();
-    this.singleUploadResult = {
-      ...putResult,
-      Bucket: this.params.Bucket,
-      Key: this.params.Key,
-      Location
-    };
-    const totalSize = byteLength(dataPart.data);
-    this.__notifyProgress({
-      loaded: totalSize,
-      total: totalSize,
-      part: 1,
-      Key: this.params.Key,
-      Bucket: this.params.Bucket
-    });
-  }
-  async __createMultipartUpload() {
-    const requestChecksumCalculation = await this.client.config.requestChecksumCalculation();
-    if (!this.createMultiPartPromise) {
-      const createCommandParams = { ...this.params, Body: void 0 };
-      if (requestChecksumCalculation === "WHEN_SUPPORTED") {
-        createCommandParams.ChecksumAlgorithm = this.params.ChecksumAlgorithm || import_client_s3.ChecksumAlgorithm.CRC32;
-      }
-      this.createMultiPartPromise = this.client.send(new import_client_s3.CreateMultipartUploadCommand(createCommandParams)).then((createMpuResponse) => {
-        this.abortMultipartUploadCommand = new import_client_s3.AbortMultipartUploadCommand({
-          Bucket: this.params.Bucket,
-          Key: this.params.Key,
-          UploadId: createMpuResponse.UploadId
-        });
-        return createMpuResponse;
-      });
-    }
-    return this.createMultiPartPromise;
-  }
-  async __doConcurrentUpload(dataFeeder) {
-    for await (const dataPart of dataFeeder) {
-      if (this.uploadEnqueuedPartsCount > this.MAX_PARTS) {
-        throw new Error(
-          `Exceeded ${this.MAX_PARTS} parts in multipart upload to Bucket: ${this.params.Bucket} Key: ${this.params.Key}.`
-        );
-      }
-      if (this.abortController.signal.aborted) {
-        return;
-      }
-      if (dataPart.partNumber === 1 && dataPart.lastPart) {
-        return await this.__uploadUsingPut(dataPart);
-      }
-      if (!this.uploadId) {
-        const { UploadId } = await this.__createMultipartUpload();
-        this.uploadId = UploadId;
-        if (this.abortController.signal.aborted) {
-          return;
+class Upload extends events.EventEmitter {
+    static MIN_PART_SIZE = 1024 * 1024 * 5;
+    MAX_PARTS = 10_000;
+    queueSize = 4;
+    partSize;
+    leavePartsOnError = false;
+    tags = [];
+    client;
+    params;
+    totalBytes;
+    totalBytesSource;
+    bytesUploadedSoFar;
+    abortController;
+    concurrentUploaders = [];
+    createMultiPartPromise;
+    abortMultipartUploadCommand = null;
+    uploadedParts = [];
+    uploadEnqueuedPartsCount = 0;
+    expectedPartsCount;
+    uploadId;
+    uploadEvent;
+    isMultiPart = true;
+    singleUploadResult;
+    sent = false;
+    constructor(options) {
+        super();
+        this.queueSize = options.queueSize || this.queueSize;
+        this.leavePartsOnError = options.leavePartsOnError || this.leavePartsOnError;
+        this.tags = options.tags || this.tags;
+        this.client = options.client;
+        this.params = options.params;
+        if (!this.params) {
+            throw new Error(`InputError: Upload requires params to be passed to upload.`);
+        }
+        this.totalBytes = this.params.ContentLength ?? byteLength(this.params.Body);
+        this.totalBytesSource = byteLengthSource(this.params.Body, this.params.ContentLength);
+        this.bytesUploadedSoFar = 0;
+        this.abortController = options.abortController ?? new abortController.AbortController();
+        this.partSize =
+            options.partSize || Math.max(Upload.MIN_PART_SIZE, Math.floor((this.totalBytes || 0) / this.MAX_PARTS));
+        if (this.totalBytes !== undefined) {
+            this.expectedPartsCount = Math.ceil(this.totalBytes / this.partSize);
+        }
+        this.__validateInput();
+    }
+    async abort() {
+        this.abortController.abort();
+    }
+    async done() {
+        if (this.sent) {
+            throw new Error("@aws-sdk/lib-storage: this instance of Upload has already executed .done(). Create a new instance.");
         }
-      }
-      const partSize = byteLength(dataPart.data) || 0;
-      const requestHandler = this.client.config.requestHandler;
-      const eventEmitter = requestHandler instanceof import_events.EventEmitter ? requestHandler : null;
-      let lastSeenBytes = 0;
-      const uploadEventListener = /* @__PURE__ */ __name((event, request) => {
-        const requestPartSize = Number(request.query["partNumber"]) || -1;
-        if (requestPartSize !== dataPart.partNumber) {
-          return;
+        this.sent = true;
+        return await Promise.race([this.__doMultipartUpload(), this.__abortTimeout(this.abortController.signal)]);
+    }
+    on(event, listener) {
+        this.uploadEvent = event;
+        return super.on(event, listener);
+    }
+    async __uploadUsingPut(dataPart) {
+        this.isMultiPart = false;
+        const params = { ...this.params, Body: dataPart.data };
+        const clientConfig = this.client.config;
+        const requestHandler = clientConfig.requestHandler;
+        const eventEmitter = requestHandler instanceof events.EventEmitter ? requestHandler : null;
+        const uploadEventListener = (event) => {
+            this.bytesUploadedSoFar = event.loaded;
+            this.totalBytes = event.total;
+            this.__notifyProgress({
+                loaded: this.bytesUploadedSoFar,
+                total: this.totalBytes,
+                part: dataPart.partNumber,
+                Key: this.params.Key,
+                Bucket: this.params.Bucket,
+            });
+        };
+        if (eventEmitter !== null) {
+            eventEmitter.on("xhr.upload.progress", uploadEventListener);
+        }
+        const resolved = await Promise.all([this.client.send(new clientS3.PutObjectCommand(params)), clientConfig?.endpoint?.()]);
+        const putResult = resolved[0];
+        let endpoint = resolved[1];
+        if (!endpoint) {
+            endpoint = middlewareEndpoint.toEndpointV1(await middlewareEndpoint.getEndpointFromInstructions(params, clientS3.PutObjectCommand, {
+                ...clientConfig,
+            }));
         }
-        if (event.total && partSize) {
-          this.bytesUploadedSoFar += event.loaded - lastSeenBytes;
-          lastSeenBytes = event.loaded;
+        if (!endpoint) {
+            throw new Error('Could not resolve endpoint from S3 "client.config.endpoint()" nor EndpointsV2.');
         }
+        if (eventEmitter !== null) {
+            eventEmitter.off("xhr.upload.progress", uploadEventListener);
+        }
+        const locationKey = this.params
+            .Key.split("/")
+            .map((segment) => smithyClient.extendedEncodeURIComponent(segment))
+            .join("/");
+        const locationBucket = smithyClient.extendedEncodeURIComponent(this.params.Bucket);
+        const Location = (() => {
+            const endpointHostnameIncludesBucket = endpoint.hostname.startsWith(`${locationBucket}.`);
+            const forcePathStyle = this.client.config.forcePathStyle;
+            const optionalPort = endpoint.port ? `:${endpoint.port}` : ``;
+            if (forcePathStyle) {
+                return `${endpoint.protocol}//${endpoint.hostname}${optionalPort}/${locationBucket}/${locationKey}`;
+            }
+            if (endpointHostnameIncludesBucket) {
+                return `${endpoint.protocol}//${endpoint.hostname}${optionalPort}/${locationKey}`;
+            }
+            return `${endpoint.protocol}//${locationBucket}.${endpoint.hostname}${optionalPort}/${locationKey}`;
+        })();
+        this.singleUploadResult = {
+            ...putResult,
+            Bucket: this.params.Bucket,
+            Key: this.params.Key,
+            Location,
+        };
+        const totalSize = byteLength(dataPart.data);
         this.__notifyProgress({
-          loaded: this.bytesUploadedSoFar,
-          total: this.totalBytes,
-          part: dataPart.partNumber,
-          Key: this.params.Key,
-          Bucket: this.params.Bucket
+            loaded: totalSize,
+            total: totalSize,
+            part: 1,
+            Key: this.params.Key,
+            Bucket: this.params.Bucket,
         });
-      }, "uploadEventListener");
-      if (eventEmitter !== null) {
-        eventEmitter.on("xhr.upload.progress", uploadEventListener);
-      }
-      this.uploadEnqueuedPartsCount += 1;
-      this.__validateUploadPart(dataPart);
-      const partResult = await this.client.send(
-        new import_client_s3.UploadPartCommand({
-          ...this.params,
-          // dataPart.data is chunked into a non-streaming buffer
-          // so the ContentLength from the input should not be used for MPU.
-          ContentLength: void 0,
-          UploadId: this.uploadId,
-          Body: dataPart.data,
-          PartNumber: dataPart.partNumber
-        })
-      );
-      if (eventEmitter !== null) {
-        eventEmitter.off("xhr.upload.progress", uploadEventListener);
-      }
-      if (this.abortController.signal.aborted) {
-        return;
-      }
-      if (!partResult.ETag) {
-        throw new Error(
-          `Part ${dataPart.partNumber} is missing ETag in UploadPart response. Missing Bucket CORS configuration for ETag header?`
-        );
-      }
-      this.uploadedParts.push({
-        PartNumber: dataPart.partNumber,
-        ETag: partResult.ETag,
-        ...partResult.ChecksumCRC32 && { ChecksumCRC32: partResult.ChecksumCRC32 },
-        ...partResult.ChecksumCRC32C && { ChecksumCRC32C: partResult.ChecksumCRC32C },
-        ...partResult.ChecksumSHA1 && { ChecksumSHA1: partResult.ChecksumSHA1 },
-        ...partResult.ChecksumSHA256 && { ChecksumSHA256: partResult.ChecksumSHA256 }
-      });
-      if (eventEmitter === null) {
-        this.bytesUploadedSoFar += partSize;
-      }
-      this.__notifyProgress({
-        loaded: this.bytesUploadedSoFar,
-        total: this.totalBytes,
-        part: dataPart.partNumber,
-        Key: this.params.Key,
-        Bucket: this.params.Bucket
-      });
-    }
-  }
-  async __doMultipartUpload() {
-    const dataFeeder = getChunk(this.params.Body, this.partSize);
-    const concurrentUploaderFailures = [];
-    for (let index = 0; index < this.queueSize; index++) {
-      const currentUpload = this.__doConcurrentUpload(dataFeeder).catch((err) => {
-        concurrentUploaderFailures.push(err);
-      });
-      this.concurrentUploaders.push(currentUpload);
-    }
-    await Promise.all(this.concurrentUploaders);
-    if (concurrentUploaderFailures.length >= 1) {
-      await this.markUploadAsAborted();
-      throw concurrentUploaderFailures[0];
-    }
-    if (this.abortController.signal.aborted) {
-      await this.markUploadAsAborted();
-      throw Object.assign(new Error("Upload aborted."), { name: "AbortError" });
-    }
-    let result;
-    if (this.isMultiPart) {
-      const { expectedPartsCount, uploadedParts, totalBytes, totalBytesSource } = this;
-      if (totalBytes !== void 0 && expectedPartsCount !== void 0 && uploadedParts.length !== expectedPartsCount) {
-        throw new Error(`Expected ${expectedPartsCount} part(s) but uploaded ${uploadedParts.length} part(s).
+    }
+    async __createMultipartUpload() {
+        const requestChecksumCalculation = await this.client.config.requestChecksumCalculation();
+        if (!this.createMultiPartPromise) {
+            const createCommandParams = { ...this.params, Body: undefined };
+            if (requestChecksumCalculation === "WHEN_SUPPORTED") {
+                createCommandParams.ChecksumAlgorithm = this.params.ChecksumAlgorithm || clientS3.ChecksumAlgorithm.CRC32;
+            }
+            this.createMultiPartPromise = this.client
+                .send(new clientS3.CreateMultipartUploadCommand(createCommandParams))
+                .then((createMpuResponse) => {
+                this.abortMultipartUploadCommand = new clientS3.AbortMultipartUploadCommand({
+                    Bucket: this.params.Bucket,
+                    Key: this.params.Key,
+                    UploadId: createMpuResponse.UploadId,
+                });
+                return createMpuResponse;
+            });
+        }
+        return this.createMultiPartPromise;
+    }
+    async __doConcurrentUpload(dataFeeder) {
+        for await (const dataPart of dataFeeder) {
+            if (this.uploadEnqueuedPartsCount > this.MAX_PARTS) {
+                throw new Error(`Exceeded ${this.MAX_PARTS} parts in multipart upload to Bucket: ${this.params.Bucket} Key: ${this.params.Key}.`);
+            }
+            if (this.abortController.signal.aborted) {
+                return;
+            }
+            if (dataPart.partNumber === 1 && dataPart.lastPart) {
+                return await this.__uploadUsingPut(dataPart);
+            }
+            if (!this.uploadId) {
+                const { UploadId } = await this.__createMultipartUpload();
+                this.uploadId = UploadId;
+                if (this.abortController.signal.aborted) {
+                    return;
+                }
+            }
+            const partSize = byteLength(dataPart.data) || 0;
+            const requestHandler = this.client.config.requestHandler;
+            const eventEmitter = requestHandler instanceof events.EventEmitter ? requestHandler : null;
+            let lastSeenBytes = 0;
+            const uploadEventListener = (event, request) => {
+                const requestPartSize = Number(request.query["partNumber"]) || -1;
+                if (requestPartSize !== dataPart.partNumber) {
+                    return;
+                }
+                if (event.total && partSize) {
+                    this.bytesUploadedSoFar += event.loaded - lastSeenBytes;
+                    lastSeenBytes = event.loaded;
+                }
+                this.__notifyProgress({
+                    loaded: this.bytesUploadedSoFar,
+                    total: this.totalBytes,
+                    part: dataPart.partNumber,
+                    Key: this.params.Key,
+                    Bucket: this.params.Bucket,
+                });
+            };
+            if (eventEmitter !== null) {
+                eventEmitter.on("xhr.upload.progress", uploadEventListener);
+            }
+            this.uploadEnqueuedPartsCount += 1;
+            this.__validateUploadPart(dataPart);
+            const partResult = await this.client.send(new clientS3.UploadPartCommand({
+                ...this.params,
+                ContentLength: undefined,
+                UploadId: this.uploadId,
+                Body: dataPart.data,
+                PartNumber: dataPart.partNumber,
+            }));
+            if (eventEmitter !== null) {
+                eventEmitter.off("xhr.upload.progress", uploadEventListener);
+            }
+            if (this.abortController.signal.aborted) {
+                return;
+            }
+            if (!partResult.ETag) {
+                throw new Error(`Part ${dataPart.partNumber} is missing ETag in UploadPart response. Missing Bucket CORS configuration for ETag header?`);
+            }
+            this.uploadedParts.push({
+                PartNumber: dataPart.partNumber,
+                ETag: partResult.ETag,
+                ...(partResult.ChecksumCRC32 && { ChecksumCRC32: partResult.ChecksumCRC32 }),
+                ...(partResult.ChecksumCRC32C && { ChecksumCRC32C: partResult.ChecksumCRC32C }),
+                ...(partResult.ChecksumSHA1 && { ChecksumSHA1: partResult.ChecksumSHA1 }),
+                ...(partResult.ChecksumSHA256 && { ChecksumSHA256: partResult.ChecksumSHA256 }),
+            });
+            if (eventEmitter === null) {
+                this.bytesUploadedSoFar += partSize;
+            }
+            this.__notifyProgress({
+                loaded: this.bytesUploadedSoFar,
+                total: this.totalBytes,
+                part: dataPart.partNumber,
+                Key: this.params.Key,
+                Bucket: this.params.Bucket,
+            });
+        }
+    }
+    async __doMultipartUpload() {
+        const dataFeeder = getChunk(this.params.Body, this.partSize);
+        const concurrentUploaderFailures = [];
+        for (let index = 0; index < this.queueSize; index++) {
+            const currentUpload = this.__doConcurrentUpload(dataFeeder).catch((err) => {
+                concurrentUploaderFailures.push(err);
+            });
+            this.concurrentUploaders.push(currentUpload);
+        }
+        await Promise.all(this.concurrentUploaders);
+        if (concurrentUploaderFailures.length >= 1) {
+            await this.markUploadAsAborted();
+            throw concurrentUploaderFailures[0];
+        }
+        if (this.abortController.signal.aborted) {
+            await this.markUploadAsAborted();
+            throw Object.assign(new Error("Upload aborted."), { name: "AbortError" });
+        }
+        let result;
+        if (this.isMultiPart) {
+            const { expectedPartsCount, uploadedParts, totalBytes, totalBytesSource } = this;
+            if (totalBytes !== undefined && expectedPartsCount !== undefined && uploadedParts.length !== expectedPartsCount) {
+                throw new Error(`Expected ${expectedPartsCount} part(s) but uploaded ${uploadedParts.length} part(s).
 The expected part count is based on the byte-count of the input.params.Body,
 which was read from ${totalBytesSource} and is ${totalBytes}.
 If this is not correct, provide an override value by setting a number
 to input.params.ContentLength in bytes.
 `);
-      }
-      this.uploadedParts.sort((a, b) => a.PartNumber - b.PartNumber);
-      const uploadCompleteParams = {
-        ...this.params,
-        Body: void 0,
-        UploadId: this.uploadId,
-        MultipartUpload: {
-          Parts: this.uploadedParts
+            }
+            this.uploadedParts.sort((a, b) => a.PartNumber - b.PartNumber);
+            const uploadCompleteParams = {
+                ...this.params,
+                Body: undefined,
+                UploadId: this.uploadId,
+                MultipartUpload: {
+                    Parts: this.uploadedParts,
+                },
+            };
+            result = await this.client.send(new clientS3.CompleteMultipartUploadCommand(uploadCompleteParams));
+            if (typeof result?.Location === "string" && result.Location.includes("%2F")) {
+                result.Location = result.Location.replace(/%2F/g, "/");
+            }
         }
-      };
-      result = await this.client.send(new import_client_s3.CompleteMultipartUploadCommand(uploadCompleteParams));
-      if (typeof result?.Location === "string" && result.Location.includes("%2F")) {
-        result.Location = result.Location.replace(/%2F/g, "/");
-      }
-    } else {
-      result = this.singleUploadResult;
-    }
-    this.abortMultipartUploadCommand = null;
-    if (this.tags.length) {
-      await this.client.send(
-        new import_client_s3.PutObjectTaggingCommand({
-          ...this.params,
-          Tagging: {
-            TagSet: this.tags
-          }
-        })
-      );
-    }
-    return result;
-  }
-  /**
-   * Abort the last multipart upload in progress
-   * if we know the upload id, the user did not specify to leave the parts, and
-   * we have a prepared AbortMultipartUpload command.
-   */
-  async markUploadAsAborted() {
-    if (this.uploadId && !this.leavePartsOnError && null !== this.abortMultipartUploadCommand) {
-      await this.client.send(this.abortMultipartUploadCommand);
-      this.abortMultipartUploadCommand = null;
-    }
-  }
-  __notifyProgress(progress) {
-    if (this.uploadEvent) {
-      this.emit(this.uploadEvent, progress);
-    }
-  }
-  async __abortTimeout(abortSignal) {
-    return new Promise((resolve, reject) => {
-      abortSignal.onabort = () => {
-        const abortError = new Error("Upload aborted.");
-        abortError.name = "AbortError";
-        reject(abortError);
-      };
-    });
-  }
-  __validateUploadPart(dataPart) {
-    const actualPartSize = byteLength(dataPart.data);
-    if (actualPartSize === void 0) {
-      throw new Error(
-        `A dataPart was generated without a measurable data chunk size for part number ${dataPart.partNumber}`
-      );
-    }
-    if (dataPart.partNumber === 1 && dataPart.lastPart) {
-      return;
-    }
-    if (!dataPart.lastPart && actualPartSize !== this.partSize) {
-      throw new Error(
-        `The byte size for part number ${dataPart.partNumber}, size ${actualPartSize} does not match expected size ${this.partSize}`
-      );
-    }
-  }
-  __validateInput() {
-    if (!this.client) {
-      throw new Error(`InputError: Upload requires a AWS client to do uploads with.`);
-    }
-    if (this.partSize < _Upload.MIN_PART_SIZE) {
-      throw new Error(
-        `EntityTooSmall: Your proposed upload part size [${this.partSize}] is smaller than the minimum allowed size [${_Upload.MIN_PART_SIZE}] (5MB)`
-      );
-    }
-    if (this.queueSize < 1) {
-      throw new Error(`Queue size: Must have at least one uploading queue.`);
-    }
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-
-0 && (module.exports = {
-  Upload
-});
+        else {
+            result = this.singleUploadResult;
+        }
+        this.abortMultipartUploadCommand = null;
+        if (this.tags.length) {
+            await this.client.send(new clientS3.PutObjectTaggingCommand({
+                ...this.params,
+                Tagging: {
+                    TagSet: this.tags,
+                },
+            }));
+        }
+        return result;
+    }
+    async markUploadAsAborted() {
+        if (this.uploadId && !this.leavePartsOnError && null !== this.abortMultipartUploadCommand) {
+            await this.client.send(this.abortMultipartUploadCommand);
+            this.abortMultipartUploadCommand = null;
+        }
+    }
+    __notifyProgress(progress) {
+        if (this.uploadEvent) {
+            this.emit(this.uploadEvent, progress);
+        }
+    }
+    async __abortTimeout(abortSignal) {
+        return new Promise((resolve, reject) => {
+            abortSignal.onabort = () => {
+                const abortError = new Error("Upload aborted.");
+                abortError.name = "AbortError";
+                reject(abortError);
+            };
+        });
+    }
+    __validateUploadPart(dataPart) {
+        const actualPartSize = byteLength(dataPart.data);
+        if (actualPartSize === undefined) {
+            throw new Error(`A dataPart was generated without a measurable data chunk size for part number ${dataPart.partNumber}`);
+        }
+        if (dataPart.partNumber === 1 && dataPart.lastPart) {
+            return;
+        }
+        if (!dataPart.lastPart && actualPartSize !== this.partSize) {
+            throw new Error(`The byte size for part number ${dataPart.partNumber}, size ${actualPartSize} does not match expected size ${this.partSize}`);
+        }
+    }
+    __validateInput() {
+        if (!this.client) {
+            throw new Error(`InputError: Upload requires a AWS client to do uploads with.`);
+        }
+        if (this.partSize < Upload.MIN_PART_SIZE) {
+            throw new Error(`EntityTooSmall: Your proposed upload part size [${this.partSize}] is smaller than the minimum allowed size [${Upload.MIN_PART_SIZE}] (5MB)`);
+        }
+        if (this.queueSize < 1) {
+            throw new Error(`Queue size: Must have at least one uploading queue.`);
+        }
+    }
+}
 
+exports.Upload = Upload;

package/dist-cjs/runtimeConfig.js

@@ -7,4 +7,7 @@ exports.runtimeConfig = {
     ...runtimeConfig_shared_1.runtimeConfigShared,
     runtime: "node",
     lstatSync: fs_1.lstatSync,
+    isFileReadStream(f) {
+        return f instanceof fs_1.ReadStream;
+    },
 };

package/dist-cjs/runtimeConfig.shared.js

@@ -3,4 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runtimeConfigShared = void 0;
 exports.runtimeConfigShared = {
     lstatSync: () => { },
+    isFileReadStream(f) {
+        return false;
+    },
 };

package/dist-es/byteLength.js

@@ -19,7 +19,7 @@ export const byteLength = (input) => {
     else if (typeof input.start === "number" && typeof input.end === "number") {
         return input.end + 1 - input.start;
     }
-    else if (typeof input.path === "string") {
+    else if (runtimeConfig.isFileReadStream(input)) {
         try {
             return runtimeConfig.lstatSync(input.path).size;
         }

package/dist-es/byteLengthSource.js

@@ -32,7 +32,7 @@ export const byteLengthSource = (input, override) => {
     else if (typeof input.start === "number" && typeof input.end === "number") {
         return BYTE_LENGTH_SOURCE.START_END_DIFF;
     }
-    else if (typeof input.path === "string") {
+    else if (runtimeConfig.isFileReadStream(input)) {
         try {
             runtimeConfig.lstatSync(input.path).size;
             return BYTE_LENGTH_SOURCE.LSTAT;

package/dist-es/runtimeConfig.js

@@ -1,7 +1,10 @@
-import { lstatSync } from "fs";
+import { lstatSync, ReadStream } from "fs";
 import { runtimeConfigShared as shared } from "./runtimeConfig.shared";
 export const runtimeConfig = {
     ...shared,
     runtime: "node",
     lstatSync,
+    isFileReadStream(f) {
+        return f instanceof ReadStream;
+    },
 };

package/dist-es/runtimeConfig.shared.js

@@ -1,3 +1,6 @@
 export const runtimeConfigShared = {
     lstatSync: () => { },
+    isFileReadStream(f) {
+        return false;
+    },
 };

package/dist-types/runtimeConfig.browser.d.ts

@@ -4,4 +4,5 @@
 export declare const runtimeConfig: {
     runtime: string;
     lstatSync: () => void;
+    isFileReadStream(f: unknown): boolean;
 };

package/dist-types/runtimeConfig.d.ts

@@ -1,7 +1,9 @@
+import { ReadStream } from "fs";
 /**
  * @internal
  */
 export declare const runtimeConfig: {
     runtime: string;
     lstatSync: import("fs").StatSyncFn;
+    isFileReadStream(f: unknown): f is ReadStream;
 };

package/dist-types/runtimeConfig.native.d.ts

@@ -4,4 +4,5 @@
 export declare const runtimeConfig: {
     runtime: string;
     lstatSync: () => void;
+    isFileReadStream(f: unknown): boolean;
 };

package/dist-types/runtimeConfig.shared.d.ts

@@ -3,4 +3,5 @@
  */
 export declare const runtimeConfigShared: {
     lstatSync: () => void;
+    isFileReadStream(f: unknown): boolean;
 };

package/dist-types/ts3.4/runtimeConfig.browser.d.ts

@@ -1,4 +1,5 @@
 export declare const runtimeConfig: {
   runtime: string;
   lstatSync: () => void;
+  isFileReadStream(f: unknown): boolean;
 };

package/dist-types/ts3.4/runtimeConfig.d.ts

@@ -1,4 +1,6 @@
+import { ReadStream } from "fs";
 export declare const runtimeConfig: {
   runtime: string;
   lstatSync: import("fs").StatSyncFn;
+  isFileReadStream(f: unknown): f is ReadStream;
 };

package/dist-types/ts3.4/runtimeConfig.native.d.ts

@@ -1,4 +1,5 @@
 export declare const runtimeConfig: {
   runtime: string;
   lstatSync: () => void;
+  isFileReadStream(f: unknown): boolean;
 };

package/dist-types/ts3.4/runtimeConfig.shared.d.ts

@@ -1,3 +1,4 @@
 export declare const runtimeConfigShared: {
   lstatSync: () => void;
+  isFileReadStream(f: unknown): boolean;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/lib-storage",
-  "version": "3.903.0",
+  "version": "3.906.0",
   "description": "Storage higher order operation",
   "main": "./dist-cjs/index.js",
   "module": "./dist-es/index.js",
@@ -39,10 +39,10 @@
     "tslib": "^2.6.2"
   },
   "peerDependencies": {
-    "@aws-sdk/client-s3": "^3.901.0"
+    "@aws-sdk/client-s3": "^3.906.0"
   },
   "devDependencies": {
-    "@aws-sdk/client-s3": "3.901.0",
+    "@aws-sdk/client-s3": "3.906.0",
     "@smithy/types": "^4.6.0",
     "@tsconfig/recommended": "1.0.1",
     "@types/node": "^18.19.69",