7z-iterator 1.1.2 → 1.3.0

package/dist/esm/sevenz/FolderStreamSplitter.d.ts

@@ -0,0 +1,101 @@
+/**
+ * FolderStreamSplitter - Splits a decompressed folder stream into individual file streams
+ *
+ * For multi-file solid archives, the folder is decompressed as a single stream.
+ * This class splits that stream into individual file streams based on known file boundaries.
+ *
+ * Features:
+ * - Lazy stream creation (streams created on first access)
+ * - Backpressure propagation (returns false when downstream is full)
+ * - Running CRC verification per file
+ * - Automatic cleanup of completed streams
+ */
+import type Stream from 'stream';
+export interface FolderStreamSplitterOptions {
+    /** Sizes of each file in the folder (in order) */
+    fileSizes: number[];
+    /** Whether to verify CRC for each file */
+    verifyCrc?: boolean;
+    /** Expected CRCs for each file (parallel to fileSizes) */
+    expectedCrcs?: (number | undefined)[];
+}
+/**
+ * Splits a decompressed folder stream into individual file streams.
+ *
+ * Usage:
+ * ```
+ * const splitter = new FolderStreamSplitter({ fileSizes: [1000, 2000, 500] });
+ *
+ * decompressStream.on('data', (chunk) => {
+ *   if (!splitter.write(chunk)) {
+ *     decompressStream.pause();
+ *     splitter.onDrain(() => decompressStream.resume());
+ *   }
+ * });
+ * decompressStream.on('end', () => splitter.end());
+ *
+ * // Get stream for file at index 1 (created lazily)
+ * const fileStream = splitter.getFileStream(1);
+ * ```
+ */
+export declare class FolderStreamSplitter {
+    private fileBoundaries;
+    private fileStreams;
+    private fileCrcs;
+    private currentFileIndex;
+    private bytesWritten;
+    private currentFileEnd;
+    private verifyCrc;
+    private expectedCrcs;
+    private finished;
+    private error;
+    private drainCallbacks;
+    private _needsDrain;
+    constructor(options: FolderStreamSplitterOptions);
+    /**
+     * Write decompressed data chunk. Data is routed to appropriate file stream(s).
+     * Returns false if backpressure should be applied (downstream is full).
+     */
+    write(chunk: Buffer): boolean;
+    /**
+     * Ensure stream exists for file index (lazy creation)
+     */
+    private ensureFileStream;
+    /**
+     * Complete current file and move to next
+     */
+    private finishCurrentFile;
+    /**
+     * Signal end of decompressed data
+     */
+    end(): void;
+    /**
+     * Emit error to all pending file streams
+     */
+    private emitError;
+    /**
+     * Get the stream for a specific file by index.
+     * Stream is created lazily on first access.
+     */
+    getFileStream(fileIndex: number): Stream.PassThrough;
+    /**
+     * Register callback for when backpressure clears
+     */
+    onDrain(callback: () => void): void;
+    /**
+     * Notify all drain callbacks
+     */
+    private notifyDrain;
+    /**
+     * Check if a specific file's stream has been fully written
+     */
+    isFileComplete(fileIndex: number): boolean;
+    /**
+     * Get total number of files in this folder
+     */
+    get fileCount(): number;
+    /**
+     * Check if splitter has encountered an error
+     */
+    getError(): Error | null;
+}

package/dist/esm/sevenz/FolderStreamSplitter.js

@@ -0,0 +1,207 @@
+/**
+ * FolderStreamSplitter - Splits a decompressed folder stream into individual file streams
+ *
+ * For multi-file solid archives, the folder is decompressed as a single stream.
+ * This class splits that stream into individual file streams based on known file boundaries.
+ *
+ * Features:
+ * - Lazy stream creation (streams created on first access)
+ * - Backpressure propagation (returns false when downstream is full)
+ * - Running CRC verification per file
+ * - Automatic cleanup of completed streams
+ */ import { crc32, PassThrough } from 'extract-base-iterator';
+/**
+ * Splits a decompressed folder stream into individual file streams.
+ *
+ * Usage:
+ * ```
+ * const splitter = new FolderStreamSplitter({ fileSizes: [1000, 2000, 500] });
+ *
+ * decompressStream.on('data', (chunk) => {
+ *   if (!splitter.write(chunk)) {
+ *     decompressStream.pause();
+ *     splitter.onDrain(() => decompressStream.resume());
+ *   }
+ * });
+ * decompressStream.on('end', () => splitter.end());
+ *
+ * // Get stream for file at index 1 (created lazily)
+ * const fileStream = splitter.getFileStream(1);
+ * ```
+ */ export class FolderStreamSplitter {
+    /**
+   * Write decompressed data chunk. Data is routed to appropriate file stream(s).
+   * Returns false if backpressure should be applied (downstream is full).
+   */ write(chunk) {
+        if (this.finished || this.error) return true;
+        let offset = 0;
+        let canContinue = true;
+        while(offset < chunk.length && this.currentFileIndex < this.fileStreams.length){
+            const remaining = chunk.length - offset;
+            const neededForFile = this.currentFileEnd - this.bytesWritten;
+            const toWrite = Math.min(remaining, neededForFile);
+            if (toWrite > 0) {
+                const fileChunk = chunk.slice(offset, offset + toWrite);
+                // Ensure stream exists (lazy creation)
+                const fileStream = this.ensureFileStream(this.currentFileIndex);
+                // Update CRC
+                if (this.verifyCrc) {
+                    this.fileCrcs[this.currentFileIndex] = crc32(fileChunk, this.fileCrcs[this.currentFileIndex]);
+                }
+                // Write to file stream, track backpressure
+                if (!fileStream.write(fileChunk)) {
+                    canContinue = false;
+                    this._needsDrain = true;
+                    fileStream.once('drain', ()=>{
+                        this._needsDrain = false;
+                        this.notifyDrain();
+                    });
+                }
+            }
+            this.bytesWritten += toWrite;
+            offset += toWrite;
+            // Check if current file is complete
+            if (this.bytesWritten >= this.currentFileEnd) {
+                this.finishCurrentFile();
+            }
+        }
+        return canContinue;
+    }
+    /**
+   * Ensure stream exists for file index (lazy creation)
+   */ ensureFileStream(fileIndex) {
+        let stream = this.fileStreams[fileIndex];
+        if (!stream) {
+            stream = new PassThrough();
+            this.fileStreams[fileIndex] = stream;
+        }
+        return stream;
+    }
+    /**
+   * Complete current file and move to next
+   */ finishCurrentFile() {
+        const fileStream = this.fileStreams[this.currentFileIndex];
+        // Verify CRC if enabled
+        if (this.verifyCrc) {
+            const expectedCrc = this.expectedCrcs[this.currentFileIndex];
+            if (expectedCrc !== undefined && this.fileCrcs[this.currentFileIndex] !== expectedCrc) {
+                const err = new Error(`CRC mismatch for file ${this.currentFileIndex}: expected ${expectedCrc.toString(16)}, got ${this.fileCrcs[this.currentFileIndex].toString(16)}`);
+                this.emitError(err);
+                return;
+            }
+        }
+        // End this file's stream
+        if (fileStream) {
+            fileStream.end();
+        }
+        // Release reference for GC
+        this.fileStreams[this.currentFileIndex] = null;
+        // Move to next file
+        this.currentFileIndex++;
+        if (this.currentFileIndex < this.fileBoundaries.length - 1) {
+            this.currentFileEnd = this.fileBoundaries[this.currentFileIndex + 1];
+        }
+    }
+    /**
+   * Signal end of decompressed data
+   */ end() {
+        if (this.finished) return;
+        this.finished = true;
+        // End any remaining streams
+        for(let i = this.currentFileIndex; i < this.fileStreams.length; i++){
+            const stream = this.fileStreams[i];
+            if (stream) {
+                stream.end();
+            }
+            this.fileStreams[i] = null;
+        }
+    }
+    /**
+   * Emit error to all pending file streams
+   */ emitError(err) {
+        this.error = err;
+        for(let i = this.currentFileIndex; i < this.fileStreams.length; i++){
+            const stream = this.fileStreams[i];
+            if (stream) {
+                stream.emit('error', err);
+                stream.end();
+            }
+            this.fileStreams[i] = null;
+        }
+    }
+    /**
+   * Get the stream for a specific file by index.
+   * Stream is created lazily on first access.
+   */ getFileStream(fileIndex) {
+        if (fileIndex < 0 || fileIndex >= this.fileBoundaries.length - 1) {
+            throw new Error(`Invalid file index: ${fileIndex}`);
+        }
+        // Check if file already completed
+        if (fileIndex < this.currentFileIndex) {
+            throw new Error(`File ${fileIndex} already completed - streams must be accessed in order`);
+        }
+        return this.ensureFileStream(fileIndex);
+    }
+    /**
+   * Register callback for when backpressure clears
+   */ onDrain(callback) {
+        if (!this._needsDrain) {
+            callback();
+        } else {
+            this.drainCallbacks.push(callback);
+        }
+    }
+    /**
+   * Notify all drain callbacks
+   */ notifyDrain() {
+        const callbacks = this.drainCallbacks;
+        this.drainCallbacks = [];
+        for(let i = 0; i < callbacks.length; i++){
+            callbacks[i]();
+        }
+    }
+    /**
+   * Check if a specific file's stream has been fully written
+   */ isFileComplete(fileIndex) {
+        return fileIndex < this.currentFileIndex;
+    }
+    /**
+   * Get total number of files in this folder
+   */ get fileCount() {
+        return this.fileBoundaries.length - 1;
+    }
+    /**
+   * Check if splitter has encountered an error
+   */ getError() {
+        return this.error;
+    }
+    constructor(options){
+        const fileSizes = options.fileSizes;
+        const verifyCrc = options.verifyCrc !== undefined ? options.verifyCrc : true;
+        const expectedCrcs = options.expectedCrcs || [];
+        this.verifyCrc = verifyCrc;
+        this.expectedCrcs = expectedCrcs;
+        this.currentFileIndex = 0;
+        this.bytesWritten = 0;
+        this.finished = false;
+        this.error = null;
+        this.drainCallbacks = [];
+        this._needsDrain = false;
+        // Calculate cumulative boundaries
+        this.fileBoundaries = [
+            0
+        ];
+        for(let i = 0; i < fileSizes.length; i++){
+            this.fileBoundaries.push(this.fileBoundaries[this.fileBoundaries.length - 1] + fileSizes[i]);
+        }
+        // Initialize streams array (lazy creation - all null initially)
+        this.fileStreams = [];
+        this.fileCrcs = [];
+        for(let i = 0; i < fileSizes.length; i++){
+            this.fileStreams.push(null);
+            this.fileCrcs.push(0);
+        }
+        // Set first file boundary
+        this.currentFileEnd = this.fileBoundaries[1] || 0;
+    }
+}

package/dist/esm/sevenz/FolderStreamSplitter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/FolderStreamSplitter.ts"],"sourcesContent":["/**\n * FolderStreamSplitter - Splits a decompressed folder stream into individual file streams\n *\n * For multi-file solid archives, the folder is decompressed as a single stream.\n * This class splits that stream into individual file streams based on known file boundaries.\n *\n * Features:\n * - Lazy stream creation (streams created on first access)\n * - Backpressure propagation (returns false when downstream is full)\n * - Running CRC verification per file\n * - Automatic cleanup of completed streams\n */\n\nimport { crc32, PassThrough } from 'extract-base-iterator';\nimport type Stream from 'stream';\n\nexport interface FolderStreamSplitterOptions {\n  /** Sizes of each file in the folder (in order) */\n  fileSizes: number[];\n  /** Whether to verify CRC for each file */\n  verifyCrc?: boolean;\n  /** Expected CRCs for each file (parallel to fileSizes) */\n  expectedCrcs?: (number | undefined)[];\n}\n\n/**\n * Splits a decompressed folder stream into individual file streams.\n *\n * Usage:\n * ```\n * const splitter = new FolderStreamSplitter({ fileSizes: [1000, 2000, 500] });\n *\n * decompressStream.on('data', (chunk) => {\n *   if (!splitter.write(chunk)) {\n *     decompressStream.pause();\n *     splitter.onDrain(() => decompressStream.resume());\n *   }\n * });\n * decompressStream.on('end', () => splitter.end());\n *\n * // Get stream for file at index 1 (created lazily)\n * const fileStream = splitter.getFileStream(1);\n * ```\n */\nexport class FolderStreamSplitter {\n  private fileBoundaries: number[]; // Cumulative offsets [0, size1, size1+size2, ...]\n  private fileStreams: (Stream.PassThrough | null)[]; // Lazy-created, null after completion\n  private fileCrcs: number[]; // Running CRC per file\n  private currentFileIndex: number;\n  private bytesWritten: number;\n  private currentFileEnd: number;\n  private verifyCrc: boolean;\n  private expectedCrcs: (number | undefined)[];\n  private finished: boolean;\n  private error: Error | null;\n  private drainCallbacks: (() => void)[];\n  private _needsDrain: boolean;\n\n  constructor(options: FolderStreamSplitterOptions) {\n    const fileSizes = options.fileSizes;\n    const verifyCrc = options.verifyCrc !== undefined ? options.verifyCrc : true;\n    const expectedCrcs = options.expectedCrcs || [];\n\n    this.verifyCrc = verifyCrc;\n    this.expectedCrcs = expectedCrcs;\n    this.currentFileIndex = 0;\n    this.bytesWritten = 0;\n    this.finished = false;\n    this.error = null;\n    this.drainCallbacks = [];\n    this._needsDrain = false;\n\n    // Calculate cumulative boundaries\n    this.fileBoundaries = [0];\n    for (let i = 0; i < fileSizes.length; i++) {\n      this.fileBoundaries.push(this.fileBoundaries[this.fileBoundaries.length - 1] + fileSizes[i]);\n    }\n\n    // Initialize streams array (lazy creation - all null initially)\n    this.fileStreams = [];\n    this.fileCrcs = [];\n    for (let i = 0; i < fileSizes.length; i++) {\n      this.fileStreams.push(null);\n      this.fileCrcs.push(0);\n    }\n\n    // Set first file boundary\n    this.currentFileEnd = this.fileBoundaries[1] || 0;\n  }\n\n  /**\n   * Write decompressed data chunk. Data is routed to appropriate file stream(s).\n   * Returns false if backpressure should be applied (downstream is full).\n   */\n  write(chunk: Buffer): boolean {\n    if (this.finished || this.error) return true;\n\n    let offset = 0;\n    let canContinue = true;\n\n    while (offset < chunk.length && this.currentFileIndex < this.fileStreams.length) {\n      const remaining = chunk.length - offset;\n      const neededForFile = this.currentFileEnd - this.bytesWritten;\n      const toWrite = Math.min(remaining, neededForFile);\n\n      if (toWrite > 0) {\n        const fileChunk = chunk.slice(offset, offset + toWrite);\n\n        // Ensure stream exists (lazy creation)\n        const fileStream = this.ensureFileStream(this.currentFileIndex);\n\n        // Update CRC\n        if (this.verifyCrc) {\n          this.fileCrcs[this.currentFileIndex] = crc32(fileChunk, this.fileCrcs[this.currentFileIndex]);\n        }\n\n        // Write to file stream, track backpressure\n        if (!fileStream.write(fileChunk)) {\n          canContinue = false;\n          this._needsDrain = true;\n          fileStream.once('drain', () => {\n            this._needsDrain = false;\n            this.notifyDrain();\n          });\n        }\n      }\n\n      this.bytesWritten += toWrite;\n      offset += toWrite;\n\n      // Check if current file is complete\n      if (this.bytesWritten >= this.currentFileEnd) {\n        this.finishCurrentFile();\n      }\n    }\n\n    return canContinue;\n  }\n\n  /**\n   * Ensure stream exists for file index (lazy creation)\n   */\n  private ensureFileStream(fileIndex: number): Stream.PassThrough {\n    let stream = this.fileStreams[fileIndex];\n    if (!stream) {\n      stream = new PassThrough();\n      this.fileStreams[fileIndex] = stream;\n    }\n    return stream;\n  }\n\n  /**\n   * Complete current file and move to next\n   */\n  private finishCurrentFile(): void {\n    const fileStream = this.fileStreams[this.currentFileIndex];\n\n    // Verify CRC if enabled\n    if (this.verifyCrc) {\n      const expectedCrc = this.expectedCrcs[this.currentFileIndex];\n      if (expectedCrc !== undefined && this.fileCrcs[this.currentFileIndex] !== expectedCrc) {\n        const err = new Error(`CRC mismatch for file ${this.currentFileIndex}: expected ${expectedCrc.toString(16)}, got ${this.fileCrcs[this.currentFileIndex].toString(16)}`);\n        this.emitError(err);\n        return;\n      }\n    }\n\n    // End this file's stream\n    if (fileStream) {\n      fileStream.end();\n    }\n\n    // Release reference for GC\n    this.fileStreams[this.currentFileIndex] = null;\n\n    // Move to next file\n    this.currentFileIndex++;\n    if (this.currentFileIndex < this.fileBoundaries.length - 1) {\n      this.currentFileEnd = this.fileBoundaries[this.currentFileIndex + 1];\n    }\n  }\n\n  /**\n   * Signal end of decompressed data\n   */\n  end(): void {\n    if (this.finished) return;\n    this.finished = true;\n\n    // End any remaining streams\n    for (let i = this.currentFileIndex; i < this.fileStreams.length; i++) {\n      const stream = this.fileStreams[i];\n      if (stream) {\n        stream.end();\n      }\n      this.fileStreams[i] = null;\n    }\n  }\n\n  /**\n   * Emit error to all pending file streams\n   */\n  private emitError(err: Error): void {\n    this.error = err;\n    for (let i = this.currentFileIndex; i < this.fileStreams.length; i++) {\n      const stream = this.fileStreams[i];\n      if (stream) {\n        stream.emit('error', err);\n        stream.end();\n      }\n      this.fileStreams[i] = null;\n    }\n  }\n\n  /**\n   * Get the stream for a specific file by index.\n   * Stream is created lazily on first access.\n   */\n  getFileStream(fileIndex: number): Stream.PassThrough {\n    if (fileIndex < 0 || fileIndex >= this.fileBoundaries.length - 1) {\n      throw new Error(`Invalid file index: ${fileIndex}`);\n    }\n\n    // Check if file already completed\n    if (fileIndex < this.currentFileIndex) {\n      throw new Error(`File ${fileIndex} already completed - streams must be accessed in order`);\n    }\n\n    return this.ensureFileStream(fileIndex);\n  }\n\n  /**\n   * Register callback for when backpressure clears\n   */\n  onDrain(callback: () => void): void {\n    if (!this._needsDrain) {\n      callback();\n    } else {\n      this.drainCallbacks.push(callback);\n    }\n  }\n\n  /**\n   * Notify all drain callbacks\n   */\n  private notifyDrain(): void {\n    const callbacks = this.drainCallbacks;\n    this.drainCallbacks = [];\n    for (let i = 0; i < callbacks.length; i++) {\n      callbacks[i]();\n    }\n  }\n\n  /**\n   * Check if a specific file's stream has been fully written\n   */\n  isFileComplete(fileIndex: number): boolean {\n    return fileIndex < this.currentFileIndex;\n  }\n\n  /**\n   * Get total number of files in this folder\n   */\n  get fileCount(): number {\n    return this.fileBoundaries.length - 1;\n  }\n\n  /**\n   * Check if splitter has encountered an error\n   */\n  getError(): Error | null {\n    return this.error;\n  }\n}\n"],"names":["crc32","PassThrough","FolderStreamSplitter","write","chunk","finished","error","offset","canContinue","length","currentFileIndex","fileStreams","remaining","neededForFile","currentFileEnd","bytesWritten","toWrite","Math","min","fileChunk","slice","fileStream","ensureFileStream","verifyCrc","fileCrcs","_needsDrain","once","notifyDrain","finishCurrentFile","fileIndex","stream","expectedCrc","expectedCrcs","undefined","err","Error","toString","emitError","end","fileBoundaries","i","emit","getFileStream","onDrain","callback","drainCallbacks","push","callbacks","isFileComplete","fileCount","getError","options","fileSizes"],"mappings":"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"}

package/dist/esm/sevenz/SevenZipParser.d.ts

@@ -17,7 +17,7 @@
  * - Non-solid: one file per folder
  * - Supports LZMA, LZMA2, COPY, BCJ2, and other codecs
  */
-import Stream from 'stream';
+import type Stream from 'stream';
 import type { ArchiveSource } from './ArchiveSource.js';
 type Readable = Stream.Readable;
 export { type ArchiveSource, BufferSource, FileSource } from './ArchiveSource.js';
@@ -36,6 +36,7 @@ export interface SevenZipEntry {
     _streamIndexInFolder: number;
     _hasStream: boolean;
     _crc?: number;
+    _canStream: boolean;
 }
 /**
  * SevenZipParser - parses 7z archives and provides entry iteration
@@ -50,6 +51,7 @@ export declare class SevenZipParser {
     private decompressedCache;
     private filesPerFolder;
     private extractedPerFolder;
+    private folderSplitters;
     constructor(source: ArchiveSource);
     /**
      * Parse the archive structure
@@ -78,14 +80,21 @@ export declare class SevenZipParser {
      */
     getEntries(): SevenZipEntry[];
     /**
-     * Get a readable stream for an entry's content
+     * Get a readable stream for an entry's content.
+     * Returns immediately - decompression happens when data is read (proper streaming).
+     * Uses true streaming for codecs that support it, buffered for others.
      */
     getEntryStream(entry: SevenZipEntry): Readable;
     /**
-     * Get a readable stream for an entry's content (callback-based async version)
-     * Uses streaming decompression for non-blocking I/O
+     * True streaming: data flows through without buffering entire folder.
+     * Only used for single-file folders with streamable codecs (BZip2, Deflate, LZMA2).
      */
-    getEntryStreamAsync(entry: SevenZipEntry, callback: (err: Error | null, stream?: Readable) => void): void;
+    private _getEntryStreamStreaming;
+    /**
+     * Buffered extraction: decompress entire folder, slice out file.
+     * Used for codecs that don't support incremental streaming (LZMA1, BCJ2).
+     */
+    private _getEntryStreamBuffered;
     /**
      * Check if a folder uses BCJ2 codec
      */
@@ -95,11 +104,6 @@ export declare class SevenZipParser {
      * Only caches when multiple files share a block, releases when last file extracted
      */
     private getDecompressedFolder;
-    /**
-     * Get decompressed data for a folder using streaming (callback-based async)
-     * Uses createDecoder() streams for non-blocking decompression
-     */
-    private getDecompressedFolderAsync;
     /**
      * Decompress a BCJ2 folder with multi-stream handling
      * BCJ2 uses 4 input streams: main, call, jump, range coder
@@ -113,4 +117,61 @@ export declare class SevenZipParser {
      * Close the parser and release resources
      */
     close(): void;
+    /**
+     * Check if a codec supports true streaming decompression.
+     *
+     * Only codecs that process data incrementally (not buffering entire input) qualify.
+     * @param codecId - The codec ID as an array of bytes
+     * @returns true if the codec can stream
+     */
+    private codecSupportsStreaming;
+    /**
+     * Check if a folder can be streamed (vs buffered).
+     *
+     * Streaming is possible when ALL codecs in the chain support streaming.
+     * BCJ2 folders are never streamable due to their 4-stream architecture.
+     *
+     * @param folderIndex - Index of the folder to check
+     * @returns true if the folder can be streamed
+     */
+    canStreamFolder(folderIndex: number): boolean;
+    /**
+     * Stream a folder's decompression.
+     *
+     * Creates a pipeline: packed data → codec decoders → output stream
+     *
+     * @param folderIndex - Index of folder to decompress
+     * @returns Object with output stream and control methods
+     */
+    streamFolder(folderIndex: number): {
+        output: Readable;
+        pause: () => void;
+        resume: () => void;
+        destroy: (err?: Error) => void;
+    };
+    /**
+     * Get a streaming entry stream (Promise-based API).
+     *
+     * For streamable folders: Returns a true streaming decompression
+     * For non-streamable folders: Falls back to buffered extraction
+     *
+     * @param entry - The entry to get stream for
+     * @returns Promise resolving to readable stream
+     */
+    getEntryStreamStreaming(entry: SevenZipEntry): Promise<Readable>;
+    /**
+     * Direct streaming for single-file folders.
+     * Pipes folder decompression directly to output with CRC verification.
+     */
+    private getEntryStreamDirect;
+    /**
+     * Get stream from folder splitter (for multi-file folders).
+     * Creates splitter on first access, reuses for subsequent files in same folder.
+     */
+    private getEntryStreamFromSplitter;
+    /**
+     * Get file sizes and CRCs for all files in a folder (in stream order).
+     * Used by FolderStreamSplitter to know file boundaries.
+     */
+    private getFolderFileInfo;
 }