elit 1.0.0-test → 1.1.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,52 +1,101 @@
 # Elit
 
-A lightweight, zero-dependency library for building reactive web applications with direct DOM manipulation.
+⚡ A lightweight, zero-dependency library for building reactive web applications with direct DOM manipulation.
 
 [![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) | [API](#api) | [Examples](#examples) | [@elit/server](./server/README.md)
 
 ## 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
+- **🚀 Modern Features**: Router, SSR, virtual scrolling, CSS-in-JS, and more
+- **🎨 Developer Experience**: Clean, intuitive API with excellent tooling support
 
 ## Installation
 
 ```bash
 npm install elit
+
+# Optional: Install dev server with HMR
+npm install --save-dev @elit/server
 ```
 
 ## Features
 
-- 🎯 **Lightweight**: Optimized for performance and small bundle size
+### Core Library (elit)
+
+- 🎯 **Ultra Lightweight**: Just 30KB minified, ~10KB gzipped - optimized for performance
 - ⚡ **Reactive State**: Built-in reactive state management with `createState`
 - 🔄 **Computed Values**: Automatic dependency tracking with `computed`
-- 🎨 **CSS-in-JS**: Type-safe styling with `CreateStyle`
+- 🌐 **Shared State**: Real-time state sync with `@elit/server` (optional)
+- 🎨 **CSS-in-JS**: Type-safe styling with `CreateStyle` - full CSS features support
 - 🛣️ **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
+- 📱 **Virtual Scrolling**: Handle 100k+ items efficiently with built-in virtual list
+- 🖥️ **SSR Support**: Full server-side rendering capabilities
+- 🎭 **SVG & MathML**: Complete support for SVG and MathML elements (100+ elements)
+- 🔧 **Performance Utilities**: Throttle, debounce, batch rendering, and chunked rendering
+- 📦 **Tree-Shakeable**: Import only what you need - excellent for bundle optimization
+- 🎮 **DOM Utilities**: Convenient helper functions for common DOM operations
+- 🔌 **No Build Required**: Works directly in browsers via CDN
+
+### Development Server (@elit/server)
+
+- ⚡ **Hot Module Replacement (HMR)**: Instant updates without page refresh
+- 🌐 **REST API Router**: Built-in routing system with regex parameters
+- 🔧 **Middleware Stack**: CORS, logging, error handling, rate limiting, compression, security headers
+- 🔄 **Shared State Sync**: Real-time WebSocket state synchronization
+- 📊 **WebSocket Support**: Built-in WebSocket server for real-time features
+- 📁 **Static File Server**: Serves your application files with MIME type detection
+- 🎯 **Zero Config**: Works out of the box with sensible defaults
+- 🛠️ **CLI Tool**: Simple command-line interface (`elit-dev`)
+- 📦 **Lightweight**: Minimal dependencies (chokidar, ws, mime-types)
 
 ## Quick Start
 
+### Development Server with HMR
+
+Get started instantly with hot module replacement:
+
+```bash
+# Install Elit and dev server
+npm install elit
+npm install --save-dev @elit/server
+
+# Start dev server
+npx elit-dev
+```
+
+Your app will automatically reload when you make changes!
+
+### 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 +103,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 +181,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 +436,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 +490,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 +517,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 +579,137 @@ 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
+```
+
+## Comparison with Other Libraries
+
+| Feature | Elit | React | Vue | Svelte |
+|---------|------|-------|-----|--------|
+| Bundle Size (min) | 30KB | ~140KB | ~90KB | ~15KB* |
+| Zero Dependencies | ✅ | ❌ | ❌ | ✅ |
+| Virtual DOM | ❌ | ✅ | ✅ | ❌ |
+| TypeScript First | ✅ | ✅ | ✅ | ✅ |
+| Built-in Router | ✅ | ❌ | ❌ | ❌ |
+| Built-in State | ✅ | ❌ | ✅ | ✅ |
+| SSR Support | ✅ | ✅ | ✅ | ✅ |
+| Learning Curve | Easy | Medium | Medium | Easy |
+
+*Svelte requires compilation
+
+## Packages
+
+This monorepo contains two packages:
+
+### elit
+[![npm version](https://img.shields.io/npm/v/elit.svg)](https://www.npmjs.com/package/elit)
+
+The core library for building reactive web applications.
+
+```bash
+npm install elit
+```
+
+### @elit/server
+[![npm version](https://img.shields.io/npm/v/@elit/server.svg)](https://www.npmjs.com/package/@elit/server)
+
+Development server with HMR, REST API, and real-time state synchronization.
+
+```bash
+npm install --save-dev @elit/server
+```
+
+[View @elit/server documentation →](./server/README.md)
+
 ## Documentation
 
-For detailed documentation, examples, and guides, visit the official documentation (coming soon).
+- 📚 [Documentation Hub](./docs/README.md)
+- ⚡ [Quick Start Guide](./docs/QUICK_START.md) - Get started in 5 minutes
+- 📖 [API Reference](./docs/API.md) - Complete API documentation
+- ⚖️ [Comparison Guide](./docs/COMPARISON.md) - Compare with React, Vue, Svelte
+- 🔄 [Migration Guide](./docs/MIGRATION.md) - Migrate from other frameworks
+- 🤝 [Contributing Guide](./CONTRIBUTING.md) - Contribute to Elit
+
+## Changelog
+
+### elit v0.1.0
+
+**Core Library:**
+- 🎉 Initial release
+- ⚡ Optimized bundle size (50% reduction from initial builds - 30KB minified)
+- 🚀 Full TypeScript support with complete type definitions
+- 🎨 Complete CSS-in-JS with CreateStyle
+- 🛣️ Client-side router with navigation guards
+- 📦 Tree-shakeable ES modules
+- 🎭 100+ HTML, SVG, and MathML elements
+- 🔧 Performance utilities (throttle, debounce, virtual scrolling)
+- 🖥️ SSR capabilities with renderToString
+- 🎮 DOM utility functions
+- 🌐 Shared state integration with @elit/server
+
+**New Package - @elit/server v0.1.0:**
+- ⚡ Hot Module Replacement (HMR) with WebSocket
+- 🌐 REST API router with regex-based parameters
+- 🔧 Middleware stack (CORS, logging, error handling, rate limiting, compression, security)
+- 🔄 Real-time shared state synchronization
+- 📊 Built-in WebSocket server
+- 📁 Static file server with MIME type detection
+- 🛠️ CLI tool (`elit-dev`)
+- 🎯 Zero-config with sensible defaults
+
+## Examples
+
+Check out the example applications in the repository:
+
+- **[HMR Example](./server/example/hmr-example.html)** - Hot Module Replacement demo
+- **[REST API Example](./server/example/api-example.js)** - Full REST API with todos
+- **[Shared State (Vanilla)](./server/example/state-demo.html)** - Real-time state sync without Elit
+- **[Shared State (Elit)](./server/example/elit-state-demo.html)** - Real-time state with Elit reactive system
+- **[Todo App](./examples)** - Complete todo application (coming soon)
+
+[View all examples →](./server/example/README.md)
+
+## 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/index.d.mts

@@ -125,6 +125,96 @@ declare const cleanupUnused: (root: HTMLElement) => number;
 declare const throttle: <T extends any[]>(fn: (...args: T) => void, delay: number) => (...args: T) => void;
 declare const debounce: <T extends any[]>(fn: (...args: T) => void, delay: number) => (...args: T) => void;
 
+/**
+ * Shared State for Elit
+ * Integrates with @elit/server for real-time state synchronization
+ */
+
+type StateChangeCallback<T = any> = (value: T, oldValue: T) => void;
+/**
+ * Shared State - syncs with @elit/server
+ */
+declare class SharedState<T = any> {
+    readonly key: string;
+    private wsUrl?;
+    private localState;
+    private ws;
+    private pendingUpdates;
+    private previousValue;
+    constructor(key: string, defaultValue: T, wsUrl?: string | undefined);
+    /**
+     * Get current value
+     */
+    get value(): T;
+    /**
+     * Set new value and sync to server
+     */
+    set value(newValue: T);
+    /**
+     * Get the underlying Elit State (for reactive binding)
+     */
+    get state(): State<T>;
+    /**
+     * Subscribe to changes (returns Elit State for reactive)
+     */
+    onChange(callback: StateChangeCallback<T>): () => void;
+    /**
+     * Update value using a function
+     */
+    update(updater: (current: T) => T): void;
+    /**
+     * Connect to WebSocket
+     */
+    private connect;
+    /**
+     * Subscribe to server state
+     */
+    private subscribe;
+    /**
+     * Handle message from server
+     */
+    private handleMessage;
+    /**
+     * Send value to server
+     */
+    private sendToServer;
+    /**
+     * Disconnect
+     */
+    disconnect(): void;
+    /**
+     * Destroy state and cleanup
+     */
+    destroy(): void;
+}
+/**
+ * Create a shared state that syncs with @elit/server
+ */
+declare function createSharedState<T>(key: string, defaultValue: T, wsUrl?: string): SharedState<T>;
+/**
+ * Shared State Manager for managing multiple shared states
+ */
+declare class SharedStateManager {
+    private states;
+    /**
+     * Create or get a shared state
+     */
+    create<T>(key: string, defaultValue: T, wsUrl?: string): SharedState<T>;
+    /**
+     * Get existing state
+     */
+    get<T>(key: string): SharedState<T> | undefined;
+    /**
+     * Delete a state
+     */
+    delete(key: string): boolean;
+    /**
+     * Clear all states
+     */
+    clear(): void;
+}
+declare const sharedStateManager: SharedStateManager;
+
 /**
  * Elit - Reactive Rendering Helpers
  */
@@ -472,6 +562,45 @@ declare const mathMsub: ElementFactory;
 declare const mathMsup: ElementFactory;
 declare const varElement: ElementFactory;
 
+/**
+ * DOM utility functions - Shorthand helpers for common document operations
+ */
+declare const doc: Document;
+declare const el: {
+    <K extends keyof HTMLElementTagNameMap>(selectors: K): HTMLElementTagNameMap[K] | null;
+    <K extends keyof SVGElementTagNameMap>(selectors: K): SVGElementTagNameMap[K] | null;
+    <K extends keyof MathMLElementTagNameMap>(selectors: K): MathMLElementTagNameMap[K] | null;
+    <K extends keyof HTMLElementDeprecatedTagNameMap>(selectors: K): HTMLElementDeprecatedTagNameMap[K] | null;
+    <E extends Element = Element>(selectors: string): E | null;
+};
+declare const els: {
+    <K extends keyof HTMLElementTagNameMap>(selectors: K): NodeListOf<HTMLElementTagNameMap[K]>;
+    <K extends keyof SVGElementTagNameMap>(selectors: K): NodeListOf<SVGElementTagNameMap[K]>;
+    <K extends keyof MathMLElementTagNameMap>(selectors: K): NodeListOf<MathMLElementTagNameMap[K]>;
+    <K extends keyof HTMLElementDeprecatedTagNameMap>(selectors: K): NodeListOf<HTMLElementDeprecatedTagNameMap[K]>;
+    <E extends Element = Element>(selectors: string): NodeListOf<E>;
+};
+declare const createEl: {
+    <K extends keyof HTMLElementTagNameMap>(tagName: K, options?: ElementCreationOptions): HTMLElementTagNameMap[K];
+    <K extends keyof HTMLElementDeprecatedTagNameMap>(tagName: K, options?: ElementCreationOptions): HTMLElementDeprecatedTagNameMap[K];
+    (tagName: string, options?: ElementCreationOptions): HTMLElement;
+};
+declare const createSvgEl: (qualifiedName: string, options?: string | ElementCreationOptions | undefined) => Element;
+declare const createMathEl: (qualifiedName: string, options?: string | ElementCreationOptions | undefined) => Element;
+declare const fragment: () => DocumentFragment;
+declare const textNode: (data: string) => Text;
+declare const commentNode: (data: string) => Comment;
+declare const elId: (elementId: string) => HTMLElement | null;
+declare const elClass: (classNames: string) => HTMLCollectionOf<Element>;
+declare const elTag: {
+    <K extends keyof HTMLElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<HTMLElementTagNameMap[K]>;
+    <K extends keyof SVGElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<SVGElementTagNameMap[K]>;
+    <K extends keyof MathMLElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<MathMLElementTagNameMap[K]>;
+    <K extends keyof HTMLElementDeprecatedTagNameMap>(qualifiedName: K): HTMLCollectionOf<HTMLElementDeprecatedTagNameMap[K]>;
+    (qualifiedName: string): HTMLCollectionOf<Element>;
+};
+declare const elName: (elementName: string) => NodeListOf<HTMLElement>;
+
 /**
  * Elit - Optimized lightweight library for creating DOM elements with reactive state
  */
@@ -498,4 +627,4 @@ declare const renderVNodeToString: (json: VNodeJson, options?: {
     indent?: number;
 }) => string;
 
-export { type CSSRule, type CSSVariable, type Child, type Children, type ContainerRule, CreateStyle, DomNode, type ElementFactory, type FontFace, type JsonNode, type KeyframeStep, type Keyframes, type LayerRule, type MediaRule, type Props, type RefCallback, type RefObject, type Route, type RouteLocation, type RouteParams, type Router, type RouterOptions, type State, type StateOptions, type SupportsRule, type VNode, type VNodeJson, type VirtualListController, a, abbr, addLink, addMeta, addStyle, address, area, article, aside, audio, b, base, batchRender, bdi, bdo, bindChecked, bindValue, blockquote, body, br, button, canvas, caption, cite, cleanupUnused, code, col, colgroup, computed, createElementFactory, createRouter, createRouterView, createState, createVirtualList, data, datalist, dd, debounce, del, details, dfn, dialog, div, dl, domNode, dt, effect, elements, em, embed, fieldset, figcaption, figure, footer, form, h1, h2, h3, h4, h5, h6, head, header, hr, html, i, iframe, img, input, ins, jsonToVNode, kbd, label, lazy, legend, li, link, main, map, mark, mathMath, mathMfrac, mathMi, mathMn, mathMo, mathMroot, mathMrow, mathMs, mathMsqrt, mathMsub, mathMsup, mathMtext, menu, meta, meter, nav, noscript, object, ol, optgroup, option, output, p, param, picture, portal, pre, progress, q, reactive, reactiveAs, renderChunked, renderJson, renderJsonToString, renderToHead, renderToString, renderVNode, renderVNodeToString, routerLink, rp, rt, ruby, s, samp, script, section, select, setTitle, slot, small, source, span, strong, style, sub, summary, sup, svgAnimate, svgAnimateMotion, svgAnimateTransform, svgCircle, svgClipPath, svgDefs, svgEllipse, svgFeBlend, svgFeColorMatrix, svgFeComponentTransfer, svgFeComposite, svgFeConvolveMatrix, svgFeDiffuseLighting, svgFeDisplacementMap, svgFeFlood, svgFeGaussianBlur, svgFeMorphology, svgFeOffset, svgFeSpecularLighting, svgFeTile, svgFeTurbulence, svgFilter, svgForeignObject, svgG, svgImage, svgLine, svgLinearGradient, svgMarker, svgMask, svgPath, svgPattern, svgPolygon, svgPolyline, svgRadialGradient, svgRect, svgSet, svgStop, svgSvg, svgSymbol, svgText, svgTspan, svgUse, table, tbody, td, template, text, textarea, tfoot, th, thead, throttle, time, title, tr, track, u, ul, vNodeJsonToVNode, varElement, video, wbr };
+export { type CSSRule, type CSSVariable, type Child, type Children, type ContainerRule, CreateStyle, DomNode, type ElementFactory, type FontFace, type JsonNode, type KeyframeStep, type Keyframes, type LayerRule, type MediaRule, type Props, type RefCallback, type RefObject, type Route, type RouteLocation, type RouteParams, type Router, type RouterOptions, SharedState, type State, type StateOptions, type SupportsRule, type VNode, type VNodeJson, type VirtualListController, a, abbr, addLink, addMeta, addStyle, address, area, article, aside, audio, b, base, batchRender, bdi, bdo, bindChecked, bindValue, blockquote, body, br, button, canvas, caption, cite, cleanupUnused, code, col, colgroup, commentNode, computed, createEl, createElementFactory, createMathEl, createRouter, createRouterView, createSharedState, createState, createSvgEl, createVirtualList, data, datalist, dd, debounce, del, details, dfn, dialog, div, dl, doc, domNode, dt, effect, el, elClass, elId, elName, elTag, elements, els, em, embed, fieldset, figcaption, figure, footer, form, fragment, h1, h2, h3, h4, h5, h6, head, header, hr, html, i, iframe, img, input, ins, jsonToVNode, kbd, label, lazy, legend, li, link, main, map, mark, mathMath, mathMfrac, mathMi, mathMn, mathMo, mathMroot, mathMrow, mathMs, mathMsqrt, mathMsub, mathMsup, mathMtext, menu, meta, meter, nav, noscript, object, ol, optgroup, option, output, p, param, picture, portal, pre, progress, q, reactive, reactiveAs, renderChunked, renderJson, renderJsonToString, renderToHead, renderToString, renderVNode, renderVNodeToString, routerLink, rp, rt, ruby, s, samp, script, section, select, setTitle, sharedStateManager, slot, small, source, span, strong, style, sub, summary, sup, svgAnimate, svgAnimateMotion, svgAnimateTransform, svgCircle, svgClipPath, svgDefs, svgEllipse, svgFeBlend, svgFeColorMatrix, svgFeComponentTransfer, svgFeComposite, svgFeConvolveMatrix, svgFeDiffuseLighting, svgFeDisplacementMap, svgFeFlood, svgFeGaussianBlur, svgFeMorphology, svgFeOffset, svgFeSpecularLighting, svgFeTile, svgFeTurbulence, svgFilter, svgForeignObject, svgG, svgImage, svgLine, svgLinearGradient, svgMarker, svgMask, svgPath, svgPattern, svgPolygon, svgPolyline, svgRadialGradient, svgRect, svgSet, svgStop, svgSvg, svgSymbol, svgText, svgTspan, svgUse, table, tbody, td, template, text, textNode, textarea, tfoot, th, thead, throttle, time, title, tr, track, u, ul, vNodeJsonToVNode, varElement, video, wbr };