neozip-cli 0.70.0-alpha

package/dist/src/neolist.js

@@ -0,0 +1,1194 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * NEOLIST - Standalone ZIP archive listing tool
+ * Usage: neolist [options] <archive>
+ */
+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.main = main;
+exports.parseArgs = parseArgs;
+exports.showHelp = showHelp;
+exports.showExtendedHelp = showExtendedHelp;
+const fs = __importStar(require("fs"));
+const server_1 = require('../neozipkit-wrappers/server');
+const src_1 = require('../neozipkit-wrappers');
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const version_1 = require("./version");
+const exit_codes_1 = require("./exit-codes");
+/**
+ * Helper function to check if ZIP is file-based
+ */
+function isFileBased(zip) {
+    try {
+        zip.getFileHandle();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Logging function that respects quiet mode
+ */
+function log(message, options = { verbose: false, quiet: false, json: false, short: false, unix: false, basic: false, opt1: false, opt2: false, optT: false, optC: false }) {
+    if (!options.quiet) {
+        console.log(message);
+    }
+}
+/**
+ * Error logging function (always shows errors)
+ */
+function logError(message) {
+    console.error(message);
+}
+/**
+ * Debug logging function (only shows in debug mode)
+ */
+function logDebug(message, options = { verbose: false, quiet: false, json: false, short: false, unix: false, basic: false, opt1: false, opt2: false, optT: false, optC: false }) {
+    if (options.debug && !options.quiet) {
+        console.log(`🐛 DEBUG: ${message}`);
+    }
+}
+/**
+ * Pad string to the right
+ */
+function padRight(s, n) {
+    return (s + ' '.repeat(n)).slice(0, n);
+}
+/**
+ * Format bytes for display
+ */
+function formatBytes(bytes) {
+    const units = ['B', 'KB', 'MB', 'GB'];
+    let i = 0;
+    let v = bytes;
+    while (v >= 1024 && i < units.length - 1) {
+        v /= 1024;
+        i++;
+    }
+    return `${v.toFixed(i === 0 ? 0 : 1)} ${units[i]}`;
+}
+/**
+ * Pad string to the left
+ */
+function padLeft(s, n) {
+    return ((' '.repeat(n)) + s).slice(-n);
+}
+/**
+ * Convert date to DOS date parts
+ */
+function toDateParts(date) {
+    const year = date.getFullYear();
+    const month = (date.getMonth() + 1).toString().padStart(2, '0');
+    const day = date.getDate().toString().padStart(2, '0');
+    const hours = date.getHours().toString().padStart(2, '0');
+    const minutes = date.getMinutes().toString().padStart(2, '0');
+    return {
+        date: `${month}-${day}-${year}`,
+        time: `${hours}:${minutes}`
+    };
+}
+/**
+ * Convert date to decimal format (YYYYMMDD.HHMMSS)
+ */
+function toDecimalTime(date) {
+    const year = date.getFullYear();
+    const month = (date.getMonth() + 1).toString().padStart(2, '0');
+    const day = date.getDate().toString().padStart(2, '0');
+    const hours = date.getHours().toString().padStart(2, '0');
+    const minutes = date.getMinutes().toString().padStart(2, '0');
+    const seconds = date.getSeconds().toString().padStart(2, '0');
+    return `${year}${month}${day}.${hours}${minutes}${seconds}`;
+}
+/**
+ * Get method label
+ */
+function methodLabel(method) {
+    switch (method.toLowerCase()) {
+        case 'stored': return 'Stored';
+        case 'deflate': return 'Deflate';
+        case 'deflate64': return 'Deflate64';
+        case 'bzip2': return 'BZip2';
+        case 'lzma': return 'LZMA';
+        case 'ppmd': return 'PPMd';
+        case 'zstd': return 'Zstd';
+        default: return method;
+    }
+}
+/**
+ * Get method name from method code
+ */
+function getMethodName(method) {
+    switch (method) {
+        case 0: return 'stored';
+        case 8: return 'deflate';
+        case 9: return 'deflate64';
+        case 12: return 'bzip2';
+        case 14: return 'lzma';
+        case 95: return 'ppmd';
+        case 93: return 'zstd'; // Z Standard compression
+        default: return `unknown (${method})`;
+    }
+}
+/**
+ * Get extra field type name from header ID
+ */
+function getExtraFieldTypeName(headerId) {
+    switch (headerId) {
+        case 0x0001: return 'ZIP64 Extended Information';
+        case 0x0007: return 'AV Info';
+        case 0x0008: return 'Reserved for extended language encoding data';
+        case 0x0009: return 'OS/2 Extended Attributes';
+        case 0x000a: return 'NTFS';
+        case 0x000c: return 'OpenVMS';
+        case 0x000d: return 'Unix';
+        case 0x000e: return 'Reserved for patch descriptor';
+        case 0x000f: return 'PKCS#7 Store for X.509 Certificates';
+        case 0x0014: return 'X.509 Certificate ID and Signature for individual file';
+        case 0x0015: return 'X.509 Certificate ID for Central Directory';
+        case 0x0016: return 'X.509 Certificate ID for Central Directory';
+        case 0x0017: return 'Strong Encryption Header';
+        case 0x0018: return 'Record Management Controls';
+        case 0x0019: return 'PKCS#7 Encryption Recipient Certificate List';
+        case 0x0065: return 'IBM S/390 (Z390), AS/400 (I400) uncompressed attributes';
+        case 0x0066: return 'Reserved for IBM S/390 (Z390), AS/400 (I400) compressed attributes';
+        case 0x4690: return 'POSZIP';
+        case 0x5455: return 'Extended Timestamp';
+        case 0x554e: return 'UNIX Extra Field (UZIP)';
+        case 0x5855: return 'Info-ZIP Unicode Path Extra Field';
+        case 0x6375: return 'Info-ZIP Unicode Comment Extra Field';
+        case 0x7075: return 'Info-ZIP Unicode Path Extra Field';
+        case 0x7855: return 'Unix Symbolic Link Extra Field';
+        case 0x7865: return 'Unix Hard Link Extra Field';
+        case 0x7875: return 'Unix UID/GID Extra Field';
+        case 0x014E: return 'SHA-256 Hash Extra Field';
+        default: return `Unknown (0x${headerId.toString(16).padStart(4, '0')})`;
+    }
+}
+/**
+ * Get the actual uncompressed size, checking for ZIP64 values
+ */
+function getActualUncompressedSize(entry) {
+    // Check if this is a ZIP64 file (32-bit size is 0xFFFFFFFF)
+    if (entry.uncompressedSize === 0xFFFFFFFF && entry.extraField) {
+        // Look for ZIP64 Extended Information (0x0001)
+        let offset = 0;
+        while (offset < entry.extraField.length - 4) {
+            const headerId = entry.extraField.readUInt16LE(offset);
+            const dataSize = entry.extraField.readUInt16LE(offset + 2);
+            if (headerId === 0x0001 && dataSize >= 8) {
+                // Read the ZIP64 uncompressed size (first 8 bytes)
+                return Number(entry.extraField.readBigUInt64LE(offset + 4));
+            }
+            offset += 4 + dataSize;
+        }
+    }
+    // Return the regular 32-bit size
+    return entry.uncompressedSize || 0;
+}
+/**
+ * Get the actual compressed size, checking for ZIP64 values
+ */
+function getActualCompressedSize(entry) {
+    // Check if this is a ZIP64 file (32-bit size is 0xFFFFFFFF)
+    if (entry.compressedSize === 0xFFFFFFFF && entry.extraField) {
+        // Look for ZIP64 Extended Information (0x0001)
+        let offset = 0;
+        while (offset < entry.extraField.length - 4) {
+            const headerId = entry.extraField.readUInt16LE(offset);
+            const dataSize = entry.extraField.readUInt16LE(offset + 2);
+            if (headerId === 0x0001 && dataSize >= 16) {
+                // Read the ZIP64 compressed size (second 8 bytes)
+                return Number(entry.extraField.readBigUInt64LE(offset + 12));
+            }
+            offset += 4 + dataSize;
+        }
+    }
+    // Return the regular 32-bit size
+    return entry.compressedSize || 0;
+}
+/**
+ * Format entry name for display (handles blockchain metadata)
+ */
+function formatEntryName(entry) {
+    if (entry.filename === src_1.TOKENIZED_METADATA) {
+        return `${src_1.TOKENIZED_METADATA} (NFT Token)`;
+    }
+    if (entry.filename === src_1.TIMESTAMP_METADATA) {
+        return `${src_1.TIMESTAMP_METADATA} (Timestamp Metadata)`;
+    }
+    if (entry.filename === src_1.TIMESTAMP_SUBMITTED) {
+        return `${src_1.TIMESTAMP_SUBMITTED} (Timestamp Submitted)`;
+    }
+    return entry.filename;
+}
+/**
+ * Read archive entries
+ */
+async function readArchiveEntries(archivePath, debugMode = false, quiet = false, inMemory = false) {
+    let spinner = null;
+    try {
+        if (!quiet) {
+            spinner = (0, ora_1.default)('Reading archive...').start();
+        }
+        // Create ZipkitServer instance
+        const zip = new server_1.ZipkitServer();
+        let entries;
+        if (inMemory) {
+            // For Buffer-based loading, read the entire file into buffer and get entries in one call
+            const buffer = fs.readFileSync(archivePath);
+            entries = zip.loadZip(buffer);
+        }
+        else {
+            // For file-based loading
+            entries = await zip.loadZipFile(archivePath);
+        }
+        // Return the actual ZipEntry instances which now include symbolic and hard link properties
+        const zipEntries = entries;
+        if (!quiet) {
+            spinner.succeed(chalk_1.default.green('Archive read successfully'));
+        }
+        return { entries: zipEntries, zip };
+    }
+    catch (error) {
+        if (spinner) {
+            spinner.fail(chalk_1.default.red('Failed to read archive'));
+        }
+        throw error;
+    }
+}
+/**
+ * Output entries in short format (names only)
+ */
+function outputShort(entries, archivePath, zip, options = { verbose: false, quiet: false, json: false, short: false, unix: false, basic: false, opt1: false, opt2: false, optT: false, optC: false }) {
+    entries.forEach(entry => {
+        console.log(formatEntryName(entry));
+    });
+    // Show archive comment by default unless suppressed
+    if (!options.noComments) {
+        const archiveComment = zip.getZipComment();
+        if (archiveComment && archiveComment.trim()) {
+            log(archiveComment, options);
+        }
+    }
+}
+/**
+ * Output entries in filenames-only format
+ */
+function outputFilenamesOnly(entries, archivePath, zip, options = { verbose: false, quiet: false, json: false, short: false, unix: false, basic: false, opt1: false, opt2: false, optT: false, optC: false }) {
+    entries.forEach(entry => {
+        console.log(formatEntryName(entry));
+    });
+}
+/**
+ * Output entries in filenames with header/totals format
+ */
+function outputFilenamesWithHeader(entries, archivePath, zip, options = { verbose: false, quiet: false, json: false, short: false, unix: false, basic: false, opt1: false, opt2: false, optT: false, optC: false }) {
+    // -2 allows -h and -t options, so we need to check for them
+    // For now, just output filenames like -1, but this can be extended
+    entries.forEach(entry => {
+        console.log(formatEntryName(entry));
+    });
+}
+/**
+ * Output entries in sortable decimal time format
+ */
+function outputDecimalTime(entries, archivePath, zip, options = { verbose: false, quiet: false, json: false, short: false, unix: false, basic: false, opt1: false, opt2: false, optT: false, optC: false }) {
+    const stats = fs.statSync(archivePath);
+    log(`Archive:  ${archivePath}`, options);
+    log(`Zip file size: ${stats.size} bytes, number of entries: ${entries.length}`, options);
+    entries.forEach(entry => {
+        const modifiedDate = entry.parseDateTime(entry.timeDateDOS) || new Date();
+        const decimalTime = toDecimalTime(modifiedDate);
+        const method = methodLabel(getMethodName(entry.cmpMethod));
+        const compressedSize = entry.compressedSize;
+        const uncompressedSize = entry.uncompressedSize;
+        const ratio = uncompressedSize > 0 ? Math.round((1 - compressedSize / uncompressedSize) * 100) : 0;
+        const crc = ((entry.crc || 0) >>> 0).toString(16).toUpperCase().padStart(8, '0');
+        const version = `${Math.floor(entry.verExtract / 10)}.${entry.verExtract % 10}`;
+        console.log(`?---------  ${version} unx ${padLeft(uncompressedSize.toString(), 8)} ${method} ${crc} ${decimalTime} ${formatEntryName(entry)}`);
+    });
+}
+/**
+ * Output entries in table format - enhanced to match working example
+ */
+function outputTable(entries, archivePath, verbose, zip, options = { verbose: false, quiet: false, json: false, short: false, unix: false, basic: false, opt1: false, opt2: false, optT: false, optC: false }) {
+    const stats = fs.statSync(archivePath);
+    log(`Archive:  ${archivePath}`, options);
+    if (verbose) {
+        // Detailed verbose format matching working example
+        const sep = '  ';
+        const lengthW = 8, sizeW = 7, cmprW = 4, methodW = 6, dateW = 10, timeW = 5, crcW = 8;
+        log(padLeft('Length', lengthW) + sep +
+            padRight('Method', methodW) + sep +
+            padLeft('Size', sizeW) + ' ' +
+            padRight('Cmpr', cmprW) + ' ' +
+            padRight('Date', dateW) + ' ' +
+            padRight('Time', timeW) + '  ' +
+            padRight('CRC-32', crcW) + sep +
+            'Name', options);
+        log('--------  ------  ------- ---- ---------- ----- --------  ----', options);
+        let totalLen = 0;
+        let totalCmp = 0;
+        entries.forEach(entry => {
+            const unc = getActualUncompressedSize(entry);
+            const cmp = getActualCompressedSize(entry);
+            totalLen += unc;
+            totalCmp += cmp;
+            const cmpr = unc > 0 ? padRight(String(Math.max(0, Math.round((1 - cmp / unc) * 100))) + '%', cmprW) : padRight('0%', cmprW);
+            const modifiedDate = entry.parseDateTime(entry.timeDateDOS) || new Date();
+            const { date, time } = toDateParts(modifiedDate);
+            const crc = ((entry.crc || 0) >>> 0).toString(16).padStart(8, '0');
+            log(padLeft(String(unc), lengthW) + sep +
+                padRight(methodLabel(getMethodName(entry.cmpMethod)), methodW) + sep +
+                padLeft(String(cmp), sizeW) + ' ' +
+                cmpr + ' ' +
+                padRight(date, dateW) + ' ' +
+                padRight(time, timeW) + '  ' +
+                padRight(crc, crcW) + sep +
+                (formatEntryName(entry) || ''), options);
+            // Show file comment below the file entry
+            if (entry.comment && !options.noComments) {
+                log(entry.comment, options);
+            }
+        });
+        log('--------  ------  ------- ---- ---------- ----- --------  ----', options);
+        const filesCount = entries.length;
+        const compressionRatio = totalLen > 0 ? Math.round((1 - totalCmp / totalLen) * 100) : 0;
+        log(padLeft(String(totalLen), lengthW) + '          ' +
+            padLeft(String(totalCmp), sizeW) + '      ' +
+            padRight(`${compressionRatio}%`, 4) + ' ' +
+            padRight(`${filesCount} files`, 0), options);
+    }
+    else {
+        // Simple format
+        const sep = '  ';
+        const lengthW = 8, dateW = 10, timeW = 5;
+        log(padLeft('Length', lengthW) + sep +
+            padRight('Date', dateW) + ' ' +
+            padRight('Time', timeW) + sep +
+            'Name', options);
+        log('-'.repeat(lengthW) + sep +
+            '-'.repeat(dateW) + ' ' +
+            '-'.repeat(timeW) + sep +
+            '----', options);
+        let totalLen = 0;
+        entries.forEach(entry => {
+            const modifiedDate = entry.parseDateTime(entry.timeDateDOS) || new Date();
+            const { date, time } = toDateParts(modifiedDate);
+            const unc = getActualUncompressedSize(entry);
+            totalLen += unc;
+            log(padLeft(String(unc), lengthW) + sep +
+                padRight(date, dateW) + ' ' +
+                padRight(time, timeW) + sep +
+                (formatEntryName(entry) || ''), options);
+            // Show file comment below the file entry
+            if (entry.comment && !options.noComments) {
+                log(entry.comment, options);
+            }
+        });
+        log('-'.repeat(lengthW) + sep +
+            ' '.repeat(dateW) + ' ' +
+            ' '.repeat(timeW) + sep +
+            '-------', options);
+        log(padLeft(String(totalLen), lengthW) + sep +
+            ' '.repeat(dateW) + ' ' +
+            ' '.repeat(timeW) + sep +
+            `${entries.length} files`, options);
+    }
+    // File comments are now shown inline below each file entry
+    // Show archive comment by default (like unzip -l) unless suppressed
+    if (!options.noComments) {
+        const archiveComment = zip.getZipComment();
+        if (archiveComment && archiveComment.trim()) {
+            log(archiveComment, options);
+        }
+    }
+}
+/**
+ * Output entries in verbose format with central directory details
+ */
+function outputVerbose(entries, archivePath, zip, options = { verbose: false, quiet: false, json: false, short: false, unix: false, basic: false, opt1: false, opt2: false, optT: false, optC: false }) {
+    const stats = fs.statSync(archivePath);
+    log(`Archive:  ${archivePath}`, options);
+    log(`Central Directory Information:`, options);
+    log('', options);
+    entries.forEach((entry, index) => {
+        // Use ZipEntry's showVerboseInfo() method for detailed information
+        log(`File ${index + 1}: ${formatEntryName(entry)}`, options);
+        // Call showVerboseInfo() directly - it will output to console
+        entry.showVerboseInfo();
+        log('', options);
+    });
+    // Summary
+    const totalSize = entries.reduce((sum, entry) => sum + getActualUncompressedSize(entry), 0);
+    const totalCompressedSize = entries.reduce((sum, entry) => sum + getActualCompressedSize(entry), 0);
+    const compressionRatio = totalSize > 0 ? Math.round((1 - totalCompressedSize / totalSize) * 100) : 0;
+    log('📊 Archive Summary:', options);
+    log(`  Files: ${entries.length}`, options);
+    log(`  Uncompressed: ${formatBytes(totalSize)}`, options);
+    log(`  Compressed: ${formatBytes(totalCompressedSize)}`, options);
+    log(`  Compression: ${compressionRatio}%`, options);
+    log(`  Archive size: ${formatBytes(stats.size)}`, options);
+}
+/**
+ * Output entries in long format
+ */
+function outputUnix(entries, archivePath, zip, options = { verbose: false, quiet: false, json: false, short: false, unix: false, basic: false, opt1: false, opt2: false, optT: false, optC: false }) {
+    const stats = fs.statSync(archivePath);
+    log(`Archive:  ${archivePath}`, options);
+    log(`Zip file size: ${stats.size} bytes, number of entries: ${entries.length}`, options);
+    entries.forEach(entry => {
+        // Format: permissions version os size method date time filename
+        // Example: ?---------  3.0 unx   111261 bx u093 25-Sep-22 10:19 bib
+        // File permissions (simplified - ? for unknown, - for file, d for directory, l for symlink)
+        let permissions = '?---------'; // Default
+        if (entry.isDirectory) {
+            permissions = 'd---------';
+        }
+        else if (entry.isSymlink) {
+            permissions = 'l---------';
+        }
+        else {
+            permissions = '?---------';
+        }
+        // Version (extract version / 10)
+        const version = `${(entry.verExtract || 30) / 10}`;
+        // OS detection
+        let os = 'unx'; // Default to Unix
+        if (entry.isMSDOS)
+            os = 'dos';
+        else if (entry.isMacOS)
+            os = 'mac';
+        else if (entry.isLinux)
+            os = 'unx';
+        else if (entry.isUnixLike)
+            os = 'unx';
+        // Size (uncompressed)
+        const size = entry.uncompressedSize || 0;
+        // Compression method
+        const methodName = getMethodName(entry.cmpMethod);
+        let method = 'bx'; // Default
+        switch (methodName.toLowerCase()) {
+            case 'stored':
+                method = 'st';
+                break;
+            case 'deflate':
+                method = 'df';
+                break;
+            case 'deflate64':
+                method = 'df';
+                break;
+            case 'bzip2':
+                method = 'b2';
+                break;
+            case 'lzma':
+                method = 'lm';
+                break;
+            case 'ppmd':
+                method = 'pm';
+                break;
+            case 'zstd':
+                method = 'zs';
+                break;
+            default:
+                method = 'bx';
+                break;
+        }
+        // Compression method code
+        const methodCode = methodName.toLowerCase() === 'zstd' ? 'u093' : 'u008';
+        // Date format (DD-MMM-YY)
+        const date = entry.parseDateTime(entry.timeDateDOS) || new Date();
+        const day = date.getDate().toString().padStart(2, '0');
+        const monthNames = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
+            'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+        const month = monthNames[date.getMonth()];
+        const year = date.getFullYear().toString().slice(-2);
+        const dateStr = `${day}-${month}-${year}`;
+        // Time format (HH:MM)
+        const timeStr = `${date.getHours().toString().padStart(2, '0')}:${date.getMinutes().toString().padStart(2, '0')}`;
+        // Filename with link information
+        let filename = formatEntryName(entry);
+        if (entry.isSymlink && entry.linkTarget) {
+            filename += ` -> ${entry.linkTarget}`;
+        }
+        else if (entry.isHardLink && entry.originalEntry) {
+            filename += ` [hard link to ${entry.originalEntry}]`;
+        }
+        // Format the line
+        const line = `${permissions}  ${version} ${os} ${size.toString().padStart(8)} ${method} ${methodCode} ${dateStr} ${timeStr} ${filename}`;
+        log(line, options);
+    });
+    // Summary line
+    const totalSize = entries.reduce((sum, entry) => sum + (entry.uncompressedSize || 0), 0);
+    const totalCompressedSize = entries.reduce((sum, entry) => sum + (entry.compressedSize || 0), 0);
+    const compressionRatio = totalSize > 0 ? Math.round((1 - totalCompressedSize / totalSize) * 100) : 0;
+    log(`${entries.length} files, ${totalSize} bytes uncompressed, ${totalCompressedSize} bytes compressed:  ${compressionRatio}.${Math.round((compressionRatio % 1) * 10)}%`, options);
+    // File comments are now shown inline below each file entry
+    // Show archive comment by default (like unzip -l) unless suppressed
+    if (!options.noComments) {
+        const archiveComment = zip.getZipComment();
+        if (archiveComment && archiveComment.trim()) {
+            log(archiveComment, options);
+        }
+    }
+}
+/**
+ * Sort entries based on the specified criteria
+ */
+function sortEntries(entries, sortBy) {
+    if (!sortBy) {
+        return entries;
+    }
+    return [...entries].sort((a, b) => {
+        switch (sortBy) {
+            case 'name':
+                return a.filename.localeCompare(b.filename);
+            case 'size':
+                return (b.uncompressedSize || 0) - (a.uncompressedSize || 0); // Descending order (largest first)
+            case 'date':
+                const dateA = a.parseDateTime(a.timeDateDOS) || new Date(0);
+                const dateB = b.parseDateTime(b.timeDateDOS) || new Date(0);
+                return dateB.getTime() - dateA.getTime(); // Descending order (newest first)
+            default:
+                return 0;
+        }
+    });
+}
+/**
+ * Filter entries based on include/exclude patterns
+ */
+function filterEntries(entries, options) {
+    if (!options.include && !options.exclude) {
+        return entries;
+    }
+    return entries.filter(entry => {
+        const fileName = entry.filename;
+        // Check exclude patterns first
+        if (options.exclude && options.exclude.length > 0) {
+            for (const pattern of options.exclude) {
+                if (matchesPattern(fileName, pattern, options.optC)) {
+                    return false; // Exclude this file
+                }
+            }
+        }
+        // Check include patterns
+        if (options.include && options.include.length > 0) {
+            for (const pattern of options.include) {
+                if (matchesPattern(fileName, pattern, options.optC)) {
+                    return true; // Include this file
+                }
+            }
+            return false; // Not in any include pattern
+        }
+        return true; // No exclude patterns matched
+    });
+}
+/**
+ * Check if a filename matches a pattern (supports wildcards)
+ */
+function matchesPattern(fileName, pattern, caseInsensitive = false) {
+    // Convert glob pattern to regex
+    const regexPattern = pattern
+        .replace(/\./g, '\\.') // Escape dots
+        .replace(/\*/g, '.*') // Convert * to .*
+        .replace(/\?/g, '.'); // Convert ? to .
+    const flags = caseInsensitive ? 'i' : '';
+    const regex = new RegExp(`^${regexPattern}$`, flags);
+    return regex.test(fileName);
+}
+/**
+ * Get operating system name from ZIP OS code
+ */
+function getOSName(osCode) {
+    const osNames = {
+        0: 'MS-DOS and OS/2',
+        1: 'Amiga',
+        2: 'OpenVMS',
+        3: 'UNIX',
+        4: 'VM/CMS',
+        5: 'Atari ST',
+        6: 'OS/2 H.P.F.S.',
+        7: 'Macintosh',
+        8: 'Z-System',
+        9: 'CP/M',
+        10: 'Windows NTFS',
+        11: 'MVS',
+        12: 'VSE',
+        13: 'Acorn Risc',
+        14: 'VFAT',
+        15: 'Alternate MVS',
+        16: 'BeOS',
+        17: 'Tandem',
+        18: 'OS/400',
+        19: 'OS X'
+    };
+    return osNames[osCode] || `Unknown (${osCode})`;
+}
+/**
+ * Output entries in JSON format
+ */
+function outputJson(entries, archivePath, zip, options = { verbose: false, quiet: false, json: false, short: false, unix: false, basic: false, opt1: false, opt2: false, optT: false, optC: false }) {
+    const stats = fs.statSync(archivePath);
+    const result = {
+        archive: archivePath,
+        size: stats.size,
+        fileCount: entries.length,
+        files: entries.map(entry => {
+            const fileInfo = {
+                name: entry.filename,
+                size: entry.uncompressedSize,
+                compressedSize: entry.compressedSize,
+                crc32: entry.crc,
+                method: getMethodName(entry.cmpMethod),
+                isDirectory: entry.isDirectory,
+                modified: (entry.parseDateTime(entry.timeDateDOS) || new Date()).toISOString()
+            };
+            // Add SHA-256 if present
+            if (entry.sha256) {
+                fileInfo.sha256 = entry.sha256;
+            }
+            // Add extended date information if present
+            if (entry.timeDateDOS) {
+                fileInfo.dosTimestamp = entry.timeDateDOS;
+            }
+            // Add platform information if present
+            if (entry.platform) {
+                fileInfo.platform = entry.platform;
+            }
+            // Add file attributes if present
+            if (entry.intFileAttr !== undefined) {
+                fileInfo.internalAttributes = entry.intFileAttr;
+            }
+            if (entry.extFileAttr !== undefined) {
+                fileInfo.externalAttributes = entry.extFileAttr;
+            }
+            // Add security information if present
+            if (entry.isEncrypted !== undefined) {
+                fileInfo.isEncrypted = entry.isEncrypted;
+            }
+            if (entry.isStrongEncrypt !== undefined) {
+                fileInfo.isStrongEncrypt = entry.isStrongEncrypt;
+            }
+            // Add symbolic link information if present
+            if (entry.isSymlink !== undefined) {
+                fileInfo.isSymlink = entry.isSymlink;
+            }
+            if (entry.linkTarget) {
+                fileInfo.linkTarget = entry.linkTarget;
+            }
+            // Add hard link information if present
+            if (entry.isHardLink !== undefined) {
+                fileInfo.isHardLink = entry.isHardLink;
+            }
+            if (entry.originalEntry) {
+                fileInfo.originalEntry = entry.originalEntry;
+            }
+            if (entry.inode !== undefined) {
+                fileInfo.inode = entry.inode;
+            }
+            // Add version information if present (properly parsed from ZIP format)
+            if (entry.verMadeBy !== undefined) {
+                const upperByte = (entry.verMadeBy >> 8) & 0xFF;
+                const lowerByte = entry.verMadeBy & 0xFF;
+                const majorVersion = Math.floor(lowerByte / 10);
+                const minorVersion = lowerByte % 10;
+                fileInfo.versionMadeBy = `${majorVersion}.${minorVersion}`;
+                fileInfo.osMadeBy = upperByte; // Operating system code
+                fileInfo.osMadeByName = getOSName(upperByte);
+            }
+            if (entry.verExtract !== undefined) {
+                const upperByte = (entry.verExtract >> 8) & 0xFF;
+                const lowerByte = entry.verExtract & 0xFF;
+                const majorVersion = Math.floor(lowerByte / 10);
+                const minorVersion = lowerByte % 10;
+                fileInfo.versionExtract = `${majorVersion}.${minorVersion}`;
+                fileInfo.osExtract = upperByte; // Operating system code
+                fileInfo.osExtractName = getOSName(upperByte);
+            }
+            // Add Unix-specific information if present
+            if (entry.uid !== undefined) {
+                fileInfo.uid = entry.uid;
+            }
+            if (entry.gid !== undefined) {
+                fileInfo.gid = entry.gid;
+            }
+            // Add file comment if present (unless suppressed)
+            if (!options.noComments && entry.comment) {
+                fileInfo.comment = entry.comment;
+            }
+            return fileInfo;
+        }),
+        summary: {
+            totalSize: entries.reduce((sum, entry) => sum + (entry.uncompressedSize || 0), 0),
+            totalCompressedSize: entries.reduce((sum, entry) => sum + (entry.compressedSize || 0), 0),
+            compressionRatio: entries.length > 0 ?
+                entries.reduce((sum, entry) => sum + ((entry.uncompressedSize || 0) - (entry.compressedSize || 0)), 0) /
+                    entries.reduce((sum, entry) => sum + (entry.uncompressedSize || 0), 0) * 100 : 0
+        },
+        tokenized: entries.some(entry => entry.filename === 'META-INF/NZIP.TOKEN'),
+        ...(!options.noComments && zip.getZipComment() ? {
+            archiveComment: zip.getZipComment()
+        } : {})
+    };
+    log(JSON.stringify(result, null, 2), options);
+}
+/**
+ * Parse command line arguments
+ */
+function parseArgs(args) {
+    const options = {
+        verbose: false,
+        quiet: false,
+        json: false,
+        short: false,
+        unix: false,
+        basic: false,
+        opt1: false,
+        opt2: false,
+        optT: false,
+        optC: false,
+        include: [],
+        exclude: [],
+        sortBy: undefined,
+        noComments: false,
+        debug: false
+    };
+    let archive = '';
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        switch (arg) {
+            case '-h':
+                showHelp();
+                process.exit(0);
+                break;
+            case '-h2':
+            case '--help-extended':
+                showExtendedHelp();
+                process.exit(0);
+                break;
+            case '--help':
+                showHelp();
+                process.exit(0);
+                break;
+            case '-V':
+            case '--version':
+                console.log(`NeoList Version: ${version_1.APP_VERSION} (${version_1.APP_RELEASE_DATE})`);
+                process.exit(0);
+                break;
+            case '-v':
+            case '--verbose':
+                options.verbose = true;
+                break;
+            case '-q':
+            case '--quiet':
+                options.quiet = true;
+                break;
+            case '-j':
+            case '--json':
+                options.json = true;
+                break;
+            case '-s':
+            case '--short':
+                options.short = true;
+                break;
+            case '-u':
+            case '--unix':
+                options.unix = true;
+                break;
+            case '-b':
+            case '--basic':
+                options.basic = true;
+                break;
+            case '-1':
+                options.opt1 = true;
+                break;
+            case '-2':
+                options.opt2 = true;
+                break;
+            case '-T':
+                options.optT = true;
+                break;
+            case '-C':
+                options.optC = true;
+                break;
+            case '-i':
+            case '--include':
+                if (i + 1 < args.length) {
+                    options.include.push(args[++i]);
+                }
+                else {
+                    console.error('Error: --include requires a pattern');
+                    showHelp();
+                    (0, exit_codes_1.exitZipinfo)(exit_codes_1.ZIPINFO_EXIT_CODES.INVALID_OPTIONS);
+                }
+                break;
+            case '-x':
+            case '--exclude':
+                if (i + 1 < args.length) {
+                    options.exclude.push(args[++i]);
+                }
+                else {
+                    console.error('Error: --exclude requires a pattern');
+                    showHelp();
+                    (0, exit_codes_1.exitZipinfo)(exit_codes_1.ZIPINFO_EXIT_CODES.INVALID_OPTIONS);
+                }
+                break;
+            case '-S':
+            case '--sort':
+                if (i + 1 < args.length) {
+                    const sortType = args[++i].toLowerCase();
+                    if (sortType === 'name' || sortType === 'size' || sortType === 'date') {
+                        options.sortBy = sortType;
+                    }
+                    else {
+                        console.error(`Error: Invalid sort type '${sortType}'. Must be 'name', 'size', or 'date'`);
+                        showHelp();
+                        (0, exit_codes_1.exitZipinfo)(exit_codes_1.ZIPINFO_EXIT_CODES.INVALID_OPTIONS);
+                    }
+                }
+                else {
+                    console.error('Error: --sort requires a sort type (name, size, or date)');
+                    showHelp();
+                    (0, exit_codes_1.exitZipinfo)(exit_codes_1.ZIPINFO_EXIT_CODES.INVALID_OPTIONS);
+                }
+                break;
+            case '--no-comments':
+                options.noComments = true;
+                break;
+            case '--debug':
+                options.debug = true;
+                break;
+            case '--in-memory':
+                options.inMemory = true;
+                break;
+            default:
+                if (arg.startsWith('-')) {
+                    console.error(`Error: Unknown option ${arg}`);
+                    showHelp();
+                    (0, exit_codes_1.exitZipinfo)(exit_codes_1.ZIPINFO_EXIT_CODES.INVALID_OPTIONS);
+                }
+                else if (!archive) {
+                    archive = arg;
+                }
+                break;
+        }
+    }
+    if (!archive) {
+        console.error('Error: Archive name is required');
+        showHelp();
+        (0, exit_codes_1.exitZipinfo)(exit_codes_1.ZIPINFO_EXIT_CODES.INVALID_OPTIONS);
+    }
+    if (!fs.existsSync(archive)) {
+        console.error(`Error: Archive not found: ${archive}`);
+        (0, exit_codes_1.exitZipinfo)(exit_codes_1.ZIPINFO_EXIT_CODES.FILES_NOT_FOUND);
+    }
+    return { archive, options };
+}
+/**
+ * Show help information
+ */
+function showHelp() {
+    console.log(`
+NeoList Version: ${version_1.APP_VERSION} (${version_1.APP_RELEASE_DATE})
+
+Usage: neolist [options] <archive>
+
+Options:
+  -h, --help          Show this help message
+  -V, --version       Show version information
+  -v, --verbose       Detailed central directory information
+  -q, --quiet         Suppress output
+  -j, --json          Output in JSON format
+  -s, --short         Short output (names only)
+  -u, --unix          Unix-style output
+  -b, --basic         Basic table output
+  -1                  Filenames only, one per line
+  -2                  Filenames with header/totals support
+  -T                  Sortable decimal time format
+  -C                  Case-insensitive filename matching
+  -i, --include       Include only files matching pattern (can be used multiple times)
+  -x, --exclude       Exclude files matching pattern (can be used multiple times)
+  -S, --sort          Sort files by name, size, or date
+      --no-comments   Suppress archive and file comments (shown by default)
+      --debug         Enable debug output
+      --in-memory     Force in-memory processing mode
+
+Arguments:
+  <archive>        ZIP file to list
+
+Examples:
+  neolist output/calgary.nzip
+  neolist -b output/calgary.nzip
+  neolist -u output/calgary.nzip
+`);
+}
+/**
+ * Show extended help information (equivalent to InfoZip's -h2)
+ */
+function showExtendedHelp() {
+    console.log('Extended Help for NeoList');
+    console.log('');
+    console.log('NeoList is a next-generation ZIP listing utility that builds upon the strengths');
+    console.log('of the ZIP format while incorporating blockchain verification and modern features.');
+    console.log('');
+    console.log('Basic command line:');
+    console.log('  neolist [options] archive [file_patterns...]');
+    console.log('');
+    console.log('Some examples:');
+    console.log('  List all files in archive:                       neolist archive.nzip');
+    console.log('  List specific files:                            neolist archive.nzip "*.txt"');
+    console.log('  Verbose listing with details:                   neolist -v archive.nzip');
+    console.log('');
+    console.log('Basic modes:');
+    console.log('  -l        list archive contents (default)');
+    console.log('  -v        verbose listing with details');
+    console.log('  -s        short listing (file names only)');
+    console.log('  -u        unix-style listing');
+    console.log('');
+    console.log('Basic options:');
+    console.log('  -q        quiet operation');
+    console.log('  -v        verbose operation');
+    console.log('  -s        short listing (file names only)');
+    console.log('  -u        unix-style listing');
+    console.log('  -j        json output format');
+    console.log('  -x        exclude files matching patterns');
+    console.log('  -i        include only files matching patterns');
+    console.log('');
+    console.log('Syntax:');
+    console.log('  The full command line syntax is:');
+    console.log('');
+    console.log('    neolist [options] archive [file_patterns...]');
+    console.log('');
+    console.log('  Archive is the ZIP file to list');
+    console.log('  File patterns specify which files to list (default: all files)');
+    console.log('');
+    console.log('Options and Values:');
+    console.log('  For short options that take values, use -ovalue or -o value or -o=value');
+    console.log('  For long option values, use either --longoption=value or --longoption value');
+    console.log('  For example:');
+    console.log('    neolist --sort=size --exclude "*.tmp" archive.nzip');
+    console.log('');
+    console.log('File Patterns:');
+    console.log('  NeoList supports the following patterns:');
+    console.log('    ?       matches any single character');
+    console.log('    *       matches any number of characters, including zero');
+    console.log('    [list]  matches char in list (regex), can do range [a-f], all but [!bf]');
+    console.log('  Examples:');
+    console.log('    neolist archive.nzip "*.txt"           # List only .txt files');
+    console.log('    neolist archive.nzip "test[0-9].*"     # List test0.txt, test1.txt, etc.');
+    console.log('');
+    console.log('Include and Exclude:');
+    console.log('  -i pattern pattern ...   include only files that match a pattern');
+    console.log('  -x pattern pattern ...   exclude files that match a pattern');
+    console.log('  Patterns are paths with optional wildcards and match paths as stored in');
+    console.log('  archive. Exclude and include lists end at next option or end of line.');
+    console.log('');
+    console.log('Sorting Options:');
+    console.log('  --sort name     sort by file name (alphabetical)');
+    console.log('  --sort size     sort by file size (largest first)');
+    console.log('  --sort date     sort by modification date (newest first)');
+    console.log('  --sort method   sort by compression method');
+    console.log('  --sort ratio    sort by compression ratio');
+    console.log('');
+    console.log('Output Formats:');
+    console.log('  -s        short listing (file names only)');
+    console.log('  -u        unix-style listing (like ls -l)');
+    console.log('  -v        verbose listing with details');
+    console.log('  --json    JSON output format');
+    console.log('  --csv     CSV output format');
+    console.log('');
+    console.log('Display Options:');
+    console.log('  --no-comments   suppress archive and file comments');
+    console.log('  --no-timestamps suppress timestamp information');
+    console.log('  --no-permissions suppress permission information');
+    console.log('  --no-compression suppress compression details');
+    console.log('');
+    console.log('Blockchain Features:');
+    console.log('  --skip-blockchain  disable blockchain verification');
+    console.log('  --network <net>    specify blockchain network (base-sepolia, ethereum, etc.)');
+    console.log('  --wallet <addr>    specify wallet address for verification');
+    console.log('  --ots-verify       verify OTS (OpenTimestamps) signatures');
+    console.log('  --ots-skip         skip OTS verification');
+    console.log('');
+    console.log('Filtering and Search:');
+    console.log('  --grep <pattern>   search for files matching pattern in names');
+    console.log('  --grep-i <pattern> case-insensitive search');
+    console.log('  --size-min <size>  show files larger than size');
+    console.log('  --size-max <size>  show files smaller than size');
+    console.log('  --date-from <date> show files modified after date');
+    console.log('  --date-to <date>   show files modified before date');
+    console.log('');
+    console.log('Progress and Verbosity:');
+    console.log('  -v        verbose operation');
+    console.log('  -q        quiet operation');
+    console.log('  --debug   show debug information');
+    console.log('  --progress show progress bar for large archives');
+    console.log('');
+    console.log('More option highlights:');
+    console.log('  --show-files          show files to be listed and exit');
+    console.log('  --count-only          show only file count');
+    console.log('  --size-only           show only total size');
+    console.log('  --compression-stats   show compression statistics');
+    console.log('');
+    console.log('For more information, visit: https://github.com/NeoWareInc/neozip-cli');
+    console.log('For detailed API documentation, see: https://docs.neoware.io/neozip');
+}
+/**
+ * Main execution function
+ */
+async function main() {
+    // Declare variables outside try block for cleanup in catch
+    let zip = null;
+    let options = null;
+    try {
+        // Parse command line arguments
+        const args = process.argv.slice(2);
+        const parsed = parseArgs(args);
+        const { archive } = parsed;
+        options = parsed.options;
+        if (options.debug) {
+            logDebug('Debug mode enabled', options);
+            logDebug(`Command line arguments: ${process.argv.join(' ')}`, options);
+            logDebug(`Working directory: ${process.cwd()}`, options);
+            logDebug(`Node.js version: ${process.version}`, options);
+            logDebug(`Platform: ${process.platform} ${process.arch}`, options);
+            logDebug(`Archive file: ${archive}`, options);
+            log('', options);
+        }
+        // Read archive entries
+        const result = await readArchiveEntries(archive, options.debug, options.quiet || options.opt1 || options.opt2 || options.optT, options.inMemory);
+        const { entries: allEntries } = result;
+        zip = result.zip;
+        if (options.debug) {
+            logDebug(`Archive loaded: ${allEntries.length} entries found`, options);
+        }
+        // Apply include/exclude filtering
+        const filteredEntries = filterEntries(allEntries, options);
+        if (options.debug) {
+            logDebug(`After filtering: ${filteredEntries.length} entries`, options);
+        }
+        // Apply sorting
+        const entries = sortEntries(filteredEntries, options.sortBy);
+        if (options.json) {
+            outputJson(entries, archive, zip, options);
+        }
+        else if (options.opt1) {
+            outputFilenamesOnly(entries, archive, zip, options);
+        }
+        else if (options.opt2) {
+            outputFilenamesWithHeader(entries, archive, zip, options);
+        }
+        else if (options.optT) {
+            outputDecimalTime(entries, archive, zip, options);
+        }
+        else if (options.short) {
+            outputShort(entries, archive, zip, options);
+        }
+        else if (options.verbose) {
+            outputVerbose(entries, archive, zip, options);
+        }
+        else if (options.unix) {
+            outputUnix(entries, archive, zip, options);
+        }
+        else if (options.basic) {
+            outputTable(entries, archive, false, zip, options);
+        }
+        else {
+            // Default is now the unzip -v format (verbose table)
+            outputTable(entries, archive, true, zip, options);
+        }
+        // Don't show success message for filenames-only modes
+        if (!options.opt1 && !options.opt2 && !options.optT) {
+            log('✓ NeoList completed successfully', options);
+        }
+        // Close file handle if file-based ZIP was loaded
+        if (zip && options && !options.inMemory && isFileBased(zip)) {
+            try {
+                await zip.closeFile();
+            }
+            catch (closeError) {
+                // Ignore cleanup errors - file may already be closed
+                if (options.debug) {
+                    logDebug(`Note: Error closing file handle: ${closeError instanceof Error ? closeError.message : String(closeError)}`, options);
+                }
+            }
+        }
+    }
+    catch (error) {
+        // Close file handle if file-based ZIP was loaded (cleanup on error)
+        if (zip && options && !options.inMemory && isFileBased(zip)) {
+            try {
+                await zip.closeFile();
+            }
+            catch (closeError) {
+                // Ignore cleanup errors
+            }
+        }
+        logError(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        if (process.argv.includes('--debug')) {
+            logError(error instanceof Error ? (error.stack || String(error)) : String(error));
+        }
+        // Determine appropriate exit code based on error type
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (errorMessage.includes('ENOENT') || errorMessage.includes('not found')) {
+            (0, exit_codes_1.exitZipinfo)(exit_codes_1.ZIPINFO_EXIT_CODES.FILES_NOT_FOUND, `Error: ${errorMessage}`);
+        }
+        else if (errorMessage.includes('password') || errorMessage.includes('encrypted')) {
+            (0, exit_codes_1.exitZipinfo)(exit_codes_1.ZIPINFO_EXIT_CODES.PASSWORD_PROTECTED, `Error: ${errorMessage}`);
+        }
+        else if (errorMessage.includes('ZIP format') || errorMessage.includes('corrupt')) {
+            (0, exit_codes_1.exitZipinfo)(exit_codes_1.ZIPINFO_EXIT_CODES.SEVERE_ZIP_ERROR, `Error: ${errorMessage}`);
+        }
+        else if (errorMessage.includes('memory') || errorMessage.includes('allocation')) {
+            (0, exit_codes_1.exitZipinfo)(exit_codes_1.ZIPINFO_EXIT_CODES.MEMORY_ERROR, `Error: ${errorMessage}`);
+        }
+        else {
+            (0, exit_codes_1.exitZipinfo)(exit_codes_1.ZIPINFO_EXIT_CODES.ZIP_FORMAT_ERROR, `Error: ${errorMessage}`);
+        }
+    }
+}
+// Always run main when this module is loaded
+// This allows it to work both when called directly and when imported by index.js
+main().catch(err => {
+    logError(`Fatal error: ${err}`);
+    (0, exit_codes_1.exitZipinfo)(exit_codes_1.ZIPINFO_EXIT_CODES.ZIP_FORMAT_ERROR);
+});
+//# sourceMappingURL=neolist.js.map