@relax.js/core 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 relax.js
+
+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

@@ -0,0 +1,188 @@
+# Relaxjs
+
+**Ship faster with less code.**
+
+Web Component library with routing, forms, DI, templating, and i18n. No virtual DOM, no build magic, no surprise re-renders.
+
+## Why Relaxjs?
+
+Modern frameworks solve problems you might not have. Relaxjs takes the opposite approach:
+
+| Framework Approach | Relaxjs Approach |
+|-------------------|------------------|
+| Virtual DOM diffing | Direct DOM manipulation |
+| Reactive state management | Explicit updates |
+| Custom template syntax | Standard HTML |
+| Framework-specific lifecycle | Native Web Component lifecycle |
+| Magic re-renders | You control what updates |
+| Custom rendering pipeline | Native async/await everywhere |
+
+> [Read the detailed comparison](docs/WhyRelaxjs.md)
+
+**The result:** You always know *when* something ran, *why* it ran, and *what* triggered it.
+
+## What Relaxjs Adds
+
+Web Components give you encapsulation and lifecycle hooks. Relaxjs fills the gaps:
+
+| Vanilla Web Components | With Relaxjs |
+|------------------------|--------------|
+| Manual form serialization | `readData(form)` returns typed objects (send it directly to backend) |
+| Query string parsing | Named routes with typed parameters |
+| DIY validation logic | `FormValidator` with HTML5 integration |
+| No component library | Table, Tabs, TreeView, Menu ready to use |
+| Manual service wiring | Decorator-based dependency injection |
+| Raw fetch boilerplate | Simple HTTP client for backend calls |
+
+You write less boilerplate while keeping full control.
+
+## Installation
+
+```bash
+npm install relaxjs
+```
+
+## Quick Examples
+
+### Form Handling
+
+Read and write form data with automatic type conversion:
+
+```typescript
+import { setFormData, readData } from 'relaxjs';
+
+// Populate a form from an object
+const user = { name: 'John', email: 'john@example.com', age: 30 };
+setFormData(form, user);
+
+// Read form data back (with types!)
+const data = readData(form);
+// { name: 'John', email: 'john@example.com', age: 30 }
+```
+
+Supports nested objects (`user.address.city`), arrays (`tags[]`), and automatic type conversion for numbers, booleans, and dates.
+
+> [Form utilities docs](docs/forms/forms.md)
+
+### Client-Side Routing
+
+Define routes and let the router handle navigation:
+
+```typescript
+import { defineRoutes, navigate, startRouting } from 'relaxjs';
+
+defineRoutes([
+    { name: 'home', path: '/', componentTagName: 'app-home' },
+    { name: 'user', path: '/users/:id', componentTagName: 'app-user' },
+    { name: 'settings', path: '/settings', componentTagName: 'app-settings' }
+]);
+
+startRouting();
+
+// Navigate programmatically
+navigate('user', { params: { id: '123' } });
+```
+
+```html
+<r-route-target></r-route-target>
+```
+
+> [Routing docs](docs/routing/Routing.md)
+
+### Form Validation
+
+HTML5-style validation with custom rules and error summaries:
+
+```typescript
+import { FormValidator } from 'relaxjs';
+
+const validator = new FormValidator(form, {
+    useSummary: true,
+    submitCallback: () => saveData()
+});
+```
+
+> [Validation docs](docs/forms/validation.md)
+
+## What's Included
+
+| Feature | Description |
+|---------|-------------|
+| **Form Utilities** | Read/write forms, type conversion, validation |
+| **Routing** | Named routes, typed parameters, guards, layouts, multiple targets |
+| **HTML Templates** | `html` tagged templates with data binding and in-place updates |
+| **HTTP Client** | Type-safe `get`/`post`/`put`/`del` with automatic JWT |
+| **WebSocket** | Auto-reconnect, message queuing, typed messages |
+| **SSE** | Server-Sent Events dispatched as DOM events |
+| **Dependency Injection** | Decorator-based DI with constructor and property injection |
+| **i18n** | ICU message format, pluralization, locale-aware formatting |
+| **Pipes** | 15 built-in data transformations for templates |
+
+## Where Relaxjs Fits
+
+Relaxjs is a good choice when:
+
+- You're building a **small-to-medium SPA** where you want direct control over the DOM
+- Your team prefers **vanilla Web Components** over framework abstractions
+- You want **gradual adoption** - use only the parts you need, no all-or-nothing buy-in
+- **Bundle size and simplicity** matter more than ecosystem breadth
+- You want to **understand what your code does** - no hidden re-renders, no magic proxies, no compiler transforms
+
+## Where Relaxjs Doesn't Fit
+
+Be honest with yourself - Relaxjs is not the right tool for everything:
+
+- **Large-scale apps with complex state** - Relaxjs has no reactive state management, no global store, no computed properties. If your UI has dozens of interdependent data flows, you'll be writing a lot of manual update logic.
+- **Server-side rendering / static site generation** - Relaxjs is client-only. If you need SEO, fast first-paint from the server, or pre-rendered pages, look at Next.js, Nuxt, or SvelteKit.
+- **Big teams that need a large talent pool** - React and Angular developers are everywhere. Finding developers who know Relaxjs (or are willing to learn a small library) is harder.
+- **Rich ecosystem needs** - There's no component marketplace, no DevTools extension, no community middleware. You build what you need or use vanilla JS libraries.
+- **Mobile / native targets** - No React Native equivalent, no Ionic integration. Relaxjs is for the browser.
+
+## How It Compares
+
+| | Relaxjs | React | Angular | Vue | Svelte |
+|---|---|---|---|---|---|
+| **Approach** | Web Components | Virtual DOM | Full framework | Virtual DOM | Compiler |
+| **Bundle size** | ~20KB gzipped | ~45KB | ~150KB+ | ~33KB | ~2KB runtime |
+| **Learning curve** | Low (vanilla TS) | Medium | High | Medium | Low-Medium |
+| **State management** | Explicit DOM updates | Hooks / Redux / Zustand | RxJS / Signals | Reactive refs | Stores / runes |
+| **Routing** | Built-in (simple) | react-router (separate) | Built-in (full) | vue-router (separate) | SvelteKit |
+| **Forms** | Built-in (HTML5 native) | Controlled / uncontrolled | Reactive forms | v-model | bind: |
+| **SSR** | No | Yes | Yes | Yes | Yes |
+| **Ecosystem** | Small | Massive | Large | Large | Growing |
+| **DI** | Built-in | None (Context API) | Built-in | Provide / Inject | None |
+| **i18n** | Built-in (ICU) | i18next etc. | Built-in | vue-i18n | i18next etc. |
+| **DevTools** | Browser DevTools | React DevTools | Angular DevTools | Vue DevTools | Svelte DevTools |
+| **Community size** | Small | Very large | Large | Large | Medium |
+
+## Philosophy
+
+This isn't a framework - it's a library. Use what you need:
+
+- Need just form handling? Import `setFormData` and `readData`.
+- Need routing? Add `defineRoutes` and `r-route-target`.
+- Need everything? It's all there.
+
+No buy-in required. No migration path to worry about. Just Web Components and TypeScript.
+
+## Documentation
+
+- [Why Relaxjs?](docs/WhyRelaxjs.md) - Detailed comparison with frameworks
+- [Getting Started](docs/GettingStarted.md) - Progressive adoption guide (7 levels)
+- [Architecture](docs/Architecture.md)
+- [Form Utilities](docs/forms/forms.md) - Validation, reading/writing, custom form components
+- [Routing](docs/routing/Routing.md) - Routes, guards, layouts, navigation
+- [HTML Templates](docs/html/html.md) - Tagged templates with data binding
+- [HTTP & WebSocket](docs/http/HttpClient.md) - REST calls, WebSocket, SSE
+- [Dependency Injection](docs/DependencyInjection.md)
+- [i18n](docs/i18n/i18n.md) - Translations, ICU format, locale switching
+- [Pipes](docs/Pipes.md) - Data transformations for templates
+- [Utilities](docs/utilities.md) - Sequential IDs, LinkedList, helpers
+
+## Browser Support
+
+Works in all browsers that support Web Components (Chrome, Firefox, Safari, Edge).
+
+## License
+
+ISC

package/dist/DataLoader.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Interface for loading paginated data from a data source.
+ * Implement this interface to provide data to table or list components
+ * that support pagination and sorting.
+ *
+ * Used by components like `r-table` to fetch data on demand as users
+ * navigate through pages or change sort order.
+ *
+ * @example
+ * // Implement for an API-backed data source
+ * class UserDataLoader implements DataLoader {
+ *     async load(options) {
+ *         const params = new URLSearchParams({
+ *             page: options.page.toString(),
+ *             pageSize: options.pageSize.toString(),
+ *             sort: JSON.stringify(options.sort)
+ *         });
+ *
+ *         const response = await fetch(`/api/users?${params}`);
+ *         return response.json();
+ *     }
+ * }
+ *
+ * @example
+ * // Use with a table component
+ * const loader: DataLoader = new UserDataLoader();
+ * const result = await loader.load({ page: 1, pageSize: 25, sort: [] });
+ * table.render(result.rows);
+ */
+export interface DataLoader {
+    /**
+     * Loads a page of data with optional sorting.
+     *
+     * @param options - The loading options
+     * @param options.page - The 1-based page number to load
+     * @param options.pageSize - Number of rows per page
+     * @param options.sort - Array of sort specifications
+     * @returns Promise resolving to rows and total count for pagination
+     */
+    load(options: {
+        page: number;
+        pageSize: number;
+        sort: {
+            column: string;
+            direction: 'asc' | 'desc';
+        }[];
+    }): Promise<{
+        rows: Record<string, any>[];
+        totalCount: number;
+    }>;
+}

package/dist/DependencyInjection.d.ts

@@ -0,0 +1,271 @@
+/**
+ * Generic constructor type used for dependency registration and injection.
+ * Represents any class constructor that can be used with the DI container.
+ *
+ * @template T - The type of object the constructor creates
+ *
+ * @example
+ * // Use with service registration
+ * class UserService {}
+ * const ctor: Constructor<UserService> = UserService;
+ * serviceCollection.registerByType(ctor, { inject: [] });
+ */
+export type Constructor<T extends object = object> = new (...args: any[]) => T;
+/**
+ * Controls how service instances are shared across the container hierarchy.
+ * Used when registering services to define their lifetime behavior.
+ *
+ * - `global`: Single instance shared everywhere (singleton pattern)
+ * - `closest`: New instance per container scope (scoped lifetime)
+ *
+ * @example
+ * // Singleton service - same instance everywhere
+ * serviceCollection.register(LoggerService, { scope: 'global', inject: [] });
+ *
+ * // Scoped service - new instance per scope
+ * serviceCollection.register(RequestContext, { scope: 'closest', inject: [] });
+ */
+export type ServiceScope = 'global' | 'closest';
+/**
+ * Configuration options for registering a service in the DI container.
+ * Controls identification, lifetime, and dependency resolution.
+ *
+ * @example
+ * // Register with constructor injection
+ * const options: RegistrationOptions = {
+ *     scope: 'global',
+ *     inject: [DatabaseConnection, ConfigService]
+ * };
+ * serviceCollection.register(UserRepository, options);
+ *
+ * @example
+ * // Register with property injection
+ * const options: RegistrationOptions = {
+ *     inject: [],
+ *     properties: { logger: Logger, config: 'appConfig' }
+ * };
+ *
+ * @example
+ * // Register with a pre-created instance
+ * const options: RegistrationOptions = {
+ *     inject: [],
+ *     instance: existingService
+ * };
+ */
+export interface RegistrationOptions {
+    /** Service lifetime - 'global' for singleton, 'closest' for scoped */
+    scope?: ServiceScope;
+    /** Optional string key for resolving by name instead of type */
+    key?: string;
+    /** Pre-existing instance to use instead of creating new one */
+    instance?: unknown;
+    /** Types or keys for constructor parameters, in order */
+    inject: (string | Constructor)[];
+    /** Map of property names to their injection types/keys */
+    properties?: Record<string, string | Constructor>;
+}
+/**
+ * Field decorator that collects property injection configuration.
+ * Updates or creates the properties mapping in registration options.
+ *
+ * @example
+ * @ContainerService({
+ *   inject: [Database],
+ *   properties: {
+ *     logger: Logger,        // Inject by type
+ *     audit: 'auditLogger'   // Inject by key
+ *   }
+ * })
+ * class UserService {
+ *   @Inject(Logger)
+ *   private logger!: Logger;
+ *
+ *   @Inject('auditLogger')
+ *   private audit!: Logger;
+ *
+ *   constructor(db: Database) {}
+ * }
+ */
+export declare function Inject<T extends object>(typeOrKey: Constructor<T> | string): (_: undefined, context: ClassFieldDecoratorContext) => (this: any) => T;
+/**
+ * Class decorator that automatically registers a service in the global DI container.
+ * Use this to declaratively register services without manual registration calls.
+ *
+ * Services are registered at module load time, so ensure this file is imported
+ * before attempting to resolve the decorated service.
+ *
+ * @param options - Registration configuration including scope and dependencies
+ *
+ * @example
+ * // Simple service with constructor injection
+ * @ContainerService({ inject: [DatabaseConnection] })
+ * class UserRepository {
+ *     constructor(private db: DatabaseConnection) {}
+ * }
+ *
+ * @example
+ * // Service with custom key for named resolution
+ * @ContainerService({ key: 'primaryCache', scope: 'global', inject: [] })
+ * class CacheService {}
+ *
+ * // Later resolve by key
+ * const cache = container.resolve('primaryCache');
+ */
+export declare function ContainerService<T extends object>(options?: RegistrationOptions): (target: Constructor<T>) => void;
+/**
+ * Internal class representing a registered service's metadata.
+ * Holds all information needed to create and configure service instances.
+ *
+ * @internal This is an implementation detail and should not be used directly.
+ */
+declare class Registration {
+    classConstructor: Constructor;
+    scope: ServiceScope;
+    inject: (string | Constructor)[];
+    properties: Record<string, string | Constructor>;
+    key?: string;
+    instance?: unknown;
+    /**
+     * Creates a new registration record.
+     *
+     * @param classConstructor - The class constructor function
+     * @param scope - Instance sharing behavior
+     * @param inject - Constructor parameter dependencies
+     * @param properties - Property injection mappings
+     * @param key - Optional string identifier
+     * @param instance - Optional pre-created instance
+     */
+    constructor(classConstructor: Constructor, scope: ServiceScope, inject: (string | Constructor)[], properties?: Record<string, string | Constructor>, key?: string, instance?: unknown);
+}
+/**
+ * Registry that stores service registration metadata.
+ * Use this to register services before they can be resolved by a ServiceContainer.
+ *
+ * Typically you'll use the global `serviceCollection` instance rather than creating your own.
+ *
+ * @example
+ * // Register a service by type
+ * serviceCollection.registerByType(LoggerService, { inject: [] });
+ *
+ * // Register with a string key
+ * serviceCollection.register(CacheService, { key: 'cache', inject: [] });
+ *
+ * // Check if service is registered
+ * const reg = serviceCollection.tryGet(LoggerService);
+ * if (reg) {
+ *     console.log('Logger is registered');
+ * }
+ */
+export declare class ServiceCollection {
+    private servicesByKey;
+    private servicesByClassName;
+    /**
+     * Registers a service with full configuration options.
+     * The service will be resolvable by both its class name and optional key.
+     *
+     * @param constructor - The service class constructor
+     * @param options - Registration configuration
+     */
+    register<T extends object>(constructor: Constructor<T>, options: RegistrationOptions): void;
+    /**
+     * Registers a service by its class type.
+     * The service will be resolvable by its class constructor.
+     *
+     * @param constructor - The service class constructor
+     * @param options - Optional registration configuration
+     */
+    registerByType<T extends object>(constructor: Constructor<T>, options?: RegistrationOptions): void;
+    private checkNameCollision;
+    private validateRegistration;
+    /**
+     * Attempts to retrieve a service registration.
+     * Returns undefined if the service is not registered.
+     *
+     * @param key - Either a string key or class constructor
+     * @returns The registration or undefined
+     */
+    tryGet<T extends object>(key: string | Constructor<T>): Registration | undefined;
+    /**
+     * Retrieves a service registration or throws if not found.
+     *
+     * @param key - Either a string key or class constructor
+     * @returns The registration
+     * @throws Error if the service is not registered
+     */
+    get<T extends object>(key: string | Constructor<T>): Registration;
+}
+/**
+ * IoC container that resolves and manages service instances.
+ * Creates instances based on registrations in a ServiceCollection,
+ * handling constructor injection, property injection, and lifetime management.
+ *
+ * Typically you'll use the global `container` instance rather than creating your own.
+ *
+ * @example
+ * // Resolve a service by class
+ * const logger = container.resolve(LoggerService);
+ *
+ * // Resolve by string key
+ * const cache = container.resolve<CacheService>('primaryCache');
+ *
+ * @example
+ * // Full setup workflow
+ * serviceCollection.register(UserService, {
+ *     inject: [DatabaseConnection],
+ *     scope: 'global'
+ * });
+ *
+ * const userService = container.resolve(UserService);
+ */
+export declare class ServiceContainer {
+    private serviceCollection;
+    private instances;
+    /**
+     * Creates a new container backed by the given service collection.
+     *
+     * @param serviceCollection - The registry containing service registrations
+     */
+    constructor(serviceCollection: ServiceCollection);
+    /**
+     * Resolves a service instance by class type or string key.
+     * Creates the instance if not already cached (for global scope).
+     * Handles constructor and property injection automatically.
+     *
+     * @param keyOrType - Either a string key or class constructor
+     * @returns The resolved service instance
+     * @throws Error if the service is not registered
+     *
+     * @example
+     * const service = container.resolve(MyService);
+     */
+    resolve<T extends object>(keyOrType: string | Constructor<T>): T;
+    /**
+     * Creates a new instance of a service, resolving all constructor dependencies.
+     */
+    private createInstance;
+    /**
+     * Injects dependencies into instance properties based on registration config.
+     */
+    private injectFields;
+}
+/**
+ * Global service collection instance for registering services.
+ * Use this to register services that can later be resolved by the container.
+ *
+ * @example
+ * import { serviceCollection } from 'relaxjs';
+ *
+ * serviceCollection.register(MyService, { inject: [Dependency] });
+ */
+export declare const serviceCollection: ServiceCollection;
+/**
+ * Global service container instance for resolving dependencies.
+ * Use this to obtain service instances with all dependencies injected.
+ *
+ * @example
+ * import { container } from 'relaxjs';
+ *
+ * const service = container.resolve(MyService);
+ */
+export declare const container: ServiceContainer;
+export {};

package/dist/DependencyInjectionOld.d.ts

@@ -0,0 +1,35 @@
+export type Constructor<T = object> = new (...args: any[]) => T;
+export declare function Inject<T>(keyOrType?: string | Constructor<T>): PropertyDecorator & ParameterDecorator;
+export interface RegistrationOptions {
+    scope?: ServiceScope;
+    key?: string;
+    instance?: unknown;
+}
+export declare function setDebugFunc(func: (...msg: any[]) => {}): void;
+export declare class ServiceCollection {
+    private servicesByKey;
+    private servicesByClassName;
+    register<T>(constructor: Constructor<T>, options: RegistrationOptions): void;
+    registerByType<T>(constructor: Constructor<T>, scope?: ServiceScope): void;
+    tryGet<T>(key: string | Constructor<T>): Registration | undefined;
+    get<T>(key: string | Constructor<T>): Registration;
+}
+export type ServiceScope = 'global' | 'closest';
+export declare function ContainerService<T>(key?: string, scope?: ServiceScope): (target: Constructor<T>) => void;
+export declare class ServiceContainer {
+    private instances;
+    private serviceCollection;
+    constructor(serviceCollection: ServiceCollection);
+    resolve<T>(keyOrType: string | Constructor<T>): T;
+    enrich<T>(instance: T): void;
+}
+export declare let serviceCollection: ServiceCollection;
+export declare let container: ServiceContainer;
+declare class Registration {
+    classConstructor: Constructor;
+    scope: ServiceScope;
+    key?: string;
+    instance?: unknown;
+    constructor(classConstructor: Constructor, scope: ServiceScope, key?: string, instance?: unknown);
+}
+export {};

package/dist/Metadata.d.ts

@@ -0,0 +1,8 @@
+import "reflect-metadata";
+interface MetadataHandler {
+    defineMetadata(metadataKey: string | symbol, value: any, target: object, propertyKey?: string | symbol): void;
+    getMetadata(metadataKey: string | symbol, target: object, propertyKey?: string | symbol): any;
+    hasMetadata(metadataKey: string | symbol, target: object, propertyKey?: string | symbol): boolean;
+}
+export declare const reflect: MetadataHandler;
+export {};

package/dist/SequentialId.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @module SequentialId
+ * Generates compact, time-ordered unique identifiers suitable for distributed systems.
+ *
+ * IDs are structured to be:
+ * - Unique across multiple clients (via baseId)
+ * - Time-sortable (timestamp is the most significant bits)
+ * - Compact (Base36 encoding produces short strings)
+ *
+ * Bit allocation (58 bits total):
+ * - 30 bits for timestamp (seconds since January 1, 2025)
+ * - 8 bits for per-second counter (supports 256 IDs/second)
+ * - 20 bits for client/endpoint identifier (supports ~1M unique sources)
+ */
+/**
+ * Generates a unique, time-ordered sequential ID.
+ *
+ * The ID combines a timestamp, per-second counter, and client identifier
+ * into a compact Base36 string. IDs generated later will sort after earlier IDs,
+ * making them suitable for ordered collections.
+ *
+ * @param baseId - Unique identifier for the client/endpoint (0 to 1,048,575).
+ *                 Use different baseIds for different servers or processes to
+ *                 avoid collisions.
+ * @returns Base36 encoded string representing the unique ID
+ * @throws Error if baseId is out of valid range
+ * @throws Error if more than 256 IDs are generated in a single second
+ * @throws Error if timestamp exceeds range (after year 2045)
+ *
+ * @example
+ * // Generate ID for server instance 1
+ * const id1 = generateSequentialId(1);
+ * // Returns something like: 'k2j8m3n5p'
+ *
+ * @example
+ * // Different servers use different baseIds
+ * const SERVER_ID = parseInt(process.env.SERVER_ID || '0');
+ * const orderId = generateSequentialId(SERVER_ID);
+ *
+ * @example
+ * // IDs are time-sortable
+ * const id1 = generateSequentialId(0);
+ * await delay(1000);
+ * const id2 = generateSequentialId(0);
+ * console.log(id1 < id2); // true (lexicographic comparison works)
+ */
+export declare function generateSequentialId(baseId: number): string;

package/dist/_alt/src/MustardEngine.d.ts

@@ -0,0 +1,30 @@
+import { CompiledTemplate } from './MustardParser';
+import { PipeRegistry } from './pipes';
+/**
+ * Main template engine that brings together parsing, rendering and pipe functions
+ * Use this as the main entry point for template operations
+ */
+export declare class Mustard {
+    private parser;
+    private pipeRegistry;
+    private templateCache;
+    constructor(customPipeRegistry?: PipeRegistry);
+    /**
+     * Render a template with the given context
+     */
+    render(template: string, context: Record<string, any>): string;
+    /**
+     * Get a compiled template function
+     */
+    getTemplate(template: string): CompiledTemplate;
+    /**
+     * Register a custom pipe function
+     */
+    registerPipe(name: string, fn: (value: any, ...args: any[]) => any): void;
+    /**
+     * Clear the template cache
+     */
+    clearCache(): void;
+}
+export declare function bindFunctions(context: Record<string, any>, functions: Record<string, Function>): Record<string, any>;
+export declare function createEngine(customPipes?: Record<string, (value: any, ...args: any[]) => any>): Mustard;