elit 1.0.0 → 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Elit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,18 +1,27 @@
 # Elit
 
-A lightweight, zero-dependency library for building reactive web applications with direct DOM manipulation.
+⚡ A full-stack TypeScript framework (~10KB gzipped) with built-in dev server, HMR, build tool, and REST API. Zero dependencies, maximum productivity.
 
 [![npm version](https://img.shields.io/npm/v/elit.svg)](https://www.npmjs.com/package/elit)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Bundle Size](https://img.shields.io/badge/bundle%20size-~10KB%20gzipped-success)](https://bundlephobia.com/package/elit)
+
+> **Quick Links:** [Installation](#installation) | [Features](#features) | [Quick Start](#quick-start) | [CLI Tools](#cli-tools) | [API](#api) | [Deployment](#deployment)
 
 ## Why Elit?
 
-- **Tiny Bundle Size**: ~5KB gzipped - no framework bloat
-- **Zero Dependencies**: Pure TypeScript, no external dependencies
-- **Direct DOM Manipulation**: No virtual DOM overhead
-- **TypeScript First**: Full type safety out of the box
-- **Reactive State**: Simple but powerful reactive state management
-- **Modern Features**: Router, SSR, virtual scrolling, and more
+- **🎯 Tiny Bundle Size**: Only ~10KB gzipped (30KB minified) - no framework bloat
+- **📦 Zero Dependencies**: Pure TypeScript, no external dependencies
+- **⚡ Lightning Fast**: Direct DOM manipulation - no virtual DOM overhead
+- **🔷 TypeScript First**: Full type safety and IntelliSense out of the box
+- **🔄 Reactive State**: Simple but powerful reactive state management
+- **🌲 Tree-Shakeable**: Import only what you need for optimal bundle size
+- **🚀 Full-Stack Ready**: Built-in dev server, HMR, build tool, and REST API
+- **🔥 Hot Module Replacement**: Instant development feedback with automatic HMR
+- **🏗️ Build System**: Integrated esbuild with automatic client/server separation
+- **🌐 REST API Router**: Built-in server-side routing with middleware stack
+- **🔌 WebSocket Support**: Real-time state synchronization out of the box
+- **🎨 Developer Experience**: CLI tools, zero config, and excellent tooling support
 
 ## Installation
 
@@ -20,33 +29,175 @@ A lightweight, zero-dependency library for building reactive web applications wi
 npm install elit
 ```
 
+## CLI Tools
+
+Elit includes a powerful CLI for development and production:
+
+```bash
+# Development server with HMR
+npx elit dev
+
+# Production build
+npx elit build
+
+# Preview production build
+npx elit preview
+```
+
+### Configuration
+
+Create `elit.config.mjs` (or .ts, .js, .json) in your project root:
+
+```javascript
+import { defineConfig } from 'elit';
+import { resolve } from 'path';
+
+export default defineConfig({
+  dev: {
+    port: 3000,
+    host: 'localhost',
+    root: './src',
+    basePath: '/',
+    open: true
+  },
+  build: {
+    entry: './src/main.ts',
+    outDir: './dist',
+    format: 'esm',
+    minify: true,
+    platform: 'browser',
+    basePath: '/app',
+    copy: [
+      {
+        from: 'index.html',
+        to: 'index.html',
+        transform: (content, config) => {
+          // Inject base tag from basePath
+          return content;
+        }
+      }
+    ]
+  },
+  preview: {
+    port: 4173,
+    root: './dist',
+    basePath: '/app'
+  }
+});
+```
+
 ## Features
 
-- 🎯 **Lightweight**: Optimized for performance and small bundle size
+### Frontend Framework
+
+- 🎯 **Ultra Lightweight**: Just 30KB minified, ~10KB gzipped
 - ⚡ **Reactive State**: Built-in reactive state management with `createState`
 - 🔄 **Computed Values**: Automatic dependency tracking with `computed`
 - 🎨 **CSS-in-JS**: Type-safe styling with `CreateStyle`
 - 🛣️ **Client-Side Router**: Hash and history mode routing with dynamic parameters
 - 📱 **Virtual Scrolling**: Handle 100k+ items efficiently
-- 🖥️ **SSR Support**: Server-side rendering capabilities
-- 🎭 **SVG & MathML**: Full support for SVG and MathML elements
-- 🔧 **Utilities**: Throttle, debounce, and batch rendering
-- 📦 **Tree-shakeable**: Import only what you need
+- 🖥️ **SSR Support**: Full server-side rendering capabilities
+- 🎭 **SVG & MathML**: Complete support for all elements
+- 🔧 **Performance Utilities**: Throttle, debounce, batch rendering
+- 📦 **Tree-Shakeable**: Import only what you need
+- 🎮 **DOM Utilities**: Convenient helper functions
+
+### Full-Stack Tools
+
+- 🔥 **Hot Module Replacement**: Instant development feedback
+- 🏗️ **Build System**: esbuild integration with automatic client/server separation
+- 🌐 **REST API Router**: Server-side routing with middleware stack
+- 🔧 **Middleware**: CORS, logging, error handling, rate limiting, compression, security
+- 🔄 **Shared State**: Real-time WebSocket state synchronization
+- 📊 **WebSocket Support**: Built-in WebSocket server
+- 📁 **Static File Server**: Gzip compression and cache headers
+- 🎯 **Zero Config**: Works out of the box with sensible defaults
+- 🔐 **Environment Variables**: Support for .env files with VITE_ prefix
 
 ## Quick Start
 
+### 1. Create Your Project
+
+```bash
+# Create a new directory
+mkdir my-elit-app
+cd my-elit-app
+
+# Initialize package.json
+npm init -y
+
+# Install Elit
+npm install elit
+```
+
+### 2. Create Your App
+
+Create `src/main.ts`:
+
+```typescript
+import { div, h1, button, createState, reactive, domNode } from 'elit';
+
+const count = createState(0);
+
+const app = div({ className: 'app' },
+  h1('Hello Elit! 🚀'),
+  reactive(count, (value) =>
+    button({
+      onclick: () => count.value++,
+      className: 'btn'
+    }, `Count: ${value}`)
+  )
+);
+
+domNode.render('#app', app);
+```
+
+Create `index.html`:
+
+```html
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Elit App</title>
+</head>
+<body>
+  <div id="app"></div>
+  <script type="module" src="src/main.ts"></script>
+</body>
+</html>
+```
+
+### 3. Start Development Server
+
+```bash
+npx elit dev
+```
+
+Your app will automatically reload when you make changes with HMR!
+
+### NPM Installation
+
+```bash
+npm install elit
+```
+
 ```typescript
 import { div, h1, p, button, createState, reactive, domNode } from 'elit';
 
 // Create reactive state
 const count = createState(0);
 
-// Create elements
+// Create elements with reactive updates
 const app = div({ className: 'app' },
-  h1('Hello Elit!'),
-  p('A lightweight DOM library'),
+  h1('Hello Elit! 👋'),
+  p('A lightweight, reactive DOM library'),
   reactive(count, (value) =>
-    button({ onclick: () => count.value++ }, `Count: ${value}`)
+    button({
+      onclick: () => count.value++,
+      className: 'btn-primary'
+    }, `Count: ${value}`)
   )
 );
 
@@ -54,6 +205,33 @@ const app = div({ className: 'app' },
 domNode.render('#app', app);
 ```
 
+### CDN Usage
+
+```html
+<!DOCTYPE html>
+<html>
+<head>
+  <script src="https://unpkg.com/elit@latest/dist/index.global.js"></script>
+</head>
+<body>
+  <div id="app"></div>
+  <script>
+    const { div, h1, button, createState, reactive, domNode } = window;
+
+    const count = createState(0);
+    const app = div(
+      h1('Hello from CDN!'),
+      reactive(count, value =>
+        button({ onclick: () => count.value++ }, `Count: ${value}`)
+      )
+    );
+
+    domNode.render('#app', app);
+  </script>
+</body>
+</html>
+```
+
 ## API
 
 ### Element Factories
@@ -105,6 +283,134 @@ const label = text(message);
 const inputEl = input({ type: 'text', ...bindValue(message) });
 ```
 
+### Shared State (Real-time Sync)
+
+**Requires `elit-server`** - Shared state syncs automatically between backend and frontend via WebSocket:
+
+```typescript
+import { createSharedState, reactive } from 'elit';
+
+// Create shared state (auto-connects to elit-server)
+const counter = createSharedState('counter', 0);
+const todos = createSharedState('todos', []);
+
+// Use with reactive rendering
+const app = div(
+  reactive(counter.state, value =>
+    div(`Counter: ${value}`)
+  ),
+  button({ onclick: () => counter.value++ }, 'Increment')
+);
+
+// Listen to changes
+counter.onChange((newValue, oldValue) => {
+  console.log(`${oldValue} → ${newValue}`);
+});
+
+// Update from any client - syncs to all
+counter.value++;
+```
+
+**Backend (Node.js with elit-server):**
+
+```javascript
+const { createDevServer } = require('elit-server');
+
+const server = createDevServer({ port: 3000 });
+
+// Create matching shared states
+const counter = server.state.create('counter', { initial: 0 });
+const todos = server.state.create('todos', { initial: [] });
+
+// Listen to changes
+counter.onChange((newValue, oldValue) => {
+  console.log(`Counter: ${oldValue} → ${newValue}`);
+});
+
+// Update from backend - syncs to all clients
+counter.value++;
+```
+
+### elit-server - Development Server
+
+Full-featured development server with HMR, REST API, and real-time features:
+
+```javascript
+const { createDevServer, Router, cors, logger } = require('elit-server');
+
+// Create REST API router
+const api = new Router();
+
+// Add middleware
+api.use(cors());
+api.use(logger());
+
+// Define routes
+api.get('/api/users', (ctx) => {
+  return { success: true, users: [...] };
+});
+
+api.post('/api/users', (ctx) => {
+  const user = ctx.body;
+  return { success: true, user };
+});
+
+// Create server with API
+const server = createDevServer({
+  port: 3000,
+  root: __dirname,
+  api,
+  logging: true
+});
+
+// Access shared state
+const counter = server.state.create('counter', {
+  initial: 0,
+  validate: (value) => typeof value === 'number'
+});
+```
+
+**CLI Usage:**
+
+```bash
+# Start dev server
+npx elit-dev
+
+# Custom port
+npx elit-dev --port 8080
+
+# Custom root directory
+npx elit-dev --root ./public
+
+# Disable auto-open browser
+npx elit-dev --no-open
+
+# Silent mode
+npx elit-dev --silent
+```
+
+**Middleware:**
+
+```javascript
+const {
+  cors,           // CORS headers
+  logger,         // Request logging
+  errorHandler,   // Error handling
+  rateLimit,      // Rate limiting
+  bodyLimit,      // Request body size limit
+  cacheControl,   // Cache headers
+  compress,       // Gzip compression
+  security        // Security headers
+} = require('elit-server');
+
+api.use(cors({ origin: '*' }));
+api.use(logger());
+api.use(rateLimit({ max: 100, window: 60000 }));
+api.use(bodyLimit(1024 * 1024)); // 1MB
+api.use(compress());
+api.use(security());
+```
+
 ### Server-Side Rendering
 
 ```typescript
@@ -232,6 +538,27 @@ addLink({ rel: 'stylesheet', href: '/styles.css' });
 addStyle('body { margin: 0; }');
 ```
 
+### DOM Utilities
+
+Elit provides convenient DOM utility functions for common operations:
+
+```typescript
+import { doc, el, els, createEl, elId, elClass, fragment } from 'elit';
+
+// Query selectors (bound to document)
+const element = el('.my-class');           // querySelector
+const elements = els('.my-class');         // querySelectorAll
+const byId = elId('my-id');               // getElementById
+const byClass = elClass('my-class');      // getElementsByClassName
+
+// Create elements
+const div = createEl('div');              // createElement
+const frag = fragment();                  // createDocumentFragment
+
+// Access document object
+doc.title = 'New Title';
+```
+
 ## Available Elements
 
 ### HTML Elements (100+)
@@ -265,6 +592,25 @@ All MathML elements are prefixed with `math`:
 
 `mathMath`, `mathMi`, `mathMn`, `mathMo`, `mathMfrac`, `mathMsqrt`, `mathMroot`, `mathMsup`, `mathMsub`, `mathMsubsup`, `mathMover`, `mathMunder`, `mathMunderover`, and more.
 
+## Bundle Size & Performance
+
+Elit is designed to be extremely lightweight while providing powerful features:
+
+| Format | Size (Minified) | Size (Gzipped) |
+|--------|----------------|----------------|
+| ESM    | 29KB          | ~10KB          |
+| CJS    | 30KB          | ~10KB          |
+| IIFE   | 30KB          | ~10KB          |
+
+**Tree-shaking**: When using ES modules, only the features you import will be included in your bundle.
+
+**Performance Optimizations**:
+- Direct DOM manipulation (no virtual DOM diffing)
+- Optimized rendering with RAF batching
+- Smart children rendering with automatic fragment usage
+- Efficient attribute updates using charCode checks
+- Minimal function closures and memory allocation
+
 ## Browser Usage
 
 When loaded via script tag, all exports are available on the `window` object:
@@ -273,7 +619,7 @@ When loaded via script tag, all exports are available on the `window` object:
 <script src="https://unpkg.com/elit@latest/dist/index.global.js"></script>
 <script>
   const { div, span, createState, domNode } = window;
-  // or use DomLib global
+  // or use DomLib global namespace
   const app = DomLib.div('Hello');
 </script>
 ```
@@ -335,14 +681,201 @@ const Counter = div(
 );
 ```
 
+## TypeScript Support
+
+Elit is written in TypeScript and provides excellent type safety:
+
+```typescript
+import { VNode, State, Props } from 'elit';
+
+// Type-safe element creation
+const props: Props = {
+  className: 'container',
+  onclick: (e: MouseEvent) => console.log(e)
+};
+
+// Type-safe state
+const count: State<number> = createState(0);
+const users: State<User[]> = createState([]);
+
+// Full IntelliSense support for all 100+ HTML elements
+```
+
+## Deployment
+
+Deploy your Elit application to production:
+
+### Build for Production
+
+```bash
+# Build your app
+npx elit build
+
+# Preview production build
+npx elit preview
+```
+
+### Deploy to Vercel
+
+```bash
+npm i -g vercel
+npm run build
+vercel --prod
+```
+
+### Deploy to Netlify
+
+```bash
+npm i -g netlify-cli
+npm run build
+netlify deploy --prod --dir=dist
+```
+
+### Deploy to GitHub Pages
+
+Create `.github/workflows/deploy.yml`:
+
+```yaml
+name: Deploy to GitHub Pages
+
+on:
+  push:
+    branches: [main]
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 18
+      - run: npm install
+      - run: npm run build
+      - uses: peaceiris/actions-gh-pages@v3
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: ./dist
+```
+
+### Docker Deployment
+
+```dockerfile
+FROM node:18-alpine AS builder
+WORKDIR /app
+COPY package*.json ./
+RUN npm install
+COPY . .
+RUN npm run build
+
+FROM nginx:alpine
+COPY --from=builder /app/dist /usr/share/nginx/html
+EXPOSE 80
+CMD ["nginx", "-g", "daemon off;"]
+```
+
+### Environment Variables
+
+Create `.env.production`:
+
+```env
+VITE_API_URL=https://api.example.com
+VITE_ENV=production
+```
+
+Access in your code:
+
+```typescript
+const apiUrl = import.meta.env.VITE_API_URL;
+const isProd = import.meta.env.PROD;
+```
+
+## Comparison with Other Frameworks
+
+| Feature | Elit | Vite + React | Next.js | SvelteKit |
+|---------|----------|--------------|---------|-----------|
+| Bundle Size | 30KB | ~140KB+ | ~200KB+ | ~15KB* |
+| Zero Dependencies | ✅ | ❌ | ❌ | ❌ |
+| Dev Server | ✅ Built-in | ✅ Vite | ✅ Built-in | ✅ Built-in |
+| HMR | ✅ | ✅ | ✅ | ✅ |
+| Build Tool | ✅ Built-in | ✅ Vite | ✅ Built-in | ✅ Built-in |
+| REST API | ✅ Built-in | ❌ | ✅ | ✅ |
+| TypeScript | ✅ | ✅ | ✅ | ✅ |
+| SSR | ✅ | ❌ | ✅ | ✅ |
+| Learning Curve | Easy | Medium | Medium | Easy |
+
+*Svelte requires compilation
+
 ## Documentation
 
-For detailed documentation, examples, and guides, visit the official documentation (coming soon).
+- 📚 [Full Documentation](https://github.com/oangsa/elit/docs)
+- ⚡ [Quick Start Guide](./docs/QUICK_START.md)
+- 📖 [API Reference](./docs/API.md)
+- 🔄 [Migration Guide](./docs/MIGRATION.md)
+- 🤝 [Contributing Guide](./CONTRIBUTING.md)
+
+## Changelog
+
+### Elit - Full-Stack Framework
+
+**Major Changes:**
+- 🚀 **Integrated Build System**: Built-in esbuild with automatic client/server code separation
+- 🔥 **CLI Tools**: New commands - `npx elit dev`, `npx elit build`, `npx elit preview`
+- 🏗️ **Zero Config**: Works out of the box with optional `elit.config.mjs`
+- 🌐 **REST API Router**: Server-side routing with full middleware stack
+- 🔄 **Shared State**: Real-time WebSocket state synchronization
+- 🎯 **basePath Support**: Configure base paths for subdirectory deployments
+- 🔐 **Environment Variables**: .env file support with VITE_ prefix
+- 📦 **Gzip Compression**: Automatic compression for production builds
+- 💾 **Cache Headers**: Smart caching for static assets
+- ⚡ **Hot Module Replacement**: Instant development feedback
+
+**Core Library:**
+- 🎯 Ultra lightweight (~10KB gzipped)
+- ⚡ Reactive state management
+- 🎨 CSS-in-JS with CreateStyle
+- 🛣️ Client-side router
+- 📱 Virtual scrolling
+- 🖥️ SSR support
+- 🎭 100+ HTML, SVG, and MathML elements
+- 🔧 Performance utilities
+- 📦 Tree-shakeable ES modules
+
+## Examples
+
+Example applications demonstrating Elit features:
+
+- 📖 **[Documentation Site](./docs)** - Full-featured docs site with i18n and blog
+- 🎯 **[Counter App](./examples/counter)** - Simple reactive counter
+- ✅ **[Todo App](./examples/todo)** - Todo list with state management
+- 🎨 **[Styled Components](./examples/styled)** - CSS-in-JS examples
+
+[View all examples →](./examples)
+
+## Links
+
+- 📦 [npm - elit](https://www.npmjs.com/package/elit)
+- 📦 [npm - elit-server](https://www.npmjs.com/package/elit-server)
+- 🐙 [GitHub Repository](https://github.com/oangsa/elit)
+- 📚 Documentation (coming soon)
+- 💬 Discord Community (coming soon)
 
 ## Contributing
 
 Contributions are welcome! Please feel free to submit a Pull Request.
 
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
 ## License
 
-MIT
+MIT License - see [LICENSE](./LICENSE) for details
+
+---
+
+**Built with ❤️ for modern web development**
+
+*Elit - Lightweight, Reactive, Powerful* 🚀

package/dist/build.d.mts

@@ -0,0 +1,11 @@
+import { B as BuildOptions, q as BuildResult } from './types-DOAdFFJB.mjs';
+import 'http';
+import 'ws';
+
+/**
+ * Build module for bundling applications
+ */
+
+declare function build(options: BuildOptions): Promise<BuildResult>;
+
+export { BuildOptions, BuildResult, build };

package/dist/build.d.ts

@@ -0,0 +1,11 @@
+import { B as BuildOptions, q as BuildResult } from './types-DOAdFFJB.js';
+import 'http';
+import 'ws';
+
+/**
+ * Build module for bundling applications
+ */
+
+declare function build(options: BuildOptions): Promise<BuildResult>;
+
+export { BuildOptions, BuildResult, build };

package/dist/build.js

@@ -0,0 +1 @@
+"use strict";var e=require("esbuild"),t=require("fs"),o=require("path"),n={outDir:"dist",minify:!0,sourcemap:!1,target:"es2020",format:"esm",treeshake:!0,logging:!0,external:[]};function i(e){if(0===e)return"0 B";let t=Math.floor(Math.log(e)/Math.log(1024));return parseFloat((e/Math.pow(1024,t)).toFixed(2))+" "+["B","KB","MB","GB"][t]}exports.build=async function(r){let l={...n,...r},s=Date.now();if(!l.entry)throw new Error("Entry file is required");let a=o.resolve(l.entry),c=o.resolve(l.outDir),g=l.outFile;if(!g){g=o.basename(l.entry,o.extname(l.entry))+("cjs"===l.format?".cjs":".js")}let f=o.join(c,g);try{t.mkdirSync(c,{recursive:!0})}catch{}l.logging&&(console.log("\n🔨 Building..."),console.log(`  Entry:  ${l.entry}`),console.log(`  Output: ${f}`),console.log(`  Format: ${l.format}`),console.log(`  Target: ${l.target}`));let u={name:"browser-only",setup(e){e.onResolve({filter:/^(node:.*|fs|path|http|https|url|os|child_process|net|tls|crypto|stream|util|events|buffer|zlib|readline|process|assert|constants|dns|domain|punycode|querystring|repl|string_decoder|sys|timers|tty|v8|vm)$/},()=>({path:"node-builtin",external:!0,sideEffects:!1})),e.onResolve({filter:/^(chokidar|esbuild|mime-types|open|ws|fs\/promises)$/},()=>({path:"server-dep",external:!0,sideEffects:!1})),e.onLoad({filter:/[\\/](server|config|cli)\.ts$/},()=>({contents:"export {}",loader:"js"}))}};try{let n=l.platform||("cjs"===l.format?"node":"browser"),r="browser"===n?[u]:[],g={};l.env&&(Object.entries(l.env).forEach(([e,t])=>{e.startsWith("VITE_")&&(g[`import.meta.env.${e}`]=JSON.stringify(t))}),l.env.MODE&&(g["import.meta.env.MODE"]=JSON.stringify(l.env.MODE)),g["import.meta.env.DEV"]=JSON.stringify("production"!==l.env.MODE),g["import.meta.env.PROD"]=JSON.stringify("production"===l.env.MODE));let m=await e.build({entryPoints:[a],bundle:!0,outfile:f,format:l.format,target:l.target,minify:l.minify,sourcemap:l.sourcemap,external:l.external,treeShaking:l.treeshake,globalName:l.globalName,platform:n,plugins:r,define:g,logLevel:l.logging?"info":"silent",metafile:!0,...l.minify&&{minifyWhitespace:!0,minifyIdentifiers:!0,minifySyntax:!0,legalComments:"none",mangleProps:/^_/,keepNames:!1}}),p=Date.now()-s,y=t.statSync(f).size;if(l.logging&&(console.log("\n✅ Build successful!"),console.log(`  Time: ${p}ms`),console.log(`  Size: ${i(y)}`),m.metafile)){let e=Object.keys(m.metafile.inputs).length;console.log(`  Files: ${e} input(s)`);let t=Object.keys(m.metafile.outputs);if(t.length>0){let e=m.metafile.outputs[t[0]];if(e&&e.inputs){let t=Object.entries(e.inputs).sort(([,e],[,t])=>t.bytesInOutput-e.bytesInOutput).slice(0,5);t.length>0&&(console.log("\n  📊 Top 5 largest modules:"),t.forEach(([e,t])=>{let o=e.split(/[/\\]/).pop()||e;console.log(`     ${o.padEnd(30)} ${i(t.bytesInOutput)}`)}))}}}let d={outputPath:f,buildTime:p,size:y};if(l.copy&&l.copy.length>0){l.logging&&console.log("\n📦 Copying files...");for(let e of l.copy){let n=o.resolve(e.from),i=o.resolve(c,e.to),r=o.dirname(i);if(t.existsSync(r)||t.mkdirSync(r,{recursive:!0}),t.existsSync(n)){if(e.transform){let o=t.readFileSync(n,"utf-8"),r=e.transform(o,l);t.writeFileSync(i,r)}else t.copyFileSync(n,i);l.logging&&console.log(`  ✓ ${e.from} → ${e.to}`)}else l.logging&&console.warn(`  ⚠ File not found: ${e.from}`)}}return l.onBuildEnd&&await l.onBuildEnd(d),l.logging&&console.log(""),d}catch(e){throw l.logging&&(console.error("\n❌ Build failed:"),console.error(e)),e}};