@donezone/cli 0.1.44 → 0.1.46

package/dist/index.js

@@ -22221,6 +22221,9 @@ class AbstractTokenizer {
     return token.get(this.numBuffer, 0);
   }
   async ignore(length) {
+    if (length < 0) {
+      throw new RangeError("ignore length must be \u2265 0 bytes");
+    }
     if (this.fileInfo.size !== undefined) {
       const bytesLeft = this.fileInfo.size - this.position;
       if (length > bytesLeft) {
@@ -22319,6 +22322,9 @@ var init_ReadStreamTokenizer = __esm(() => {
       return bytesRead;
     }
     async ignore(length) {
+      if (length < 0) {
+        throw new RangeError("ignore length must be \u2265 0 bytes");
+      }
       const bufSize = Math.min(maxBufferSize, length);
       const buf = new Uint8Array(bufSize);
       let totBytesRead = 0;
@@ -24248,6 +24254,23 @@ var init_supported = __esm(() => {
 });
 
 // ../../node_modules/file-type/core.js
+function patchWebByobTokenizerClose(tokenizer) {
+  const streamReader = tokenizer?.streamReader;
+  if (streamReader?.constructor?.name !== "WebStreamByobReader") {
+    return tokenizer;
+  }
+  const { reader } = streamReader;
+  const cancelAndRelease = async () => {
+    await reader.cancel();
+    reader.releaseLock();
+  };
+  streamReader.close = cancelAndRelease;
+  streamReader.abort = async () => {
+    streamReader.interrupted = true;
+    await cancelAndRelease();
+  };
+  return tokenizer;
+}
 function getSafeBound(value, maximum, reason) {
   if (!Number.isFinite(value) || value < 0 || value > maximum) {
     throw new ParserHardLimitError(`${reason} has invalid size ${value} (maximum ${maximum} bytes)`);
@@ -24589,6 +24612,39 @@ function normalizeSampleSize(sampleSize) {
   }
   return Math.max(1, Math.trunc(sampleSize));
 }
+function readByobReaderWithSignal(reader, buffer, signal) {
+  if (signal === undefined) {
+    return reader.read(buffer);
+  }
+  signal.throwIfAborted();
+  return new Promise((resolve3, reject) => {
+    const cleanup = () => {
+      signal.removeEventListener("abort", onAbort);
+    };
+    const onAbort = () => {
+      const abortReason = signal.reason;
+      cleanup();
+      (async () => {
+        try {
+          await reader.cancel(abortReason);
+        } catch {
+        }
+      })();
+      reject(abortReason);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    (async () => {
+      try {
+        const result = await reader.read(buffer);
+        cleanup();
+        resolve3(result);
+      } catch (error) {
+        cleanup();
+        reject(error);
+      }
+    })();
+  });
+}
 function normalizeMpegOffsetTolerance(mpegOffsetTolerance) {
   if (!Number.isFinite(mpegOffsetTolerance)) {
     return 0;
@@ -24739,7 +24795,10 @@ class FileTypeParser {
       ...this.tokenizerOptions
     };
   }
-  async fromTokenizer(tokenizer, detectionReentryCount = 0) {
+  createTokenizerFromWebStream(stream) {
+    return patchWebByobTokenizerClose(fromWebStream(stream, this.getTokenizerOptions()));
+  }
+  async parseTokenizer(tokenizer, detectionReentryCount = 0) {
     this.detectionReentryCount = detectionReentryCount;
     const initialPosition = tokenizer.position;
     for (const detector of this.detectors) {
@@ -24763,6 +24822,13 @@ class FileTypeParser {
       }
     }
   }
+  async fromTokenizer(tokenizer) {
+    try {
+      return await this.parseTokenizer(tokenizer);
+    } finally {
+      await tokenizer.close();
+    }
+  }
   async fromBuffer(input) {
     if (!(input instanceof Uint8Array || input instanceof ArrayBuffer)) {
       throw new TypeError(`Expected the \`input\` argument to be of type \`Uint8Array\` or \`ArrayBuffer\`, got \`${typeof input}\``);
@@ -24774,20 +24840,14 @@ class FileTypeParser {
     return this.fromTokenizer(fromBuffer(buffer, this.getTokenizerOptions()));
   }
   async fromBlob(blob) {
+    this.options.signal?.throwIfAborted();
     const tokenizer = fromBlob(blob, this.getTokenizerOptions());
-    try {
-      return await this.fromTokenizer(tokenizer);
-    } finally {
-      await tokenizer.close();
-    }
+    return this.fromTokenizer(tokenizer);
   }
   async fromStream(stream) {
-    const tokenizer = fromWebStream(stream, this.getTokenizerOptions());
-    try {
-      return await this.fromTokenizer(tokenizer);
-    } finally {
-      await tokenizer.close();
-    }
+    this.options.signal?.throwIfAborted();
+    const tokenizer = this.createTokenizerFromWebStream(stream);
+    return this.fromTokenizer(tokenizer);
   }
   async toDetectionStream(stream, options) {
     const sampleSize = normalizeSampleSize(options?.sampleSize ?? reasonableDetectionSizeInBytes);
@@ -24795,7 +24855,7 @@ class FileTypeParser {
     let firstChunk;
     const reader = stream.getReader({ mode: "byob" });
     try {
-      const { value: chunk, done } = await reader.read(new Uint8Array(sampleSize));
+      const { value: chunk, done } = await readByobReaderWithSignal(reader, new Uint8Array(sampleSize), this.options.signal);
       firstChunk = chunk;
       if (!done && chunk) {
         try {
@@ -24823,6 +24883,57 @@ class FileTypeParser {
     newStream.fileType = detectedFileType;
     return newStream;
   }
+  async detectGzip(tokenizer) {
+    if (this.gzipProbeDepth >= maximumNestedGzipProbeDepth) {
+      return {
+        ext: "gz",
+        mime: "application/gzip"
+      };
+    }
+    const gzipHandler = new GzipHandler(tokenizer);
+    const limitedInflatedStream = createByteLimitedReadableStream(gzipHandler.inflate(), maximumNestedGzipDetectionSizeInBytes);
+    const hasUnknownSize = hasUnknownFileSize(tokenizer);
+    let timeout;
+    let probeSignal;
+    let probeParser;
+    let compressedFileType;
+    if (hasUnknownSize) {
+      const timeoutController = new AbortController;
+      timeout = setTimeout(() => {
+        timeoutController.abort(new DOMException(`Operation timed out after ${unknownSizeGzipProbeTimeoutInMilliseconds} ms`, "TimeoutError"));
+      }, unknownSizeGzipProbeTimeoutInMilliseconds);
+      probeSignal = this.options.signal === undefined ? timeoutController.signal : AbortSignal.any([this.options.signal, timeoutController.signal]);
+      probeParser = new FileTypeParser({
+        ...this.options,
+        signal: probeSignal
+      });
+      probeParser.gzipProbeDepth = this.gzipProbeDepth + 1;
+    } else {
+      this.gzipProbeDepth++;
+    }
+    try {
+      compressedFileType = await (probeParser ?? this).fromStream(limitedInflatedStream);
+    } catch (error) {
+      if (error?.name === "AbortError" && probeSignal?.reason?.name !== "TimeoutError") {
+        throw error;
+      }
+    } finally {
+      clearTimeout(timeout);
+      if (!hasUnknownSize) {
+        this.gzipProbeDepth--;
+      }
+    }
+    if (compressedFileType?.ext === "tar") {
+      return {
+        ext: "tar.gz",
+        mime: "application/gzip"
+      };
+    }
+    return {
+      ext: "gz",
+      mime: "application/gzip"
+    };
+  }
   check(header, options) {
     return _check(this.buffer, header, options);
   }
@@ -24835,6 +24946,12 @@ class FileTypeParser {
       tokenizer.fileInfo.size = Number.MAX_SAFE_INTEGER;
     }
     this.tokenizer = tokenizer;
+    if (hasUnknownFileSize(tokenizer)) {
+      await tokenizer.peekBuffer(this.buffer, { length: 3, mayBeLess: true });
+      if (this.check([31, 139, 8])) {
+        return this.detectGzip(tokenizer);
+      }
+    }
     await tokenizer.peekBuffer(this.buffer, { length: 32, mayBeLess: true });
     if (this.check([66, 77])) {
       return {
@@ -24912,35 +25029,7 @@ class FileTypeParser {
       };
     }
     if (this.check([31, 139, 8])) {
-      if (this.gzipProbeDepth >= maximumNestedGzipProbeDepth) {
-        return {
-          ext: "gz",
-          mime: "application/gzip"
-        };
-      }
-      const gzipHandler = new GzipHandler(tokenizer);
-      const limitedInflatedStream = createByteLimitedReadableStream(gzipHandler.inflate(), maximumNestedGzipDetectionSizeInBytes);
-      let compressedFileType;
-      try {
-        this.gzipProbeDepth++;
-        compressedFileType = await this.fromStream(limitedInflatedStream);
-      } catch (error) {
-        if (error?.name === "AbortError") {
-          throw error;
-        }
-      } finally {
-        this.gzipProbeDepth--;
-      }
-      if (compressedFileType?.ext === "tar") {
-        return {
-          ext: "tar.gz",
-          mime: "application/gzip"
-        };
-      }
-      return {
-        ext: "gz",
-        mime: "application/gzip"
-      };
+      return this.detectGzip(tokenizer);
     }
     if (this.check([66, 90, 104])) {
       return {
@@ -24982,7 +25071,7 @@ class FileTypeParser {
         return;
       }
       this.detectionReentryCount++;
-      return this.fromTokenizer(tokenizer, this.detectionReentryCount);
+      return this.parseTokenizer(tokenizer, this.detectionReentryCount);
     }
     if (this.checkString("MP+")) {
       return {
@@ -26264,7 +26353,7 @@ class FileTypeParser {
     }
   }
 }
-var reasonableDetectionSizeInBytes = 4100, maximumMpegOffsetTolerance, maximumZipEntrySizeInBytes, maximumZipEntryCount = 1024, maximumZipBufferedReadSizeInBytes, maximumUntrustedSkipSizeInBytes, maximumUnknownSizePayloadProbeSizeInBytes, maximumZipTextEntrySizeInBytes, maximumNestedGzipDetectionSizeInBytes, maximumNestedGzipProbeDepth = 1, maximumId3HeaderSizeInBytes, maximumEbmlDocumentTypeSizeInBytes = 64, maximumEbmlElementPayloadSizeInBytes, maximumEbmlElementCount = 256, maximumPngChunkCount = 512, maximumPngStreamScanBudgetInBytes, maximumAsfHeaderObjectCount = 512, maximumTiffTagCount = 512, maximumDetectionReentryCount = 256, maximumPngChunkSizeInBytes, maximumAsfHeaderPayloadSizeInBytes, maximumTiffStreamIfdOffsetInBytes, maximumTiffIfdOffsetInBytes, recoverableZipErrorMessages, recoverableZipErrorMessagePrefixes, recoverableZipErrorCodes, ParserHardLimitError, zipDataDescriptorSignature = 134695760, zipDataDescriptorLengthInBytes = 16, zipDataDescriptorOverlapLengthInBytes, supportedExtensions, supportedMimeTypes;
+var reasonableDetectionSizeInBytes = 4100, maximumMpegOffsetTolerance, maximumZipEntrySizeInBytes, maximumZipEntryCount = 1024, maximumZipBufferedReadSizeInBytes, maximumUntrustedSkipSizeInBytes, maximumUnknownSizePayloadProbeSizeInBytes, maximumZipTextEntrySizeInBytes, maximumNestedGzipDetectionSizeInBytes, maximumNestedGzipProbeDepth = 1, unknownSizeGzipProbeTimeoutInMilliseconds = 100, maximumId3HeaderSizeInBytes, maximumEbmlDocumentTypeSizeInBytes = 64, maximumEbmlElementPayloadSizeInBytes, maximumEbmlElementCount = 256, maximumPngChunkCount = 512, maximumPngStreamScanBudgetInBytes, maximumAsfHeaderObjectCount = 512, maximumTiffTagCount = 512, maximumDetectionReentryCount = 256, maximumPngChunkSizeInBytes, maximumAsfHeaderPayloadSizeInBytes, maximumTiffStreamIfdOffsetInBytes, maximumTiffIfdOffsetInBytes, recoverableZipErrorMessages, recoverableZipErrorMessagePrefixes, recoverableZipErrorCodes, ParserHardLimitError, zipDataDescriptorSignature = 134695760, zipDataDescriptorLengthInBytes = 16, zipDataDescriptorOverlapLengthInBytes, supportedExtensions, supportedMimeTypes;
 var init_core2 = __esm(() => {
   init_lib3();
   init_core();
@@ -26295,7 +26384,8 @@ var init_core2 = __esm(() => {
     "ZIP entry count exceeds ",
     "Unsupported ZIP compression method:",
     "ZIP entry compressed data exceeds ",
-    "ZIP entry decompressed data exceeds "
+    "ZIP entry decompressed data exceeds ",
+    "Expected data-descriptor-signature at position "
   ];
   recoverableZipErrorCodes = new Set([
     "Z_BUF_ERROR",
@@ -26397,7 +26487,8 @@ var init_file_type = __esm(() => {
   init_core2();
   FileTypeParser2 = class FileTypeParser2 extends FileTypeParser {
     async fromStream(stream) {
-      const tokenizer = await (stream instanceof WebReadableStream ? fromWebStream(stream, this.getTokenizerOptions()) : fromStream2(stream, this.getTokenizerOptions()));
+      this.options.signal?.throwIfAborted();
+      const tokenizer = await (stream instanceof WebReadableStream ? this.createTokenizerFromWebStream(stream) : fromStream2(stream, this.getTokenizerOptions()));
       try {
         return await super.fromTokenizer(tokenizer);
       } catch (error) {
@@ -26406,10 +26497,13 @@ var init_file_type = __esm(() => {
         }
         throw error;
       } finally {
-        await tokenizer.close();
+        if (stream instanceof Readable && !stream.destroyed) {
+          stream.destroy();
+        }
       }
     }
     async fromFile(path) {
+      this.options.signal?.throwIfAborted();
       const fileHandle = await fs.open(path, fileSystemConstants.O_RDONLY | fileSystemConstants.O_NONBLOCK);
       const fileStat = await fileHandle.stat();
       if (!fileStat.isFile()) {
@@ -26423,41 +26517,65 @@ var init_file_type = __esm(() => {
           size: fileStat.size
         }
       });
-      try {
-        return await super.fromTokenizer(tokenizer);
-      } finally {
-        await tokenizer.close();
-      }
+      return super.fromTokenizer(tokenizer);
     }
     async toDetectionStream(readableStream, options = {}) {
       if (!(readableStream instanceof Readable)) {
         return super.toDetectionStream(readableStream, options);
       }
-      const sampleSize = normalizeSampleSize(options.sampleSize ?? reasonableDetectionSizeInBytes);
+      const { sampleSize = reasonableDetectionSizeInBytes } = options;
+      const { signal } = this.options;
+      const normalizedSampleSize = normalizeSampleSize(sampleSize);
+      signal?.throwIfAborted();
       return new Promise((resolve3, reject) => {
-        readableStream.on("error", reject);
-        readableStream.once("readable", () => {
+        let isSettled = false;
+        const cleanup = () => {
+          readableStream.off("error", onError);
+          readableStream.off("readable", onReadable);
+          signal?.removeEventListener("abort", onAbort);
+        };
+        const settle = (callback, value) => {
+          if (isSettled) {
+            return;
+          }
+          isSettled = true;
+          cleanup();
+          callback(value);
+        };
+        const onError = (error) => {
+          settle(reject, error);
+        };
+        const onAbort = () => {
+          if (!readableStream.destroyed) {
+            readableStream.destroy();
+          }
+          settle(reject, signal.reason);
+        };
+        const onReadable = () => {
           (async () => {
             try {
               const pass = new PassThrough;
               const outputStream = pipeline ? pipeline(readableStream, pass, () => {
               }) : readableStream.pipe(pass);
-              const chunk = readableStream.read(sampleSize) ?? readableStream.read() ?? new Uint8Array(0);
+              const chunk = readableStream.read(normalizedSampleSize) ?? readableStream.read() ?? new Uint8Array(0);
               try {
                 pass.fileType = await this.fromBuffer(chunk);
               } catch (error) {
                 if (error instanceof EndOfStreamError) {
                   pass.fileType = undefined;
                 } else {
-                  reject(error);
+                  settle(reject, error);
                 }
               }
-              resolve3(outputStream);
+              settle(resolve3, outputStream);
             } catch (error) {
-              reject(error);
+              settle(reject, error);
             }
           })();
-        });
+        };
+        readableStream.on("error", onError);
+        readableStream.once("readable", onReadable);
+        signal?.addEventListener("abort", onAbort, { once: true });
       });
     }
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@donezone/cli",
-  "version": "0.1.44",
+  "version": "0.1.46",
   "doneZoneVersion": "0.1.41",
   "doneClientVersion": "0.1.41",
   "private": false,