@ardrive/turbo-sdk 1.26.0 → 1.27.0-alpha.1

package/bundles/web.bundle.min.js

@@ -114609,7 +114609,7 @@ var require_wrapAsync = __commonJS({
     function isAsyncGenerator(fn2) {
       return fn2[Symbol.toStringTag] === "AsyncGenerator";
     }
-    function isAsyncIterable(obj) {
+    function isAsyncIterable2(obj) {
       return typeof obj[Symbol.asyncIterator] === "function";
     }
     function wrapAsync(asyncFn) {
@@ -114620,7 +114620,7 @@ var require_wrapAsync = __commonJS({
     exports15.default = wrapAsync;
     exports15.isAsync = isAsync2;
     exports15.isAsyncGenerator = isAsyncGenerator;
-    exports15.isAsyncIterable = isAsyncIterable;
+    exports15.isAsyncIterable = isAsyncIterable2;
   }
 });
 
@@ -313540,9 +313540,9 @@ var DataItem = class _DataItem {
         return false;
       }
     }
-    const Signer3 = indexToType[sigType];
+    const Signer4 = indexToType[sigType];
     const signatureData = await ar_data_base_default(item);
-    return await Signer3.verify(item.rawOwner, signatureData, item.rawSignature);
+    return await Signer4.verify(item.rawOwner, signatureData, item.rawSignature);
   }
   async getSignatureData() {
     return ar_data_base_default(this);
@@ -313953,8 +313953,8 @@ async function processStream(stream2) {
     transform.end();
     if (id3 !== (0, import_base64url11.default)(createHash("sha256").update(signature2).digest()))
       throw new Error("ID doesn't match signature");
-    const Signer3 = indexToType[signatureType];
-    if (!await Signer3.verify(owner, await signatureData, signature2))
+    const Signer4 = indexToType[signatureType];
+    if (!await Signer4.verify(owner, await signatureData, signature2))
       throw new Error("Invalid signature");
     items.push({
       id: id3,
@@ -314072,7 +314072,7 @@ var import_winston = __toESM(require_winston(), 1);
 init_dirname();
 init_buffer2();
 init_process2();
-var version16 = "1.26.0-alpha.1";
+var version16 = "1.26.0";
 
 // src/common/logger.ts
 var TurboWinstonLogger = class _TurboWinstonLogger {
@@ -367315,7 +367315,9 @@ function createReadableStreamWithEvents({
 }) {
   const originalStream = data instanceof ReadableStream ? data : new ReadableStream({
     start: (controller) => {
-      controller.enqueue(data);
+      controller.enqueue(
+        new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
+      );
       controller.close();
     }
   });
@@ -367333,12 +367335,14 @@ function createReadableStreamWithEvents({
           controller.close();
           return;
         }
-        processedBytes += value.length;
+        processedBytes += value.byteLength;
         emitter.emit(eventNamesMap["on-progress"], {
           processedBytes,
           totalBytes: dataSize
         });
-        controller.enqueue(value);
+        controller.enqueue(
+          new Uint8Array(value.buffer, value.byteOffset, value.byteLength)
+        );
       } catch (error) {
         emitter.emit(eventNamesMap["on-error"], error);
         controller.error(error);
@@ -367366,7 +367370,7 @@ function createReadableWithEvents({
   let processedBytes = 0;
   existingStream.on("data", (chunk) => {
     eventingStream.write(chunk);
-    processedBytes += chunk.length;
+    processedBytes += chunk.byteLength;
     emitter.emit(eventNamesMap["on-progress"], {
       processedBytes,
       totalBytes: dataSize
@@ -367495,6 +367499,22 @@ function createStreamWithUploadEvents({
     }
   });
 }
+function createStreamWithSigningEvents({
+  data,
+  dataSize,
+  emitter = new TurboEventEmitter()
+}) {
+  return createStreamWithEvents({
+    data,
+    dataSize,
+    emitter,
+    eventNamesMap: {
+      "on-progress": "signing-progress",
+      "on-error": "signing-error",
+      "on-end": "signing-success"
+    }
+  });
+}
 
 // src/common/upload.ts
 var creditSharingTagNames = {
@@ -367528,17 +367548,17 @@ var TurboUnauthenticatedUploadService = class {
     signal,
     events = {}
   }) {
-    const fileSize = dataItemSizeFactory();
+    const dataItemSize = dataItemSizeFactory();
     this.logger.debug("Uploading signed data item...");
     const emitter = new TurboEventEmitter(events);
     const { stream: streamWithUploadEvents, resume } = createStreamWithUploadEvents({
       data: dataItemStreamFactory(),
-      dataSize: fileSize,
+      dataSize: dataItemSize,
       emitter
     });
     const headers = {
       "content-type": "application/octet-stream",
-      "content-length": `${fileSize}`
+      "content-length": `${dataItemSize}`
     };
     if (dataItemOpts !== void 0 && dataItemOpts.paidBy !== void 0) {
       const paidBy = Array.isArray(dataItemOpts.paidBy) ? dataItemOpts.paidBy : [dataItemOpts.paidBy];
@@ -367627,7 +367647,6 @@ var TurboAuthenticatedBaseUploadService = class extends TurboUnauthenticatedUplo
         throw new CanceledError2();
       }
       try {
-        this.logger.debug("Uploading signed data item...");
         const response = await this.uploadSignedDataItem({
           dataItemStreamFactory,
           dataItemSizeFactory,
@@ -367747,6 +367766,7 @@ ${lastError instanceof Error ? lastError.message : lastError}`;
       };
       try {
         const result2 = await this.uploadFile({
+          // TODO: can fix this type by passing a class generic and specifying in the node/web abstracts which stream type to use
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
           fileStreamFactory: () => this.getFileStreamForFile(file),
           fileSizeFactory: () => this.getFileSize(file),
@@ -367789,6 +367809,7 @@ ${lastError instanceof Error ? lastError.message : lastError}`;
     ];
     const manifestBuffer = Buffer.from(JSON.stringify(manifest));
     const manifestResponse = await this.uploadFile({
+      // TODO: can fix this type by passing a class generic and specifying in the node/web abstracts which stream type to use
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       fileStreamFactory: () => this.createManifestStream(manifestBuffer),
       fileSizeFactory: () => manifestBuffer.byteLength,
@@ -368345,23 +368366,87 @@ var TurboDataItemAbstractSigner = class {
 init_dirname();
 init_buffer2();
 init_process2();
-async function readableStreamToBuffer({
-  stream: stream2,
-  size
-}) {
-  const reader = stream2.getReader();
-  const buffer2 = Buffer.alloc(size);
-  let offset2 = 0;
-  let done = false;
-  while (!done) {
-    const { done: streamDone, value } = await reader.read();
-    done = streamDone;
-    if (!done) {
-      buffer2.set(value, offset2);
-      offset2 += value.byteLength;
+var DEFAULT_STREAM_CHUNK_SIZE = 20 * 1024 * 1024;
+function ensureChunkedStream(input, maxChunkSize = DEFAULT_STREAM_CHUNK_SIZE) {
+  const reader = input.getReader();
+  let leftover = null;
+  return new ReadableStream({
+    async pull(controller) {
+      if (leftover) {
+        const chunk = leftover.subarray(0, maxChunkSize);
+        leftover = leftover.subarray(chunk.length);
+        if (leftover.length === 0)
+          leftover = null;
+        controller.enqueue(chunk);
+        return;
+      }
+      const { value, done } = await reader.read();
+      if (done) {
+        controller.close();
+        return;
+      }
+      if (!(value instanceof Uint8Array)) {
+        throw new TypeError("Expected Uint8Array from source stream");
+      }
+      if (value.byteLength <= maxChunkSize) {
+        controller.enqueue(value);
+      } else {
+        controller.enqueue(value.subarray(0, maxChunkSize));
+        leftover = value.subarray(maxChunkSize);
+      }
     }
+  });
+}
+function createUint8ArrayReadableStreamFactory({
+  data,
+  maxChunkSize = DEFAULT_STREAM_CHUNK_SIZE
+}) {
+  if (data instanceof Blob) {
+    return () => ensureChunkedStream(data.stream());
+  }
+  if (data instanceof ReadableStream) {
+    return () => {
+      const reader = data.getReader();
+      const stream2 = new ReadableStream({
+        async pull(controller) {
+          const { value, done } = await reader.read();
+          if (done) {
+            controller.close();
+            return;
+          }
+          if (ArrayBuffer.isView(value)) {
+            controller.enqueue(
+              new Uint8Array(value.buffer, value.byteOffset, value.byteLength)
+            );
+          } else if (value instanceof ArrayBuffer || value instanceof SharedArrayBuffer) {
+            controller.enqueue(new Uint8Array(value));
+          } else {
+            throw new TypeError("Unsupported chunk type in ReadableStream");
+          }
+        }
+      });
+      return ensureChunkedStream(stream2, maxChunkSize);
+    };
   }
-  return buffer2;
+  return () => {
+    let uint8;
+    if (typeof data === "string") {
+      uint8 = new TextEncoder().encode(data);
+    } else if (ArrayBuffer.isView(data)) {
+      uint8 = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    } else if (data instanceof ArrayBuffer || data instanceof SharedArrayBuffer) {
+      uint8 = new Uint8Array(data);
+    } else {
+      throw new TypeError("Unsupported input type for stream");
+    }
+    const stream2 = new ReadableStream({
+      start(controller) {
+        controller.enqueue(uint8);
+        controller.close();
+      }
+    });
+    return ensureChunkedStream(stream2, maxChunkSize);
+  };
 }
 
 // src/web/signer.ts
@@ -368386,58 +368471,21 @@ var TurboWebArweaveSigner = class extends TurboDataItemAbstractSigner {
   }) {
     await this.setPublicKey();
     const fileSize = fileSizeFactory();
-    try {
-      const fileStream = fileStreamFactory();
-      emitter?.emit("signing-progress", {
-        processedBytes: 0,
-        totalBytes: fileSize
-      });
-      const buffer2 = fileStream instanceof Buffer ? fileStream : await readableStreamToBuffer({
-        stream: fileStream,
-        size: fileSize
-      });
-      emitter?.emit("signing-progress", {
-        processedBytes: Math.floor(fileSize / 2),
-        totalBytes: fileSize
-      });
-      let signedDataItem;
-      this.logger.debug("Signing data item...");
-      if (this.signer instanceof InjectedArweaveSigner) {
-        this.logger.debug(
-          "Arconnect signer detected, signing with Arconnect signData Item API..."
-        );
-        const sign6 = Buffer.from(
-          await this.signer["signer"].signDataItem({
-            data: Uint8Array.from(buffer2),
-            tags: dataItemOpts?.tags,
-            target: dataItemOpts?.target,
-            anchor: dataItemOpts?.anchor
-          })
-        );
-        signedDataItem = new DataItem(sign6);
-      } else {
-        signedDataItem = createData(
-          Uint8Array.from(buffer2),
-          this.signer,
-          dataItemOpts
-        );
-        await signedDataItem.sign(this.signer);
-      }
-      emitter?.emit("signing-progress", {
-        processedBytes: fileSize,
-        totalBytes: fileSize
-      });
-      emitter?.emit("signing-success");
-      this.logger.debug("Successfully signed data item...");
-      return {
-        // while this returns a Buffer - it needs to match our return type for uploading
-        dataItemStreamFactory: () => signedDataItem.getRaw(),
-        dataItemSizeFactory: () => signedDataItem.getRaw().length
-      };
-    } catch (error) {
-      emitter?.emit("signing-error", error);
-      throw error;
-    }
+    this.logger.debug("Signing data item...");
+    const { signedDataItemFactory, signedDataItemSize } = await streamSignerReadableStream({
+      streamFactory: createUint8ArrayReadableStreamFactory({
+        data: fileStreamFactory()
+      }),
+      signer: this.signer,
+      dataItemOpts,
+      fileSize,
+      emitter
+    });
+    this.logger.debug("Successfully signed data item...");
+    return {
+      dataItemStreamFactory: signedDataItemFactory,
+      dataItemSizeFactory: () => signedDataItemSize
+    };
   }
   async generateSignedRequestHeaders() {
     await this.setPublicKey();
@@ -368448,6 +368496,113 @@ var TurboWebArweaveSigner = class extends TurboDataItemAbstractSigner {
     return super.signData(dataToSign);
   }
 };
+var readableStreamToAsyncIterable = (stream2) => ({
+  async *[Symbol.asyncIterator]() {
+    const reader = stream2.getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        if (value !== void 0)
+          yield Buffer.from(value);
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+});
+async function streamSignerReadableStream({
+  streamFactory,
+  signer,
+  dataItemOpts,
+  fileSize,
+  emitter
+}) {
+  try {
+    const header = createData("", signer, dataItemOpts);
+    const headerSize = header.getRaw().byteLength;
+    const totalDataItemSizeWithHeader = fileSize + headerSize;
+    const [stream1, stream2] = streamFactory().tee();
+    const reader1 = stream1.getReader();
+    let bytesProcessed = 0;
+    const eventingStream = new ReadableStream({
+      start() {
+        bytesProcessed = headerSize;
+        emitter?.emit("signing-progress", {
+          processedBytes: bytesProcessed,
+          totalBytes: totalDataItemSizeWithHeader
+        });
+      },
+      async pull(controller) {
+        const { done, value } = await reader1.read();
+        if (done) {
+          controller.close();
+          return;
+        }
+        bytesProcessed += value.byteLength;
+        controller.enqueue(value);
+        emitter?.emit("signing-progress", {
+          processedBytes: bytesProcessed,
+          totalBytes: totalDataItemSizeWithHeader
+        });
+      },
+      cancel() {
+        reader1.cancel();
+      }
+    });
+    const asyncIterableReadableStream = readableStreamToAsyncIterable(eventingStream);
+    const parts = [
+      (0, import_utils.stringToBuffer)("dataitem"),
+      (0, import_utils.stringToBuffer)("1"),
+      (0, import_utils.stringToBuffer)(header.signatureType.toString()),
+      Uint8Array.from(header.rawOwner),
+      Uint8Array.from(header.rawTarget),
+      Uint8Array.from(header.rawAnchor),
+      Uint8Array.from(header.rawTags),
+      asyncIterableReadableStream
+    ];
+    const hash6 = await deepHash(parts);
+    const sigBytes = Buffer.from(await signer.sign(hash6));
+    emitter?.emit("signing-success");
+    header.setSignature(sigBytes);
+    const headerBytes = header.getRaw();
+    const signedDataItemFactory = () => {
+      const reader = stream2.getReader();
+      return new ReadableStream({
+        start(controller) {
+          controller.enqueue(Uint8Array.from(headerBytes));
+          bytesProcessed += headerBytes.byteLength;
+        },
+        async pull(controller) {
+          try {
+            const { done, value } = await reader.read();
+            if (done) {
+              controller.close();
+              return;
+            }
+            controller.enqueue(value);
+          } catch (error) {
+            controller.error(error);
+          }
+        },
+        cancel() {
+          reader.cancel();
+        }
+      });
+    };
+    return {
+      signedDataItemSize: totalDataItemSizeWithHeader,
+      signedDataItemFactory
+    };
+  } catch (error) {
+    emitter?.emit("signing-error", error);
+    throw error;
+  }
+}
+function isAsyncIterable(data) {
+  return typeof data[Symbol.asyncIterator] === "function";
+}
 
 // src/web/upload.ts
 init_dirname();
@@ -368649,6 +368804,7 @@ export {
   TurboAuthenticatedClient,
   TurboAuthenticatedPaymentService,
   TurboAuthenticatedUploadService,
+  TurboEventEmitter,
   TurboFactory,
   TurboUnauthenticatedClient,
   TurboUnauthenticatedPaymentService,
@@ -368658,6 +368814,9 @@ export {
   USD,
   WinstonToTokenAmount,
   ZeroDecimalCurrency,
+  createStreamWithEvents,
+  createStreamWithSigningEvents,
+  createStreamWithUploadEvents,
   creditSharingTagNames,
   currencyMap,
   defaultPaymentServiceURL,
@@ -368669,6 +368828,7 @@ export {
   developmentUploadServiceURL,
   exponentMap,
   fiatCurrencyTypes,
+  isAsyncIterable,
   isCurrency,
   isEthPrivateKey,
   isEthereumWalletAdapter,
@@ -368681,8 +368841,10 @@ export {
   lamportToTokenAmount,
   mARIOToTokenAmount,
   privateKeyFromKyveMnemonic,
+  readableStreamToAsyncIterable,
   signerFromKyveMnemonic,
   signerFromKyvePrivateKey2 as signerFromKyvePrivateKey,
+  streamSignerReadableStream,
   tokenToBaseMap,
   tokenTypes,
   ukyveToTokenAmount,

package/lib/cjs/common/events.js

@@ -46,7 +46,7 @@ function createReadableStreamWithEvents({ data, dataSize, emitter, eventNamesMap
         ? data
         : new ReadableStream({
             start: (controller) => {
-                controller.enqueue(data);
+                controller.enqueue(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
                 controller.close();
             },
         });
@@ -64,12 +64,12 @@ function createReadableStreamWithEvents({ data, dataSize, emitter, eventNamesMap
                     controller.close();
                     return;
                 }
-                processedBytes += value.length;
+                processedBytes += value.byteLength;
                 emitter.emit(eventNamesMap['on-progress'], {
                     processedBytes,
                     totalBytes: dataSize,
                 });
-                controller.enqueue(value);
+                controller.enqueue(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
             }
             catch (error) {
                 emitter.emit(eventNamesMap['on-error'], error);
@@ -125,7 +125,7 @@ function createReadableWithEvents({ data, dataSize, emitter, eventNamesMap, }) {
     let processedBytes = 0;
     existingStream.on('data', (chunk) => {
         eventingStream.write(chunk);
-        processedBytes += chunk.length;
+        processedBytes += chunk.byteLength;
         emitter.emit(eventNamesMap['on-progress'], {
             processedBytes,
             totalBytes: dataSize,

package/lib/cjs/common/upload.js

@@ -44,19 +44,19 @@ class TurboUnauthenticatedUploadService {
         this.retryConfig = retryConfig;
     }
     async uploadSignedDataItem({ dataItemStreamFactory, dataItemSizeFactory, dataItemOpts, signal, events = {}, }) {
-        const fileSize = dataItemSizeFactory();
+        const dataItemSize = dataItemSizeFactory();
         this.logger.debug('Uploading signed data item...');
         // create the tapped stream with events
         const emitter = new events_js_1.TurboEventEmitter(events);
         // create the stream with upload events
         const { stream: streamWithUploadEvents, resume } = (0, events_js_1.createStreamWithUploadEvents)({
             data: dataItemStreamFactory(),
-            dataSize: fileSize,
+            dataSize: dataItemSize,
             emitter,
         });
         const headers = {
             'content-type': 'application/octet-stream',
-            'content-length': `${fileSize}`,
+            'content-length': `${dataItemSize}`,
         };
         if (dataItemOpts !== undefined && dataItemOpts.paidBy !== undefined) {
             const paidBy = Array.isArray(dataItemOpts.paidBy)
@@ -140,11 +140,10 @@ class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUploadServ
             if (signal?.aborted) {
                 throw new axios_1.CanceledError();
             }
+            // Now that we have the signed data item, we can upload it using the uploadSignedDataItem method
+            // which will create a new emitter with upload events. We await
+            // this result due to the wrapped retry logic of this method.
             try {
-                this.logger.debug('Uploading signed data item...');
-                // Now that we have the signed data item, we can upload it using the uploadSignedDataItem method
-                // which will create a new emitter with upload events. We await
-                // this result due to the wrapped retry logic of this method.
                 const response = await this.uploadSignedDataItem({
                     dataItemStreamFactory,
                     dataItemSizeFactory,
@@ -250,6 +249,7 @@ class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUploadServ
             };
             try {
                 const result = await this.uploadFile({
+                    // TODO: can fix this type by passing a class generic and specifying in the node/web abstracts which stream type to use
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     fileStreamFactory: () => this.getFileStreamForFile(file),
                     fileSizeFactory: () => this.getFileSize(file),
@@ -294,6 +294,7 @@ class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUploadServ
         ];
         const manifestBuffer = Buffer.from(JSON.stringify(manifest));
         const manifestResponse = await this.uploadFile({
+            // TODO: can fix this type by passing a class generic and specifying in the node/web abstracts which stream type to use
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             fileStreamFactory: () => this.createManifestStream(manifestBuffer),
             fileSizeFactory: () => manifestBuffer.byteLength,

package/lib/cjs/utils/readableStream.js

@@ -1,6 +1,4 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readableStreamToBuffer = readableStreamToBuffer;
 /**
  * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
  *
@@ -16,6 +14,12 @@ exports.readableStreamToBuffer = readableStreamToBuffer;
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_STREAM_CHUNK_SIZE = void 0;
+exports.readableStreamToBuffer = readableStreamToBuffer;
+exports.ensureChunkedStream = ensureChunkedStream;
+exports.createUint8ArrayReadableStreamFactory = createUint8ArrayReadableStreamFactory;
+exports.DEFAULT_STREAM_CHUNK_SIZE = 20 * 1024 * 1024; // 20mb
 async function readableStreamToBuffer({ stream, size, }) {
     const reader = stream.getReader();
     const buffer = Buffer.alloc(size);
@@ -31,3 +35,97 @@ async function readableStreamToBuffer({ stream, size, }) {
     }
     return buffer;
 }
+function ensureChunkedStream(input, maxChunkSize = exports.DEFAULT_STREAM_CHUNK_SIZE) {
+    const reader = input.getReader();
+    let leftover = null;
+    return new ReadableStream({
+        async pull(controller) {
+            // If we have leftover from a previous large chunk, continue slicing it
+            if (leftover) {
+                const chunk = leftover.subarray(0, maxChunkSize);
+                leftover = leftover.subarray(chunk.length);
+                if (leftover.length === 0)
+                    leftover = null;
+                controller.enqueue(chunk);
+                return;
+            }
+            const { value, done } = await reader.read();
+            if (done) {
+                controller.close();
+                return;
+            }
+            // Runtime check because ReadableStream defaults to <any> and can be abused
+            if (!(value instanceof Uint8Array)) {
+                throw new TypeError('Expected Uint8Array from source stream');
+            }
+            if (value.byteLength <= maxChunkSize) {
+                controller.enqueue(value);
+            }
+            else {
+                // Slice and enqueue one piece now, keep the rest
+                // subarray is the new view with the same buffer (not copy)
+                controller.enqueue(value.subarray(0, maxChunkSize));
+                leftover = value.subarray(maxChunkSize);
+            }
+        },
+    });
+}
+function createUint8ArrayReadableStreamFactory({ data, maxChunkSize = exports.DEFAULT_STREAM_CHUNK_SIZE, }) {
+    // Blob streams are already ReadableStream<Uint8Array>
+    if (data instanceof Blob) {
+        return () => ensureChunkedStream(data.stream());
+    }
+    // We need to handle the case where the data is a ReadableStream that is not a Uint8Array
+    // This is to ensure downstream code can handle the data as a Uint8Array
+    if (data instanceof ReadableStream) {
+        return () => {
+            const reader = data.getReader();
+            const stream = new ReadableStream({
+                async pull(controller) {
+                    const { value, done } = await reader.read();
+                    if (done) {
+                        controller.close();
+                        return;
+                    }
+                    if (ArrayBuffer.isView(value)) {
+                        // specifying offset and length is required to ensure chunks remain within their slice of the buffer
+                        controller.enqueue(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
+                    }
+                    else if (value instanceof ArrayBuffer ||
+                        value instanceof SharedArrayBuffer) {
+                        controller.enqueue(new Uint8Array(value));
+                    }
+                    else {
+                        throw new TypeError('Unsupported chunk type in ReadableStream');
+                    }
+                },
+            });
+            return ensureChunkedStream(stream, maxChunkSize);
+        };
+    }
+    return () => {
+        let uint8;
+        if (typeof data === 'string') {
+            uint8 = new TextEncoder().encode(data);
+        }
+        else if (ArrayBuffer.isView(data)) {
+            // In theory we could use the view directly, but that might allow other typed arrays like BigInt64Array to be used which could behave unexpectedly downstream
+            // specifying offset and length is required to ensure chunks remain within their slice of the buffer
+            uint8 = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        }
+        else if (data instanceof ArrayBuffer ||
+            data instanceof SharedArrayBuffer) {
+            uint8 = new Uint8Array(data);
+        }
+        else {
+            throw new TypeError('Unsupported input type for stream');
+        }
+        const stream = new ReadableStream({
+            start(controller) {
+                controller.enqueue(uint8);
+                controller.close();
+            },
+        });
+        return ensureChunkedStream(stream, maxChunkSize);
+    };
+}

package/lib/cjs/version.js

@@ -17,4 +17,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
 // AUTOMATICALLY GENERATED FILE - DO NOT TOUCH
-exports.version = '1.26.0';
+exports.version = '1.27.0-alpha.1';