neozip-cli 0.75.0-beta → 0.75.1-beta

package/dist/src/neozip/file-operations.js

@@ -0,0 +1,924 @@
+"use strict";
+/**
+ * File operations for NeoZip CLI
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldUpdateFile = shouldUpdateFile;
+exports.loadExistingArchive = loadExistingArchive;
+exports.collectFilesRecursively = collectFilesRecursively;
+exports.filterFiles = filterFiles;
+exports.findOldestEntryTime = findOldestEntryTime;
+exports.moveFiles = moveFiles;
+exports.deleteFromArchive = deleteFromArchive;
+exports.loadExistingArchiveLarge = loadExistingArchiveLarge;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const minimatch_1 = require("minimatch");
+const neozipkit_1 = __importDefault(require("neozipkit"));
+const neozipkit_2 = require("neozipkit");
+const node_1 = __importDefault(require("neozipkit/node"));
+const utils_1 = require("./utils");
+const exit_codes_1 = require("../exit-codes");
+/**
+ * Check if a file should be updated based on modification time
+ */
+async function shouldUpdateFile(entryName, fileStat, existingArchive, isFreshen = false) {
+    if (!existingArchive) {
+        return !isFreshen; // No existing archive: add all files for update, add none for freshen
+    }
+    try {
+        const entries = existingArchive.getDirectory() || [];
+        const existingEntry = entries.find((entry) => entry.filename === entryName);
+        if (!existingEntry) {
+            return !isFreshen; // File doesn't exist in archive: add it for update, skip it for freshen
+        }
+        // Compare modification times using milliseconds since 1970
+        // Prioritize extended timestamps (NTFS) over DOS timestamps
+        let existingTime;
+        // First try extended timestamp (NTFS/Unix) - already in milliseconds since 1970
+        if (existingEntry.ntfsTime && existingEntry.ntfsTime.mtime) {
+            existingTime = existingEntry.ntfsTime.mtime;
+        }
+        else if (existingEntry.extendedTime && existingEntry.extendedTime.mtime) {
+            existingTime = existingEntry.extendedTime.mtime;
+        }
+        else if (existingEntry.parseDateTime && existingEntry.lastModTimeDate) {
+            // Use the parseDateTime method if available (same as neolist.ts)
+            const parsedDate = existingEntry.parseDateTime(existingEntry.lastModTimeDate);
+            existingTime = parsedDate ? parsedDate.getTime() : 0;
+        }
+        else if (existingEntry.lastModTimeDate) {
+            existingTime = new Date(existingEntry.lastModTimeDate).getTime();
+        }
+        else if (existingEntry.timeDateDOS) {
+            // timeDateDOS is in seconds since 1970, convert to milliseconds
+            existingTime = existingEntry.timeDateDOS * 1000;
+        }
+        else {
+            // If we can't get the time, assume we should update
+            return true;
+        }
+        const fileTime = fileStat.mtimeMs;
+        // Debug output for date comparison (can be enabled with DEBUG_UPDATE=1)
+        if (process.env.DEBUG_UPDATE) {
+            console.log(`Date comparison for ${entryName}:`);
+            console.log(`  File time: ${new Date(fileTime).toISOString()}`);
+            console.log(`  Archive time: ${new Date(existingTime).toISOString()}`);
+            console.log(`  File newer: ${fileTime > existingTime}`);
+            console.log(`  Timestamp sources:`, {
+                ntfsTime: existingEntry.ntfsTime,
+                extendedTime: existingEntry.extendedTime,
+                timeDateDOS: existingEntry.timeDateDOS,
+                lastModTimeDate: existingEntry.lastModTimeDate,
+                hasParseDateTime: !!existingEntry.parseDateTime
+            });
+        }
+        // Compare at second precision to avoid millisecond differences
+        const fileTimeSeconds = Math.floor(fileTime / 1000);
+        const existingTimeSeconds = Math.floor(existingTime / 1000);
+        return fileTimeSeconds > existingTimeSeconds; // Update if file is newer
+    }
+    catch (error) {
+        // If we can't check, assume we should update
+        return true;
+    }
+}
+/**
+ * Load existing archive if it exists
+ */
+function loadExistingArchive(archiveName, options) {
+    if (!fs.existsSync(archiveName)) {
+        return null;
+    }
+    try {
+        // For in-memory option, use optimized large file loader
+        if (options?.inMemory) {
+            try {
+                const result = loadExistingArchiveLarge(archiveName);
+                if (result) {
+                    return result;
+                }
+                // If result is null, treat as new archive (file doesn't exist or is invalid)
+                return null;
+            }
+            catch (error) {
+                // Only abort if large loader actually fails (throws exception)
+                throw new Error(`Failed to load large ZIP archive ${archiveName} using optimized EOCD loading. The archive may be corrupted or in an unsupported format.`);
+            }
+        }
+        // Standard loader (existing code)
+        const data = fs.readFileSync(archiveName);
+        const zip = new neozipkit_1.default();
+        zip.loadZip(data);
+        return zip;
+    }
+    catch (error) {
+        // If we can't load the existing archive, treat it as new
+        return null;
+    }
+}
+/**
+ * Recursively collect files and directories
+ */
+function collectFilesRecursively(inputPaths, options) {
+    const collectedFiles = [];
+    // Track inodes to detect hard links (Unix-like systems only)
+    const inodeMap = new Map(); // inode -> first entry name
+    /**
+     * Helper function to process a file and detect hard links
+     */
+    function processFile(filePath, entryName, lstat) {
+        // Check for hard links (Unix-like systems only)
+        if (options.hardLinks && process.platform !== 'win32' && lstat.nlink > 1) {
+            const inode = lstat.ino; // inode number
+            if (inodeMap.has(inode)) {
+                // This is a hard link to an existing file
+                const originalEntry = inodeMap.get(inode);
+                collectedFiles.push({
+                    entryName: entryName,
+                    absPath: filePath,
+                    displayPath: filePath,
+                    stat: lstat,
+                    isDirectory: false,
+                    isHardLink: true,
+                    originalEntry: originalEntry,
+                    inode: inode
+                });
+                if (options.debug) {
+                    console.log(`🔗 Hard link detected: ${entryName} -> ${originalEntry} (inode: ${inode})`);
+                }
+            }
+            else {
+                // First occurrence of this inode
+                inodeMap.set(inode, entryName);
+                collectedFiles.push({
+                    entryName: entryName,
+                    absPath: filePath,
+                    displayPath: filePath,
+                    stat: lstat,
+                    isDirectory: false,
+                    inode: inode
+                });
+            }
+        }
+        else {
+            // Regular file (no hard link detection or not requested)
+            collectedFiles.push({
+                entryName: entryName,
+                absPath: filePath,
+                displayPath: filePath,
+                stat: lstat,
+                isDirectory: false
+            });
+        }
+    }
+    for (const inputPath of inputPaths) {
+        if (!fs.existsSync(inputPath)) {
+            console.error(`Error: Path not found: ${inputPath}`);
+            (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.CANT_FIND_ARCHIVE);
+        }
+        // Use lstat to detect symbolic links
+        const lstat = fs.lstatSync(inputPath);
+        if (lstat.isSymbolicLink()) {
+            // Handle symbolic links
+            if (options.symlinks) {
+                // Store the symbolic link itself
+                const linkTarget = fs.readlinkSync(inputPath);
+                collectedFiles.push({
+                    entryName: options.junkPaths ? path.basename(inputPath) : inputPath,
+                    absPath: inputPath,
+                    displayPath: inputPath,
+                    stat: lstat,
+                    isDirectory: false,
+                    isSymlink: true,
+                    linkTarget: linkTarget
+                });
+            }
+            else {
+                // Follow the symbolic link (default behavior)
+                try {
+                    const stat = fs.statSync(inputPath); // This follows the link
+                    if (stat.isFile()) {
+                        collectedFiles.push({
+                            entryName: options.junkPaths ? path.basename(inputPath) : inputPath,
+                            absPath: inputPath,
+                            displayPath: inputPath,
+                            stat: stat,
+                            isDirectory: false
+                        });
+                    }
+                    else if (stat.isDirectory() && options.recurse) {
+                        // Recursively process the directory that the symlink points to
+                        const subFiles = collectFilesRecursively([inputPath], options);
+                        collectedFiles.push(...subFiles);
+                    }
+                }
+                catch (error) {
+                    console.error(`Warning: Cannot follow symbolic link ${inputPath}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+        else if (lstat.isFile()) {
+            // It's a regular file, process it for hard link detection
+            const entryName = options.junkPaths ? path.basename(inputPath) : inputPath;
+            processFile(inputPath, entryName, lstat);
+        }
+        else if (lstat.isDirectory()) {
+            if (options.recurse) {
+                // Recursively collect files from directory
+                const dirContents = fs.readdirSync(inputPath);
+                for (const item of dirContents) {
+                    const itemPath = path.join(inputPath, item);
+                    const itemLstat = fs.lstatSync(itemPath);
+                    if (itemLstat.isSymbolicLink()) {
+                        // Handle symbolic links in subdirectories
+                        if (options.symlinks) {
+                            // Store the symbolic link itself
+                            const linkTarget = fs.readlinkSync(itemPath);
+                            const relativePath = path.relative(process.cwd(), itemPath);
+                            collectedFiles.push({
+                                entryName: options.junkPaths ? path.basename(itemPath) : relativePath,
+                                absPath: itemPath,
+                                displayPath: itemPath,
+                                stat: itemLstat,
+                                isDirectory: false,
+                                isSymlink: true,
+                                linkTarget: linkTarget
+                            });
+                        }
+                        else {
+                            // Follow the symbolic link (default behavior)
+                            try {
+                                const itemStat = fs.statSync(itemPath); // This follows the link
+                                if (itemStat.isFile()) {
+                                    const relativePath = path.relative(process.cwd(), itemPath);
+                                    collectedFiles.push({
+                                        entryName: options.junkPaths ? path.basename(itemPath) : relativePath,
+                                        absPath: itemPath,
+                                        displayPath: itemPath,
+                                        stat: itemStat,
+                                        isDirectory: false
+                                    });
+                                }
+                                else if (itemStat.isDirectory()) {
+                                    // Recursively process the directory that the symlink points to
+                                    const subFiles = collectFilesRecursively([itemPath], options);
+                                    collectedFiles.push(...subFiles);
+                                }
+                            }
+                            catch (error) {
+                                console.error(`Warning: Cannot follow symbolic link ${itemPath}: ${error instanceof Error ? error.message : String(error)}`);
+                            }
+                        }
+                    }
+                    else if (itemLstat.isFile()) {
+                        const relativePath = path.relative(process.cwd(), itemPath);
+                        const entryName = options.junkPaths ? path.basename(itemPath) : relativePath;
+                        processFile(itemPath, entryName, itemLstat);
+                    }
+                    else if (itemLstat.isDirectory()) {
+                        // Recursively process subdirectory
+                        const subFiles = collectFilesRecursively([itemPath], options);
+                        collectedFiles.push(...subFiles);
+                    }
+                }
+            }
+            else {
+                console.error(`Error: ${inputPath} is a directory. Use -r/--recurse to include directories.`);
+                (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.CANT_CREATE_FILE);
+            }
+        }
+    }
+    return collectedFiles;
+}
+/**
+ * Filter files based on include/exclude patterns
+ */
+function filterFiles(files, options) {
+    if (!options.include && !options.exclude && !options.suffixes) {
+        return files;
+    }
+    return files.filter(filePath => {
+        const fileName = path.basename(filePath);
+        const relativePath = path.relative(process.cwd(), filePath);
+        // Check include patterns first (if any)
+        if (options.include && options.include.length > 0) {
+            const matchesInclude = options.include.some(pattern => (0, minimatch_1.minimatch)(fileName, pattern) || (0, minimatch_1.minimatch)(relativePath, pattern));
+            if (!matchesInclude) {
+                return false;
+            }
+        }
+        // Check exclude patterns
+        if (options.exclude && options.exclude.length > 0) {
+            const matchesExclude = options.exclude.some(pattern => (0, minimatch_1.minimatch)(fileName, pattern) || (0, minimatch_1.minimatch)(relativePath, pattern));
+            if (matchesExclude) {
+                return false;
+            }
+        }
+        // Check suffix exclusion (don't compress files with these suffixes)
+        if (options.suffixes && options.suffixes.length > 0) {
+            const fileExtension = path.extname(fileName).toLowerCase();
+            const hasExcludedSuffix = options.suffixes.some(suffix => {
+                // Remove leading dot if present and normalize
+                const normalizedSuffix = suffix.startsWith('.') ? suffix.substring(1) : suffix;
+                return fileExtension === `.${normalizedSuffix.toLowerCase()}`;
+            });
+            if (hasExcludedSuffix) {
+                return false;
+            }
+        }
+        return true;
+    });
+}
+/**
+ * Find the oldest entry time in a ZIP archive
+ */
+async function findOldestEntryTime(zip) {
+    try {
+        const entries = await zip.getDirectory(false) || [];
+        if (entries.length === 0) {
+            return null;
+        }
+        let oldestTime = null;
+        for (const entry of entries) {
+            // Convert DOS time to JavaScript Date
+            const dosTime = entry.timeDateDOS || 0;
+            if (dosTime === 0)
+                continue;
+            // Extract date and time from DOS format
+            const day = dosTime & 0x1F;
+            const month = (dosTime >> 5) & 0x0F;
+            const year = ((dosTime >> 9) & 0x7F) + 1980;
+            const seconds = (dosTime >> 16) & 0x1F;
+            const minutes = (dosTime >> 21) & 0x3F;
+            const hours = (dosTime >> 27) & 0x1F;
+            // Create Date object
+            const entryTime = new Date(year, month - 1, day, hours, minutes, seconds * 2);
+            if (!oldestTime || entryTime < oldestTime) {
+                oldestTime = entryTime;
+            }
+        }
+        return oldestTime;
+    }
+    catch (error) {
+        return null;
+    }
+}
+/**
+ * Move files (delete originals after successful ZIP creation)
+ */
+async function moveFiles(files, options) {
+    if (options.quiet)
+        return; // Skip if quiet mode
+    (0, utils_1.log)('🗑️  Moving files (deleting originals)...', options);
+    for (const file of files) {
+        try {
+            const stat = fs.statSync(file);
+            if (stat.isFile()) {
+                fs.unlinkSync(file);
+                if (options.verbose) {
+                    (0, utils_1.log)(`   deleted: ${file}`, options);
+                }
+            }
+            else if (stat.isDirectory()) {
+                // For directories, delete all files recursively
+                const deleteRecursively = (dirPath) => {
+                    const entries = fs.readdirSync(dirPath);
+                    for (const entry of entries) {
+                        const fullPath = path.join(dirPath, entry);
+                        const entryStat = fs.statSync(fullPath);
+                        if (entryStat.isDirectory()) {
+                            deleteRecursively(fullPath);
+                        }
+                        else {
+                            fs.unlinkSync(fullPath);
+                            if (options.verbose) {
+                                (0, utils_1.log)(`   deleted: ${fullPath}`, options);
+                            }
+                        }
+                    }
+                    fs.rmdirSync(dirPath);
+                    if (options.verbose) {
+                        (0, utils_1.log)(`   deleted: ${dirPath}/`, options);
+                    }
+                };
+                deleteRecursively(file);
+            }
+        }
+        catch (error) {
+            (0, utils_1.logError)(`Warning: Could not delete ${file}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    (0, utils_1.log)('✅ Files moved successfully', options);
+}
+/**
+ * Delete specified files from an existing archive
+ */
+async function deleteFromArchive(archiveName, filesToDelete, options) {
+    if (!fs.existsSync(archiveName)) {
+        console.error(`Error: Archive not found: ${archiveName}`);
+        (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.CANT_FIND_ARCHIVE);
+    }
+    (0, utils_1.log)(`🗑️  Deleting files from: ${archiveName}`, options);
+    (0, utils_1.log)(`📁 Files to delete: ${filesToDelete.length} file(s)`, options);
+    try {
+        // Read the existing archive
+        const zipData = fs.readFileSync(archiveName);
+        const zip = new neozipkit_1.default();
+        zip.loadZip(zipData);
+        const entries = zip.getDirectory() || [];
+        const originalCount = entries.length;
+        if (options.debug) {
+            (0, utils_1.logDebug)(`Original archive has ${originalCount} entries`, options);
+            (0, utils_1.logDebug)(`Files to delete: ${filesToDelete.join(', ')}`, options);
+        }
+        // Find entries to delete
+        const entriesToDelete = [];
+        const entriesNotFound = [];
+        for (const fileToDelete of filesToDelete) {
+            const found = entries.find((entry) => entry.filename === fileToDelete);
+            if (found) {
+                entriesToDelete.push(fileToDelete);
+                if (options.verbose) {
+                    (0, utils_1.log)(`  Found: ${fileToDelete}`, options);
+                }
+            }
+            else {
+                entriesNotFound.push(fileToDelete);
+                if (options.verbose) {
+                    (0, utils_1.log)(`  Not found: ${fileToDelete}`, options);
+                }
+            }
+        }
+        if (entriesNotFound.length > 0) {
+            console.error(`Warning: ${entriesNotFound.length} file(s) not found in archive:`);
+            entriesNotFound.forEach(file => console.error(`  ${file}`));
+        }
+        if (entriesToDelete.length === 0) {
+            console.error('Error: No files found to delete');
+            (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.NO_FILES_MATCHED);
+        }
+        if (entriesToDelete.length === originalCount) {
+            // If we're deleting all files, just delete the archive
+            fs.unlinkSync(archiveName);
+            (0, utils_1.log)('✅ Archive deleted (all files removed)', options);
+            return;
+        }
+        // Create new archive without the deleted files
+        const newZip = new node_1.default();
+        const outParts = [];
+        // Build entries list for new archive
+        const newEntries = [];
+        for (const entry of entries) {
+            if (!entriesToDelete.includes(entry.filename)) {
+                // Copy entry to new archive
+                const newEntry = new neozipkit_2.ZipEntry(entry.filename);
+                Object.assign(newEntry, entry);
+                // Copy the file data from the existing archive
+                try {
+                    const existingData = await (async () => {
+                        try {
+                            const kit = new node_1.default();
+                            kit.loadZip(zipData);
+                            return await kit.extract(entry);
+                        }
+                        catch {
+                            return null;
+                        }
+                    })();
+                    if (existingData) {
+                        newEntry.fileBuffer = existingData;
+                        newEntry.isUpdated = true;
+                    }
+                }
+                catch (error) {
+                    if (options.verbose) {
+                        (0, utils_1.log)(`warning: Could not copy entry ${entry.filename}`, options);
+                    }
+                }
+                newEntries.push(newEntry);
+            }
+        }
+        // Build ZIP file data using ZipCompress
+        let currentOffset = 0;
+        const zipDataChunks = [];
+        for (const entry of newEntries) {
+            if (entry.fileBuffer) {
+                // Entry has pre-loaded buffer
+                const fileData = entry.fileBuffer;
+                // Compress the data using ZipCompress
+                const compressedData = await newZip.compressFileBuffer(entry, fileData, {
+                    level: 6,
+                    useZstd: true,
+                    useSHA256: false
+                });
+                // Set local header offset
+                entry.localHdrOffset = currentOffset;
+                // Add to ZIP
+                zipDataChunks.push(compressedData);
+                currentOffset += compressedData.length;
+            }
+        }
+        // Build central directory
+        const centralDirChunks = [];
+        for (const entry of newEntries) {
+            const centralDirEntry = entry.centralDirEntry();
+            centralDirChunks.push(centralDirEntry);
+        }
+        const centralDir = Buffer.concat(centralDirChunks);
+        // Build end of central directory
+        const endOfCentralDir = Buffer.alloc(22);
+        endOfCentralDir.writeUInt32LE(0x06054b50, 0); // Signature
+        endOfCentralDir.writeUInt16LE(0, 4); // This disk
+        endOfCentralDir.writeUInt16LE(0, 6); // Disk with CD
+        endOfCentralDir.writeUInt16LE(newEntries.length, 8); // Entries on this disk
+        endOfCentralDir.writeUInt16LE(newEntries.length, 10); // Total entries
+        endOfCentralDir.writeUInt32LE(centralDir.length, 12); // CD size
+        endOfCentralDir.writeUInt32LE(currentOffset, 16); // CD offset
+        endOfCentralDir.writeUInt16LE(0, 20); // Comment length
+        // Combine everything
+        const compressedZipData = Buffer.concat(zipDataChunks);
+        const newZipData = Buffer.concat([compressedZipData, centralDir, endOfCentralDir]);
+        fs.writeFileSync(archiveName, newZipData);
+        const remainingCount = originalCount - entriesToDelete.length;
+        (0, utils_1.log)(`✅ Deleted ${entriesToDelete.length} file(s) from archive`, options);
+        (0, utils_1.log)(`📁 Remaining files: ${remainingCount}`, options);
+    }
+    catch (error) {
+        console.error(`Error: Failed to delete files from archive: ${error instanceof Error ? error.message : String(error)}`);
+        (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.CANT_WRITE_ARCHIVE);
+    }
+}
+// ============================================================================
+// Large ZIP File EOCD Loading Functions
+// ============================================================================
+/**
+ * Locates the End of Central Directory (EOCD) signature in a ZIP file
+ * Uses backwards search from the end of the file (InfoZip algorithm)
+ * @param fd - File descriptor
+ * @param fileSize - Size of the file in bytes
+ * @returns Object with EOCD offset and ZIP64 flag, or null if not found
+ */
+function locateEOCD(fd, fileSize) {
+    // EOCD signature: 0x06054b50
+    const EOCD_SIGNATURE = 0x06054b50;
+    const ZIP64_EOCD_SIGNATURE = 0x07064b50;
+    // Maximum comment length is 65535 bytes, so search last 64KB + EOCD size
+    const maxCommentSize = 65535;
+    const eocdMinSize = 22;
+    const searchSize = Math.min(maxCommentSize + eocdMinSize, fileSize);
+    const searchStart = Math.max(0, fileSize - searchSize);
+    // Read the last portion of the file
+    const buffer = Buffer.alloc(searchSize);
+    try {
+        fs.readSync(fd, buffer, 0, searchSize, searchStart);
+    }
+    catch (error) {
+        (0, utils_1.logError)(`Failed to read file for EOCD search: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+    // Search backwards for EOCD signature
+    for (let i = buffer.length - eocdMinSize; i >= 0; i--) {
+        try {
+            const signature = buffer.readUInt32LE(i);
+            if (signature === EOCD_SIGNATURE) {
+                const eocdOffset = searchStart + i;
+                // Check if this is a ZIP64 EOCD locator (20 bytes before standard EOCD)
+                const zip64LocatorOffset = eocdOffset - 20;
+                if (zip64LocatorOffset >= 0) {
+                    try {
+                        const zip64Buffer = Buffer.alloc(20);
+                        fs.readSync(fd, zip64Buffer, 0, 20, zip64LocatorOffset);
+                        if (zip64Buffer.readUInt32LE(0) === ZIP64_EOCD_SIGNATURE) {
+                            return { offset: eocdOffset, isZip64: true };
+                        }
+                    }
+                    catch (error) {
+                        // ZIP64 locator not found, continue with standard EOCD
+                    }
+                }
+                return { offset: eocdOffset, isZip64: false };
+            }
+        }
+        catch (error) {
+            // Continue searching
+        }
+    }
+    return null;
+}
+/**
+ * Parses central directory entries from a central directory buffer
+ * @param cdBuffer - Buffer containing central directory data
+ * @returns Array of ZipEntry objects
+ */
+function parseCentralDirectoryEntries(cdBuffer) {
+    const entries = [];
+    try {
+        // Central Directory File Header signature
+        const CD_SIGNATURE = 0x02014b50;
+        let offset = 0;
+        while (offset < cdBuffer.length - 4) {
+            // Look for central directory signature
+            if (cdBuffer.readUInt32LE(offset) === CD_SIGNATURE) {
+                try {
+                    // Parse central directory entry
+                    const entry = parseCentralDirectoryEntry(cdBuffer, offset);
+                    if (entry) {
+                        entries.push(entry);
+                    }
+                    // Move to next entry
+                    // Central directory entry size varies, so we need to calculate it
+                    const filenameLength = cdBuffer.readUInt16LE(offset + 28);
+                    const extraFieldLength = cdBuffer.readUInt16LE(offset + 30);
+                    const commentLength = cdBuffer.readUInt16LE(offset + 32);
+                    const entrySize = 46 + filenameLength + extraFieldLength + commentLength;
+                    offset += entrySize;
+                }
+                catch (error) {
+                    // If we can't parse this entry, skip it
+                    offset += 4;
+                }
+            }
+            else {
+                offset += 4;
+            }
+        }
+    }
+    catch (error) {
+        (0, utils_1.logError)(`Error parsing central directory entries: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return entries;
+}
+/**
+ * Parses a single central directory entry
+ * @param data - Buffer containing central directory data
+ * @param offset - Offset of the entry in the buffer
+ * @returns ZipEntry object or null if parsing fails
+ */
+function parseCentralDirectoryEntry(data, offset) {
+    try {
+        // Central Directory File Header structure (46 bytes + variable length fields)
+        const versionMadeBy = data.readUInt16LE(offset + 4);
+        const versionNeeded = data.readUInt16LE(offset + 6);
+        const generalPurposeBitFlag = data.readUInt16LE(offset + 8);
+        const compressionMethod = data.readUInt16LE(offset + 10);
+        const lastModTime = data.readUInt16LE(offset + 12);
+        const lastModDate = data.readUInt16LE(offset + 14);
+        const crc32 = data.readUInt32LE(offset + 16);
+        const compressedSize = data.readUInt32LE(offset + 20);
+        const uncompressedSize = data.readUInt32LE(offset + 24);
+        const filenameLength = data.readUInt16LE(offset + 28);
+        const extraFieldLength = data.readUInt16LE(offset + 30);
+        const commentLength = data.readUInt16LE(offset + 32);
+        const diskNumberStart = data.readUInt16LE(offset + 34);
+        const internalFileAttributes = data.readUInt16LE(offset + 36);
+        const externalFileAttributes = data.readUInt32LE(offset + 38);
+        const localHeaderOffset = data.readUInt32LE(offset + 42);
+        // Read filename
+        const filename = data.subarray(offset + 46, offset + 46 + filenameLength).toString('utf8');
+        // Convert DOS date/time to JavaScript timestamp
+        const modifiedTime = dosDateTimeToTimestamp(lastModDate, lastModTime);
+        // Create ZipEntry object
+        const entry = new neozipkit_2.ZipEntry(filename);
+        entry.filename = filename;
+        entry.uncompressedSize = uncompressedSize;
+        entry.compressedSize = compressedSize;
+        entry.cmpMethod = compressionMethod;
+        entry.crc = crc32;
+        entry.lastModTimeDate = modifiedTime;
+        entry.verMadeBy = versionMadeBy;
+        entry.verExtract = versionNeeded;
+        entry.bitFlags = generalPurposeBitFlag;
+        entry.intFileAttr = internalFileAttributes;
+        entry.extFileAttr = externalFileAttributes;
+        entry.localHdrOffset = localHeaderOffset;
+        entry.volNumber = diskNumberStart;
+        return entry;
+    }
+    catch (error) {
+        (0, utils_1.logError)(`Error parsing central directory entry at offset ${offset}: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}
+/**
+ * Converts DOS date/time to JavaScript timestamp
+ * @param dosDate - DOS date value
+ * @param dosTime - DOS time value
+ * @returns JavaScript timestamp
+ */
+function dosDateTimeToTimestamp(dosDate, dosTime) {
+    // Extract date components
+    const year = ((dosDate >> 9) & 0x7F) + 1980;
+    const month = (dosDate >> 5) & 0x0F;
+    const day = dosDate & 0x1F;
+    // Extract time components
+    const hour = (dosTime >> 11) & 0x1F;
+    const minute = (dosTime >> 5) & 0x3F;
+    const second = (dosTime & 0x1F) * 2;
+    // Create Date object
+    const date = new Date(year, month - 1, day, hour, minute, second);
+    return date.getTime();
+}
+/**
+ * Parses a standard End of Central Directory record
+ * @param fd - File descriptor
+ * @param eocdOffset - Offset of the EOCD record
+ * @returns Parsed EOCD information
+ */
+function parseEOCDRecord(fd, eocdOffset) {
+    try {
+        // Read EOCD record (minimum 22 bytes)
+        const eocdBuffer = Buffer.alloc(22);
+        fs.readSync(fd, eocdBuffer, 0, 22, eocdOffset);
+        // Verify signature
+        if (eocdBuffer.readUInt32LE(0) !== 0x06054b50) {
+            return null;
+        }
+        const entriesOnDisk = eocdBuffer.readUInt16LE(8);
+        const totalEntries = eocdBuffer.readUInt16LE(10);
+        const cdSize = eocdBuffer.readUInt32LE(12);
+        const cdOffset = eocdBuffer.readUInt32LE(16);
+        const commentLength = eocdBuffer.readUInt16LE(20);
+        // Check for ZIP64 markers
+        const isZip64Marker = (totalEntries === 0xFFFF || cdSize === 0xFFFFFFFF || cdOffset === 0xFFFFFFFF);
+        return {
+            entriesOnDisk,
+            totalEntries,
+            cdSize,
+            cdOffset,
+            commentLength,
+            isZip64Marker
+        };
+    }
+    catch (error) {
+        (0, utils_1.logError)(`Failed to parse EOCD record: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}
+/**
+ * Parses ZIP64 End of Central Directory record
+ * @param fd - File descriptor
+ * @param eocdOffset - Offset of the standard EOCD record
+ * @returns Parsed ZIP64 EOCD information
+ */
+function parseZip64EOCD(fd, eocdOffset) {
+    try {
+        // ZIP64 EOCD locator is 20 bytes before standard EOCD
+        const zip64LocatorOffset = eocdOffset - 20;
+        const locatorBuffer = Buffer.alloc(20);
+        fs.readSync(fd, locatorBuffer, 0, 20, zip64LocatorOffset);
+        // Verify ZIP64 EOCD locator signature
+        if (locatorBuffer.readUInt32LE(0) !== 0x07064b50) {
+            return null;
+        }
+        // Get ZIP64 EOCD record offset
+        const zip64EOCDOffset = Number(locatorBuffer.readBigUInt64LE(8));
+        // Read ZIP64 EOCD record (minimum 56 bytes)
+        const zip64EOCDBuffer = Buffer.alloc(56);
+        fs.readSync(fd, zip64EOCDBuffer, 0, 56, zip64EOCDOffset);
+        // Verify ZIP64 EOCD signature
+        if (zip64EOCDBuffer.readUInt32LE(0) !== 0x06064b50) {
+            return null;
+        }
+        const totalEntries = zip64EOCDBuffer.readBigUInt64LE(24);
+        const cdSize = zip64EOCDBuffer.readBigUInt64LE(40);
+        const cdOffset = zip64EOCDBuffer.readBigUInt64LE(48);
+        return {
+            totalEntries,
+            cdSize,
+            cdOffset
+        };
+    }
+    catch (error) {
+        (0, utils_1.logError)(`Failed to parse ZIP64 EOCD record: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}
+/**
+ * Loads an existing ZIP archive using optimized large file handling
+ * Uses backwards search to locate EOCD and loads only the central directory
+ * @param archiveName - Path to the ZIP archive
+ * @returns Zipkit instance or null if loading fails
+ */
+function loadExistingArchiveLarge(archiveName) {
+    if (!fs.existsSync(archiveName)) {
+        return null;
+    }
+    let fd = null;
+    try {
+        // Open file for random access
+        fd = fs.openSync(archiveName, 'r');
+        const stats = fs.fstatSync(fd);
+        const fileSize = stats.size;
+        if (fileSize < 22) {
+            // File too small to be a valid ZIP
+            return null;
+        }
+        // Locate EOCD signature
+        const eocdLocation = locateEOCD(fd, fileSize);
+        if (!eocdLocation) {
+            (0, utils_1.logError)(`EOCD signature not found in ${archiveName}`);
+            return null;
+        }
+        // Parse EOCD record
+        const eocdInfo = parseEOCDRecord(fd, eocdLocation.offset);
+        if (!eocdInfo) {
+            (0, utils_1.logError)(`Failed to parse EOCD record in ${archiveName}`);
+            return null;
+        }
+        let cdSize;
+        let cdOffset;
+        let totalEntries;
+        if (eocdInfo.isZip64Marker && eocdLocation.isZip64) {
+            // Use ZIP64 values
+            const zip64Info = parseZip64EOCD(fd, eocdLocation.offset);
+            if (!zip64Info) {
+                (0, utils_1.logError)(`Failed to parse ZIP64 EOCD record in ${archiveName}`);
+                return null;
+            }
+            cdSize = Number(zip64Info.cdSize);
+            cdOffset = Number(zip64Info.cdOffset);
+            totalEntries = Number(zip64Info.totalEntries);
+        }
+        else {
+            // Use standard values
+            cdSize = eocdInfo.cdSize;
+            cdOffset = eocdInfo.cdOffset;
+            totalEntries = eocdInfo.totalEntries;
+        }
+        // Validate central directory bounds
+        if (cdOffset < 0 || cdSize <= 0 || cdOffset + cdSize > fileSize) {
+            (0, utils_1.logError)(`Invalid central directory bounds in ${archiveName}: offset=${cdOffset}, size=${cdSize}, fileSize=${fileSize}`);
+            return null;
+        }
+        // Read central directory
+        const cdBuffer = Buffer.alloc(cdSize);
+        fs.readSync(fd, cdBuffer, 0, cdSize, cdOffset);
+        // Verify central directory signature
+        if (cdBuffer.readUInt32LE(0) !== 0x02014b50) {
+            (0, utils_1.logError)(`Invalid central directory signature in ${archiveName}`);
+            return null;
+        }
+        // Create a complete ZIP file buffer by combining CD with EOCD
+        // Read the EOCD and comment
+        const eocdAndCommentSize = fileSize - eocdLocation.offset;
+        const eocdAndCommentBuffer = Buffer.alloc(eocdAndCommentSize);
+        fs.readSync(fd, eocdAndCommentBuffer, 0, eocdAndCommentSize, eocdLocation.offset);
+        // Create complete ZIP buffer: CD + EOCD + comment
+        const completeZipBuffer = Buffer.concat([cdBuffer, eocdAndCommentBuffer]);
+        const zip = new neozipkit_1.default();
+        zip.loadZip(completeZipBuffer);
+        return zip;
+    }
+    catch (error) {
+        (0, utils_1.logError)(`Failed to load large ZIP archive ${archiveName}: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+    finally {
+        if (fd !== null) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch (error) {
+                // Ignore close errors
+            }
+        }
+    }
+}
+//# sourceMappingURL=file-operations.js.map