@beclab/olaresid 0.1.6 → 0.1.7

package/examples/generate-mnemonic.ts

@@ -21,7 +21,7 @@ async function example1_generateNew() {
 
 	// Generate a 12-word mnemonic
 	console.log('\n🔑 Generating 12-word mnemonic...');
-	const mnemonic12 = await generateMnemonic(12);
+	const mnemonic12 = generateMnemonic(12);
 	console.log(`Mnemonic: ${mnemonic12}`);
 
 	console.log('\n⏳ Deriving keys using Trust Wallet Core...');
@@ -35,7 +35,7 @@ async function example1_generateNew() {
 	// Generate a 24-word mnemonic
 	console.log('\n' + '-'.repeat(60));
 	console.log('\n🔑 Generating 24-word mnemonic...');
-	const mnemonic24 = await generateMnemonic(24);
+	const mnemonic24 = generateMnemonic(24);
 	console.log(`Mnemonic: ${mnemonic24}`);
 
 	console.log('\n⏳ Deriving keys...');
@@ -95,7 +95,7 @@ async function example4_parallelDerivation() {
 	console.log('Example 4: Parallel Key Derivation (Performance Test)');
 	console.log('='.repeat(60));
 
-	const mnemonic = await generateMnemonic(12);
+	const mnemonic = generateMnemonic(12);
 	console.log(`\n📝 Mnemonic: ${mnemonic}`);
 
 	console.log('\n⏳ Deriving owner and DID in parallel...');

package/examples/register-subdomain.ts

@@ -79,7 +79,7 @@ async function main() {
 	console.log('\n📝 Step 4: Generate Mnemonic for Subdomain');
 	console.log('-'.repeat(60));
 
-	const mnemonic = await generateMnemonic(12);
+	const mnemonic = generateMnemonic(12);
 	console.log('✅ Generated 12-word mnemonic:');
 	console.log(`   ${mnemonic}`);
 	console.log(

package/examples/transfer-domain.ts

@@ -98,7 +98,7 @@ async function main() {
 		mnemonic = process.env.NEW_OWNER_MNEMONIC;
 		console.log('📝 Using provided mnemonic');
 	} else {
-		mnemonic = await generateMnemonic(12);
+		mnemonic = generateMnemonic(12);
 		console.log('🔑 Generated 12-word mnemonic:');
 		console.log(`   ${mnemonic}`);
 		console.log(

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@beclab/olaresid",
-    "version": "0.1.6",
+    "version": "0.1.7",
     "description": "DID Contract SDK with CLI tool",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
@@ -39,6 +39,7 @@
     "dependencies": {
         "@solana/web3.js": "^1.87.6",
         "@trustwallet/wallet-core": "^3.2.9",
+        "bip39": "^3.1.0",
         "ethers": "^6.9.1",
         "multiformats": "9.6.4",
         "tweetnacl": "^1.0.3",

package/src/business/index.ts

@@ -4,12 +4,6 @@ import { parseContractError } from '../utils/error-parser';
 import { TagContext } from './tag-context';
 import { TagTypeBuilder } from '../utils/tag-type-builder';
 import { normalizeToDomain } from '../utils/olares-id';
-import {
-	base64ToUint8Array,
-	uint8ArrayToHex,
-	hexToUint8Array,
-	uint8ArrayToBase64
-} from '../utils/crypto-utils';
 
 export interface TransactionResult<T = any> {
 	// Basic transaction information
@@ -54,11 +48,7 @@ export {
 	getDIDFromMnemonic,
 	generateDIDKeyData,
 	deriveDIDFromMnemonic,
-	getEd25519JwkFromMnemonic,
-	base64ToUint8Array,
-	uint8ArrayToHex,
-	hexToUint8Array,
-	uint8ArrayToBase64
+	getEd25519JwkFromMnemonic
 } from '../utils/crypto-utils';
 export type { RSAPublicKeyData, DIDKeyData } from '../utils/crypto-utils';
 
@@ -190,7 +180,7 @@ export class DomainContext {
 	 * ```typescript
 	 * // For parent domain "parent.com", register subdomain "child"
 	 * const parentDomain = olaresId.domain('parent.com');
-	 * const mnemonic = await generateMnemonic(12);
+	 * const mnemonic = generateMnemonic(12);
 	 *
 	 * const result = await parentDomain.registerSubdomain('child', mnemonic);
 	 * // This will register "child.parent.com"
@@ -276,7 +266,7 @@ export class DomainContext {
 	 *
 	 * @example
 	 * ```typescript
-	 * const mnemonic = await generateMnemonic(12);
+	 * const mnemonic = generateMnemonic(12);
 	 * const result = await domain.transfer(mnemonic);
 	 * if (result.success) {
 	 *   console.log('Domain transferred!');
@@ -871,7 +861,7 @@ export class DomainContext {
 			} catch {
 				// Try base64
 				try {
-					const secretKey = base64ToUint8Array(solanaPrivateKey);
+					const secretKey = Buffer.from(solanaPrivateKey, 'base64');
 					solanaWallet = Keypair.fromSecretKey(secretKey);
 				} catch {
 					// Try as JSON array
@@ -882,9 +872,9 @@ export class DomainContext {
 				}
 			}
 
-			// Get Solana address as bytes32 (cross-platform)
+			// Get Solana address as bytes32
 			const solanaAddressBytes =
-				'0x' + uint8ArrayToHex(solanaWallet.publicKey.toBytes());
+				'0x' + solanaWallet.publicKey.toBuffer().toString('hex');
 
 			// Get current timestamp
 			const signAt = Math.floor(Date.now() / 1000) - 30 * 60; // 30 minutes ago
@@ -944,8 +934,8 @@ export class DomainContext {
 				decodeUTF8(solanaMsg),
 				solanaWallet.secretKey
 			);
-			// Convert signature to hex (cross-platform)
-			const sigFromAuthAddrHex = '0x' + uint8ArrayToHex(sigFromAuthAddr);
+			const sigFromAuthAddrHex =
+				'0x' + Buffer.from(sigFromAuthAddr).toString('hex');
 
 			// Call contract
 			const tx = await rootTagger.updateSolanaWallet(
@@ -1008,7 +998,7 @@ export class DomainContext {
 			} catch {
 				// Try base64
 				try {
-					const secretKey = base64ToUint8Array(solanaPrivateKey);
+					const secretKey = Buffer.from(solanaPrivateKey, 'base64');
 					solanaWallet = Keypair.fromSecretKey(secretKey);
 				} catch {
 					// Try as JSON array
@@ -1019,9 +1009,9 @@ export class DomainContext {
 				}
 			}
 
-			// Get Solana address as bytes32 (cross-platform)
+			// Get Solana address as bytes32
 			const solanaAddressBytes =
-				'0x' + uint8ArrayToHex(solanaWallet.publicKey.toBytes());
+				'0x' + solanaWallet.publicKey.toBuffer().toString('hex');
 
 			// Get current timestamp
 			const signAt = Math.floor(Date.now() / 1000) - 30 * 60; // 30 minutes ago
@@ -1122,8 +1112,11 @@ export class DomainContext {
 			// Extract addresses from the result and convert to base58
 			// Result is array of { algorithm, addr } where addr is bytes32
 			return result.map((item: any) => {
-				// Convert hex to Uint8Array (cross-platform)
-				const buffer = hexToUint8Array(item.addr);
+				// Remove 0x prefix and convert hex to buffer
+				const hexStr = item.addr.startsWith('0x')
+					? item.addr.slice(2)
+					: item.addr;
+				const buffer = Buffer.from(hexStr, 'hex');
 				// Convert to Solana public key and then to base58
 				return new PublicKey(buffer).toBase58();
 			});
@@ -1438,16 +1431,13 @@ export function bytes4ToIpv4(bytes4Hex: string): string {
  */
 export function pemToDer(pem: string): string {
 	// Remove PEM headers, footers, and whitespace
-	const base64Str = pem
+	const base64 = pem
 		.replace(/-----BEGIN.*?-----/g, '')
 		.replace(/-----END.*?-----/g, '')
 		.replace(/\s/g, '');
 
-	// Convert base64 to Uint8Array using cross-platform method
-	const derBuffer = base64ToUint8Array(base64Str);
-
-	// Convert to hex string
-	const hexString = uint8ArrayToHex(derBuffer);
+	const derBuffer = Buffer.from(base64, 'base64');
+	const hexString = derBuffer.toString('hex');
 
 	// Convert to hex string with 0x prefix
 	return '0x' + hexString;
@@ -1462,14 +1452,13 @@ export function derToPem(derHex: string): string {
 	// Remove '0x' prefix if present
 	const hexString = derHex.startsWith('0x') ? derHex.slice(2) : derHex;
 
-	// Convert hex to base64 using cross-platform methods
-	const bytes = hexToUint8Array(hexString);
-	const base64Str = uint8ArrayToBase64(bytes);
+	const derBuffer = Buffer.from(hexString, 'hex');
+	const base64 = derBuffer.toString('base64');
 
 	// Split base64 into 64-character lines for PEM format
 	const lines: string[] = [];
-	for (let i = 0; i < base64Str.length; i += 64) {
-		lines.push(base64Str.slice(i, i + 64));
+	for (let i = 0; i < base64.length; i += 64) {
+		lines.push(base64.slice(i, i + 64));
 	}
 
 	// Construct PEM format with headers and footers

package/src/cli.ts

@@ -1014,7 +1014,7 @@ async function registerSubdomain(
 				);
 				process.exit(1);
 			}
-			mnemonic = await generateMnemonic(wordCount);
+			mnemonic = generateMnemonic(wordCount);
 
 			// Save mnemonic to file
 			const mnemonicFile = './subdomain-mnemonic.txt';
@@ -1141,7 +1141,7 @@ async function transferDomain(
 				);
 				process.exit(1);
 			}
-			mnemonic = await generateMnemonic(wordCount);
+			mnemonic = generateMnemonic(wordCount);
 
 			// Save mnemonic to file
 			const mnemonicFile = './transfer-new-owner-mnemonic.txt';
@@ -1228,7 +1228,7 @@ async function cryptoGenerate(options: CliOptions): Promise<void> {
 			process.exit(1);
 		}
 
-		const mnemonic = await generateMnemonic(wordCount);
+		const mnemonic = generateMnemonic(wordCount);
 
 		// Save mnemonic to file
 		const outputFile = options.output || './mnemonic.txt';
@@ -2953,7 +2953,6 @@ async function main(): Promise<void> {
 	}
 }
 
-// 运行主函数
 main().catch((error) => {
 	console.error(
 		'❌ Unexpected error:',

package/src/index.ts

@@ -38,12 +38,7 @@ export {
 	getDIDFromMnemonic,
 	generateDIDKeyData,
 	deriveDIDFromMnemonic,
-	getEd25519JwkFromMnemonic,
-	// Cross-platform encoding utilities
-	base64ToUint8Array,
-	uint8ArrayToHex,
-	hexToUint8Array,
-	uint8ArrayToBase64
+	getEd25519JwkFromMnemonic
 } from './business';
 
 type Domain = PackageDomain.Domain;

package/src/utils/crypto-utils.ts

@@ -6,13 +6,13 @@
  * compatibility across the entire Olares ecosystem.
  */
 
+import * as bip39 from 'bip39';
 import * as varint from 'varint';
 import { base58btc } from 'multiformats/bases/base58';
 import { base64url } from 'multiformats/bases/base64';
 
 // Browser globals type declaration
 declare const window: any;
-declare const atob: (input: string) => string;
 declare const btoa: (input: string) => string;
 
 export interface RSAPublicKeyData {
@@ -26,61 +26,6 @@ export interface DIDKeyData {
 	mnemonic: string;
 }
 
-// ============================================================================
-// Cross-platform encoding utilities (Browser + Node.js compatible)
-// ============================================================================
-
-/**
- * Convert base64 string to Uint8Array (cross-platform)
- * Works in both browser and Node.js environments
- * @param base64 base64 encoded string
- * @returns Uint8Array
- */
-export function base64ToUint8Array(base64: string): Uint8Array {
-	const binaryString = atob(base64);
-	const bytes = new Uint8Array(binaryString.length);
-	for (let i = 0; i < binaryString.length; i++) {
-		bytes[i] = binaryString.charCodeAt(i);
-	}
-	return bytes;
-}
-
-/**
- * Convert Uint8Array to hex string (cross-platform)
- * @param bytes Uint8Array to convert
- * @returns hex string without '0x' prefix
- */
-export function uint8ArrayToHex(bytes: Uint8Array): string {
-	return Array.from(bytes)
-		.map((b) => b.toString(16).padStart(2, '0'))
-		.join('');
-}
-
-/**
- * Convert hex string to Uint8Array (cross-platform)
- * @param hex hex string (with or without '0x' prefix)
- * @returns Uint8Array
- */
-export function hexToUint8Array(hex: string): Uint8Array {
-	const cleanHex = hex.startsWith('0x') ? hex.slice(2) : hex;
-	const bytes = new Uint8Array(cleanHex.length / 2);
-	for (let i = 0; i < cleanHex.length; i += 2) {
-		bytes[i / 2] = parseInt(cleanHex.slice(i, i + 2), 16);
-	}
-	return bytes;
-}
-
-/**
- * Convert Uint8Array to base64 string (cross-platform)
- * Works in both browser and Node.js environments
- * @param bytes Uint8Array to convert
- * @returns base64 encoded string
- */
-export function uint8ArrayToBase64(bytes: Uint8Array): string {
-	const binaryString = String.fromCharCode(...bytes);
-	return btoa(binaryString);
-}
-
 // ============================================================================
 // Trust Wallet Core Management
 // ============================================================================
@@ -92,7 +37,6 @@ let loadingPromise: Promise<any> | null = null;
 /**
  * Load Trust Wallet Core (lazy loading)
  * Works in both Node.js and browser environments
- * Handles different module export formats (CommonJS vs ESM)
  */
 async function loadWalletCore(): Promise<any> {
 	// Return cached instance if already loaded
@@ -108,33 +52,18 @@ async function loadWalletCore(): Promise<any> {
 	// Start loading
 	loadingPromise = (async () => {
 		try {
-			// Dynamic import works in both Node.js ESM and browser ESM
-			const WalletCoreModule = await import('@trustwallet/wallet-core');
-
-			// Handle different export formats (CommonJS vs ESM)
-			let initWasmFunc: any;
-			if (WalletCoreModule.initWasm) {
-				// ESM named export
-				initWasmFunc = WalletCoreModule.initWasm;
-			} else if (
-				WalletCoreModule.default &&
-				(WalletCoreModule.default as any).initWasm
+			// Check if running in browser or Node.js
+			if (
+				typeof window !== 'undefined' &&
+				typeof require === 'undefined'
 			) {
-				// ESM default export with initWasm
-				initWasmFunc = (WalletCoreModule.default as any).initWasm;
-			} else if (WalletCoreModule.default) {
-				// Default export is the function itself
-				initWasmFunc = WalletCoreModule.default;
-			} else {
-				// Module itself is the function
-				initWasmFunc = WalletCoreModule as any;
-			}
-
-			// Call the init function
-			if (typeof initWasmFunc === 'function') {
-				walletCore = await initWasmFunc();
+				// Browser environment with ES modules
+				const { initWasm } = await import('@trustwallet/wallet-core');
+				walletCore = await initWasm();
 			} else {
-				throw new Error('initWasm is not a function');
+				// Node.js environment
+				const { initWasm } = require('@trustwallet/wallet-core');
+				walletCore = await initWasm();
 			}
 
 			walletCoreLoaded = true;
@@ -155,38 +84,23 @@ async function loadWalletCore(): Promise<any> {
 // multicodec code for Ed25519 keys (0xed)
 const ED25519_CODEC_ID = varint.encode(parseInt('0xed', 16));
 
-/**
- * Simple mnemonic validation (checks word count)
- * @param mnemonic BIP39 mnemonic phrase
- * @returns true if mnemonic has valid word count (12, 15, 18, 21, or 24 words)
- */
-function validateMnemonic(mnemonic: string): boolean {
-	const words = mnemonic.trim().split(/\s+/);
-	const validWordCounts = [12, 15, 18, 21, 24];
-	return validWordCounts.includes(words.length);
-}
-
 // ============================================================================
 // Mnemonic and Key Derivation Functions
 // ============================================================================
 
 /**
- * Generate a random BIP39 mnemonic phrase using Trust Wallet Core
- * Works in both Node.js and browser environments
- *
+ * Generate a random BIP39 mnemonic phrase
  * @param wordCount Number of words (12, 15, 18, 21, or 24), default is 12
- * @returns A promise that resolves to a mnemonic phrase string
+ * @returns A mnemonic phrase string
  *
  * @example
  * ```typescript
- * const mnemonic = await generateMnemonic(12);
+ * const mnemonic = generateMnemonic(12);
  * console.log(mnemonic);
  * // Output: "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about"
  * ```
  */
-export async function generateMnemonic(
-	wordCount: number = 12
-): Promise<string> {
+export function generateMnemonic(wordCount: number = 12): string {
 	// Convert word count to entropy bits
 	// 12 words = 128 bits, 15 words = 160 bits, etc.
 	const strengthMap: Record<number, number> = {
@@ -204,14 +118,7 @@ export async function generateMnemonic(
 		);
 	}
 
-	// Ensure Wallet Core is loaded
-	const core = await loadWalletCore();
-	const { HDWallet } = core;
-
-	const wallet = HDWallet.create(strength, '');
-	const mnemonic = wallet.mnemonic();
-
-	return mnemonic;
+	return bip39.generateMnemonic(strength);
 }
 
 /**
@@ -231,10 +138,8 @@ export async function getEthereumAddressFromMnemonic(
 	mnemonic: string
 ): Promise<string> {
 	// Validate mnemonic
-	if (!validateMnemonic(mnemonic)) {
-		throw new Error(
-			'Invalid mnemonic phrase: must have 12, 15, 18, 21, or 24 words'
-		);
+	if (!bip39.validateMnemonic(mnemonic)) {
+		throw new Error('Invalid mnemonic phrase');
 	}
 
 	const core = await loadWalletCore();
@@ -262,10 +167,8 @@ export async function getEVMPrivateKeyFromMnemonic(
 	mnemonic: string
 ): Promise<string> {
 	// Validate mnemonic
-	if (!validateMnemonic(mnemonic)) {
-		throw new Error(
-			'Invalid mnemonic phrase: must have 12, 15, 18, 21, or 24 words'
-		);
+	if (!bip39.validateMnemonic(mnemonic)) {
+		throw new Error('Invalid mnemonic phrase');
 	}
 
 	const core = await loadWalletCore();
@@ -276,9 +179,9 @@ export async function getEVMPrivateKeyFromMnemonic(
 	// Get private key for Ethereum
 	const privateKeyData = wallet.getKeyForCoin(CoinType.ethereum);
 
-	// Convert to hex string with 0x prefix (cross-platform)
-	const privateKeyBytes = new Uint8Array(privateKeyData.data());
-	const privateKeyHex = '0x' + uint8ArrayToHex(privateKeyBytes);
+	// Convert to hex string with 0x prefix
+	const privateKeyHex =
+		'0x' + Buffer.from(privateKeyData.data()).toString('hex');
 
 	return privateKeyHex;
 }
@@ -327,10 +230,8 @@ async function getID(mnemonic: string): Promise<string> {
  */
 export async function getDIDFromMnemonic(mnemonic: string): Promise<string> {
 	// Validate mnemonic
-	if (!validateMnemonic(mnemonic)) {
-		throw new Error(
-			'Invalid mnemonic phrase: must have 12, 15, 18, 21, or 24 words'
-		);
+	if (!bip39.validateMnemonic(mnemonic)) {
+		throw new Error('Invalid mnemonic phrase');
 	}
 
 	const id = await getID(mnemonic);
@@ -377,10 +278,8 @@ export async function getEd25519JwkFromMnemonic(mnemonic: string): Promise<{
 	privateJwk: any;
 }> {
 	// Validate mnemonic
-	if (!validateMnemonic(mnemonic)) {
-		throw new Error(
-			'Invalid mnemonic phrase: must have 12, 15, 18, 21, or 24 words'
-		);
+	if (!bip39.validateMnemonic(mnemonic)) {
+		throw new Error('Invalid mnemonic phrase');
 	}
 
 	const core = await loadWalletCore();
@@ -443,10 +342,8 @@ export async function deriveDIDFromMnemonic(mnemonic: string): Promise<{
 	did: string;
 }> {
 	// Validate mnemonic once upfront
-	if (!validateMnemonic(mnemonic)) {
-		throw new Error(
-			'Invalid mnemonic phrase: must have 12, 15, 18, 21, or 24 words'
-		);
+	if (!bip39.validateMnemonic(mnemonic)) {
+		throw new Error('Invalid mnemonic phrase');
 	}
 
 	// Derive both in parallel for better performance
@@ -475,7 +372,7 @@ export async function deriveDIDFromMnemonic(mnemonic: string): Promise<{
 export async function generateDIDKeyData(
 	wordCount: number = 12
 ): Promise<DIDKeyData> {
-	const mnemonic = await generateMnemonic(wordCount);
+	const mnemonic = generateMnemonic(wordCount);
 	const { owner, did } = await deriveDIDFromMnemonic(mnemonic);
 
 	return {

package/examples/encoding-utils.ts

@@ -1,96 +0,0 @@
-/**
- * Test encoding utilities exported from olaresid
- */
-
-import {
-	base64ToUint8Array,
-	uint8ArrayToHex,
-	hexToUint8Array,
-	uint8ArrayToBase64
-} from '../src/index';
-
-async function main() {
-	console.log('============================================================');
-	console.log('Testing Cross-platform Encoding Utilities');
-	console.log(
-		'============================================================\n'
-	);
-
-	// Test data
-	const testString = 'Hello, Olares!';
-	const testBytes = new TextEncoder().encode(testString);
-
-	console.log('📝 Original text:', testString);
-	console.log('📦 Original bytes:', testBytes);
-	console.log('');
-
-	// Test 1: Uint8Array to Hex
-	console.log('🔄 Test 1: uint8ArrayToHex()');
-	console.log('------------------------------------------------------------');
-	const hexString = uint8ArrayToHex(testBytes);
-	console.log('✅ Hex string:', hexString);
-	console.log('');
-
-	// Test 2: Hex to Uint8Array
-	console.log('🔄 Test 2: hexToUint8Array()');
-	console.log('------------------------------------------------------------');
-	const bytesFromHex = hexToUint8Array(hexString);
-	console.log('✅ Bytes from hex:', bytesFromHex);
-	console.log(
-		'✅ Matches original:',
-		JSON.stringify(bytesFromHex) === JSON.stringify(testBytes)
-	);
-	console.log('');
-
-	// Test 3: Uint8Array to Base64
-	console.log('🔄 Test 3: uint8ArrayToBase64()');
-	console.log('------------------------------------------------------------');
-	const base64String = uint8ArrayToBase64(testBytes);
-	console.log('✅ Base64 string:', base64String);
-	console.log('');
-
-	// Test 4: Base64 to Uint8Array
-	console.log('🔄 Test 4: base64ToUint8Array()');
-	console.log('------------------------------------------------------------');
-	const bytesFromBase64 = base64ToUint8Array(base64String);
-	console.log('✅ Bytes from base64:', bytesFromBase64);
-	console.log(
-		'✅ Matches original:',
-		JSON.stringify(bytesFromBase64) === JSON.stringify(testBytes)
-	);
-	console.log('');
-
-	// Test 5: Round-trip conversion
-	console.log('🔄 Test 5: Round-trip conversion (hex)');
-	console.log('------------------------------------------------------------');
-	const hex1 = uint8ArrayToHex(testBytes);
-	const bytes1 = hexToUint8Array(hex1);
-	const hex2 = uint8ArrayToHex(bytes1);
-	console.log('✅ Round-trip hex successful:', hex1 === hex2);
-	console.log('');
-
-	console.log('🔄 Test 6: Round-trip conversion (base64)');
-	console.log('------------------------------------------------------------');
-	const b64_1 = uint8ArrayToBase64(testBytes);
-	const bytes2 = base64ToUint8Array(b64_1);
-	const b64_2 = uint8ArrayToBase64(bytes2);
-	console.log('✅ Round-trip base64 successful:', b64_1 === b64_2);
-	console.log('');
-
-	// Test 7: Hex with 0x prefix
-	console.log('🔄 Test 7: Hex with 0x prefix');
-	console.log('------------------------------------------------------------');
-	const hexWithPrefix = '0x' + hexString;
-	const bytesFromPrefixedHex = hexToUint8Array(hexWithPrefix);
-	console.log(
-		'✅ Can handle 0x prefix:',
-		JSON.stringify(bytesFromPrefixedHex) === JSON.stringify(testBytes)
-	);
-	console.log('');
-
-	console.log('============================================================');
-	console.log('✅ All encoding utility tests passed!');
-	console.log('============================================================');
-}
-
-main().catch(console.error);

package/examples/frontend-demo/.dockerignore

@@ -1,40 +0,0 @@
-# Dependencies
-node_modules
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-pnpm-debug.log*
-
-# Build output
-dist
-.vite
-
-# Environment files
-.env
-.env.local
-.env.*.local
-
-# IDE
-.vscode
-.idea
-*.swp
-*.swo
-*~
-
-# OS
-.DS_Store
-Thumbs.db
-
-# Git
-.git
-.gitignore
-.github
-
-# Documentation
-README.md
-QUICKSTART.md
-*.md
-
-# Logs
-logs
-*.log