7z-iterator 0.1.0

package/dist/esm/lib/streamToSource.js

@@ -0,0 +1,100 @@
+// Hybrid stream handling: buffers in memory up to threshold, then switches to temp file
+import once from 'call-once-fn';
+import { bufferFrom } from 'extract-base-iterator';
+import fs from 'fs';
+import mkdirp from 'mkdirp-classic';
+import oo from 'on-one';
+import path from 'path';
+import { BufferSource, FileSource } from '../sevenz/SevenZipParser.js';
+// Default memory threshold: 100 MB
+var DEFAULT_MEMORY_THRESHOLD = 100 * 1024 * 1024;
+/**
+ * Convert a stream to an ArchiveSource (BufferSource for small files, FileSource for large)
+ *
+ * Algorithm:
+ * 1. Buffer stream data in memory up to memoryThreshold
+ * 2. If threshold exceeded, write all buffered data to temp file and continue streaming
+ * 3. When done, return BufferSource for memory buffer or FileSource for temp file
+ */ export default function streamToSource(stream, options, callback) {
+    var threshold = options.memoryThreshold !== undefined ? options.memoryThreshold : DEFAULT_MEMORY_THRESHOLD;
+    var tempPath = options.tempPath;
+    var chunks = [];
+    var totalSize = 0;
+    var writeStream = null;
+    var useTempFile = false;
+    var end = once(callback);
+    function onData(chunk) {
+        // Convert string chunks to Buffer
+        var buf = typeof chunk === 'string' ? bufferFrom(chunk) : chunk;
+        totalSize += buf.length;
+        if (!useTempFile && totalSize <= threshold) {
+            // Still under threshold - buffer in memory
+            chunks.push(buf);
+        } else if (!useTempFile) {
+            // Just exceeded threshold - switch to temp file
+            useTempFile = true;
+            if (!tempPath) {
+                end(new Error('memoryThreshold exceeded but no tempPath provided'));
+                return;
+            }
+            mkdirp.sync(path.dirname(tempPath));
+            writeStream = fs.createWriteStream(tempPath);
+            // Write all buffered chunks to temp file
+            for(var i = 0; i < chunks.length; i++){
+                writeStream.write(chunks[i]);
+            }
+            chunks = []; // Allow GC
+            // Write current chunk
+            writeStream.write(buf);
+        } else {
+            // Already using temp file - write directly
+            if (writeStream) {
+                writeStream.write(buf);
+            }
+        }
+    }
+    function onEnd() {
+        if (useTempFile && writeStream && tempPath) {
+            // Close write stream, then open for reading
+            var filePath = tempPath; // Capture for closure
+            writeStream.end(()=>{
+                fs.open(filePath, 'r', (err, fd)=>{
+                    if (err) return end(err);
+                    fs.stat(filePath, (statErr, stats)=>{
+                        if (statErr) {
+                            fs.closeSync(fd);
+                            return end(statErr);
+                        }
+                        end(null, {
+                            source: new FileSource(fd, stats.size),
+                            fd: fd,
+                            tempPath: filePath
+                        });
+                    });
+                });
+            });
+        } else {
+            // Use memory buffer
+            var fullBuffer = Buffer.concat(chunks);
+            end(null, {
+                source: new BufferSource(fullBuffer)
+            });
+        }
+    }
+    function onError(err) {
+        // Clean up if we created a temp file
+        if (writeStream) {
+            writeStream.end();
+        }
+        end(err);
+    }
+    stream.on('data', onData);
+    oo(stream, [
+        'error'
+    ], onError);
+    oo(stream, [
+        'end',
+        'close',
+        'finish'
+    ], onEnd);
+}

package/dist/esm/lib/streamToSource.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/lib/streamToSource.ts"],"sourcesContent":["// Hybrid stream handling: buffers in memory up to threshold, then switches to temp file\nimport once from 'call-once-fn';\nimport { bufferFrom } from 'extract-base-iterator';\nimport fs from 'fs';\nimport mkdirp from 'mkdirp-classic';\nimport oo from 'on-one';\nimport path from 'path';\nimport { BufferSource, FileSource } from '../sevenz/SevenZipParser.ts';\n\n// Default memory threshold: 100 MB\nvar DEFAULT_MEMORY_THRESHOLD = 100 * 1024 * 1024;\n\nexport interface StreamToSourceOptions {\n  memoryThreshold?: number;\n  tempPath?: string;\n}\n\nexport interface SourceResult {\n  source: BufferSource | FileSource;\n  fd?: number; // Set if FileSource was used (caller must close)\n  tempPath?: string; // Set if temp file was created (caller must clean up)\n}\n\nexport type Callback = (error?: Error, result?: SourceResult) => void;\n\n/**\n * Convert a stream to an ArchiveSource (BufferSource for small files, FileSource for large)\n *\n * Algorithm:\n * 1. Buffer stream data in memory up to memoryThreshold\n * 2. If threshold exceeded, write all buffered data to temp file and continue streaming\n * 3. When done, return BufferSource for memory buffer or FileSource for temp file\n */\nexport default function streamToSource(stream: NodeJS.ReadableStream, options: StreamToSourceOptions, callback: Callback): void {\n  var threshold = options.memoryThreshold !== undefined ? options.memoryThreshold : DEFAULT_MEMORY_THRESHOLD;\n  var tempPath = options.tempPath;\n\n  var chunks: Buffer[] = [];\n  var totalSize = 0;\n  var writeStream: fs.WriteStream | null = null;\n  var useTempFile = false;\n\n  var end = once(callback);\n\n  function onData(chunk: Buffer | string): void {\n    // Convert string chunks to Buffer\n    var buf = typeof chunk === 'string' ? bufferFrom(chunk) : chunk;\n    totalSize += buf.length;\n\n    if (!useTempFile && totalSize <= threshold) {\n      // Still under threshold - buffer in memory\n      chunks.push(buf);\n    } else if (!useTempFile) {\n      // Just exceeded threshold - switch to temp file\n      useTempFile = true;\n\n      if (!tempPath) {\n        end(new Error('memoryThreshold exceeded but no tempPath provided'));\n        return;\n      }\n\n      mkdirp.sync(path.dirname(tempPath));\n      writeStream = fs.createWriteStream(tempPath);\n\n      // Write all buffered chunks to temp file\n      for (var i = 0; i < chunks.length; i++) {\n        writeStream.write(chunks[i]);\n      }\n      chunks = []; // Allow GC\n\n      // Write current chunk\n      writeStream.write(buf);\n    } else {\n      // Already using temp file - write directly\n      if (writeStream) {\n        writeStream.write(buf);\n      }\n    }\n  }\n\n  function onEnd(): void {\n    if (useTempFile && writeStream && tempPath) {\n      // Close write stream, then open for reading\n      var filePath = tempPath; // Capture for closure\n      writeStream.end(() => {\n        fs.open(filePath, 'r', (err, fd) => {\n          if (err) return end(err);\n          fs.stat(filePath, (statErr, stats) => {\n            if (statErr) {\n              fs.closeSync(fd);\n              return end(statErr);\n            }\n            end(null, {\n              source: new FileSource(fd, stats.size),\n              fd: fd,\n              tempPath: filePath,\n            });\n          });\n        });\n      });\n    } else {\n      // Use memory buffer\n      var fullBuffer = Buffer.concat(chunks);\n      end(null, {\n        source: new BufferSource(fullBuffer),\n      });\n    }\n  }\n\n  function onError(err: Error): void {\n    // Clean up if we created a temp file\n    if (writeStream) {\n      writeStream.end();\n    }\n    end(err);\n  }\n\n  stream.on('data', onData);\n  oo(stream, ['error'], onError);\n  oo(stream, ['end', 'close', 'finish'], onEnd);\n}\n"],"names":["once","bufferFrom","fs","mkdirp","oo","path","BufferSource","FileSource","DEFAULT_MEMORY_THRESHOLD","streamToSource","stream","options","callback","threshold","memoryThreshold","undefined","tempPath","chunks","totalSize","writeStream","useTempFile","end","onData","chunk","buf","length","push","Error","sync","dirname","createWriteStream","i","write","onEnd","filePath","open","err","fd","stat","statErr","stats","closeSync","source","size","fullBuffer","Buffer","concat","onError","on"],"mappings":"AAAA,wFAAwF;AACxF,OAAOA,UAAU,eAAe;AAChC,SAASC,UAAU,QAAQ,wBAAwB;AACnD,OAAOC,QAAQ,KAAK;AACpB,OAAOC,YAAY,iBAAiB;AACpC,OAAOC,QAAQ,SAAS;AACxB,OAAOC,UAAU,OAAO;AACxB,SAASC,YAAY,EAAEC,UAAU,QAAQ,8BAA8B;AAEvE,mCAAmC;AACnC,IAAIC,2BAA2B,MAAM,OAAO;AAe5C;;;;;;;CAOC,GACD,eAAe,SAASC,eAAeC,MAA6B,EAAEC,OAA8B,EAAEC,QAAkB;IACtH,IAAIC,YAAYF,QAAQG,eAAe,KAAKC,YAAYJ,QAAQG,eAAe,GAAGN;IAClF,IAAIQ,WAAWL,QAAQK,QAAQ;IAE/B,IAAIC,SAAmB,EAAE;IACzB,IAAIC,YAAY;IAChB,IAAIC,cAAqC;IACzC,IAAIC,cAAc;IAElB,IAAIC,MAAMrB,KAAKY;IAEf,SAASU,OAAOC,KAAsB;QACpC,kCAAkC;QAClC,IAAIC,MAAM,OAAOD,UAAU,WAAWtB,WAAWsB,SAASA;QAC1DL,aAAaM,IAAIC,MAAM;QAEvB,IAAI,CAACL,eAAeF,aAAaL,WAAW;YAC1C,2CAA2C;YAC3CI,OAAOS,IAAI,CAACF;QACd,OAAO,IAAI,CAACJ,aAAa;YACvB,gDAAgD;YAChDA,cAAc;YAEd,IAAI,CAACJ,UAAU;gBACbK,IAAI,IAAIM,MAAM;gBACd;YACF;YAEAxB,OAAOyB,IAAI,CAACvB,KAAKwB,OAAO,CAACb;YACzBG,cAAcjB,GAAG4B,iBAAiB,CAACd;YAEnC,yCAAyC;YACzC,IAAK,IAAIe,IAAI,GAAGA,IAAId,OAAOQ,MAAM,EAAEM,IAAK;gBACtCZ,YAAYa,KAAK,CAACf,MAAM,CAACc,EAAE;YAC7B;YACAd,SAAS,EAAE,EAAE,WAAW;YAExB,sBAAsB;YACtBE,YAAYa,KAAK,CAACR;QACpB,OAAO;YACL,2CAA2C;YAC3C,IAAIL,aAAa;gBACfA,YAAYa,KAAK,CAACR;YACpB;QACF;IACF;IAEA,SAASS;QACP,IAAIb,eAAeD,eAAeH,UAAU;YAC1C,4CAA4C;YAC5C,IAAIkB,WAAWlB,UAAU,sBAAsB;YAC/CG,YAAYE,GAAG,CAAC;gBACdnB,GAAGiC,IAAI,CAACD,UAAU,KAAK,CAACE,KAAKC;oBAC3B,IAAID,KAAK,OAAOf,IAAIe;oBACpBlC,GAAGoC,IAAI,CAACJ,UAAU,CAACK,SAASC;wBAC1B,IAAID,SAAS;4BACXrC,GAAGuC,SAAS,CAACJ;4BACb,OAAOhB,IAAIkB;wBACb;wBACAlB,IAAI,MAAM;4BACRqB,QAAQ,IAAInC,WAAW8B,IAAIG,MAAMG,IAAI;4BACrCN,IAAIA;4BACJrB,UAAUkB;wBACZ;oBACF;gBACF;YACF;QACF,OAAO;YACL,oBAAoB;YACpB,IAAIU,aAAaC,OAAOC,MAAM,CAAC7B;YAC/BI,IAAI,MAAM;gBACRqB,QAAQ,IAAIpC,aAAasC;YAC3B;QACF;IACF;IAEA,SAASG,QAAQX,GAAU;QACzB,qCAAqC;QACrC,IAAIjB,aAAa;YACfA,YAAYE,GAAG;QACjB;QACAA,IAAIe;IACN;IAEA1B,OAAOsC,EAAE,CAAC,QAAQ1B;IAClBlB,GAAGM,QAAQ;QAAC;KAAQ,EAAEqC;IACtB3C,GAAGM,QAAQ;QAAC;QAAO;QAAS;KAAS,EAAEuB;AACzC"}

package/dist/esm/nextEntry.d.ts

@@ -0,0 +1,4 @@
+import type SevenZipIterator from './SevenZipIterator.js';
+import type { Entry, EntryCallback } from './types.js';
+export type NextCallback = (error?: Error, entry?: Entry) => undefined;
+export default function nextEntry<_T>(iterator: SevenZipIterator, callback: EntryCallback): undefined;

package/dist/esm/nextEntry.js

@@ -0,0 +1,86 @@
+import once from 'call-once-fn';
+import { DirectoryEntry, SymbolicLinkEntry } from 'extract-base-iterator';
+import compact from 'lodash.compact';
+import path from 'path';
+import FileEntry from './FileEntry.js';
+export default function nextEntry(iterator, callback) {
+    if (!iterator.iterator) {
+        callback(new Error('iterator missing'));
+        return;
+    }
+    var entry = null;
+    entry = iterator.iterator.next();
+    var nextCallback = once((err, entry)=>{
+        // keep processing
+        if (entry) iterator.push(nextEntry);
+        err ? callback(err) : callback(null, entry ? {
+            done: false,
+            value: entry
+        } : {
+            done: true,
+            value: null
+        });
+    });
+    // done: signal iteration is complete
+    if (iterator.isDone() || !entry) return callback(null, {
+        done: true,
+        value: null
+    });
+    // Skip anti-files (these mark files to delete in delta archives)
+    if (entry.isAntiFile) {
+        iterator.push(nextEntry);
+        return callback(null, null);
+    }
+    // Determine type from entry
+    var type = entry.type;
+    // Default modes (decimal values for Node 0.8 compatibility)
+    // 0o755 = 493, 0o644 = 420
+    var defaultMode = type === 'directory' ? 493 : 420;
+    // Build attributes from 7z entry
+    // mtime must be timestamp (number) for FileAttributes compatibility
+    var mtimeDate = entry.mtime || new Date();
+    var attributes = {
+        path: compact(entry.path.split(path.sep)).join(path.sep),
+        basename: entry.name,
+        mtime: mtimeDate.getTime(),
+        mode: entry.mode !== undefined ? entry.mode : defaultMode
+    };
+    switch(type){
+        case 'directory':
+            attributes.type = 'directory';
+            return nextCallback(null, new DirectoryEntry(attributes));
+        case 'link':
+            {
+                // For symlinks, the file content IS the symlink target path
+                // Read the content to get the linkpath for SymbolicLinkEntry
+                var parser = iterator.iterator.getParser();
+                var stream = parser.getEntryStream(entry);
+                var chunks = [];
+                stream.on('data', (chunk)=>{
+                    chunks.push(chunk);
+                });
+                stream.on('end', ()=>{
+                    var linkpath = Buffer.concat(chunks).toString('utf8');
+                    var linkAttributes = {
+                        path: attributes.path,
+                        mtime: attributes.mtime,
+                        mode: attributes.mode,
+                        linkpath: linkpath
+                    };
+                    nextCallback(null, new SymbolicLinkEntry(linkAttributes));
+                });
+                stream.on('error', (err)=>{
+                    nextCallback(err);
+                });
+                return;
+            }
+        case 'file':
+            {
+                attributes.type = 'file';
+                attributes.size = entry.size;
+                var parser2 = iterator.iterator.getParser();
+                return nextCallback(null, new FileEntry(attributes, entry, parser2, iterator.lock));
+            }
+    }
+    return callback(new Error(`Unrecognized entry type: ${type}`));
+}

package/dist/esm/nextEntry.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/nextEntry.ts"],"sourcesContent":["import once from 'call-once-fn';\nimport { type DirectoryAttributes, DirectoryEntry, type FileAttributes, type LinkAttributes, SymbolicLinkEntry } from 'extract-base-iterator';\nimport compact from 'lodash.compact';\nimport path from 'path';\nimport FileEntry from './FileEntry.ts';\nimport type SevenZipIterator from './SevenZipIterator.ts';\nimport type { SevenZipEntry } from './sevenz/SevenZipParser.ts';\nimport type { Entry, EntryCallback } from './types.ts';\n\nexport type NextCallback = (error?: Error, entry?: Entry) => undefined;\n\n// Entry attributes object that gets mutated in switch - union of possible shapes\n// mtime is number for FileAttributes compatibility (timestamp in ms)\ntype EntryAttributesBuilder = {\n  path: string;\n  basename: string;\n  mtime: number;\n  mode: number;\n  type?: 'file' | 'directory';\n  size?: number;\n};\n\nexport default function nextEntry<_T>(iterator: SevenZipIterator, callback: EntryCallback): undefined {\n  if (!iterator.iterator) {\n    callback(new Error('iterator missing'));\n    return;\n  }\n\n  var entry: SevenZipEntry | null = null;\n  entry = iterator.iterator.next();\n\n  var nextCallback = once((err?: Error, entry?: Entry) => {\n    // keep processing\n    if (entry) iterator.push(nextEntry);\n    err ? callback(err) : callback(null, entry ? { done: false, value: entry } : { done: true, value: null });\n  }) as NextCallback;\n\n  // done: signal iteration is complete\n  if (iterator.isDone() || !entry) return callback(null, { done: true, value: null });\n\n  // Skip anti-files (these mark files to delete in delta archives)\n  if (entry.isAntiFile) {\n    iterator.push(nextEntry);\n    return callback(null, null);\n  }\n\n  // Determine type from entry\n  var type = entry.type;\n\n  // Default modes (decimal values for Node 0.8 compatibility)\n  // 0o755 = 493, 0o644 = 420\n  var defaultMode = type === 'directory' ? 493 : 420;\n\n  // Build attributes from 7z entry\n  // mtime must be timestamp (number) for FileAttributes compatibility\n  var mtimeDate = entry.mtime || new Date();\n  var attributes: EntryAttributesBuilder = {\n    path: compact(entry.path.split(path.sep)).join(path.sep),\n    basename: entry.name,\n    mtime: mtimeDate.getTime(),\n    mode: entry.mode !== undefined ? entry.mode : defaultMode,\n  };\n\n  switch (type) {\n    case 'directory':\n      attributes.type = 'directory';\n      return nextCallback(null, new DirectoryEntry(attributes as DirectoryAttributes));\n\n    case 'link': {\n      // For symlinks, the file content IS the symlink target path\n      // Read the content to get the linkpath for SymbolicLinkEntry\n      var parser = iterator.iterator.getParser();\n      var stream = parser.getEntryStream(entry);\n      var chunks: Buffer[] = [];\n\n      stream.on('data', (chunk: Buffer) => {\n        chunks.push(chunk);\n      });\n      stream.on('end', () => {\n        var linkpath = Buffer.concat(chunks).toString('utf8');\n\n        var linkAttributes: LinkAttributes = {\n          path: attributes.path,\n          mtime: attributes.mtime,\n          mode: attributes.mode,\n          linkpath: linkpath,\n        };\n\n        nextCallback(null, new SymbolicLinkEntry(linkAttributes));\n      });\n      stream.on('error', (err: Error) => {\n        nextCallback(err);\n      });\n      return;\n    }\n\n    case 'file': {\n      attributes.type = 'file';\n      attributes.size = entry.size;\n      var parser2 = iterator.iterator.getParser();\n      return nextCallback(null, new FileEntry(attributes as FileAttributes, entry, parser2, iterator.lock));\n    }\n  }\n\n  return callback(new Error(`Unrecognized entry type: ${type}`));\n}\n"],"names":["once","DirectoryEntry","SymbolicLinkEntry","compact","path","FileEntry","nextEntry","iterator","callback","Error","entry","next","nextCallback","err","push","done","value","isDone","isAntiFile","type","defaultMode","mtimeDate","mtime","Date","attributes","split","sep","join","basename","name","getTime","mode","undefined","parser","getParser","stream","getEntryStream","chunks","on","chunk","linkpath","Buffer","concat","toString","linkAttributes","size","parser2","lock"],"mappings":"AAAA,OAAOA,UAAU,eAAe;AAChC,SAAmCC,cAAc,EAA4CC,iBAAiB,QAAQ,wBAAwB;AAC9I,OAAOC,aAAa,iBAAiB;AACrC,OAAOC,UAAU,OAAO;AACxB,OAAOC,eAAe,iBAAiB;AAkBvC,eAAe,SAASC,UAAcC,QAA0B,EAAEC,QAAuB;IACvF,IAAI,CAACD,SAASA,QAAQ,EAAE;QACtBC,SAAS,IAAIC,MAAM;QACnB;IACF;IAEA,IAAIC,QAA8B;IAClCA,QAAQH,SAASA,QAAQ,CAACI,IAAI;IAE9B,IAAIC,eAAeZ,KAAK,CAACa,KAAaH;QACpC,kBAAkB;QAClB,IAAIA,OAAOH,SAASO,IAAI,CAACR;QACzBO,MAAML,SAASK,OAAOL,SAAS,MAAME,QAAQ;YAAEK,MAAM;YAAOC,OAAON;QAAM,IAAI;YAAEK,MAAM;YAAMC,OAAO;QAAK;IACzG;IAEA,qCAAqC;IACrC,IAAIT,SAASU,MAAM,MAAM,CAACP,OAAO,OAAOF,SAAS,MAAM;QAAEO,MAAM;QAAMC,OAAO;IAAK;IAEjF,iEAAiE;IACjE,IAAIN,MAAMQ,UAAU,EAAE;QACpBX,SAASO,IAAI,CAACR;QACd,OAAOE,SAAS,MAAM;IACxB;IAEA,4BAA4B;IAC5B,IAAIW,OAAOT,MAAMS,IAAI;IAErB,4DAA4D;IAC5D,2BAA2B;IAC3B,IAAIC,cAAcD,SAAS,cAAc,MAAM;IAE/C,iCAAiC;IACjC,oEAAoE;IACpE,IAAIE,YAAYX,MAAMY,KAAK,IAAI,IAAIC;IACnC,IAAIC,aAAqC;QACvCpB,MAAMD,QAAQO,MAAMN,IAAI,CAACqB,KAAK,CAACrB,KAAKsB,GAAG,GAAGC,IAAI,CAACvB,KAAKsB,GAAG;QACvDE,UAAUlB,MAAMmB,IAAI;QACpBP,OAAOD,UAAUS,OAAO;QACxBC,MAAMrB,MAAMqB,IAAI,KAAKC,YAAYtB,MAAMqB,IAAI,GAAGX;IAChD;IAEA,OAAQD;QACN,KAAK;YACHK,WAAWL,IAAI,GAAG;YAClB,OAAOP,aAAa,MAAM,IAAIX,eAAeuB;QAE/C,KAAK;YAAQ;gBACX,4DAA4D;gBAC5D,6DAA6D;gBAC7D,IAAIS,SAAS1B,SAASA,QAAQ,CAAC2B,SAAS;gBACxC,IAAIC,SAASF,OAAOG,cAAc,CAAC1B;gBACnC,IAAI2B,SAAmB,EAAE;gBAEzBF,OAAOG,EAAE,CAAC,QAAQ,CAACC;oBACjBF,OAAOvB,IAAI,CAACyB;gBACd;gBACAJ,OAAOG,EAAE,CAAC,OAAO;oBACf,IAAIE,WAAWC,OAAOC,MAAM,CAACL,QAAQM,QAAQ,CAAC;oBAE9C,IAAIC,iBAAiC;wBACnCxC,MAAMoB,WAAWpB,IAAI;wBACrBkB,OAAOE,WAAWF,KAAK;wBACvBS,MAAMP,WAAWO,IAAI;wBACrBS,UAAUA;oBACZ;oBAEA5B,aAAa,MAAM,IAAIV,kBAAkB0C;gBAC3C;gBACAT,OAAOG,EAAE,CAAC,SAAS,CAACzB;oBAClBD,aAAaC;gBACf;gBACA;YACF;QAEA,KAAK;YAAQ;gBACXW,WAAWL,IAAI,GAAG;gBAClBK,WAAWqB,IAAI,GAAGnC,MAAMmC,IAAI;gBAC5B,IAAIC,UAAUvC,SAASA,QAAQ,CAAC2B,SAAS;gBACzC,OAAOtB,aAAa,MAAM,IAAIP,UAAUmB,YAA8Bd,OAAOoC,SAASvC,SAASwC,IAAI;YACrG;IACF;IAEA,OAAOvC,SAAS,IAAIC,MAAM,CAAC,yBAAyB,EAAEU,MAAM;AAC9D"}

package/dist/esm/package.json

@@ -0,0 +1 @@
+{ "type": "module" }

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

@@ -0,0 +1,58 @@
+export interface NumberReadResult {
+    value: number;
+    bytesRead: number;
+}
+/**
+ * Read a variable-length encoded number from a buffer
+ * @param buf - Buffer containing encoded number
+ * @param offset - Offset to start reading from
+ * @returns Object with value and number of bytes consumed
+ */
+export declare function readNumber(buf: Buffer, offset: number): NumberReadResult;
+/**
+ * Read a raw 64-bit little-endian number (used in some fixed-size fields)
+ * @param buf - Buffer containing the number
+ * @param offset - Offset to start reading from
+ * @returns The number value
+ */
+export declare function readRawNumber(buf: Buffer, offset: number): number;
+/**
+ * Calculate the encoded size of a number
+ * @param value - The number to encode
+ * @returns Number of bytes needed to encode the value
+ */
+export declare function encodedSize(value: number): number;
+/**
+ * Read a boolean encoded as a single byte
+ * @param buf - Buffer to read from
+ * @param offset - Offset to read from
+ * @returns true if byte is non-zero
+ */
+export declare function readBoolean(buf: Buffer, offset: number): boolean;
+/**
+ * Read a "defined" bitmask for an array of items.
+ * Used when some items in a list have optional values.
+ *
+ * Format: If "allDefined" byte is 0, a bitmask follows indicating which items have values.
+ * If "allDefined" byte is non-zero, all items are defined.
+ *
+ * @param buf - Buffer to read from
+ * @param offset - Offset to start reading
+ * @param count - Number of items
+ * @returns Object with defined array and bytes consumed
+ */
+export declare function readDefinedVector(buf: Buffer, offset: number, count: number): {
+    defined: boolean[];
+    bytesRead: number;
+};
+/**
+ * Read an array of variable-length numbers
+ * @param buf - Buffer to read from
+ * @param offset - Offset to start reading
+ * @param count - Number of items to read
+ * @returns Object with values array and bytes consumed
+ */
+export declare function readNumberArray(buf: Buffer, offset: number, count: number): {
+    values: number[];
+    bytesRead: number;
+};

package/dist/esm/sevenz/NumberCodec.js

@@ -0,0 +1,138 @@
+// Variable-length integer encoding for 7z format
+// Reference: https://py7zr.readthedocs.io/en/latest/archive_format.html
+//
+// 7z uses a space-efficient encoding where the first byte determines length:
+// 0xxxxxxx                    -> 1 byte  (0-127)
+// 10xxxxxx xxxxxxxx           -> 2 bytes (0-16383)
+// 110xxxxx + 2 bytes          -> 3 bytes
+// 1110xxxx + 3 bytes          -> 4 bytes
+// 11110xxx + 4 bytes          -> 5 bytes
+// 111110xx + 5 bytes          -> 6 bytes
+// 1111110x + 6 bytes          -> 7 bytes
+// 11111110 + 7 bytes          -> 8 bytes
+// 11111111 + 8 bytes          -> 9 bytes (full 64-bit)
+//
+// NOTE: Returns JavaScript number which is accurate up to 2^53 - 1 (~9 PB).
+// This covers all practical file sizes.
+import { readUInt64LE } from 'extract-base-iterator';
+/**
+ * Read a variable-length encoded number from a buffer
+ * @param buf - Buffer containing encoded number
+ * @param offset - Offset to start reading from
+ * @returns Object with value and number of bytes consumed
+ */ export function readNumber(buf, offset) {
+    var firstByte = buf[offset];
+    // Count leading 1 bits to determine extra bytes
+    var mask = 0x80;
+    var extraBytes = 0;
+    while((firstByte & mask) !== 0 && extraBytes < 8){
+        extraBytes++;
+        mask = mask >>> 1;
+    }
+    // Special case: all 8 bits set means 8 extra bytes
+    if (extraBytes === 8) {
+        // Full 64-bit value follows
+        return {
+            value: readUInt64LE(buf, offset + 1),
+            bytesRead: 9
+        };
+    }
+    // Mask off the length bits from first byte
+    var value = firstByte & (mask - 1 | mask);
+    // Add remaining bytes (big-endian order)
+    for(var i = 0; i < extraBytes; i++){
+        value = value * 256 + buf[offset + 1 + i];
+    }
+    return {
+        value: value,
+        bytesRead: 1 + extraBytes
+    };
+}
+/**
+ * Read a raw 64-bit little-endian number (used in some fixed-size fields)
+ * @param buf - Buffer containing the number
+ * @param offset - Offset to start reading from
+ * @returns The number value
+ */ export function readRawNumber(buf, offset) {
+    return readUInt64LE(buf, offset);
+}
+/**
+ * Calculate the encoded size of a number
+ * @param value - The number to encode
+ * @returns Number of bytes needed to encode the value
+ */ export function encodedSize(value) {
+    if (value < 0x80) return 1; // 7 bits
+    if (value < 0x4000) return 2; // 14 bits
+    if (value < 0x200000) return 3; // 21 bits
+    if (value < 0x10000000) return 4; // 28 bits
+    if (value < 0x800000000) return 5; // 35 bits
+    if (value < 0x40000000000) return 6; // 42 bits
+    if (value < 0x2000000000000) return 7; // 49 bits
+    // 2^56 = 72057594037927936 (use calculated value to avoid precision loss)
+    if (value < 72057594037927936) return 8; // 56 bits
+    return 9; // 64 bits
+}
+/**
+ * Read a boolean encoded as a single byte
+ * @param buf - Buffer to read from
+ * @param offset - Offset to read from
+ * @returns true if byte is non-zero
+ */ export function readBoolean(buf, offset) {
+    return buf[offset] !== 0;
+}
+/**
+ * Read a "defined" bitmask for an array of items.
+ * Used when some items in a list have optional values.
+ *
+ * Format: If "allDefined" byte is 0, a bitmask follows indicating which items have values.
+ * If "allDefined" byte is non-zero, all items are defined.
+ *
+ * @param buf - Buffer to read from
+ * @param offset - Offset to start reading
+ * @param count - Number of items
+ * @returns Object with defined array and bytes consumed
+ */ export function readDefinedVector(buf, offset, count) {
+    var allDefined = buf[offset] !== 0;
+    var bytesRead = 1;
+    var defined = [];
+    if (allDefined) {
+        // All items are defined
+        for(var i = 0; i < count; i++){
+            defined.push(true);
+        }
+    } else {
+        // Read bitmask
+        var bitsNeeded = count;
+        var bytesNeeded = Math.ceil(bitsNeeded / 8);
+        for(var byteIdx = 0; byteIdx < bytesNeeded; byteIdx++){
+            var byte = buf[offset + 1 + byteIdx];
+            for(var bit = 7; bit >= 0 && defined.length < count; bit--){
+                defined.push((byte & 1 << bit) !== 0);
+            }
+        }
+        bytesRead += bytesNeeded;
+    }
+    return {
+        defined: defined,
+        bytesRead: bytesRead
+    };
+}
+/**
+ * Read an array of variable-length numbers
+ * @param buf - Buffer to read from
+ * @param offset - Offset to start reading
+ * @param count - Number of items to read
+ * @returns Object with values array and bytes consumed
+ */ export function readNumberArray(buf, offset, count) {
+    var values = [];
+    var totalBytesRead = 0;
+    for(var i = 0; i < count; i++){
+        var result = readNumber(buf, offset + totalBytesRead);
+        values.push(result.value);
+        totalBytesRead += result.bytesRead;
+    }
+    return {
+        values: values,
+        bytesRead: totalBytesRead
+    };
+}

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

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/NumberCodec.ts"],"sourcesContent":["// Variable-length integer encoding for 7z format\n// Reference: https://py7zr.readthedocs.io/en/latest/archive_format.html\n//\n// 7z uses a space-efficient encoding where the first byte determines length:\n// 0xxxxxxx                    -> 1 byte  (0-127)\n// 10xxxxxx xxxxxxxx           -> 2 bytes (0-16383)\n// 110xxxxx + 2 bytes          -> 3 bytes\n// 1110xxxx + 3 bytes          -> 4 bytes\n// 11110xxx + 4 bytes          -> 5 bytes\n// 111110xx + 5 bytes          -> 6 bytes\n// 1111110x + 6 bytes          -> 7 bytes\n// 11111110 + 7 bytes          -> 8 bytes\n// 11111111 + 8 bytes          -> 9 bytes (full 64-bit)\n//\n// NOTE: Returns JavaScript number which is accurate up to 2^53 - 1 (~9 PB).\n// This covers all practical file sizes.\n\nimport { readUInt64LE } from 'extract-base-iterator';\n\nexport interface NumberReadResult {\n  value: number;\n  bytesRead: number;\n}\n\n/**\n * Read a variable-length encoded number from a buffer\n * @param buf - Buffer containing encoded number\n * @param offset - Offset to start reading from\n * @returns Object with value and number of bytes consumed\n */\nexport function readNumber(buf: Buffer, offset: number): NumberReadResult {\n  var firstByte = buf[offset];\n\n  // Count leading 1 bits to determine extra bytes\n  var mask = 0x80;\n  var extraBytes = 0;\n\n  while ((firstByte & mask) !== 0 && extraBytes < 8) {\n    extraBytes++;\n    mask = mask >>> 1;\n  }\n\n  // Special case: all 8 bits set means 8 extra bytes\n  if (extraBytes === 8) {\n    // Full 64-bit value follows\n    return {\n      value: readUInt64LE(buf, offset + 1),\n      bytesRead: 9,\n    };\n  }\n\n  // Mask off the length bits from first byte\n  var value = firstByte & ((mask - 1) | mask);\n\n  // Add remaining bytes (big-endian order)\n  for (var i = 0; i < extraBytes; i++) {\n    value = value * 256 + buf[offset + 1 + i];\n  }\n\n  return {\n    value: value,\n    bytesRead: 1 + extraBytes,\n  };\n}\n\n/**\n * Read a raw 64-bit little-endian number (used in some fixed-size fields)\n * @param buf - Buffer containing the number\n * @param offset - Offset to start reading from\n * @returns The number value\n */\nexport function readRawNumber(buf: Buffer, offset: number): number {\n  return readUInt64LE(buf, offset);\n}\n\n/**\n * Calculate the encoded size of a number\n * @param value - The number to encode\n * @returns Number of bytes needed to encode the value\n */\nexport function encodedSize(value: number): number {\n  if (value < 0x80) return 1; // 7 bits\n  if (value < 0x4000) return 2; // 14 bits\n  if (value < 0x200000) return 3; // 21 bits\n  if (value < 0x10000000) return 4; // 28 bits\n  if (value < 0x800000000) return 5; // 35 bits\n  if (value < 0x40000000000) return 6; // 42 bits\n  if (value < 0x2000000000000) return 7; // 49 bits\n  // 2^56 = 72057594037927936 (use calculated value to avoid precision loss)\n  if (value < 72057594037927936) return 8; // 56 bits\n  return 9; // 64 bits\n}\n\n/**\n * Read a boolean encoded as a single byte\n * @param buf - Buffer to read from\n * @param offset - Offset to read from\n * @returns true if byte is non-zero\n */\nexport function readBoolean(buf: Buffer, offset: number): boolean {\n  return buf[offset] !== 0;\n}\n\n/**\n * Read a \"defined\" bitmask for an array of items.\n * Used when some items in a list have optional values.\n *\n * Format: If \"allDefined\" byte is 0, a bitmask follows indicating which items have values.\n * If \"allDefined\" byte is non-zero, all items are defined.\n *\n * @param buf - Buffer to read from\n * @param offset - Offset to start reading\n * @param count - Number of items\n * @returns Object with defined array and bytes consumed\n */\nexport function readDefinedVector(buf: Buffer, offset: number, count: number): { defined: boolean[]; bytesRead: number } {\n  var allDefined = buf[offset] !== 0;\n  var bytesRead = 1;\n  var defined: boolean[] = [];\n\n  if (allDefined) {\n    // All items are defined\n    for (var i = 0; i < count; i++) {\n      defined.push(true);\n    }\n  } else {\n    // Read bitmask\n    var bitsNeeded = count;\n    var bytesNeeded = Math.ceil(bitsNeeded / 8);\n\n    for (var byteIdx = 0; byteIdx < bytesNeeded; byteIdx++) {\n      var byte = buf[offset + 1 + byteIdx];\n      for (var bit = 7; bit >= 0 && defined.length < count; bit--) {\n        defined.push((byte & (1 << bit)) !== 0);\n      }\n    }\n    bytesRead += bytesNeeded;\n  }\n\n  return { defined: defined, bytesRead: bytesRead };\n}\n\n/**\n * Read an array of variable-length numbers\n * @param buf - Buffer to read from\n * @param offset - Offset to start reading\n * @param count - Number of items to read\n * @returns Object with values array and bytes consumed\n */\nexport function readNumberArray(buf: Buffer, offset: number, count: number): { values: number[]; bytesRead: number } {\n  var values: number[] = [];\n  var totalBytesRead = 0;\n\n  for (var i = 0; i < count; i++) {\n    var result = readNumber(buf, offset + totalBytesRead);\n    values.push(result.value);\n    totalBytesRead += result.bytesRead;\n  }\n\n  return { values: values, bytesRead: totalBytesRead };\n}\n"],"names":["readUInt64LE","readNumber","buf","offset","firstByte","mask","extraBytes","value","bytesRead","i","readRawNumber","encodedSize","readBoolean","readDefinedVector","count","allDefined","defined","push","bitsNeeded","bytesNeeded","Math","ceil","byteIdx","byte","bit","length","readNumberArray","values","totalBytesRead","result"],"mappings":"AAAA,iDAAiD;AACjD,wEAAwE;AACxE,EAAE;AACF,6EAA6E;AAC7E,iDAAiD;AACjD,mDAAmD;AACnD,yCAAyC;AACzC,yCAAyC;AACzC,yCAAyC;AACzC,yCAAyC;AACzC,yCAAyC;AACzC,yCAAyC;AACzC,uDAAuD;AACvD,EAAE;AACF,4EAA4E;AAC5E,wCAAwC;AAExC,SAASA,YAAY,QAAQ,wBAAwB;AAOrD;;;;;CAKC,GACD,OAAO,SAASC,WAAWC,GAAW,EAAEC,MAAc;IACpD,IAAIC,YAAYF,GAAG,CAACC,OAAO;IAE3B,gDAAgD;IAChD,IAAIE,OAAO;IACX,IAAIC,aAAa;IAEjB,MAAO,AAACF,CAAAA,YAAYC,IAAG,MAAO,KAAKC,aAAa,EAAG;QACjDA;QACAD,OAAOA,SAAS;IAClB;IAEA,mDAAmD;IACnD,IAAIC,eAAe,GAAG;QACpB,4BAA4B;QAC5B,OAAO;YACLC,OAAOP,aAAaE,KAAKC,SAAS;YAClCK,WAAW;QACb;IACF;IAEA,2CAA2C;IAC3C,IAAID,QAAQH,YAAa,CAAA,AAACC,OAAO,IAAKA,IAAG;IAEzC,yCAAyC;IACzC,IAAK,IAAII,IAAI,GAAGA,IAAIH,YAAYG,IAAK;QACnCF,QAAQA,QAAQ,MAAML,GAAG,CAACC,SAAS,IAAIM,EAAE;IAC3C;IAEA,OAAO;QACLF,OAAOA;QACPC,WAAW,IAAIF;IACjB;AACF;AAEA;;;;;CAKC,GACD,OAAO,SAASI,cAAcR,GAAW,EAAEC,MAAc;IACvD,OAAOH,aAAaE,KAAKC;AAC3B;AAEA;;;;CAIC,GACD,OAAO,SAASQ,YAAYJ,KAAa;IACvC,IAAIA,QAAQ,MAAM,OAAO,GAAG,SAAS;IACrC,IAAIA,QAAQ,QAAQ,OAAO,GAAG,UAAU;IACxC,IAAIA,QAAQ,UAAU,OAAO,GAAG,UAAU;IAC1C,IAAIA,QAAQ,YAAY,OAAO,GAAG,UAAU;IAC5C,IAAIA,QAAQ,aAAa,OAAO,GAAG,UAAU;IAC7C,IAAIA,QAAQ,eAAe,OAAO,GAAG,UAAU;IAC/C,IAAIA,QAAQ,iBAAiB,OAAO,GAAG,UAAU;IACjD,0EAA0E;IAC1E,IAAIA,QAAQ,mBAAmB,OAAO,GAAG,UAAU;IACnD,OAAO,GAAG,UAAU;AACtB;AAEA;;;;;CAKC,GACD,OAAO,SAASK,YAAYV,GAAW,EAAEC,MAAc;IACrD,OAAOD,GAAG,CAACC,OAAO,KAAK;AACzB;AAEA;;;;;;;;;;;CAWC,GACD,OAAO,SAASU,kBAAkBX,GAAW,EAAEC,MAAc,EAAEW,KAAa;IAC1E,IAAIC,aAAab,GAAG,CAACC,OAAO,KAAK;IACjC,IAAIK,YAAY;IAChB,IAAIQ,UAAqB,EAAE;IAE3B,IAAID,YAAY;QACd,wBAAwB;QACxB,IAAK,IAAIN,IAAI,GAAGA,IAAIK,OAAOL,IAAK;YAC9BO,QAAQC,IAAI,CAAC;QACf;IACF,OAAO;QACL,eAAe;QACf,IAAIC,aAAaJ;QACjB,IAAIK,cAAcC,KAAKC,IAAI,CAACH,aAAa;QAEzC,IAAK,IAAII,UAAU,GAAGA,UAAUH,aAAaG,UAAW;YACtD,IAAIC,OAAOrB,GAAG,CAACC,SAAS,IAAImB,QAAQ;YACpC,IAAK,IAAIE,MAAM,GAAGA,OAAO,KAAKR,QAAQS,MAAM,GAAGX,OAAOU,MAAO;gBAC3DR,QAAQC,IAAI,CAAC,AAACM,CAAAA,OAAQ,KAAKC,GAAG,MAAO;YACvC;QACF;QACAhB,aAAaW;IACf;IAEA,OAAO;QAAEH,SAASA;QAASR,WAAWA;IAAU;AAClD;AAEA;;;;;;CAMC,GACD,OAAO,SAASkB,gBAAgBxB,GAAW,EAAEC,MAAc,EAAEW,KAAa;IACxE,IAAIa,SAAmB,EAAE;IACzB,IAAIC,iBAAiB;IAErB,IAAK,IAAInB,IAAI,GAAGA,IAAIK,OAAOL,IAAK;QAC9B,IAAIoB,SAAS5B,WAAWC,KAAKC,SAASyB;QACtCD,OAAOV,IAAI,CAACY,OAAOtB,KAAK;QACxBqB,kBAAkBC,OAAOrB,SAAS;IACpC;IAEA,OAAO;QAAEmB,QAAQA;QAAQnB,WAAWoB;IAAe;AACrD"}

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

@@ -0,0 +1,96 @@
+import { type Readable } from 'readable-stream';
+export interface SevenZipEntry {
+    name: string;
+    path: string;
+    type: 'file' | 'directory' | 'link';
+    size: number;
+    mtime?: Date;
+    atime?: Date;
+    ctime?: Date;
+    mode?: number;
+    isAntiFile: boolean;
+    _folderIndex: number;
+    _streamIndex: number;
+    _streamIndexInFolder: number;
+    _hasStream: boolean;
+}
+/**
+ * Archive source abstraction - allows reading from file descriptor or buffer
+ */
+export interface ArchiveSource {
+    read(position: number, length: number): Buffer;
+    getSize(): number;
+    close(): void;
+}
+/**
+ * Buffer-based archive source
+ */
+export declare class BufferSource implements ArchiveSource {
+    private buffer;
+    constructor(buffer: Buffer);
+    read(position: number, length: number): Buffer;
+    getSize(): number;
+    close(): void;
+}
+/**
+ * File descriptor based archive source
+ */
+export declare class FileSource implements ArchiveSource {
+    private fd;
+    private size;
+    constructor(fd: number, size: number);
+    read(position: number, length: number): Buffer;
+    getSize(): number;
+    close(): void;
+}
+/**
+ * SevenZipParser - parses 7z archives and provides entry iteration
+ */
+export declare class SevenZipParser {
+    private source;
+    private signature;
+    private streamsInfo;
+    private filesInfo;
+    private entries;
+    private parsed;
+    private decompressedCache;
+    constructor(source: ArchiveSource);
+    /**
+     * Parse the archive structure
+     * Must be called before iterating entries
+     */
+    parse(): void;
+    /**
+     * Handle compressed header (kEncodedHeader)
+     */
+    private handleCompressedHeader;
+    /**
+     * Parse streams info from encoded header block
+     * This is a simplified parser for the header's own compression info
+     */
+    private parseEncodedHeaderStreams;
+    /**
+     * Build the entries list from parsed file info
+     */
+    private buildEntries;
+    /**
+     * Create an entry from file info
+     */
+    private createEntry;
+    /**
+     * Get the list of entries
+     */
+    getEntries(): SevenZipEntry[];
+    /**
+     * Get a readable stream for an entry's content
+     */
+    getEntryStream(entry: SevenZipEntry): Readable;
+    /**
+     * Get decompressed data for a folder, with caching for solid archives
+     */
+    private getDecompressedFolder;
+    /**
+     * Close the parser and release resources
+     */
+    close(): void;
+}