@cj-tech-master/excelts 4.2.1-canary.20260111102127.f808a37 → 4.2.1

package/dist/{esm/modules/archive/unzip/stream.js → browser/modules/archive/parse.js}

@@ -1,12 +1,14 @@
 import zlib from "zlib";
-import { DATA_DESCRIPTOR_SIGNATURE_BYTES, PullStream, runParseLoop, streamUntilValidatedDataDescriptor } from "./stream.base.js";
+import { writeUint32LE } from "./utils/binary.js";
+import { PullStream, runParseLoop, streamUntilValidatedDataDescriptor } from "./parse.base.js";
+import { DATA_DESCRIPTOR_SIG } from "./zip-constants.js";
 /**
  * Creates an InflateRaw stream using Node.js native zlib.
  */
 function createInflateRaw() {
     return zlib.createInflateRaw();
 }
-const dataDescriptorSignature = DATA_DESCRIPTOR_SIGNATURE_BYTES;
+const dataDescriptorSignature = writeUint32LE(DATA_DESCRIPTOR_SIG);
 export function createParseClass(createInflateRawFn) {
     return class Parse extends PullStream {
         constructor(opts = {}) {
@@ -61,12 +63,9 @@ export function createParseClass(createInflateRawFn) {
         _streamUntilValidatedDataDescriptor() {
             return streamUntilValidatedDataDescriptor({
                 source: {
+                    getView: () => this._queue.view(),
                     getLength: () => this._queue.length,
                     read: (length) => this._queue.read(length),
-                    peekChunks: (length) => this._queue.peekChunks(length),
-                    discard: (length) => this._queue.discard(length),
-                    indexOfPattern: (pattern, startIndex) => this._queue.indexOfPattern(pattern, startIndex),
-                    peekUint32LE: (offset) => this._queue.peekUint32LE(offset),
                     isFinished: () => this.finished,
                     onDataAvailable: (cb) => {
                         this.on("chunk", cb);

package/dist/browser/modules/archive/{compression/streaming-compress.browser.d.ts → streaming-compress.browser.d.ts}

@@ -6,8 +6,8 @@
  *
  * API compatible with Node.js version - supports .on("data"), .on("end"), .write(callback), .end()
  */
-export type { DeflateStream, InflateStream, StreamCompressOptions, StreamingCodec } from "@archive/compression/streaming-compress.base";
-import { type DeflateStream, type InflateStream, type StreamCompressOptions } from "@archive/compression/streaming-compress.base";
+export type { StreamCompressOptions } from "@archive/streaming-compress.base";
+import { type DeflateStream, type InflateStream, type StreamCompressOptions } from "@archive/streaming-compress.base";
 /**
  * Check if deflate-raw streaming compression is supported by this library.
  *

package/dist/browser/modules/archive/{compression/streaming-compress.browser.js → streaming-compress.browser.js}

@@ -6,11 +6,11 @@
  *
  * API compatible with Node.js version - supports .on("data"), .on("end"), .write(callback), .end()
  */
-import { EventEmitter } from "../../stream/index.browser.js";
+import { EventEmitter } from "../stream/index.browser.js";
 import { deflateRawCompressed, inflateRaw } from "./deflate-fallback.js";
 import { hasDeflateRawWebStreams } from "./compress.base.js";
-import { concatUint8Arrays } from "../utils/bytes.js";
-import { DEFAULT_COMPRESS_LEVEL } from "../defaults.js";
+import { concatUint8Arrays } from "./utils/bytes.js";
+import { DEFAULT_COMPRESS_LEVEL } from "./defaults.js";
 import { asError } from "./streaming-compress.base.js";
 /**
  * Check if deflate-raw streaming compression is supported by this library.

package/dist/browser/modules/archive/{compression/streaming-compress.d.ts → streaming-compress.d.ts}

@@ -4,8 +4,8 @@
  * Uses zlib.createDeflateRaw() with explicit flush() calls for real chunk-by-chunk streaming.
  * Each write() immediately produces compressed output without waiting for end().
  */
-export type { DeflateStream, InflateStream, StreamCompressOptions, StreamingCodec } from "@archive/compression/streaming-compress.base";
-import type { DeflateStream, InflateStream, StreamCompressOptions } from "@archive/compression/streaming-compress.base";
+export type { DeflateStream, InflateStream, StreamCompressOptions, StreamingCodec } from "@archive/streaming-compress.base";
+import type { DeflateStream, InflateStream, StreamCompressOptions } from "@archive/streaming-compress.base";
 /**
  * Create a true streaming DEFLATE compressor
  * Returns a Transform stream that emits compressed data immediately after each write

package/dist/browser/modules/archive/{compression/streaming-compress.js → streaming-compress.js}

@@ -5,8 +5,8 @@
  * Each write() immediately produces compressed output without waiting for end().
  */
 import { createDeflateRaw, createInflateRaw, constants } from "zlib";
-import { Transform } from "../../stream/index.browser.js";
-import { DEFAULT_COMPRESS_LEVEL } from "../defaults.js";
+import { Transform } from "../stream/index.browser.js";
+import { DEFAULT_COMPRESS_LEVEL } from "./defaults.js";
 /**
  * Wrapper around zlib DeflateRaw that flushes after every write
  * This ensures true streaming behavior - data is emitted immediately, not buffered

package/dist/browser/modules/archive/{zip/stream.d.ts → streaming-zip.d.ts}

@@ -2,18 +2,17 @@
  * True Streaming ZIP creator - shared implementation.
  *
  * This module is intentionally platform-agnostic.
- * - In Node builds it uses `./compression/crc32` + `./compression/streaming-compress` (zlib-backed).
+ * - In Node builds it uses `./crc32` + `./streaming-compress` (zlib-backed).
  * - In browser builds the bundler aliases those imports to their browser variants.
  */
 import type { ZipTimestampMode } from "@archive/utils/timestamps";
-import type { ZipEntryInfo as UnzipZipEntryInfo } from "@archive/zip-spec/zip-entry-info";
+import type { ZipEntryInfo as UnzipZipEntryInfo } from "@archive/zip-entry-info";
 /**
  * Internal entry info for central directory
  */
 interface ZipEntryInfo {
     name: Uint8Array;
     extraField: Uint8Array;
-    comment: Uint8Array;
     flags: number;
     crc: number;
     compressedSize: number;
@@ -35,62 +34,43 @@ export declare class ZipDeflateFile {
     private _finalized;
     private _headerEmitted;
     private _ondata;
-    private _onerror;
     private _centralDirEntryInfo;
     private _pendingEnd;
     private _emittedDataDescriptor;
     private _localHeader;
-    private _deflateWanted;
-    private _pendingChunks;
-    private _sampleBuffer;
-    private _sampleLen;
-    private _smartStore;
     private _completeResolve;
     private _completeReject;
     private _completePromise;
     private _completeError;
     private _dataQueue;
     private _finalQueued;
-    private _pushChain;
     readonly name: string;
     readonly level: number;
     readonly nameBytes: Uint8Array;
-    readonly commentBytes: Uint8Array;
     readonly dosTime: number;
     readonly dosDate: number;
     readonly extraField: Uint8Array;
     private readonly _flags;
-    private _compressionMethod;
+    private readonly _compressionMethod;
     private readonly _modTime;
     constructor(name: string, options?: {
         level?: number;
         modTime?: Date;
         timestamps?: ZipTimestampMode;
-        comment?: string;
-        smartStore?: boolean;
     });
-    private _buildCompressionMethod;
-    private _initDeflateStream;
     private _buildLocalHeader;
-    private _accumulateSample;
-    private _shouldDecide;
-    private _decideCompressionIfNeeded;
-    private _emitHeaderIfNeeded;
-    private _flushPendingChunks;
     private _enqueueData;
     private _flushQueue;
     get ondata(): ((data: Uint8Array, final: boolean) => void) | undefined;
     set ondata(cb: (data: Uint8Array, final: boolean) => void);
-    get onerror(): ((err: Error) => void) | undefined;
-    set onerror(cb: (err: Error) => void);
     private _resolveComplete;
     private _rejectComplete;
     private _ensureCompletePromise;
     private _tapCallback;
+    private _emitHeaderIfNeeded;
     private _writeData;
     private _endDeflateAndWait;
     private _finalizeAfterWrite;
-    private _pushUnchained;
     /**
      * Push data - immediately compresses and outputs
      * Returns a Promise that resolves when the write is complete.
@@ -128,13 +108,10 @@ export declare class StreamingZip {
     private currentOffset;
     private ended;
     private endPending;
-    private zipComment;
     private fileQueue;
     private fileQueueIndex;
     private activeFile;
-    constructor(callback: (err: Error | null, data: Uint8Array, final: boolean) => void, options?: {
-        comment?: string;
-    });
+    constructor(callback: (err: Error | null, data: Uint8Array, final: boolean) => void);
     add(file: ZipDeflateFile): void;
     private _processNextFile;
     private _finalize;

package/dist/{esm/modules/archive/zip/stream.js → browser/modules/archive/streaming-zip.js}

@@ -2,16 +2,15 @@
  * True Streaming ZIP creator - shared implementation.
  *
  * This module is intentionally platform-agnostic.
- * - In Node builds it uses `./compression/crc32` + `./compression/streaming-compress` (zlib-backed).
+ * - In Node builds it uses `./crc32` + `./streaming-compress` (zlib-backed).
  * - In browser builds the bundler aliases those imports to their browser variants.
  */
-import { crc32Update, crc32Finalize } from "../compression/crc32.js";
-import { createDeflateStream } from "../compression/streaming-compress.js";
-import { DEFAULT_ZIP_LEVEL, DEFAULT_ZIP_TIMESTAMPS } from "../defaults.js";
-import { buildZipEntryMetadata, resolveZipCompressionMethod } from "./zip-entry-metadata.js";
-import { decodeUtf8, encodeUtf8 } from "../utils/text.js";
-import { isProbablyIncompressible } from "../utils/compressibility.js";
-import { buildCentralDirectoryHeader, buildDataDescriptor, buildEndOfCentralDirectory, buildLocalFileHeader, VERSION_MADE_BY, VERSION_NEEDED } from "../zip-spec/zip-records.js";
+import { crc32Update, crc32Finalize } from "./crc32.browser.js";
+import { createDeflateStream } from "./streaming-compress.browser.js";
+import { DEFAULT_ZIP_LEVEL, DEFAULT_ZIP_TIMESTAMPS } from "./defaults.js";
+import { buildZipEntryMetadata } from "./zip-entry-metadata.js";
+import { buildCentralDirectoryHeader, buildDataDescriptor, buildEndOfCentralDirectory, buildLocalFileHeader } from "./zip-records.js";
+import { VERSION_MADE_BY, VERSION_NEEDED } from "./zip-constants.js";
 /**
  * True Streaming ZIP File - compresses chunk by chunk
  */
@@ -24,15 +23,9 @@ export class ZipDeflateFile {
         this._finalized = false;
         this._headerEmitted = false;
         this._ondata = null;
-        this._onerror = null;
         this._centralDirEntryInfo = null;
         this._pendingEnd = false;
         this._emittedDataDescriptor = false;
-        this._localHeader = null;
-        // Smart STORE: delay method selection until we sample data.
-        this._deflateWanted = null;
-        this._pendingChunks = [];
-        this._sampleLen = 0;
         // Promise resolution for completion (including data descriptor)
         this._completeResolve = null;
         this._completeReject = null;
@@ -41,70 +34,46 @@ export class ZipDeflateFile {
         // Queue for incoming data before ondata is set
         this._dataQueue = [];
         this._finalQueued = false;
-        // Serialize push() calls so callers don't need to await to preserve ordering.
-        this._pushChain = Promise.resolve();
         this.name = name;
         const modTime = options?.modTime ?? new Date();
         this._modTime = modTime;
         this.level = options?.level ?? DEFAULT_ZIP_LEVEL;
-        this._smartStore = options?.smartStore ?? true;
-        this._sampleBuffer = this._smartStore ? new Uint8Array(64 * 1024) : new Uint8Array(0);
         const metadata = buildZipEntryMetadata({
             name,
-            comment: options?.comment ?? "",
+            comment: "",
             modTime,
             timestamps: options?.timestamps ?? DEFAULT_ZIP_TIMESTAMPS,
             useDataDescriptor: true,
-            deflate: false
+            deflate: this.level > 0
         });
         this.nameBytes = metadata.nameBytes;
-        this.commentBytes = metadata.commentBytes;
         this.dosTime = metadata.dosTime;
         this.dosDate = metadata.dosDate;
         this.extraField = metadata.extraField;
         this._flags = metadata.flags;
         this._compressionMethod = metadata.compressionMethod;
-        // If smart store is disabled, decide method upfront and keep true streaming semantics.
-        if (!this._smartStore) {
-            const deflate = this.level > 0;
-            this._deflateWanted = deflate;
-            this._compressionMethod = this._buildCompressionMethod(deflate);
-            if (deflate) {
-                this._initDeflateStream();
-            }
-            return;
-        }
-        // Level 0: always STORE.
-        if (this.level === 0) {
-            this._deflateWanted = false;
-            this._compressionMethod = this._buildCompressionMethod(false);
-        }
-    }
-    _buildCompressionMethod(deflate) {
-        return resolveZipCompressionMethod(deflate);
-    }
-    _initDeflateStream() {
-        if (this._deflate) {
-            return;
+        // Create deflate stream for compression
+        if (this.level > 0) {
+            this._deflate = createDeflateStream({ level: this.level });
+            this._deflate.on("error", (err) => {
+                this._rejectComplete(err);
+            });
+            // Handle compressed output - this is true streaming!
+            this._deflate.on("data", (chunk) => {
+                this._compressedSize += chunk.length;
+                this._enqueueData(chunk, false);
+            });
+            // Handle end - emit data descriptor
+            // IMPORTANT: Only use 'end' event, NOT 'finish'!
+            // Node.js zlib emits events in order: finish -> data -> end
+            this._deflate.on("end", () => {
+                if (this._pendingEnd && !this._emittedDataDescriptor) {
+                    this._emittedDataDescriptor = true;
+                    this._emitDataDescriptor();
+                }
+            });
         }
-        this._deflate = createDeflateStream({ level: this.level });
-        this._deflate.on("error", (err) => {
-            this._rejectComplete(err);
-        });
-        // Handle compressed output - this is true streaming!
-        this._deflate.on("data", (chunk) => {
-            this._compressedSize += chunk.length;
-            this._enqueueData(chunk, false);
-        });
-        // Handle end - emit data descriptor
-        // IMPORTANT: Only use 'end' event, NOT 'finish'!
-        // Node.js zlib emits events in order: finish -> data -> end
-        this._deflate.on("end", () => {
-            if (this._pendingEnd && !this._emittedDataDescriptor) {
-                this._emittedDataDescriptor = true;
-                this._emitDataDescriptor();
-            }
-        });
+        this._localHeader = this._buildLocalHeader();
     }
     _buildLocalHeader() {
         // CRC + sizes are written via data descriptor for true streaming.
@@ -121,63 +90,6 @@ export class ZipDeflateFile {
             versionNeeded: VERSION_NEEDED
         });
     }
-    _accumulateSample(data) {
-        if (this._deflateWanted !== null) {
-            return;
-        }
-        if (this._sampleLen >= this._sampleBuffer.length) {
-            return;
-        }
-        const take = Math.min(this._sampleBuffer.length - this._sampleLen, data.length);
-        if (take <= 0) {
-            return;
-        }
-        this._sampleBuffer.set(data.subarray(0, take), this._sampleLen);
-        this._sampleLen += take;
-    }
-    _shouldDecide(final) {
-        if (this._deflateWanted !== null) {
-            return false;
-        }
-        return final || this._sampleLen >= 16 * 1024;
-    }
-    _decideCompressionIfNeeded(final) {
-        if (this._deflateWanted !== null) {
-            return;
-        }
-        // Match non-streaming builder semantics: empty files never need DEFLATE.
-        if (final && this._sampleLen === 0) {
-            this._deflateWanted = false;
-            this._compressionMethod = this._buildCompressionMethod(false);
-            this._localHeader = null;
-            return;
-        }
-        // Default to DEFLATE unless heuristic says STORE.
-        const sample = this._sampleBuffer.subarray(0, this._sampleLen);
-        const store = isProbablyIncompressible(sample);
-        this._deflateWanted = !store;
-        this._compressionMethod = this._buildCompressionMethod(this._deflateWanted);
-        this._localHeader = null;
-        if (this._deflateWanted) {
-            this._initDeflateStream();
-        }
-    }
-    _emitHeaderIfNeeded() {
-        if (this._headerEmitted) {
-            return;
-        }
-        this._emitHeader();
-        this._headerEmitted = true;
-    }
-    async _flushPendingChunks() {
-        if (this._pendingChunks.length === 0) {
-            return;
-        }
-        for (const chunk of this._pendingChunks) {
-            await this._writeData(chunk);
-        }
-        this._pendingChunks = [];
-    }
     _enqueueData(data, final) {
         if (this._ondata) {
             this._ondata(data, final);
@@ -209,29 +121,13 @@ export class ZipDeflateFile {
         // Flush any queued data
         this._flushQueue();
     }
-    get onerror() {
-        return this._onerror ?? undefined;
-    }
-    set onerror(cb) {
-        this._onerror = cb;
-        // If an error already occurred, surface it immediately.
-        if (this._completeError) {
-            cb(this._completeError);
-        }
-    }
     _resolveComplete() {
         if (this._completeResolve) {
             this._completeResolve();
         }
     }
     _rejectComplete(err) {
-        if (this._completeError) {
-            return;
-        }
         this._completeError = err;
-        if (this._onerror) {
-            this._onerror(err);
-        }
         if (this._completeReject) {
             this._completeReject(err);
         }
@@ -257,6 +153,13 @@ export class ZipDeflateFile {
         }
         promise.then(() => callback()).catch(err => callback(err));
     }
+    _emitHeaderIfNeeded() {
+        if (this._headerEmitted) {
+            return;
+        }
+        this._emitHeader();
+        this._headerEmitted = true;
+    }
     _writeData(data) {
         if (data.length === 0) {
             return Promise.resolve();
@@ -314,60 +217,27 @@ export class ZipDeflateFile {
         this._emitDataDescriptor();
         return completePromise;
     }
-    _pushUnchained(data, final, callback) {
+    /**
+     * Push data - immediately compresses and outputs
+     * Returns a Promise that resolves when the write is complete.
+     * If final=true, it resolves after the data descriptor is emitted.
+     */
+    push(data, final = false, callback) {
         if (this._finalized) {
             const promise = Promise.reject(new Error("Cannot push to finalized ZipDeflateFile"));
             this._tapCallback(promise, callback);
             return promise;
         }
-        if (this._deflateWanted === null) {
-            this._accumulateSample(data);
-            if (!this._shouldDecide(final)) {
-                if (data.length > 0) {
-                    this._pendingChunks.push(data);
-                }
-                const promise = Promise.resolve();
-                this._tapCallback(promise, callback);
-                return promise;
-            }
-            this._decideCompressionIfNeeded(final);
-            this._emitHeaderIfNeeded();
-            const hadPendingChunks = this._pendingChunks.length > 0;
-            const flushPromise = this._flushPendingChunks();
-            let writePromise = flushPromise;
-            if (data.length > 0) {
-                writePromise = hadPendingChunks
-                    ? flushPromise.then(() => this._writeData(data))
-                    : this._writeData(data);
-            }
-            const promise = final ? this._finalizeAfterWrite(writePromise) : writePromise;
-            this._tapCallback(promise, callback);
-            return promise;
-        }
         this._emitHeaderIfNeeded();
         const writePromise = this._writeData(data);
         const promise = final ? this._finalizeAfterWrite(writePromise) : writePromise;
         this._tapCallback(promise, callback);
         return promise;
     }
-    /**
-     * Push data - immediately compresses and outputs
-     * Returns a Promise that resolves when the write is complete.
-     * If final=true, it resolves after the data descriptor is emitted.
-     */
-    push(data, final = false, callback) {
-        const promise = (this._pushChain = this._pushChain.then(() => this._pushUnchained(data, final, callback)));
-        // Prevent unhandled rejection when callers intentionally ignore the Promise.
-        promise.catch(() => { });
-        return promise;
-    }
     /**
      * Emit local file header with Data Descriptor flag
      */
     _emitHeader() {
-        if (!this._localHeader) {
-            this._localHeader = this._buildLocalHeader();
-        }
         this._enqueueData(this._localHeader, false);
     }
     /**
@@ -380,7 +250,6 @@ export class ZipDeflateFile {
         this._centralDirEntryInfo = {
             name: this.nameBytes,
             extraField: this.extraField,
-            comment: this.commentBytes,
             flags: this._flags,
             crc: crcValue,
             compressedSize: this._compressedSize,
@@ -419,7 +288,7 @@ export class ZipDeflateFile {
             crc32: this._centralDirEntryInfo.crc,
             lastModified: this._modTime,
             localHeaderOffset: this._centralDirEntryInfo.offset,
-            comment: decodeUtf8(this._centralDirEntryInfo.comment),
+            comment: "",
             externalAttributes: 0,
             isEncrypted: false
         };
@@ -436,7 +305,7 @@ export class ZipDeflateFile {
  * Streaming ZIP Creator - processes files sequentially
  */
 export class StreamingZip {
-    constructor(callback, options) {
+    constructor(callback) {
         this.entries = [];
         this.currentOffset = 0;
         this.ended = false;
@@ -446,12 +315,10 @@ export class StreamingZip {
         this.fileQueueIndex = 0;
         this.activeFile = null;
         this.callback = callback;
-        // Avoid per-instance TextEncoder allocations.
-        this.zipComment = options?.comment ? encodeUtf8(options.comment) : new Uint8Array(0);
     }
     add(file) {
         if (this.ended) {
-            throw new Error("Cannot add files after calling end() ");
+            throw new Error("Cannot add files after calling end()");
         }
         this.fileQueue.push(file);
         // If no active file, process this one
@@ -474,18 +341,7 @@ export class StreamingZip {
         const file = this.fileQueue[this.fileQueueIndex++];
         this.activeFile = file;
         const startOffset = this.currentOffset;
-        const empty = new Uint8Array(0);
-        file.onerror = (err) => {
-            if (this.ended) {
-                return;
-            }
-            this.ended = true;
-            this.callback(err, empty, true);
-        };
         file.ondata = (data, final) => {
-            if (this.ended) {
-                return;
-            }
             this.currentOffset += data.length;
             this.callback(null, data, false);
             if (final) {
@@ -511,7 +367,7 @@ export class StreamingZip {
             const header = buildCentralDirectoryHeader({
                 fileName: entry.name,
                 extraField: entry.extraField,
-                comment: entry.comment ?? empty,
+                comment: empty,
                 flags: entry.flags,
                 compressionMethod: entry.compressionMethod,
                 dosTime: entry.dosTime,
@@ -530,7 +386,7 @@ export class StreamingZip {
             entryCount: this.entries.length,
             centralDirSize,
             centralDirOffset,
-            comment: this.zipComment
+            comment: empty
         });
         this.callback(null, eocd, true);
     }

package/dist/browser/modules/archive/utils/bytes.js

@@ -45,18 +45,21 @@ export function indexOfUint8ArrayPattern(buffer, pattern, startIndex = 0) {
     }
     // Fast paths for small patterns (very common in ZIP parsing: 2/3/4-byte signatures).
     if (patLen === 1) {
-        return buffer.indexOf(pattern[0], start);
+        const p0 = pattern[0];
+        for (let i = start; i < bufLen; i++) {
+            if (buffer[i] === p0) {
+                return i;
+            }
+        }
+        return -1;
     }
     if (patLen === 2) {
         const p0 = pattern[0];
         const p1 = pattern[1];
-        const last = bufLen - 2;
-        let i = buffer.indexOf(p0, start);
-        while (i !== -1 && i <= last) {
-            if (buffer[i + 1] === p1) {
+        for (let i = start; i <= bufLen - 2; i++) {
+            if (buffer[i] === p0 && buffer[i + 1] === p1) {
                 return i;
             }
-            i = buffer.indexOf(p0, i + 1);
         }
         return -1;
     }
@@ -64,13 +67,10 @@ export function indexOfUint8ArrayPattern(buffer, pattern, startIndex = 0) {
         const p0 = pattern[0];
         const p1 = pattern[1];
         const p2 = pattern[2];
-        const last = bufLen - 3;
-        let i = buffer.indexOf(p0, start);
-        while (i !== -1 && i <= last) {
-            if (buffer[i + 1] === p1 && buffer[i + 2] === p2) {
+        for (let i = start; i <= bufLen - 3; i++) {
+            if (buffer[i] === p0 && buffer[i + 1] === p1 && buffer[i + 2] === p2) {
                 return i;
             }
-            i = buffer.indexOf(p0, i + 1);
         }
         return -1;
     }
@@ -79,13 +79,13 @@ export function indexOfUint8ArrayPattern(buffer, pattern, startIndex = 0) {
         const p1 = pattern[1];
         const p2 = pattern[2];
         const p3 = pattern[3];
-        const last = bufLen - 4;
-        let i = buffer.indexOf(p0, start);
-        while (i !== -1 && i <= last) {
-            if (buffer[i + 1] === p1 && buffer[i + 2] === p2 && buffer[i + 3] === p3) {
+        for (let i = start; i <= bufLen - 4; i++) {
+            if (buffer[i] === p0 &&
+                buffer[i + 1] === p1 &&
+                buffer[i + 2] === p2 &&
+                buffer[i + 3] === p3) {
                 return i;
             }
-            i = buffer.indexOf(p0, i + 1);
         }
         return -1;
     }