neozipkit 0.2.1 → 0.3.0

package/src/{shared → core}/ZipEntry.ts

@@ -13,12 +13,10 @@ import {
   FILE_SYSTEM, 
   HDR_ID,
   DOS_FILE_ATTR,
-  TIMESTAMP_SUBMITTED,
  } from './constants/Headers';
-import { getuid, getgid } from 'process';
-import { ZipFileEntry, FileData } from './types';
-import HashAccumulater from './components/HashAccumulator';
-import { crc32 } from './components/Util';
+import { ZipFileEntry, FileData } from '../types';
+import { Logger } from './components/Logger';
+import { crc32 } from './encryption/ZipCrypto';
 
 const VER_ENCODING = 30;
 const VER_EXTRACT = 10;                             // Version needed to extract (1.0)
@@ -27,7 +25,7 @@ const VER_EXTRACT = 10;                             // Version needed to extract
  * Class representing a single entry (file or directory) within a ZIP archive
  */
 export default class ZipEntry implements ZipFileEntry {
-  debug = false;
+  debug = true;
 
   verMadeBy: number = 0;        // Read Version Made By
   verExtract: number = 0;       // Read Version Needed to Extract
@@ -67,6 +65,15 @@ export default class ZipEntry implements ZipFileEntry {
   uid: number | null = null;        // User ID
   gid: number | null = null;        // Group ID
   sha256: string | null = null;     // SHA-256 hash of the file
+  
+  // Symbolic link data
+  isSymlink: boolean = false;       // Entry is a symbolic link
+  linkTarget: string | null = null; // Target path for symbolic links
+  
+  // Hard link data
+  isHardLink: boolean = false;      // Entry is a hard link
+  originalEntry: string | null = null; // Original entry name for hard links
+  inode: number | null = null;      // Inode number for hard links
 
   fileData?: FileData;
 
@@ -186,7 +193,7 @@ export default class ZipEntry implements ZipFileEntry {
             const unicodeName = _data.subarray(5).toString('utf8');
             this.filename = unicodeName;
             if (this.debug) {
-              console.log(`Using Unicode Path: ${this.filename}`);
+              Logger.log(`Using Unicode Path: ${this.filename}`);
             }
           }
         }
@@ -232,6 +239,27 @@ export default class ZipEntry implements ZipFileEntry {
               }
             }
           }
+        } else if (_id === HDR_ID.SYMLINK) {
+          // Extract symbolic link information
+          if (_len >= 3) {  // Version + Target Length + Target
+            const version = _data.readUInt8(0);
+            const targetLength = _data.readUInt16LE(1);
+            if (targetLength > 0 && _len >= 3 + targetLength) {
+              this.isSymlink = true;
+              this.linkTarget = _data.subarray(3, 3 + targetLength).toString('utf8');
+            }
+          }
+        } else if (_id === HDR_ID.HARDLINK) {
+          // Extract hard link information
+          if (_len >= 11) {  // Version + Inode + Original Length + Original
+            const version = _data.readUInt8(0);
+            this.inode = _data.readUInt32LE(1);
+            const originalLength = _data.readUInt16LE(5);
+            if (originalLength > 0 && _len >= 7 + originalLength) {
+              this.isHardLink = true;
+              this.originalEntry = _data.subarray(7, 7 + originalLength).toString('utf8');
+            }
+          }
         }
         // Skip Unicode Path here as we already processed it
         i += 4 + _len;
@@ -241,7 +269,7 @@ export default class ZipEntry implements ZipFileEntry {
     // File Comment Length - 2 bytes
     let comLen = data.readUInt16LE(CENTRAL_DIR.COMMENT_LEN);
     if (comLen > 0)
-      this.comment = data.toString('utf8', CENTRAL_DIR.SIZE + fnameLen + extraLen, CENTRAL_DIR.SIZE + fnameLen + extraLen + comLen);
+      this.comment = data.toString('utf8', CENTRAL_DIR.SIZE + fnameLen, CENTRAL_DIR.SIZE + fnameLen + comLen);
 
     if (this.debug)
       this.showVerboseInfo();
@@ -294,7 +322,6 @@ export default class ZipEntry implements ZipFileEntry {
    * @returns Buffer containing the local header data
    */
   createLocalHdr(): Buffer {
-    const commentLen = this.comment?.length ?? 0;
     let extraFieldLen = 0;
     
     // Only create Unicode Path field if needed
@@ -306,7 +333,7 @@ export default class ZipEntry implements ZipFileEntry {
       extraFieldLen = 5 + unicodeNameLen + 4;
     }
     
-    const data = Buffer.alloc(LOCAL_HDR.SIZE + this.filename.length + commentLen + extraFieldLen);
+    const data = Buffer.alloc(LOCAL_HDR.SIZE + this.filename.length + extraFieldLen);
     
     // "PK\003\004"
     data.writeUInt32LE(LOCAL_HDR.SIGNATURE, 0);
@@ -342,11 +369,8 @@ export default class ZipEntry implements ZipFileEntry {
       extraOffset = this.addUnicodePathField(data, extraOffset);
     }
 
-    // Add comment if present (after extra field)
-    if (commentLen > 0 && this.comment) {
-      const commentBuf = Buffer.from(this.comment, 'utf8');
-      commentBuf.copy(data, extraOffset);
-    }
+    // File comments are NOT stored in local headers (ZIP specification)
+    // They are only stored in the central directory
 
     return data;
   }
@@ -357,12 +381,20 @@ export default class ZipEntry implements ZipFileEntry {
    */
   centralDirEntry(): Buffer {
     // Calculate the length of the extra fields
-    const commentLen = this.comment?.length ?? 0;
+    const commentLen = this.comment ? Buffer.from(this.comment, 'utf8').length : 0;
     const utfLen = this.universalTime ? 9 : 0;  // 4 bytes header + 5 bytes data
     const uidgidLen = this.uid && this.gid ? 11 + 4 : 0;  // 1 byte version + 1 byte size + 4 bytes data + 1 byte size + 4 bytes data
     const sha256Buf = this.sha256 ? Buffer.from(this.sha256, 'hex') : null;
     const sha256Len = sha256Buf ? (sha256Buf.length + 4) : 0;
     
+    // Calculate symbolic link extra field length
+    const symlinkLen = this.isSymlink && this.linkTarget ? 
+      (4 + 1 + 2 + Buffer.byteLength(this.linkTarget, 'utf8')) : 0; // 4 bytes header + 1 byte version + 2 bytes length + target
+    
+    // Calculate hard link extra field length
+    const hardlinkLen = this.isHardLink && this.originalEntry && this.inode !== null ? 
+      (4 + 1 + 4 + 2 + Buffer.byteLength(this.originalEntry, 'utf8')) : 0; // 4 bytes header + 1 byte version + 4 bytes inode + 2 bytes length + original
+    
     // Only add Unicode Path field if needed
     const needsUnicode = this.needsUnicodeHandling();
     let unicodePathLen = 0;
@@ -373,10 +405,14 @@ export default class ZipEntry implements ZipFileEntry {
       unicodePathLen = 5 + unicodeNameLen + 4;
     }
     
-    const extraLen = utfLen + sha256Len + uidgidLen + (needsUnicode ? unicodePathLen : 0);
+    const extraLen = utfLen + sha256Len + uidgidLen + symlinkLen + hardlinkLen + (needsUnicode ? unicodePathLen : 0);
 
+    // Calculate actual filename length (ASCII conversion may change length)
+    const asciiName = this.filename.replace(/[^\x00-\x7E]/g, '?');
+    const fnameLen = asciiName.length;
+    
     // Central directory header size (46 Bytes + filename + comment + extra fields)
-    const data = Buffer.alloc(CENTRAL_DIR.SIZE + this.filename.length + commentLen + extraLen);
+    const data = Buffer.alloc(CENTRAL_DIR.SIZE + fnameLen + commentLen + extraLen);
     
     // "PK\001\002"
     data.writeUInt32LE(CENTRAL_DIR.SIGNATURE, 0);
@@ -413,52 +449,82 @@ export default class ZipEntry implements ZipFileEntry {
 
     // Write filename - use ASCII filename (replacing non-ASCII with ?)
     // This ensures compatibility with older ZIP readers
-    const asciiName = this.filename.replace(/[^\x00-\x7E]/g, '?');
     const fnameBuf = Buffer.from(asciiName);
     fnameBuf.copy(data, CENTRAL_DIR.SIZE);
 
+    // Add file comment immediately after filename (InfoZip format)
+    let currentOffset = CENTRAL_DIR.SIZE + fnameLen;
     if (commentLen > 0 && this.comment) {
       const commentBuf = Buffer.from(this.comment, 'utf8');
-      commentBuf.copy(data, CENTRAL_DIR.SIZE + fnameBuf.length);
+      commentBuf.copy(data, currentOffset);
+      currentOffset += commentLen;
     }
 
-    // Add Extra Field data
-    let extraOffset = CENTRAL_DIR.SIZE + fnameBuf.length + commentLen;
+    // Add Extra Field data after file comment
+    let extraOffset = currentOffset;
 
     // Add Universal Time field
     if (this.universalTime) {
       data.writeUInt16LE(HDR_ID.UNV_TIME, extraOffset);     // 0x5455
       data.writeUInt16LE(5, extraOffset + 2);               // Length of data (flags + time)
-      data.writeUInt8(0x03, extraOffset + 4);               // Flags: 1=Mod time, 2=Access time
-      data.writeUInt32LE(this.universalTime, extraOffset + 5); // Unix timestamp
-      extraOffset += 9;  // 4 bytes header + 1 byte flags + 4 bytes data
+      data.writeUInt8(1, extraOffset + 4);                  // Flags: modification time present
+      data.writeUInt32LE(Math.floor(Date.now() / 1000), extraOffset + 5); // Unix timestamp
+      extraOffset += 9;
+    }
+
+    // Add SHA-256 field
+    if (sha256Buf) {
+      data.writeUInt16LE(HDR_ID.SHA256, extraOffset);       // 0x1f
+      data.writeUInt16LE(sha256Buf.length, extraOffset + 2); // Length of data
+      sha256Buf.copy(data, extraOffset + 4);
+      extraOffset += 4 + sha256Buf.length;
     }
 
-    // Unix UID/GID Extra Field (0x7875)
+    // Add UID/GID field
     if (this.uid && this.gid) {
-      const uidgidLen = 11;  // 1 byte version + 1 byte size + 4 bytes data + 1 byte size + 4 bytes data
-      data.writeUInt16LE(HDR_ID.UID_GID, extraOffset);     // 0x7875
-      data.writeUInt16LE(uidgidLen, extraOffset + 2);      // Length
-      data.writeUInt8(1, extraOffset + 4);                 // Version
-      data.writeUInt8(4, extraOffset + 5);                 // Size of UID/GID
-      data.writeUInt32LE(this.uid, extraOffset + 6);       // UID
-      data.writeUInt8(4, extraOffset + 10);                // Size of UID/GID
-      data.writeUInt32LE(this.gid, extraOffset + 11);      // GID
-      extraOffset += uidgidLen + 4;
+      data.writeUInt16LE(HDR_ID.UID_GID, extraOffset);       // 0x7875
+      data.writeUInt16LE(11, extraOffset + 2);              // Length of data
+      data.writeUInt8(1, extraOffset + 4);                  // Version
+      data.writeUInt8(4, extraOffset + 5);                  // UID size
+      data.writeUInt32LE(this.uid, extraOffset + 6);        // UID
+      data.writeUInt8(4, extraOffset + 10);                 // GID size
+      data.writeUInt32LE(this.gid, extraOffset + 11);       // GID
+      extraOffset += 15;
     }
-    
-    // Add Unicode Path Extra Field only if needed
+
+    // Add symbolic link field
+    if (this.isSymlink && this.linkTarget) {
+      const targetBuf = Buffer.from(this.linkTarget, 'utf8');
+      const dataLen = 1 + 2 + targetBuf.length; // version + length + target
+      
+      data.writeUInt16LE(HDR_ID.SYMLINK, extraOffset);       // 0x7855
+      data.writeUInt16LE(dataLen, extraOffset + 2);          // Length of data
+      data.writeUInt8(1, extraOffset + 4);                   // Version
+      data.writeUInt16LE(targetBuf.length, extraOffset + 5); // Target length
+      targetBuf.copy(data, extraOffset + 7);                 // Target path
+      extraOffset += 4 + dataLen;
+    }
+
+    // Add hard link field
+    if (this.isHardLink && this.originalEntry && this.inode !== null) {
+      const originalBuf = Buffer.from(this.originalEntry, 'utf8');
+      const dataLen = 1 + 4 + 2 + originalBuf.length; // version + inode + length + original
+      
+      data.writeUInt16LE(HDR_ID.HARDLINK, extraOffset);       // 0x7865
+      data.writeUInt16LE(dataLen, extraOffset + 2);           // Length of data
+      data.writeUInt8(1, extraOffset + 4);                    // Version
+      data.writeUInt32LE(this.inode, extraOffset + 5);        // Inode number
+      data.writeUInt16LE(originalBuf.length, extraOffset + 9); // Original entry length
+      originalBuf.copy(data, extraOffset + 11);               // Original entry path
+      extraOffset += 4 + dataLen;
+    }
+
+    // Add Unicode Path field if needed
     if (needsUnicode) {
       extraOffset = this.addUnicodePathField(data, extraOffset);
     }
 
-    // Add SHA256 field
-    if (sha256Buf) {
-      data.writeUInt16LE(HDR_ID.SHA256, extraOffset);     
-      data.writeUInt16LE(sha256Buf.length, extraOffset + 2);
-      sha256Buf.copy(data, extraOffset + 4);
-      extraOffset += sha256Buf.length + 4;
-    }
+    // File comment is already written immediately after filename
 
     return data;
   }
@@ -474,14 +540,27 @@ export default class ZipEntry implements ZipFileEntry {
    */
   setDateTime(date: Date): number {
     if (!date) return 0;
-    let time =
-        (((date.getFullYear() - 1980) & 0x7f) << 25) | // b09-16 years from 1980
-        ((date.getMonth() + 1) << 21) | // b05-08 month
-        (date.getDate() << 16) | // b00-04 hour
-        // 2 bytes time
-        (date.getHours() << 11) | // b11-15 hour
-        (date.getMinutes() << 5) | // b05-10 minute
-        (date.getSeconds() >> 1); // b00-04 seconds divided by 2
+    
+    // DOS date/time format:
+    // Date part (16 bits): Year (7 bits) + Month (4 bits) + Day (5 bits)
+    // Time part (16 bits): Hour (5 bits) + Minute (6 bits) + Second (5 bits, stored as seconds/2)
+    
+    const year = date.getFullYear() - 1980; // Years since 1980
+    const month = date.getMonth() + 1; // Month (1-12)
+    const day = date.getDate(); // Day (1-31)
+    const hour = date.getHours(); // Hour (0-23)
+    const minute = date.getMinutes(); // Minute (0-59)
+    const second = date.getSeconds(); // Second (0-59)
+    
+    // Pack date: year (7 bits) + month (4 bits) + day (5 bits)
+    const datePart = ((year & 0x7f) << 9) | ((month & 0x0f) << 5) | (day & 0x1f);
+    
+    // Pack time: hour (5 bits) + minute (6 bits) + second/2 (5 bits)
+    const timePart = ((hour & 0x1f) << 11) | ((minute & 0x3f) << 5) | ((second >> 1) & 0x1f);
+    
+    // Combine date and time parts
+    const time = (datePart << 16) | timePart;
+    
     return time;
   }
 
@@ -493,13 +572,20 @@ export default class ZipEntry implements ZipFileEntry {
   parseDateTime(timeStamp: number): Date | null {
     if (timeStamp == 0)
       return null;
-    return new Date(
-      ((timeStamp >> 25) & 0x3f) + 1980,    // Year
-      ((timeStamp >> 21) & 0x0f) - 1,       // Month
-      (timeStamp >> 16) & 0x1f,             // Day
-      (timeStamp >> 11) & 0x1f,             // Hour
-      (timeStamp >> 5) & 0x3f,              // Min
-      (timeStamp & 0x1f) << 1);             // Sec 
+    
+    // Extract date part (upper 16 bits)
+    const datePart = (timeStamp >> 16) & 0xffff;
+    const year = ((datePart >> 9) & 0x7f) + 1980;  // Year (7 bits) + 1980
+    const month = ((datePart >> 5) & 0x0f) - 1;    // Month (4 bits) - 1 for 0-based
+    const day = datePart & 0x1f;                   // Day (5 bits)
+    
+    // Extract time part (lower 16 bits)
+    const timePart = timeStamp & 0xffff;
+    const hour = (timePart >> 11) & 0x1f;          // Hour (5 bits)
+    const minute = (timePart >> 5) & 0x3f;         // Minute (6 bits)
+    const second = (timePart & 0x1f) << 1;         // Second (5 bits) * 2
+    
+    return new Date(year, month, day, hour, minute, second);
   }
 
   /**
@@ -656,31 +742,31 @@ export default class ZipEntry implements ZipFileEntry {
    * Includes compression, encryption, timestamps, and extra fields
    */
   showVerboseInfo() {
-    console.log('=== Central Directory Entry (%s) ===', this.filename);
-    console.log('unzip from start of archive: ', this.localHdrOffset);
-    console.log('File system or operating system of origin:    ', this.fileSystemToString());
-    console.log('Version of encoding software:                 ', this.verMadeBy);
-    console.log('Compression Method:                           ', this.cmpMethodToString());
-    console.log('File Security Status:                         ', 
+    Logger.log('=== Central Directory Entry (%s) ===', this.filename);
+    Logger.log('unzip from start of archive: ', this.localHdrOffset);
+    Logger.log('File system or operating system of origin:    ', this.fileSystemToString());
+    Logger.log('Version of encoding software:                 ', this.verMadeBy);
+    Logger.log('Compression Method:                           ', this.cmpMethodToString());
+    Logger.log('File Security Status:                         ', 
       this.bitFlags & GP_FLAG.ENCRYPTED ? 
         this.bitFlags & GP_FLAG.STRONG_ENCRYPT ? 'Strong Encrypt' : 'Encrypted' :
         'Not Encrypted');
-    console.log('File Modified (DOS date/time)                 ', this.toFormattedDateString()); 
-    console.log('File Modified (UTC)                           ', this.toFormattedUTCDateString());
-    console.log('Compressed Size:                              ', this.compressedSize);
-    console.log('UnCompressed Size:                            ', this.uncompressedSize);
-    console.log(`32-bit CRC value (hex):                        ${this.crc.toString(16).padStart(8, '0')}`);
-    console.log('Length of extra field:                        ', this.extraField?.length ?? 0);
-    console.log('Length of file comment:                       ', this.comment?.length ?? 0);
-    console.log('Unix File Attributes:                         ');
-    console.log('MS-DOS File Attributes:                       ', this.dosAttributesToString());
+    Logger.log('File Modified (DOS date/time)                 ', this.toFormattedDateString()); 
+    Logger.log('File Modified (UTC)                           ', this.toFormattedUTCDateString());
+    Logger.log('Compressed Size:                              ', this.compressedSize);
+    Logger.log('UnCompressed Size:                            ', this.uncompressedSize);
+    Logger.log(`32-bit CRC value (hex):                        ${this.crc.toString(16).padStart(8, '0')}`);
+    Logger.log('Length of extra field:                        ', this.extraField?.length ?? 0);
+    Logger.log('Length of file comment:                       ', this.comment?.length ?? 0);
+    Logger.log('Unix File Attributes:                         ');
+    Logger.log('MS-DOS File Attributes:                       ', this.dosAttributesToString());
     if (this.extraField) {
-      console.log('\nThe Central-Directory Extra Field contains:');
+      Logger.log('\nThe Central-Directory Extra Field contains:');
       try {
         for (let i = 0; i < this.extraField.length; ) {
           // Ensure we have at least 4 bytes (header ID + length)
           if (i + 4 > this.extraField.length) {
-            console.log(`   Warning: Truncated extra field at offset ${i}`);
+            Logger.log(`   Warning: Truncated extra field at offset ${i}`);
             break;
           }
           
@@ -690,7 +776,7 @@ export default class ZipEntry implements ZipFileEntry {
           
           // Validate the length to ensure it doesn't exceed buffer bounds
           if (_len < 0 || i + 4 + _len > this.extraField.length) {
-            console.log(`   Warning: Invalid extra field length (${_len}) at offset ${i} for ID ${_idStr}`);
+            Logger.log(`   Warning: Invalid extra field length (${_len}) at offset ${i} for ID ${_idStr}`);
             break;
           }
           
@@ -698,22 +784,22 @@ export default class ZipEntry implements ZipFileEntry {
           
           try {
             if (_id === HDR_ID.SHA256) {          
-              console.log(`   ID[0x${_idStr}] NeoZip-SHA256: ${_data.toString('hex')}`);
+              Logger.log(`   ID[0x${_idStr}] NeoZip-SHA256: ${_data.toString('hex')}`);
             } else if (_id === HDR_ID.UNV_TIME) {
               if (_len >= 5) {
                 const flags = _data.readUInt8(0);
                 const timestamp = _data.readUInt32LE(1);
                 const date = new Date(timestamp * 1000);
-                console.log(`   ID[0x${_idStr}] Universal Time: flags=${flags}, time=${date.toISOString()}`);
+                Logger.log(`   ID[0x${_idStr}] Universal Time: flags=${flags}, time=${date.toISOString()}`);
               } else {
-                console.log(`   ID[0x${_idStr}] Universal Time: (invalid length ${_len})`);
+                Logger.log(`   ID[0x${_idStr}] Universal Time: (invalid length ${_len})`);
               }
             } else if (_id === HDR_ID.UID_GID) {
               if (_len >= 5) {
                 const version = _data.readUInt8(0);
                 const uidSize = _data.readUInt8(1);
                 if (2 + uidSize > _len) {
-                  console.log(`   ID[0x${_idStr}] Unix UID/GID: (invalid UID size ${uidSize})`);
+                  Logger.log(`   ID[0x${_idStr}] Unix UID/GID: (invalid UID size ${uidSize})`);
                 } else {
                   const uid = _data.readUIntLE(2, Math.min(uidSize, 4));
                   let gid = 0;
@@ -723,10 +809,37 @@ export default class ZipEntry implements ZipFileEntry {
                       gid = _data.readUIntLE(2 + uidSize + 1, Math.min(gidSize, 4));
                     }
                   }
-                  console.log(`   ID[0x${_idStr}] Unix UID/GID: version=${version}, uid=${uid}, gid=${gid}`);
+                  Logger.log(`   ID[0x${_idStr}] Unix UID/GID: version=${version}, uid=${uid}, gid=${gid}`);
+                }
+              } else {
+                Logger.log(`   ID[0x${_idStr}] Unix UID/GID: (invalid length ${_len})`);
+              }
+            } else if (_id === HDR_ID.SYMLINK) {
+              if (_len >= 3) {
+                const version = _data.readUInt8(0);
+                const targetLength = _data.readUInt16LE(1);
+                if (targetLength > 0 && _len >= 3 + targetLength) {
+                  const target = _data.subarray(3, 3 + targetLength).toString('utf8');
+                  Logger.log(`   ID[0x${_idStr}] Symbolic Link: version=${version}, target="${target}"`);
+                } else {
+                  Logger.log(`   ID[0x${_idStr}] Symbolic Link: (invalid target length ${targetLength})`);
+                }
+              } else {
+                Logger.log(`   ID[0x${_idStr}] Symbolic Link: (invalid length ${_len})`);
+              }
+            } else if (_id === HDR_ID.HARDLINK) {
+              if (_len >= 11) {
+                const version = _data.readUInt8(0);
+                const inode = _data.readUInt32LE(1);
+                const originalLength = _data.readUInt16LE(5);
+                if (originalLength > 0 && _len >= 7 + originalLength) {
+                  const original = _data.subarray(7, 7 + originalLength).toString('utf8');
+                  Logger.log(`   ID[0x${_idStr}] Hard Link: version=${version}, inode=${inode}, original="${original}"`);
+                } else {
+                  Logger.log(`   ID[0x${_idStr}] Hard Link: (invalid original length ${originalLength})`);
                 }
               } else {
-                console.log(`   ID[0x${_idStr}] Unix UID/GID: (invalid length ${_len})`);
+                Logger.log(`   ID[0x${_idStr}] Hard Link: (invalid length ${_len})`);
               }
             } else if (_id === HDR_ID.UNICODE_PATH) {
               if (_len >= 5) {
@@ -740,28 +853,65 @@ export default class ZipEntry implements ZipFileEntry {
                 
                 const crcMatch = nameCrc32 === calculatedCrc ? 'MATCH' : 'MISMATCH';
                 
-                console.log(`   ID[0x${_idStr}] Unicode Path: version=${version}, CRC32=${nameCrc32.toString(16)} (${crcMatch})`);
-                console.log(`                      Path: "${unicodeName}"`);
+                Logger.log(`   ID[0x${_idStr}] Unicode Path: version=${version}, CRC32=${nameCrc32.toString(16)} (${crcMatch})`);
+                Logger.log(`                      Path: "${unicodeName}"`);
               } else {
-                console.log(`   ID[0x${_idStr}] Unicode Path: (invalid length ${_len})`);
+                Logger.log(`   ID[0x${_idStr}] Unicode Path: (invalid length ${_len})`);
+              }
+            } else if (_id === HDR_ID.ZIP64) {
+              // ZIP64 Extended Information (0x0001)
+              Logger.log(`   ID[0x${_idStr}] ZIP64 Extended Information:`);
+              if (_len >= 8) {
+                let offset = 0;
+                
+                // Read uncompressed size (8 bytes) if present
+                if (offset + 8 <= _len) {
+                  const uncompressedSize = _data.readBigUInt64LE(offset);
+                  Logger.log(`     Uncompressed Size (ZIP64): ${uncompressedSize.toString()} bytes`);
+                  offset += 8;
+                }
+                
+                // Read compressed size (8 bytes) if present
+                if (offset + 8 <= _len) {
+                  const compressedSize = _data.readBigUInt64LE(offset);
+                  Logger.log(`     Compressed Size (ZIP64): ${compressedSize.toString()} bytes`);
+                  offset += 8;
+                }
+                
+                // Read local header offset (8 bytes) if present
+                if (offset + 8 <= _len) {
+                  const localHeaderOffset = _data.readBigUInt64LE(offset);
+                  Logger.log(`     Local Header Offset (ZIP64): ${localHeaderOffset.toString()}`);
+                  offset += 8;
+                }
+                
+                // Read disk number (4 bytes) if present
+                if (offset + 4 <= _len) {
+                  const diskNumber = _data.readUInt32LE(offset);
+                  Logger.log(`     Disk Number (ZIP64): ${diskNumber}`);
+                }
+              } else {
+                Logger.log(`     ZIP64 Extended Information: (invalid length ${_len})`);
               }
             } else {
               // For unknown fields, show a hex preview of the first few bytes
               const preview = _len > 0 
                 ? _data.slice(0, Math.min(16, _len)).toString('hex')
                 : '';
-              console.log(`   ID[0x${_idStr}] Unknown field: length=${_len} bytes${preview ? ', data=' + preview + '...' : ''}`);
+              Logger.log(`   ID[0x${_idStr}] Unknown field: length=${_len} bytes${preview ? ', data=' + preview + '...' : ''}`);
             }
           } catch (error: any) {
-            console.log(`   Error parsing extra field ID[0x${_idStr}]: ${error.message}`);
+            Logger.log(`   Error parsing extra field ID[0x${_idStr}]: ${error.message}`);
           }
           
           i += 4 + _len;
         }
       } catch (error: any) {
-        console.log(`   Error parsing extra fields: ${error.message}`);
+        Logger.log(`   Error parsing extra fields: ${error.message}`);
       }
     }
-    console.log('\n');
+    Logger.log('\n');
   }
 }
+
+export { ZipEntry };