@bjoernboss/mws 1.0.0

package/LICENSE.txt

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2024-2026 Bjoern Boss Henrichsen
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,301 @@
+# MWS - Modular Web Server
+![TypeScript](https://img.shields.io/badge/language-TypeScript-blue?style=flat-square)
+[![License](https://img.shields.io/badge/license-BSD--3--Clause-brightgreen?style=flat-square)](LICENSE.txt)
+
+A lightweight TypeScript framework for hosting isolated modules behind HTTP/HTTPS and WebSocket endpoints. Each module owns a subtree in the URL space and is isolated from its siblings. Modules compose into trees for path-based routing, hostname routing, and request interception.
+
+The server integrates various automation features, such as error handling, validations, caching... Further, it contains integrated logging for proper connection tracing and logging.
+
+## Installation
+Only depends on [`ws`](https://github.com/websockets/ws) at runtime.
+
+	$ npm install @bjoernboss/mws
+
+Requires Node.js 22 or later.
+
+Note: Look into the source `TypeScript` code on [`GitHub`](https://github.com/BjoernBoss/mws).
+
+## Quick Start
+
+```typescript
+import { Server, ModuleHandler, ClientRequest, Media, addLogger, createConsoleLogger } from "@bjoernboss/mws";
+
+addLogger(createConsoleLogger());
+
+class HelloModule extends ModuleHandler {
+	constructor() {
+		super('hello');
+	}
+
+	protected override async handleRequest(client: ClientRequest): Promise<void> {
+		client.respond('Hello, World!', { media: Media.Text });
+	}
+}
+
+const server = new Server();
+server.listen(new HelloModule(), { port: 8080 });
+```
+
+For HTTPS, pass a TLS configuration:
+
+```typescript
+server.listen(new HelloModule(), {
+	port: 443,
+	tls: { key: './privkey.pem', cert: './fullchain.pem' }
+});
+```
+
+## Writing Modules
+
+A module extends `ModuleHandler` and implements up to three lifecycle hooks:
+
+```typescript
+import { ModuleHandler, ClientRequest, Server } from "@bjoernboss/mws";
+
+export class MyModule extends ModuleHandler {
+	constructor() {
+		super('my-module');
+	}
+
+	/* Called once when first attached to a server (directly or through a parent module) */
+	protected override async handleInitialize(server: Server): Promise<void> {
+		/* allocate resources, start timers */
+	}
+
+	/* Called for every incoming request routed to this module */
+	protected override async handleRequest(client: ClientRequest, params?: object): Promise<void> {
+		/* respond to the client */
+	}
+
+	/* Called once after the module has stopped and all clients have left;
+	   accepted WebSockets are still open and must be closed manually */
+	protected override async handleStop(): Promise<void> {
+		/* release resources, close WebSockets */
+	}
+}
+```
+
+Only `handleRequest` is required. Unhandled requests can be handled by parent modules or receive an automatic `404 Not Found`.
+
+Modules form a tree via `linkModule()`. They only ever see requests relative to their `root`. Path translation happens automatically when dispatching to children — client paths are rebased relative to each child module's position in the tree. A module can be linked to multiple parents and will only be initialized once, on first attachment to a server.
+
+### Header and HTML Patching
+
+Parent modules can register patches that modify outgoing headers or HTML pages before they are sent to the client:
+
+```typescript
+/* called just before headers are sent (in reverse registration order) */
+client.patchHeaders((status, headers) => {
+	headers['X-Custom'] = 'value';
+});
+
+/* called just before an HTML page is finalized (in reverse registration order) */
+client.patchHtmlPage(async (page, status, headers) => {
+	page.head.push(build.LoadScript('/analytics.js'));
+});
+```
+
+Patches are scoped to the current handler context and automatically removed when the handler returns.
+
+### Shutdown
+
+`server.stop()` waits for all active request handlers to complete before shutting down. Long-running handlers **must** check `client.claimed` or await `client.responded` to detect when the connection has been broken, and exit promptly.
+
+### Stopping Individual Modules
+
+Calling `module.stop()` detaches the module and waits for its active clients to drain. By default, a module stops automatically when all its parents unlink it; this can be disabled with `module.stopOnDetach(false)`.
+
+## Helper Modules
+
+Factory functions create common module patterns without subclassing:
+
+### dispatch — Path Routing
+
+Routes requests to children by longest URL path match. Stops itself once all children have been unlinked.
+
+```typescript
+import { Server, dispatch } from "@bjoernboss/mws";
+
+const server = new Server();
+server.listen(dispatch({
+	'/api': apiModule,
+	'/static': staticModule
+}), { port: 8080 });
+```
+
+### host — Hostname Routing
+
+Routes requests to children by longest hostname match (supports sub-domain matching).
+
+```typescript
+import { Server, host } from "@bjoernboss/mws";
+
+server.listen(host({
+	'api.example.com': apiModule,
+	'example.com': mainModule
+}), { port: 8080 });
+```
+
+### bind — Parameter and Translation Binding
+
+Forwards all requests to a single child handler, optionally injecting `params` and a path `translate` map.
+
+```typescript
+import { bind } from "@bjoernboss/mws";
+
+const bound = bind(myModule, {
+	params: { role: 'admin' },
+	translate: { '/v2': '/' }
+});
+```
+
+### check — Host and Port Validation
+
+Validates the request hostname and port before forwarding. Responds `404` and kills the connection on mismatch.
+
+```typescript
+import { check } from "@bjoernboss/mws";
+
+const checked = check(myModule, ['localhost', '127.0.0.1'], { port: 8080 });
+```
+
+### lambda — Callback-Based Handler
+
+Handles requests via callbacks instead of subclassing, with optional attached child modules.
+
+```typescript
+import { lambda, ClientRequest, Server, AttachedModule } from "@bjoernboss/mws";
+
+const handler = lambda({
+	attach: { api: apiModule },
+	setup: async function (server: Server, links: Record<string, AttachedModule>) {
+		/* runs on first attachment */
+	},
+	handle: async function (client: ClientRequest, params, links) {
+		if (client.isSubPathOf('/api'))
+			await links.api.handle(client, { translate: { '/api': '/' } });
+		else
+			client.respondNotFound();
+	},
+	stop: async function (links) {
+		/* cleanup */
+	}
+});
+```
+
+## Request Handling
+
+`ClientRequest` automatically manages requests to handle errors, prevent double-responses, and ensure expected HTTP behavior.
+
+### Receiving Data
+
+```typescript
+/* as a complete buffer */
+const data = await client.receiveAllBuffer(1_000_000);
+
+/* as a decoded string */
+const text = await client.receiveAllText('utf-8', 1_000_000);
+
+/* as a readable stream */
+const stream = client.receiveData(1_000_000);
+
+/* directly to a file (fails if the file already exists) */
+await client.receiveToFile('/uploads/file.bin', 10_000_000);
+```
+
+### Responding
+
+```typescript
+/* simple text or buffer */
+client.respond('OK', { media: Media.Text, status: Status.Ok });
+
+/* streaming response */
+const writer = client.respondData({ media: Media.Json, dynamicEncode: true });
+writer.end(JSON.stringify(data));
+
+/* file with automatic range requests, etag, last-modified, encoding, and caching */
+if (!await client.tryRespondFile('/var/www/index.html'))
+	client.respondNotFound();
+
+/* HTML page */
+await client.respondHtml(page, { status: Status.Ok });
+```
+
+Convenience methods: `respondOk`, `respondNotFound`, `respondBadRequest`, `respondForbidden`, `respondInternalError`, `respondConflict`, `respondSeeOther`, `respondTemporaryRedirect`, `respondPermanentRedirect`, `respondCreated`, and others.
+
+## WebSocket
+
+```typescript
+protected override async handleRequest(client: ClientRequest): Promise<void> {
+	const ws = await client.acceptWebSocket();
+	if (ws == null) return;
+
+	ws.on('data', (data: Buffer) => {
+		ws.send(data);
+	});
+	ws.on('close', () => {
+		/* cleanup */
+	});
+}
+```
+
+`ClientSocket` handles alive checks automatically via configurable ping/pong intervals (`ClientConfig.webSocketTimeout`, `ClientConfig.webSocketAliveTimeout`).
+
+Non-upgrade requests that reach `acceptWebSocket()` receive an automatic `426 Upgrade Required` response.
+
+## Caching
+
+`Server` provides integrated caching with a two-layer system:
+
+### In-Memory File Cache
+
+An LRU cache for frequently served files. Encoded variants (gzip, brotli, ...) are cached alongside the original.
+
+`client.tryRespondFile()` reads through this cache automatically.
+
+### Immutable Versioned Paths
+
+File paths can be tagged with a unique version identifier so clients can cache them immutably:
+
+```typescript
+/* style.css becomes style.<id>.css — the id changes when the file changes */
+const versionedPath = server.cache.immutable('my-handler', '/static/style.css');
+```
+
+When a request arrives for an immutable path, the cache strips the version tag, serves the underlying file, and redirects stale version tags to the current one. Set `CacheConfig.immutableStatePath` to persist version mappings across restarts.
+
+### Direct Cache Access
+
+```typescript
+const buffer = await server.cache.read('/path/to/data.json');
+await server.cache.write('/path/to/output.json', JSON.stringify(data));
+server.cache.flush();
+```
+
+## HTML Building
+
+The `build` namespace provides programmatic HTML construction with automatic escaping:
+
+```typescript
+import { build } from "@bjoernboss/mws";
+
+const page = new build.HtmlPage({
+	head: [
+		build.Title('My Page'),
+		build.Meta('viewport', 'width=device-width, initial-scale=1'),
+		build.LoadStyle('/style.css'),
+		build.LoadScript('/app.js', { defer: '' })
+	],
+	body: [
+		build.Div({ id: 'root' }, [
+			build.Text('Hello, World!')
+		])
+	]
+});
+```
+
+Plain strings passed as `HtmlString` values are automatically HTML-escaped. Use `build.Safe(content)` to mark trusted content that should not be escaped.
+
+## Internal Methods
+
+Methods prefixed with `_` (e.g. `_rootAttachToServer`, `_pushTranslation`, `_restoreSnapshot`) are framework-internal and **must not** be called by module implementations. They are `public` for cross-class access within the framework, but are not part of the public API and may change without notice.

package/dist/base.d.ts

@@ -0,0 +1,198 @@
+import * as libZlib from "zlib";
+import * as libStream from "stream";
+export interface StatusType {
+    code: number;
+    msg: string;
+}
+export declare const Status: {
+    readonly Ok: {
+        readonly code: 200;
+        readonly msg: "OK";
+    };
+    readonly Created: {
+        readonly code: 201;
+        readonly msg: "Created";
+    };
+    readonly PartialContent: {
+        readonly code: 206;
+        readonly msg: "Partial Content";
+    };
+    readonly SeeOther: {
+        readonly code: 303;
+        readonly msg: "See Other";
+    };
+    readonly NotModified: {
+        readonly code: 304;
+        readonly msg: "Not Modified";
+    };
+    readonly TemporaryRedirect: {
+        readonly code: 307;
+        readonly msg: "Temporary Redirect";
+    };
+    readonly PermanentRedirect: {
+        readonly code: 308;
+        readonly msg: "Permanent Redirect";
+    };
+    readonly BadRequest: {
+        readonly code: 400;
+        readonly msg: "Bad Request";
+    };
+    readonly Forbidden: {
+        readonly code: 403;
+        readonly msg: "Forbidden";
+    };
+    readonly NotFound: {
+        readonly code: 404;
+        readonly msg: "Not Found";
+    };
+    readonly MethodNotAllowed: {
+        readonly code: 405;
+        readonly msg: "Method Not Allowed";
+    };
+    readonly RequestTimeout: {
+        readonly code: 408;
+        readonly msg: "Request Timeout";
+    };
+    readonly Conflict: {
+        readonly code: 409;
+        readonly msg: "Conflict";
+    };
+    readonly PreconditionFailed: {
+        readonly code: 412;
+        readonly msg: "Precondition Failed";
+    };
+    readonly ContentTooLarge: {
+        readonly code: 413;
+        readonly msg: "Content Too Large";
+    };
+    readonly UnsupportedMediaType: {
+        readonly code: 415;
+        readonly msg: "Unsupported Media Type";
+    };
+    readonly RangeIssue: {
+        readonly code: 416;
+        readonly msg: "Range Not Satisfiable";
+    };
+    readonly UpgradeRequired: {
+        readonly code: 426;
+        readonly msg: "Upgrade Required";
+    };
+    readonly InternalError: {
+        readonly code: 500;
+        readonly msg: "Internal Server Error";
+    };
+};
+export interface MediaType {
+    fileEnding: string[];
+    mediaType: string;
+    encoding: string;
+    compressible: boolean;
+}
+export declare const Media: {
+    readonly Html: {
+        readonly fileEnding: ["html"];
+        readonly mediaType: "text/html";
+        readonly encoding: "charset=utf-8";
+        readonly compressible: true;
+    };
+    readonly Css: {
+        readonly fileEnding: ["css"];
+        readonly mediaType: "text/css";
+        readonly encoding: "charset=utf-8";
+        readonly compressible: true;
+    };
+    readonly JavaScript: {
+        readonly fileEnding: ["js"];
+        readonly mediaType: "text/javascript";
+        readonly encoding: "charset=utf-8";
+        readonly compressible: true;
+    };
+    readonly Text: {
+        readonly fileEnding: ["txt", "text"];
+        readonly mediaType: "text/plain";
+        readonly encoding: "charset=utf-8";
+        readonly compressible: true;
+    };
+    readonly Json: {
+        readonly fileEnding: ["json"];
+        readonly mediaType: "application/json";
+        readonly encoding: "charset=utf-8";
+        readonly compressible: true;
+    };
+    readonly Mp4: {
+        readonly fileEnding: ["mp4"];
+        readonly mediaType: "video/mp4";
+        readonly encoding: "";
+        readonly compressible: false;
+    };
+    readonly Png: {
+        readonly fileEnding: ["png"];
+        readonly mediaType: "image/png";
+        readonly encoding: "";
+        readonly compressible: false;
+    };
+    readonly Gif: {
+        readonly fileEnding: ["gif"];
+        readonly mediaType: "image/gif";
+        readonly encoding: "";
+        readonly compressible: false;
+    };
+    readonly Jpg: {
+        readonly fileEnding: ["jpg", "jpeg"];
+        readonly mediaType: "image/jpeg";
+        readonly encoding: "";
+        readonly compressible: false;
+    };
+    readonly Svg: {
+        readonly fileEnding: ["svg"];
+        readonly mediaType: "image/svg+xml";
+        readonly encoding: "";
+        readonly compressible: true;
+    };
+    readonly Unknown: {
+        readonly fileEnding: [];
+        readonly mediaType: "application/octet-stream";
+        readonly encoding: "";
+        readonly compressible: false;
+    };
+};
+export interface EncodingType {
+    name: string;
+    makeDecode(): libStream.Transform;
+    makeEncode(): libStream.Transform;
+    encodeBuffer(buffer: Buffer): Buffer;
+}
+export declare const Encoding: {
+    readonly Br: {
+        readonly name: "br";
+        readonly makeDecode: () => libZlib.BrotliDecompress;
+        readonly makeEncode: () => libZlib.BrotliCompress;
+        readonly encodeBuffer: (buffer: Buffer) => NonSharedBuffer;
+    };
+    readonly Zstd: {
+        readonly name: "zstd";
+        readonly makeDecode: () => libZlib.ZstdDecompress;
+        readonly makeEncode: () => libZlib.ZstdCompress;
+        readonly encodeBuffer: (buffer: Buffer) => NonSharedBuffer;
+    };
+    readonly Gzip: {
+        readonly name: "gzip";
+        readonly makeDecode: () => libZlib.Gunzip;
+        readonly makeEncode: () => libZlib.Gzip;
+        readonly encodeBuffer: (buffer: Buffer) => NonSharedBuffer;
+    };
+    readonly Deflate: {
+        readonly name: "deflate";
+        readonly makeDecode: () => libZlib.Inflate;
+        readonly makeEncode: () => libZlib.Deflate;
+        readonly encodeBuffer: (buffer: Buffer) => NonSharedBuffer;
+    };
+    readonly Identity: {
+        readonly name: "identity";
+        readonly makeDecode: () => libStream.PassThrough;
+        readonly makeEncode: () => libStream.PassThrough;
+        readonly encodeBuffer: (buffer: Buffer) => Buffer<ArrayBufferLike>;
+    };
+};
+export declare const MIN_ENCODING_SIZE: number;
+//# sourceMappingURL=base.d.ts.map

package/dist/base.js

@@ -0,0 +1,73 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
+/* Copyright (c) 2026 Bjoern Boss Henrichsen */
+import * as libZlib from "zlib";
+import * as libStream from "stream";
+export const Status = {
+    Ok: { code: 200, msg: 'OK' },
+    Created: { code: 201, msg: 'Created' },
+    PartialContent: { code: 206, msg: 'Partial Content' },
+    SeeOther: { code: 303, msg: 'See Other' },
+    NotModified: { code: 304, msg: 'Not Modified' },
+    TemporaryRedirect: { code: 307, msg: 'Temporary Redirect' },
+    PermanentRedirect: { code: 308, msg: 'Permanent Redirect' },
+    BadRequest: { code: 400, msg: 'Bad Request' },
+    Forbidden: { code: 403, msg: 'Forbidden' },
+    NotFound: { code: 404, msg: 'Not Found' },
+    MethodNotAllowed: { code: 405, msg: 'Method Not Allowed' },
+    RequestTimeout: { code: 408, msg: 'Request Timeout' },
+    Conflict: { code: 409, msg: 'Conflict' },
+    PreconditionFailed: { code: 412, msg: 'Precondition Failed' },
+    ContentTooLarge: { code: 413, msg: 'Content Too Large' },
+    UnsupportedMediaType: { code: 415, msg: 'Unsupported Media Type' },
+    RangeIssue: { code: 416, msg: 'Range Not Satisfiable' },
+    UpgradeRequired: { code: 426, msg: 'Upgrade Required' },
+    InternalError: { code: 500, msg: 'Internal Server Error' }
+};
+export const Media = {
+    Html: { fileEnding: ['html'], mediaType: 'text/html', encoding: 'charset=utf-8', compressible: true },
+    Css: { fileEnding: ['css'], mediaType: 'text/css', encoding: 'charset=utf-8', compressible: true },
+    JavaScript: { fileEnding: ['js'], mediaType: 'text/javascript', encoding: 'charset=utf-8', compressible: true },
+    Text: { fileEnding: ['txt', 'text'], mediaType: 'text/plain', encoding: 'charset=utf-8', compressible: true },
+    Json: { fileEnding: ['json'], mediaType: 'application/json', encoding: 'charset=utf-8', compressible: true },
+    Mp4: { fileEnding: ['mp4'], mediaType: 'video/mp4', encoding: '', compressible: false },
+    Png: { fileEnding: ['png'], mediaType: 'image/png', encoding: '', compressible: false },
+    Gif: { fileEnding: ['gif'], mediaType: 'image/gif', encoding: '', compressible: false },
+    Jpg: { fileEnding: ['jpg', 'jpeg'], mediaType: 'image/jpeg', encoding: '', compressible: false },
+    Svg: { fileEnding: ['svg'], mediaType: 'image/svg+xml', encoding: '', compressible: true },
+    Unknown: { fileEnding: [], mediaType: 'application/octet-stream', encoding: '', compressible: false }
+};
+export const Encoding = {
+    Br: {
+        name: 'br',
+        makeDecode: () => libZlib.createBrotliDecompress(),
+        makeEncode: () => libZlib.createBrotliCompress(),
+        encodeBuffer: (buffer) => libZlib.brotliCompressSync(buffer)
+    },
+    Zstd: {
+        name: 'zstd',
+        makeDecode: () => libZlib.createZstdDecompress(),
+        makeEncode: () => libZlib.createZstdCompress(),
+        encodeBuffer: (buffer) => libZlib.zstdCompressSync(buffer)
+    },
+    Gzip: {
+        name: 'gzip',
+        makeDecode: () => libZlib.createGunzip(),
+        makeEncode: () => libZlib.createGzip(),
+        encodeBuffer: (buffer) => libZlib.gzipSync(buffer)
+    },
+    Deflate: {
+        name: 'deflate',
+        makeDecode: () => libZlib.createInflate(),
+        makeEncode: () => libZlib.createDeflate(),
+        encodeBuffer: (buffer) => libZlib.deflateSync(buffer)
+    },
+    Identity: {
+        name: 'identity',
+        makeDecode: () => new libStream.PassThrough(),
+        makeEncode: () => new libStream.PassThrough(),
+        encodeBuffer: (buffer) => buffer
+    }
+};
+/* minimum size for content is considered encodable */
+export const MIN_ENCODING_SIZE = 1_000;
+//# sourceMappingURL=base.js.map

package/dist/builder.d.ts

@@ -0,0 +1,58 @@
+export type HtmlString = HtmlGuard | string;
+export declare class HtmlGuard {
+    content: string;
+    private constructor();
+    static get(str: HtmlString): HtmlGuard;
+    static make(str: string, safe: boolean): HtmlGuard;
+}
+export declare function Safe(content: string, safe?: boolean): HtmlGuard;
+export interface HtmlComponent {
+    finalize(indent: string): string;
+    simple(): boolean;
+}
+export declare class EmbeddedContent implements HtmlComponent {
+    private content;
+    constructor(content: string, safe: boolean);
+    simple(): boolean;
+    finalize(_: string): string;
+}
+export declare class SingleTag implements HtmlComponent {
+    private content;
+    constructor(name: string, properties: Record<string, HtmlString>);
+    simple(): boolean;
+    finalize(indent: string): string;
+}
+export declare class DualTag implements HtmlComponent {
+    private openTag;
+    private closeTag;
+    private children;
+    constructor(name: string, properties: Record<string, HtmlString>, children: HtmlComponent[] | HtmlComponent);
+    simple(): boolean;
+    finalize(indent: string): string;
+}
+export declare class HtmlPage {
+    private _head;
+    private _body;
+    language: HtmlString;
+    constructor(options?: {
+        language?: HtmlString;
+        head?: HtmlComponent[] | HtmlComponent;
+        body?: HtmlComponent[] | HtmlComponent;
+    });
+    get head(): HtmlComponent[];
+    set head(value: HtmlComponent | HtmlComponent[]);
+    get body(): HtmlComponent[];
+    set body(value: HtmlComponent | HtmlComponent[]);
+    finalize(): string;
+}
+export declare function Embed(content: string, safe: boolean): HtmlComponent;
+export declare function Meta(name: HtmlString, content: HtmlString): HtmlComponent;
+export declare function Title(name: HtmlString): HtmlComponent;
+export declare function LoadStyle(path: HtmlString): HtmlComponent;
+export declare function LoadScript(path: HtmlString, properties?: Record<string, HtmlString>): HtmlComponent;
+export declare function AddStyle(content: string, properties?: Record<string, HtmlString>): HtmlComponent;
+export declare function AddScript(content: string, properties?: Record<string, HtmlString>): HtmlComponent;
+export declare function Text(text: HtmlString, properties?: Record<string, HtmlString>): HtmlComponent;
+export declare function Div(properties?: Record<string, HtmlString>, children?: HtmlComponent[] | HtmlComponent): HtmlComponent;
+export declare function LoadingError(): HtmlComponent;
+//# sourceMappingURL=builder.d.ts.map