neozipkit 0.1.1

package/dist/browser/TokenVerifierBrowser.js

@@ -0,0 +1,299 @@
+"use strict";
+// ======================================
+//	TokenVerifierBrowser.ts
+//  Browser-compatible blockchain token verification utilities for ZIP archives
+//  Copyright (c) 2025 NeoWare, Inc. All rights reserved.
+// ======================================
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenVerifierBrowser = void 0;
+exports.createTokenVerifier = createTokenVerifier;
+exports.checkForTokenization = checkForTokenization;
+const Headers_1 = require("../shared/constants/Headers");
+const constants_1 = require("../server/blockchain/constants");
+// Network configuration for blockchain queries
+const NETWORK_CONFIG = {
+    'Base Sepolia': {
+        chainId: 84532,
+        rpcUrls: [
+            'https://sepolia.base.org',
+            'https://base-sepolia.g.alchemy.com/v2/demo',
+            'https://base-sepolia-rpc.publicnode.com',
+            'https://base-sepolia.blockpi.network/v1/rpc/public'
+        ]
+    },
+    'Base Mainnet': {
+        chainId: 8453,
+        rpcUrls: [
+            'https://mainnet.base.org',
+            'https://base-mainnet.g.alchemy.com/v2/demo',
+            'https://base-rpc.publicnode.com',
+            'https://base.blockpi.network/v1/rpc/public'
+        ]
+    }
+};
+// Use the complete contract ABI from constants
+const CONTRACT_ABI = constants_1.NZIP_CONTRACT_ABI;
+/**
+ * Browser-compatible token verification class
+ */
+class TokenVerifierBrowser {
+    constructor(zipKit) {
+        this.zipKit = zipKit;
+    }
+    /**
+     * Checks if the ZIP file contains NFT token metadata and verifies the merkle root
+     */
+    async checkForTokenization(zipEntries, options = {}) {
+        // Look for the tokenized metadata file
+        const tokenEntry = zipEntries.find(entry => entry.filename === Headers_1.TOKENIZED_METADATA);
+        if (!tokenEntry) {
+            return {
+                isTokenized: false,
+                tokenMetadata: null,
+                calculatedMerkleRoot: null,
+                blockchainMerkleRoot: null,
+                verificationPassed: false
+            };
+        }
+        try {
+            // Extract the token metadata
+            const tokenData = await this.zipKit.extractBlob(tokenEntry);
+            if (!tokenData) {
+                return {
+                    isTokenized: false,
+                    tokenMetadata: null,
+                    calculatedMerkleRoot: null,
+                    blockchainMerkleRoot: null,
+                    verificationPassed: false,
+                    errorMessage: 'Could not read token metadata'
+                };
+            }
+            const tokenContent = await this.blobToString(tokenData);
+            const tokenMetadata = JSON.parse(tokenContent);
+            // Validate token metadata structure
+            if (!this.validateTokenInfo(tokenMetadata)) {
+                return {
+                    isTokenized: false,
+                    tokenMetadata: null,
+                    calculatedMerkleRoot: null,
+                    blockchainMerkleRoot: null,
+                    verificationPassed: false,
+                    errorMessage: 'Invalid token metadata structure'
+                };
+            }
+            // Skip verification if requested
+            if (options.skipHash || options.skipToken) {
+                return {
+                    isTokenized: true,
+                    tokenMetadata,
+                    calculatedMerkleRoot: null,
+                    blockchainMerkleRoot: null,
+                    verificationPassed: false,
+                    errorMessage: options.skipHash ? 'Hash verification skipped' : 'Token verification skipped'
+                };
+            }
+            // Calculate merkle root excluding token file
+            const calculatedMerkleRoot = await this.calculateMerkleRootExcludingToken(zipEntries);
+            if (!calculatedMerkleRoot) {
+                return {
+                    isTokenized: true,
+                    tokenMetadata,
+                    calculatedMerkleRoot: null,
+                    blockchainMerkleRoot: null,
+                    verificationPassed: false,
+                    errorMessage: 'Could not calculate merkle root'
+                };
+            }
+            // Query blockchain for the actual merkle root and timestamp
+            const blockchainData = await this.queryBlockchainData(tokenMetadata);
+            if (!blockchainData.merkleRoot) {
+                return {
+                    isTokenized: true,
+                    tokenMetadata,
+                    calculatedMerkleRoot,
+                    blockchainMerkleRoot: null,
+                    blockchainTimestamp: blockchainData.timestamp ?? undefined,
+                    verificationPassed: false,
+                    errorMessage: 'Could not retrieve merkle root from blockchain'
+                };
+            }
+            const verificationPassed = blockchainData.merkleRoot === calculatedMerkleRoot;
+            return {
+                isTokenized: true,
+                tokenMetadata,
+                calculatedMerkleRoot,
+                blockchainMerkleRoot: blockchainData.merkleRoot,
+                blockchainTimestamp: blockchainData.timestamp ?? undefined,
+                verificationPassed,
+                errorMessage: verificationPassed ? undefined : 'Merkle root mismatch - archive may be tampered'
+            };
+        }
+        catch (error) {
+            return {
+                isTokenized: false,
+                tokenMetadata: null,
+                calculatedMerkleRoot: null,
+                blockchainMerkleRoot: null,
+                verificationPassed: false,
+                errorMessage: `Error processing token: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    /**
+     * Validates token metadata structure
+     */
+    validateTokenInfo(tokenMetadata) {
+        return tokenMetadata &&
+            typeof tokenMetadata.version === 'string' &&
+            typeof tokenMetadata.tokenId === 'string' &&
+            typeof tokenMetadata.contractAddress === 'string' &&
+            typeof tokenMetadata.network === 'string' &&
+            typeof tokenMetadata.networkChainId === 'number' &&
+            typeof tokenMetadata.transactionHash === 'string' &&
+            typeof tokenMetadata.merkleRoot === 'string' &&
+            typeof tokenMetadata.fileName === 'string' &&
+            typeof tokenMetadata.mintedAt === 'string';
+    }
+    /**
+     * Calculates the merkle root excluding the token metadata file
+     */
+    async calculateMerkleRootExcludingToken(zipEntries) {
+        try {
+            // Get all entries except the token file
+            const contentEntries = zipEntries.filter(entry => entry.filename !== Headers_1.TOKENIZED_METADATA);
+            if (contentEntries.length === 0) {
+                return null;
+            }
+            // For each content entry, ensure we have SHA-256 hash calculated
+            for (const entry of contentEntries) {
+                if (!entry.sha256) {
+                    // Extract the file to calculate its SHA-256 hash
+                    await this.zipKit.extractBlob(entry);
+                }
+            }
+            // Calculate merkle root from content files
+            // This would need to be implemented based on the ZipKit's merkle tree functionality
+            // For now, we'll use a placeholder that would need to be implemented
+            return await this.zipKit.getMerkleRoot?.() || null;
+        }
+        catch (error) {
+            console.error('Error calculating merkle root:', error);
+            return null;
+        }
+    }
+    /**
+     * Queries the blockchain to get the actual merkle root and timestamp stored in the smart contract
+     */
+    async queryBlockchainData(tokenMetadata) {
+        try {
+            // Dynamic import of ethers to avoid SSR issues
+            const { ethers } = await Promise.resolve().then(() => __importStar(require('ethers')));
+            const networkConfig = NETWORK_CONFIG[tokenMetadata.network];
+            if (!networkConfig) {
+                console.warn(`Unsupported network: ${tokenMetadata.network}`);
+                return { merkleRoot: null, timestamp: null };
+            }
+            // Try multiple RPC endpoints
+            for (const rpcUrl of networkConfig.rpcUrls) {
+                try {
+                    const provider = new ethers.JsonRpcProvider(rpcUrl);
+                    // Test connection with a timeout
+                    const blockNumber = await Promise.race([
+                        provider.getBlockNumber(),
+                        new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout')), 5000))
+                    ]);
+                    // Create contract instance
+                    const contract = new ethers.Contract(tokenMetadata.contractAddress, CONTRACT_ABI, provider);
+                    // Call getZipFileInfo to get the blockchain-stored data
+                    const zipInfo = await contract.getZipFileInfo(tokenMetadata.tokenId);
+                    return {
+                        merkleRoot: zipInfo.merkleRootHash,
+                        timestamp: Number(zipInfo.tokenizationTime)
+                    };
+                }
+                catch (error) {
+                    console.warn(`RPC ${rpcUrl} failed:`, error);
+                    continue;
+                }
+            }
+            console.warn(`All RPC endpoints failed for network: ${tokenMetadata.network}`);
+            return { merkleRoot: null, timestamp: null };
+        }
+        catch (error) {
+            console.error('Blockchain query error:', error);
+            return { merkleRoot: null, timestamp: null };
+        }
+    }
+    /**
+     * Helper to convert Blob to string
+     */
+    async blobToString(blob) {
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.onload = () => resolve(reader.result);
+            reader.onerror = reject;
+            reader.readAsText(blob);
+        });
+    }
+    /**
+     * Creates a formatted summary of token information
+     */
+    createTokenSummary(tokenMetadata) {
+        return `
+🎫 NFT Token Information:
+   Token ID: ${tokenMetadata.tokenId}
+   Network: ${tokenMetadata.network}
+   Contract: ${tokenMetadata.contractAddress}
+   Transaction: ${tokenMetadata.transactionHash}
+   File: ${tokenMetadata.fileName}
+   Minted: ${new Date(tokenMetadata.mintedAt).toLocaleString()}
+   `;
+    }
+}
+exports.TokenVerifierBrowser = TokenVerifierBrowser;
+/**
+ * Creates a new TokenVerifierBrowser instance
+ */
+function createTokenVerifier(zipKit) {
+    return new TokenVerifierBrowser(zipKit);
+}
+/**
+ * Convenience function to check for tokenization
+ */
+async function checkForTokenization(zipKit, zipEntries, options = {}) {
+    const verifier = new TokenVerifierBrowser(zipKit);
+    return verifier.checkForTokenization(zipEntries, options);
+}

package/dist/browser/ZipKitBrowser.d.ts

@@ -0,0 +1,18 @@
+import ZipKit, { CompressOptions, CreateZipOptions } from '../shared/ZipKit';
+import ZipEntry from '../shared/ZipEntry';
+import Errors from '../shared/constants/Errors';
+import * as Headers from '../shared/constants/Headers';
+import { sha256 } from '../shared/components/ZipCrypto';
+import { getTypeOf } from '../shared/components/Util';
+import type { FileData } from '../shared/types';
+export * from '../shared/ZipKit';
+export { ZipEntry, Errors, Headers, sha256, getTypeOf };
+export default class ZipKitBrowser extends ZipKit {
+    constructor();
+    loadZipBlob(data: Blob): Promise<ZipEntry[] | null>;
+    createZipFileEntry(file: FileData): ZipEntry;
+    hashFile(file: FileData): Promise<string>;
+    compressDataBlob(entry: ZipEntry, data: Blob, options?: CompressOptions): Promise<Buffer>;
+    extractBlob(entry: ZipEntry, skipHashCheck?: boolean): Promise<Blob | null>;
+    createZipBlob(cmpOptions?: CompressOptions, options?: CreateZipOptions): Promise<Blob | null>;
+}

package/dist/browser/ZipKitBrowser.js

@@ -0,0 +1,250 @@
+"use strict";
+// ======================================
+//	ZipKitBrowser.ts
+//  Copyright (c) 2025 NeoWare, Inc. All rights reserved.
+// ======================================
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTypeOf = exports.sha256 = exports.Headers = exports.Errors = exports.ZipEntry = void 0;
+const ZipKit_1 = __importDefault(require("../shared/ZipKit"));
+const ZipEntry_1 = __importDefault(require("../shared/ZipEntry"));
+exports.ZipEntry = ZipEntry_1.default;
+const Errors_1 = __importDefault(require("../shared/constants/Errors"));
+exports.Errors = Errors_1.default;
+const Headers = __importStar(require("../shared/constants/Headers"));
+exports.Headers = Headers;
+const Headers_1 = require("../shared/constants/Headers");
+const ZipCrypto_1 = require("../shared/components/ZipCrypto");
+Object.defineProperty(exports, "sha256", { enumerable: true, get: function () { return ZipCrypto_1.sha256; } });
+const Util_1 = require("../shared/components/Util");
+const Util_2 = require("../shared/components/Util");
+Object.defineProperty(exports, "getTypeOf", { enumerable: true, get: function () { return Util_2.getTypeOf; } });
+// Re-export everything from ZipKit
+__exportStar(require("../shared/ZipKit"), exports);
+// ======================================
+//	ZipKitBrowser
+// ======================================
+class ZipKitBrowser extends ZipKit_1.default {
+    constructor() {
+        super(); // Call the parent constructor
+        // console.log('ZipKit.support.isNode: ', ZipKit.support.isNode);
+        // console.log('ZipKit.support.buffer: ', ZipKit.support.buffer);
+        // console.log('ZipKit.support.blob: ', ZipKit.support.blob);
+        // console.log('ZipKit.support.streams: ', ZipKit.support.streams);
+        // console.log('ZipKit.support.fileReader: ', ZipKit.support.fileReader);
+    }
+    // --------------------------------------
+    // Load a ZIP file from a Blob and return the ZipEntry array
+    async loadZipBlob(data) {
+        if ((0, Util_2.getTypeOf)(data) !== Util_2.DATATYPE.BLOB) {
+            throw new Error(Errors_1.default.DATATYPE_UNSUPPORTED);
+        }
+        return new Promise((resolve, reject) => {
+            const _readEntries = (data) => {
+                try {
+                    super.loadZip(data);
+                    return super.getDirectory();
+                }
+                catch (error) {
+                    reject(error);
+                    return null;
+                }
+            };
+            const reader = new window.FileReader();
+            reader.readAsArrayBuffer(data);
+            reader.onload = function (e) {
+                if (!this.result) {
+                    reject(new Error('Failed to read file'));
+                    return;
+                }
+                const _inBuf = Buffer.from(this.result);
+                resolve(_readEntries(_inBuf));
+            };
+            reader.onerror = function (e) {
+                reject(this.error || new Error('Failed to read file'));
+            };
+        });
+    }
+    // --------------------------------------
+    // Create a ZipEntry for a File object
+    createZipFileEntry(file) {
+        const entry = super.createZipEntry(file.name);
+        entry.fileData = file;
+        entry.uncompressedSize = file.size;
+        const fileDate = new Date(file.lastModified);
+        entry.timeDateDOS = entry.setDateTime(fileDate);
+        entry.cmpMethod = Headers.CMP_METHOD.DEFLATED;
+        return entry;
+    }
+    // --------------------------------------
+    // Calculate the SHA256 hash of a File object
+    async hashFile(file) {
+        const arrayBuffer = await file.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        return (0, ZipCrypto_1.sha256)(buffer);
+    }
+    // --------------------------------------
+    // Compress the data and return the compressed data buffer
+    // Set the ZipEntry compressSize and CRC32 values
+    async compressDataBlob(entry, data, options) {
+        if ((0, Util_2.getTypeOf)(data) !== Util_2.DATATYPE.BLOB) {
+            throw new Error(Errors_1.default.DATATYPE_UNSUPPORTED);
+        }
+        return new Promise(async (resolve, reject) => {
+            const _compressData = async (entry, data, options) => {
+                return await super.compressData(entry, data, options);
+            };
+            const reader = new window.FileReader();
+            reader.readAsArrayBuffer(data);
+            reader.onload = async function (e) {
+                if (!this.result) {
+                    reject(new Error('Failed to read file'));
+                    return;
+                }
+                try {
+                    const _inBuf = Buffer.from(this.result);
+                    const result = await _compressData(entry, _inBuf, options);
+                    resolve(result);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            };
+            reader.onerror = function (e) {
+                reject(this.error || new Error('Failed to read file'));
+            };
+        });
+    }
+    // --------------------------------------
+    // Extract a Blob from a ZipEntry
+    async extractBlob(entry, skipHashCheck) {
+        try {
+            const _outBuf = await super.extract(entry, skipHashCheck);
+            if (!_outBuf)
+                return null;
+            // Convert Buffer to Uint8Array for Blob compatibility
+            const uint8Array = new Uint8Array(_outBuf);
+            return new Blob([uint8Array], { type: 'application/octet-stream' });
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    // --------------------------------------
+    // Create a ZIP file in memory and return a Blob
+    async createZipBlob(cmpOptions, options) {
+        const _onError = options?.onError || (() => { });
+        const _onEntryDone = options?.onEntryDone || (() => { });
+        const zipEntries = super.getDirectory();
+        if (!zipEntries) {
+            _onError(new Error(Errors_1.default.NO_FILES));
+            return null;
+        }
+        let offset = 0;
+        const buffers = [];
+        for (const entry of zipEntries) {
+            if (!entry.isUpdated) {
+                // CRITICAL FIX: Check for token files even in copy mode
+                if (entry.filename === Headers_1.TOKENIZED_METADATA || entry.filename === Headers_1.TIMESTAMP_SUBMITTED || entry.filename === Headers_1.TIMESTAMP_METADATA) {
+                    // Force this entry to be processed with special handling instead of copied
+                    entry.isUpdated = true;
+                    // Don't continue here - let it fall through to special handling below
+                }
+                else {
+                    const inData = super.copyEntry(entry);
+                    entry.localHdrOffset = offset;
+                    offset += inData.length;
+                    buffers.push(inData);
+                    _onEntryDone(entry, 'Copied');
+                    continue;
+                }
+            }
+            if (!entry.fileData) {
+                _onError(new Error(Errors_1.default.FILE_NOT_FOUND));
+                return null;
+            }
+            const fileBuffer = await entry.fileData.arrayBuffer();
+            // Special handling for token metadata files - store uncompressed with CRC-32
+            if (entry.filename === Headers_1.TOKENIZED_METADATA || entry.filename === Headers_1.TIMESTAMP_SUBMITTED || entry.filename === Headers_1.TIMESTAMP_METADATA) {
+                // For token metadata, use STORED compression (no compression)
+                const buffer = Buffer.from(fileBuffer);
+                // Calculate CRC-32 for the token file (not SHA-256 to avoid Merkle Root interference)
+                entry.crc = (0, Util_1.crc32)(buffer);
+                // Set up entry for STORED compression
+                entry.cmpMethod = 0; // STORED
+                entry.compressedSize = buffer.length;
+                entry.uncompressedSize = buffer.length;
+                // Do NOT set SHA-256 hash for token metadata to avoid Merkle Root calculation
+                // entry.sha256 should remain undefined for metadata files
+                const localHdr = entry.createLocalHdr();
+                entry.localHdrOffset = offset;
+                offset += localHdr.length + buffer.length;
+                buffers.push(localHdr);
+                buffers.push(buffer);
+                _onEntryDone(entry, 'Stored (metadata)');
+            }
+            else {
+                // Normal file processing with compression
+                const cmpData = await super.compressData(entry, Buffer.from(fileBuffer), cmpOptions);
+                const localHdr = entry.createLocalHdr();
+                entry.localHdrOffset = offset;
+                offset += localHdr.length + cmpData.length;
+                buffers.push(localHdr);
+                buffers.push(cmpData);
+                _onEntryDone(entry, 'Written');
+            }
+        }
+        const centralDirOffset = offset;
+        for (const entry of zipEntries) {
+            const centralDirEntry = entry.centralDirEntry();
+            offset += centralDirEntry.length;
+            buffers.push(centralDirEntry);
+        }
+        const centralDirSize = offset - centralDirOffset;
+        const ceBuf = super.centralEndHdr(centralDirSize, centralDirOffset);
+        buffers.push(ceBuf);
+        const combinedBuffer = Buffer.concat(buffers);
+        // Convert Buffer to Uint8Array for Blob compatibility
+        const uint8Array = new Uint8Array(combinedBuffer);
+        return new Blob([uint8Array], { type: 'application/zip' });
+    }
+}
+exports.default = ZipKitBrowser;

package/dist/browser/ZipKitStampBrowser.d.ts

@@ -0,0 +1,2 @@
+export declare const createTimestamp: (hash: string, options?: any) => Promise<any>;
+export declare const verifyTimestamp: (timestamp: any, options?: any) => Promise<any>;

package/dist/browser/ZipKitStampBrowser.js

@@ -0,0 +1,12 @@
+"use strict";
+// A browser-safe version of ZipKitStamp
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyTimestamp = exports.createTimestamp = void 0;
+const createTimestamp = async (hash, options = {}) => {
+    throw new Error('Blockchain timestamp creation is not supported in browsers');
+};
+exports.createTimestamp = createTimestamp;
+const verifyTimestamp = async (timestamp, options = {}) => {
+    throw new Error('Blockchain timestamp verification is not supported in browsers');
+};
+exports.verifyTimestamp = verifyTimestamp;

package/dist/browser-index.d.ts

@@ -0,0 +1,21 @@
+import ZipKit from './shared/ZipKit';
+export { ZipEntry, Errors, CMP_METHOD, TIMESTAMP_METADATA, TIMESTAMP_SUBMITTED } from './shared/ZipKit';
+export type { CompressOptions } from './shared/ZipKit';
+export * from './shared/ZipKit';
+export * from './shared/ZipEntry';
+export default ZipKit;
+export { default as ZipKitBrowser } from './browser/ZipKitBrowser';
+export { CertificateGeneratorBrowser } from './browser/CertificateGeneratorBrowser';
+export { TokenVerificationResult, checkForTokenization as checkForTokenizationBrowser, NZipTokenInfo } from './browser/TokenVerifierBrowser';
+export type { TokenVerificationOptions } from './browser/TokenVerifierBrowser';
+export { default as HashAccumulator } from './shared/components/HashAccumulator';
+export * from './shared/components/Util';
+export * from './shared/components/Support';
+export * from './shared/types';
+export * from './shared/constants/Headers';
+export * from './shared/constants/Errors';
+export * from './shared/version';
+export declare const PlatformUtils: {
+    isBrowser: boolean;
+    isNode: string | false;
+};

package/dist/browser-index.js

@@ -0,0 +1,58 @@
+"use strict";
+// =============================================================================
+// NeoZipKit - Browser-Only Package Exports  
+// =============================================================================
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlatformUtils = exports.HashAccumulator = exports.checkForTokenizationBrowser = exports.CertificateGeneratorBrowser = exports.ZipKitBrowser = exports.TIMESTAMP_SUBMITTED = exports.TIMESTAMP_METADATA = exports.CMP_METHOD = exports.Errors = exports.ZipEntry = void 0;
+// Core shared exports
+const ZipKit_1 = __importDefault(require("./shared/ZipKit"));
+var ZipKit_2 = require("./shared/ZipKit");
+Object.defineProperty(exports, "ZipEntry", { enumerable: true, get: function () { return ZipKit_2.ZipEntry; } });
+Object.defineProperty(exports, "Errors", { enumerable: true, get: function () { return ZipKit_2.Errors; } });
+Object.defineProperty(exports, "CMP_METHOD", { enumerable: true, get: function () { return ZipKit_2.CMP_METHOD; } });
+Object.defineProperty(exports, "TIMESTAMP_METADATA", { enumerable: true, get: function () { return ZipKit_2.TIMESTAMP_METADATA; } });
+Object.defineProperty(exports, "TIMESTAMP_SUBMITTED", { enumerable: true, get: function () { return ZipKit_2.TIMESTAMP_SUBMITTED; } });
+__exportStar(require("./shared/ZipKit"), exports);
+__exportStar(require("./shared/ZipEntry"), exports);
+exports.default = ZipKit_1.default;
+// Browser-only exports
+var ZipKitBrowser_1 = require("./browser/ZipKitBrowser");
+Object.defineProperty(exports, "ZipKitBrowser", { enumerable: true, get: function () { return __importDefault(ZipKitBrowser_1).default; } });
+var CertificateGeneratorBrowser_1 = require("./browser/CertificateGeneratorBrowser");
+Object.defineProperty(exports, "CertificateGeneratorBrowser", { enumerable: true, get: function () { return CertificateGeneratorBrowser_1.CertificateGeneratorBrowser; } });
+var TokenVerifierBrowser_1 = require("./browser/TokenVerifierBrowser");
+Object.defineProperty(exports, "checkForTokenizationBrowser", { enumerable: true, get: function () { return TokenVerifierBrowser_1.checkForTokenization; } });
+// Shared component exports
+var HashAccumulator_1 = require("./shared/components/HashAccumulator");
+Object.defineProperty(exports, "HashAccumulator", { enumerable: true, get: function () { return __importDefault(HashAccumulator_1).default; } });
+__exportStar(require("./shared/components/Util"), exports);
+__exportStar(require("./shared/components/Support"), exports);
+// Type and constant exports
+__exportStar(require("./shared/types"), exports);
+__exportStar(require("./shared/constants/Headers"), exports);
+__exportStar(require("./shared/constants/Errors"), exports);
+__exportStar(require("./shared/version"), exports);
+// Platform-specific conditional exports
+exports.PlatformUtils = {
+    // Browser detection
+    isBrowser: typeof window !== 'undefined' && typeof document !== 'undefined',
+    // Node.js detection  
+    isNode: typeof process !== 'undefined' && process.versions && process.versions.node,
+};