neozipkit 0.2.1 → 0.3.0

package/dist/blockchain/ZipKitVerifier.js

@@ -1,289 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-/**
- * ZipKitVerifier - Handles NFT token verification for ZIP files
- * Verifier API for NZIP-NFT smart contract.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZipKitVerifier = void 0;
-const ethers_1 = require("ethers");
-const contracts_1 = require("./contracts");
-// Network configurations
-const NETWORK_CONFIGS = {
-    'base-sepolia': {
-        name: 'Base Sepolia',
-        rpcUrl: 'https://sepolia.base.org',
-        contractAddress: contracts_1.CONTRACT_CONFIGS[84532].address, // Use real contract address
-        explorerUrl: 'https://sepolia.basescan.org',
-        chainId: 84532
-    },
-    'base-mainnet': {
-        name: 'Base Mainnet',
-        rpcUrl: 'https://mainnet.base.org',
-        contractAddress: contracts_1.CONTRACT_CONFIGS[8453].address, // Use real contract address
-        explorerUrl: 'https://basescan.org',
-        chainId: 8453
-    }
-};
-/**
- * Blockchain Token Verifier for ZIP files
- */
-class ZipKitVerifier {
-    constructor(options = {}) {
-        this.debug = options.debug || false;
-        if (this.debug) {
-            console.log(`[DEBUG] ZipKitVerifier initialized`);
-        }
-    }
-    /**
-     * Extract and validate token metadata from ZIP
-     */
-    async extractTokenMetadata(tokenBuffer) {
-        try {
-            if (this.debug) {
-                console.log(`[DEBUG] Extracting token metadata from buffer (${tokenBuffer.length} bytes)`);
-            }
-            const tokenData = JSON.parse(tokenBuffer.toString('utf8'));
-            // Validate required fields
-            const requiredFields = ['tokenId', 'contractAddress', 'network'];
-            for (const field of requiredFields) {
-                if (!tokenData[field]) {
-                    if (this.debug) {
-                        console.log(`[DEBUG] Missing required field: ${field}`);
-                    }
-                    return {
-                        success: false,
-                        error: `Missing required field: ${field}`
-                    };
-                }
-            }
-            if (this.debug) {
-                console.log(`[DEBUG] Token metadata extracted successfully`);
-                console.log(`[DEBUG] Token ID: ${tokenData.tokenId}, Network: ${tokenData.network}`);
-            }
-            return {
-                success: true,
-                metadata: tokenData
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Invalid JSON format';
-            if (this.debug) {
-                console.log(`[DEBUG] Failed to parse token metadata: ${errorMessage}`);
-            }
-            return {
-                success: false,
-                error: `Invalid token metadata format: ${errorMessage}`
-            };
-        }
-    }
-    /**
-     * Map network name to RPC configuration
-     */
-    getNetworkConfig(networkName) {
-        const normalizedName = networkName.toLowerCase();
-        if (this.debug) {
-            console.log(`[DEBUG] Looking up network config for: ${normalizedName}`);
-        }
-        // Map various network name variations to our configs
-        if (normalizedName.includes('sepolia')) {
-            return { success: true, config: NETWORK_CONFIGS['base-sepolia'] };
-        }
-        else if (normalizedName.includes('base') && !normalizedName.includes('sepolia')) {
-            return { success: true, config: NETWORK_CONFIGS['base-mainnet'] };
-        }
-        if (this.debug) {
-            console.log(`[DEBUG] Unsupported network: ${normalizedName}`);
-        }
-        return {
-            success: false,
-            error: `Unsupported network: ${networkName}`
-        };
-    }
-    /**
-     * Perform merkle root comparison
-     */
-    compareMerkleRoots(calculated, declared) {
-        if (this.debug) {
-            console.log(`[DEBUG] Comparing merkle roots`);
-            console.log(`[DEBUG] Calculated: ${calculated || 'null'}`);
-            console.log(`[DEBUG] Declared: ${declared || 'null'}`);
-        }
-        if (!calculated) {
-            return {
-                success: false,
-                match: false,
-                error: 'Cannot calculate merkle root from archive contents'
-            };
-        }
-        if (!declared) {
-            return {
-                success: false,
-                match: false,
-                calculated,
-                error: 'No merkle root found in token metadata'
-            };
-        }
-        const match = calculated === declared;
-        if (this.debug) {
-            console.log(`[DEBUG] Merkle root match: ${match}`);
-        }
-        return {
-            success: true,
-            match,
-            calculated,
-            declared
-        };
-    }
-    /**
-     * Verify token against blockchain
-     */
-    async verifyOnChain(tokenId, contractAddress, networkConfig, merkleRoot) {
-        try {
-            if (this.debug) {
-                console.log(`[DEBUG] Starting on-chain verification`);
-                console.log(`[DEBUG] Token ID: ${tokenId}, Contract: ${contractAddress}`);
-                console.log(`[DEBUG] Network: ${networkConfig.name}, RPC: ${networkConfig.rpcUrl}`);
-            }
-            const provider = new ethers_1.ethers.JsonRpcProvider(networkConfig.rpcUrl);
-            const contract = new ethers_1.ethers.Contract(contractAddress, contracts_1.NZIP_CONTRACT_ABI, provider);
-            if (this.debug) {
-                console.log(`[DEBUG] Calling contract.verifyZipFile(${tokenId}, ${merkleRoot.substring(0, 10)}...)`);
-            }
-            const isValid = await contract.verifyZipFile(tokenId, merkleRoot);
-            if (this.debug) {
-                console.log(`[DEBUG] On-chain verification result: ${isValid}`);
-            }
-            return { success: true, isValid };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Network error';
-            if (this.debug) {
-                console.log(`[DEBUG] On-chain verification failed: ${errorMessage}`);
-            }
-            return {
-                success: false,
-                error: errorMessage
-            };
-        }
-    }
-    /**
-     * Complete verification process
-     */
-    async verifyToken(tokenMetadata, calculatedMerkleRoot, options = {}) {
-        try {
-            if (this.debug) {
-                console.log(`[DEBUG] Starting complete token verification`);
-            }
-            // Get network configuration
-            const networkResult = this.getNetworkConfig(tokenMetadata.network);
-            if (!networkResult.success || !networkResult.config) {
-                return {
-                    success: false,
-                    message: networkResult.error || 'Unknown network error',
-                    errorDetails: {
-                        errorType: 'NETWORK_ERROR',
-                        networkName: tokenMetadata.network
-                    }
-                };
-            }
-            const networkConfig = networkResult.config;
-            const declaredMerkleRoot = tokenMetadata.merkleRoot;
-            // Compare merkle roots if hash verification is not skipped
-            if (!options.skipHash) {
-                const merkleComparison = this.compareMerkleRoots(calculatedMerkleRoot, declaredMerkleRoot);
-                if (!merkleComparison.success) {
-                    return {
-                        success: false,
-                        message: merkleComparison.error || 'Merkle root verification failed',
-                        errorDetails: {
-                            errorType: 'MERKLE_ERROR',
-                            merkleRoot: declaredMerkleRoot || 'null'
-                        }
-                    };
-                }
-                if (!merkleComparison.match) {
-                    return {
-                        success: false,
-                        message: 'Archive integrity verification FAILED - merkle root mismatch',
-                        errorDetails: {
-                            errorType: 'MERKLE_ERROR',
-                            merkleRoot: `calculated: ${merkleComparison.calculated}, declared: ${merkleComparison.declared}`
-                        }
-                    };
-                }
-            }
-            // Perform on-chain verification
-            const merkleToVerify = calculatedMerkleRoot;
-            if (!merkleToVerify) {
-                return {
-                    success: false,
-                    message: 'No merkle root available for verification',
-                    errorDetails: {
-                        errorType: 'MERKLE_ERROR'
-                    }
-                };
-            }
-            const onChainResult = await this.verifyOnChain(tokenMetadata.tokenId, tokenMetadata.contractAddress, networkConfig, merkleToVerify);
-            if (!onChainResult.success) {
-                return {
-                    success: false,
-                    message: `Blockchain verification failed: ${onChainResult.error}`,
-                    errorDetails: {
-                        errorType: 'CONTRACT_ERROR',
-                        networkName: tokenMetadata.network,
-                        rpcUrl: networkConfig.rpcUrl,
-                        contractAddress: tokenMetadata.contractAddress,
-                        tokenId: tokenMetadata.tokenId
-                    }
-                };
-            }
-            if (!onChainResult.isValid) {
-                return {
-                    success: false,
-                    message: 'Blockchain verification FAILED - token or merkle root invalid',
-                    errorDetails: {
-                        errorType: 'CONTRACT_ERROR',
-                        tokenId: tokenMetadata.tokenId,
-                        contractAddress: tokenMetadata.contractAddress,
-                        merkleRoot: merkleToVerify
-                    }
-                };
-            }
-            // Success - create verification details
-            const mintDate = tokenMetadata.mintDate ||
-                (tokenMetadata.creationTimestamp ? new Date(tokenMetadata.creationTimestamp * 1000).toLocaleString() : '') ||
-                '8/01/2025 at 1:00:00 PM'; // fallback
-            return {
-                success: true,
-                message: 'Archive integrity VERIFIED against blockchain records',
-                tokenMetadata,
-                verificationDetails: {
-                    tokenId: tokenMetadata.tokenId,
-                    network: tokenMetadata.network,
-                    contractAddress: tokenMetadata.contractAddress,
-                    merkleRoot: merkleToVerify,
-                    mintDate,
-                    calculatedMerkleRoot: calculatedMerkleRoot || undefined,
-                    declaredMerkleRoot: declaredMerkleRoot || undefined,
-                    merkleRootMatch: !options.skipHash ? calculatedMerkleRoot === declaredMerkleRoot : undefined,
-                    onChainValid: true
-                }
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown verification error';
-            if (this.debug) {
-                console.log(`[DEBUG] Verification process failed: ${errorMessage}`);
-            }
-            return {
-                success: false,
-                message: `Tokenization verification failed: ${errorMessage}`,
-                errorDetails: {
-                    errorType: 'METADATA_ERROR'
-                }
-            };
-        }
-    }
-}
-exports.ZipKitVerifier = ZipKitVerifier;

package/dist/blockchain/ZipKitWallet.d.ts

@@ -1,69 +0,0 @@
-import { ethers } from 'ethers';
-import { WalletSetupResult, MintingOptions } from './types';
-export interface CommonTokenConfig {
-    address: string;
-    name: string;
-    symbol: string;
-    type: 'ERC20' | 'ERC721';
-}
-export interface TokenInfo {
-    address: string;
-    name: string;
-    symbol: string;
-    balance: string;
-    decimals?: number;
-    type: 'ERC20' | 'ERC721' | 'NZIP';
-}
-export interface WalletBasicInfo {
-    ethBalance: string;
-    transactionCount: number;
-    networkName: string;
-    chainId: bigint;
-    latestBlock: number;
-}
-export interface TokenScanResult {
-    foundTokens: number[];
-    searchMethod: 'recent-events' | 'iteration' | 'common-ids' | 'none';
-}
-export interface NZipTokenDetails {
-    tokenId: string;
-    merkleRootHash: string;
-    fileName: string;
-    timestamp: number;
-    tokenURI?: string;
-    creator: string;
-    creationTimestamp: number;
-    tokenizationTime: number;
-    ipfsHash?: string;
-}
-export declare class ZipKitWallet {
-    private wallet;
-    private provider;
-    private promptUser;
-    private findExistingWallets;
-    private loadWalletFromFile;
-    setupWallet(options: MintingOptions): Promise<WalletSetupResult>;
-    private createNewWallet;
-    private connectToNetwork;
-    getWallet(): ethers.Wallet | null;
-    getProvider(): ethers.JsonRpcProvider | null;
-    isReady(): boolean;
-    isOnline(): boolean;
-}
-export declare class WalletAnalyzer {
-    private provider;
-    constructor(provider: ethers.JsonRpcProvider);
-    getWalletBasics(address: string): Promise<WalletBasicInfo>;
-    scanForNZipTokens(contractAddress: string, ownerAddress: string): Promise<TokenScanResult>;
-    getNZipTokenDetails(contractAddress: string, tokenIds: number[]): Promise<NZipTokenDetails[]>;
-    getContractInfo(contractAddress: string): Promise<{
-        name: string;
-        symbol: string;
-        totalSupply: string;
-    } | null>;
-    checkERC20Tokens(ownerAddress: string, tokenConfigs: CommonTokenConfig[]): Promise<TokenInfo[]>;
-    checkNFTCollections(ownerAddress: string, nftConfigs: CommonTokenConfig[]): Promise<TokenInfo[]>;
-    static detectNZipContract(): string | undefined;
-    static getCommonTokens(network: string): CommonTokenConfig[];
-    static getCommonNFTs(network: string): CommonTokenConfig[];
-}

package/dist/blockchain/contracts.d.ts

@@ -1,14 +0,0 @@
-export interface ContractConfig {
-    address: string;
-    network: string;
-    chainId: number;
-    explorerUrl: string;
-    rpcUrls: string[];
-}
-export declare const CONTRACT_CONFIGS: Record<number, ContractConfig>;
-export declare const NZIP_CONTRACT_ABI: string[];
-export declare const DEFAULT_NETWORK = 84532;
-export declare const CURRENT_DEPLOYMENT: ContractConfig;
-export declare const getContractConfig: (chainId: number) => ContractConfig;
-export declare const getSupportedNetworks: () => number[];
-export declare const isNetworkSupported: (chainId: number) => boolean;

package/dist/blockchain/contracts.js

@@ -1,77 +0,0 @@
-"use strict";
-// Contract addresses and configurations for different networks
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNetworkSupported = exports.getSupportedNetworks = exports.getContractConfig = exports.CURRENT_DEPLOYMENT = exports.DEFAULT_NETWORK = exports.NZIP_CONTRACT_ABI = exports.CONTRACT_CONFIGS = void 0;
-// NZIP NFT Contract configurations by network
-exports.CONTRACT_CONFIGS = {
-    // Base Sepolia (Primary testnet)
-    84532: {
-        address: '0xFD76a5d420704F34d84b0767961835c43D7b30a8', // Production contract v2.0
-        network: 'Base Sepolia',
-        chainId: 84532,
-        explorerUrl: 'https://sepolia.basescan.org',
-        rpcUrls: [
-            'https://sepolia.base.org',
-            'https://base-sepolia.g.alchemy.com/v2/demo',
-            'https://base-sepolia-rpc.publicnode.com'
-        ]
-    },
-    // Base Mainnet (Production)
-    8453: {
-        address: '0x2716c4609fD97DaEdF429BC4B4Ec2faa81e2cC60',
-        network: 'Base Mainnet',
-        chainId: 8453,
-        explorerUrl: 'https://basescan.org',
-        rpcUrls: [
-            'https://mainnet.base.org',
-            'https://base.drpc.org',
-            'https://base.gateway.tenderly.co'
-        ]
-    },
-    // Ethereum Sepolia (Testnet) - disabled until NZIP is deployed
-    // 11155111: {
-    //   address: '0x0000000000000000000000000000000000000000',
-    //   network: 'Sepolia Testnet',
-    //   chainId: 11155111,
-    //   explorerUrl: 'https://sepolia.etherscan.io',
-    //   rpcUrls: []
-    // },
-    // Ethereum Mainnet (Production) - disabled until NZIP is deployed
-    // 1: {
-    //   address: '0x0000000000000000000000000000000000000000',
-    //   network: 'Ethereum Mainnet',
-    //   chainId: 1,
-    //   explorerUrl: 'https://etherscan.io',
-    //   rpcUrls: []
-    // }
-};
-// Contract ABI (same for all networks)
-exports.NZIP_CONTRACT_ABI = [
-    "function publicMintZipFile(string memory fileName, string memory merkleRootHash, uint256 creationTimestamp, string memory ipfsHash, string memory metadataURI) public returns (uint256)",
-    "function totalSupply() external view returns (uint256)",
-    "function getTokensByMerkleRoot(string memory merkleRoot) external view returns (uint256[])",
-    "function getZipFileInfo(uint256 tokenId) external view returns (tuple(string fileName, string merkleRootHash, string ipfsHash, address creator, uint256 creationTimestamp, uint256 tokenizationTime, uint256 blockNumber))",
-    "function ownerOf(uint256 tokenId) external view returns (address)",
-    "function balanceOf(address owner) external view returns (uint256)",
-    "function isZipFileTokenized(string memory merkleRootHash, uint256 creationTimestamp) external view returns (bool exists, uint256 tokenId)",
-    "function verifyZipFile(uint256 tokenId, string memory providedMerkleRoot) external view returns (bool isValid)",
-    "function getVersion() external pure returns (string memory)",
-    "event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)",
-    "event ZipFileTokenized(uint256 indexed tokenId, address indexed creator, string fileName, string merkleRootHash, uint256 creationTimestamp, string ipfsHash, uint256 tokenizationTime, uint256 blockNumber)"
-];
-// Default configuration (Base Sepolia for development)
-exports.DEFAULT_NETWORK = 84532;
-exports.CURRENT_DEPLOYMENT = exports.CONTRACT_CONFIGS[exports.DEFAULT_NETWORK];
-// Helper functions
-const getContractConfig = (chainId) => {
-    return exports.CONTRACT_CONFIGS[chainId] || exports.CURRENT_DEPLOYMENT;
-};
-exports.getContractConfig = getContractConfig;
-const getSupportedNetworks = () => {
-    return Object.keys(exports.CONTRACT_CONFIGS).map(Number);
-};
-exports.getSupportedNetworks = getSupportedNetworks;
-const isNetworkSupported = (chainId) => {
-    return chainId in exports.CONTRACT_CONFIGS;
-};
-exports.isNetworkSupported = isNetworkSupported;

package/dist/blockchain/types.d.ts

@@ -1,47 +0,0 @@
-import type { Wallet, JsonRpcProvider } from 'ethers';
-export interface WalletInfo {
-    address: string;
-    privateKey: string;
-    mnemonic: string;
-}
-export interface NetworkConfig {
-    name: string;
-    rpcUrl: string;
-    chainId: number;
-    explorerUrl: string;
-}
-export interface WalletSetupResult {
-    wallet: Wallet | null;
-    provider: JsonRpcProvider | null;
-    success: boolean;
-    message?: string;
-}
-export interface MintingResult {
-    success: boolean;
-    message: string;
-    tokenId?: string;
-    txHash?: string;
-    creationTimestamp?: number;
-}
-export interface MintingOptions {
-    wallet?: string;
-    network: string;
-    mintToken: boolean;
-}
-export interface TokenMetadata {
-    tokenId: string;
-    contractAddress: string;
-    network: string;
-    merkleRoot: string;
-    networkChainId?: number;
-    transactionHash?: string;
-    blockNumber?: number;
-    fileName?: string;
-    archiveName?: string;
-    mintedAt?: string;
-    mintDate?: string;
-    creationTimestamp?: number;
-    ipfsHash?: string;
-    version?: string;
-}
-export declare const NETWORKS: Record<string, NetworkConfig>;

package/dist/blockchain/types.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NETWORKS = void 0;
-// Network configuration
-exports.NETWORKS = {
-    'base': {
-        name: 'Base Mainnet',
-        rpcUrl: 'https://mainnet.base.org',
-        chainId: 8453,
-        explorerUrl: 'https://basescan.org'
-    },
-    'base-sepolia': {
-        name: 'Base Sepolia',
-        rpcUrl: 'https://sepolia.base.org',
-        chainId: 84532,
-        explorerUrl: 'https://sepolia.basescan.org'
-    },
-    'base-goerli': {
-        name: 'Base Goerli',
-        rpcUrl: 'https://goerli.base.org',
-        chainId: 84531,
-        explorerUrl: 'https://goerli.basescan.org'
-    },
-    'localhost': {
-        name: 'Localhost',
-        rpcUrl: 'http://localhost:8545',
-        chainId: 31337,
-        explorerUrl: 'http://localhost:8545'
-    }
-};

package/dist/browser/ZipKitBrowser.d.ts

@@ -1,18 +0,0 @@
-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/ZipKitStampBrowser.d.ts

@@ -1,2 +0,0 @@
-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

@@ -1,12 +0,0 @@
-"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

@@ -1,18 +0,0 @@
-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 { 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

@@ -1,57 +0,0 @@
-"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.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; } });
-// export { CertificateGeneratorBrowser } from './browser/CertificateGeneratorBrowser';
-// export { TokenVerificationResult, checkForTokenization as checkForTokenizationBrowser, NZipTokenInfo } from './browser/TokenVerifierBrowser';
-// export type { TokenVerificationOptions } from './browser/TokenVerifierBrowser';
-// 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,
-};