@relax.js/core 1.0.0

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

@@ -0,0 +1,63 @@
+type Token = TextToken | VariableToken | FunctionToken;
+type TokenType = 'text' | 'variable' | 'function';
+interface BaseToken {
+    type: TokenType;
+    value: string;
+}
+interface TextToken extends BaseToken {
+    type: 'text';
+}
+interface VariableToken extends BaseToken {
+    type: 'variable';
+    path: string[];
+    pipes: string[];
+}
+interface FunctionToken extends BaseToken {
+    type: 'function';
+    name: string;
+    params: string[];
+    pipes: string[];
+}
+export type CompiledTemplate = (context: Record<string, any>, pipeFunctions?: PipeFunctions) => string;
+type PipeFunctions = Record<string, (value: any, ...args: any[]) => any>;
+export declare class MustacheParser {
+    private static readonly TAG_REGEX;
+    private static readonly FUNCTION_REGEX;
+    private static readonly PIPE_DELIMITER;
+    private static readonly PATH_DELIMITER;
+    private cache;
+    /**
+     * Parse a template string into tokens
+     */
+    parse(template: string): Token[];
+    /**
+     * Parse a single tag into a token
+     */
+    private parseTag;
+    /**
+     * Compile a template string into a function
+     */
+    compile(template: string): CompiledTemplate;
+    /**
+     * Render a single token with the given context
+     */
+    private renderToken;
+    /**
+     * Execute a function from the context
+     */
+    private executeFunction;
+    /**
+     * Apply pipe transformations to a value
+     */
+    private applyPipes;
+    /**
+     * Clear the parser cache
+     */
+    clearCache(): void;
+}
+export declare class TemplateError extends Error {
+    token?: Token;
+    constructor(message: string, token?: Token);
+}
+export declare const createTemplate: (template: string) => CompiledTemplate;
+export {};

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

@@ -0,0 +1,35 @@
+/**
+ * Represents an argument in a template function
+ * @typedef ArgumentType - Can be a string, number, or variable reference
+ */
+export type CurlyTokenType = {
+    type: 'string';
+    value: string;
+} | {
+    type: 'number';
+    value: number;
+} | {
+    type: 'variable';
+    name: string;
+};
+/**
+ * Represents a part of the template
+ */
+export type CurlyToken = {
+    type: 'text';
+    content: string;
+} | {
+    type: 'variable';
+    name: string;
+    pipes: string[];
+} | {
+    type: 'function';
+    signature: string;
+    pipes: string[];
+};
+/**
+ * Parses a template string and extracts parts
+ * @param templateString - String with template variables in {{variable|pipe}} format
+ * @returns Array of parsed parts (text, variable, or function)
+ */
+export declare function parseCurly(templateString: string): CurlyToken[];

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

@@ -0,0 +1,93 @@
+export type PipeFunction = (value: any, ...args: any[]) => any;
+/**
+ * Converts a string to uppercase
+ * @param value The string to convert
+ * @returns The uppercase string
+ */
+export declare function uppercasePipe(value: string): string;
+/**
+ * Converts a string to lowercase
+ * @param value The string to convert
+ * @returns The lowercase string
+ */
+export declare function lowercasePipe(value: string): string;
+/**
+ * Capitalizes the first character of a string
+ * @param value The string to capitalize
+ * @returns The capitalized string
+ */
+export declare function capitalizePipe(value: string): string;
+/**
+ * Truncates a string to a specified length and adds ellipsis
+ * @param value The string to truncate
+ * @param length Maximum length before truncation
+ * @returns The truncated string with ellipsis if needed
+ */
+export declare function truncatePipe(value: string, length: string): string;
+/**
+ * Formats a number as USD currency
+ * @param value The number to format
+ * @returns Formatted currency string
+ */
+export declare function currencyPipe(value: number): string;
+/**
+ * Formats a date value according to the specified format
+ * @param value Date value (string, number, or Date object)
+ * @param format Format type: 'short', 'long', or default (ISO)
+ * @returns Formatted date string
+ */
+export declare function datePipe(value: string | number | Date, format?: string): string;
+/**
+ * Joins array elements with the specified separator
+ * @param value Array to join
+ * @param separator Character(s) to use between elements (defaults to comma)
+ * @returns Joined string or original value if not an array
+ */
+export declare function joinPipe(value: any[], separator?: string): string | any;
+/**
+ * Returns the first element of an array
+ * @param value Array to extract from
+ * @returns First element or empty string if array is empty/invalid
+ */
+export declare function firstPipe(value: any[]): any;
+/**
+ * Returns the last element of an array
+ * @param value Array to extract from
+ * @returns Last element or empty string if array is empty/invalid
+ */
+export declare function lastPipe(value: any[]): any;
+/**
+ * Returns the keys of an object
+ * @param value Object to extract keys from
+ * @returns Array of object keys or empty array if not an object
+ */
+export declare function keysPipe(value: object): string[];
+/**
+ * Returns a default value if the input is falsy
+ * @param value Input value to check
+ * @param defaultValue Value to return if input is falsy
+ * @returns Original value or default value
+ */
+export declare function defaultPipe(value: any, defaultValue: string): any;
+/**
+ * Implements ternary operator as a pipe
+ * @param value Condition to evaluate
+ * @param trueValue Value to return if condition is truthy
+ * @param falseValue Value to return if condition is falsy
+ * @returns Selected value based on condition
+ */
+export declare function ternaryPipe(value: any, trueValue: string, falseValue: string): string;
+/**
+ * Creates and returns a map of all available pipe functions
+ * @returns Map of pipe name to pipe function
+ */
+export declare function createPipeRegistry(): Map<string, PipeFunction>;
+export declare const defaultPipes: Map<string, PipeFunction>;
+/**
+ * Applies a series of pipes to a value
+ * @param value Initial value to transform
+ * @param pipes Array of pipe strings (name and optional arguments separated by ':')
+ * @param pipeFunctions Optional custom pipe registry (uses defaultPipes if not provided)
+ * @returns The transformed value after applying all pipes
+ */
+export declare function applyPipes(value: any, pipes: string[], pipeFunctions?: Map<string, PipeFunction>): any;

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

@@ -0,0 +1,166 @@
+/**
+ * @module Template
+ * A lightweight DOM-based template engine inspired by Mustache/Handlebars but with enhanced
+ * functionality for direct DOM manipulation without virtual DOM overhead.
+ *
+ * Design philosophy:
+ * - Keep DOM references intact during updates instead of replacing elements
+ * - Enable fine-grained binding at the attribute and text node level
+ * - Support component-like patterns with function calls and pipes
+ * - Provide conditional rendering and iteration with minimal syntax
+ */
+/**
+ * Typed representation of arguments in template function calls
+ * Used during parsing to distinguish between literal values and variable references
+ * before they're resolved against the actual data context
+ */
+export type CurlyTokenType = {
+    type: 'string';
+    value: string;
+} | {
+    type: 'number';
+    value: number;
+} | {
+    type: 'variable';
+    name: string;
+};
+/**
+ * Internal AST (Abstract Syntax Tree) nodes for template parsing
+ * Each token represents a distinct part of the template with its own rendering logic
+ */
+export type CurlyToken = {
+    type: 'text';
+    content: string;
+} | {
+    type: 'variable';
+    name: string;
+    pipes: string[];
+} | {
+    type: 'function';
+    signature: string;
+    pipes: string[];
+};
+/**
+ * Tokenizes a template string into a sequence of text and expression tokens
+ * Functions as the lexical analyzer in the template compilation process
+ * @param templateString - Raw template string with embedded expressions
+ * @returns AST nodes representing the template structure
+ */
+export declare function parseCurly(templateString: string): CurlyToken[];
+/**
+ * Orchestrates the DOM traversal and binding process
+ * Acts as a registry for all data and initialization callbacks
+ * that will be triggered when template is rendered
+ */
+export interface ParserContext {
+    currentNode: Node;
+    nodePath: number[];
+    getNodePath(node: Node): number[];
+    traverseNode(node: Node): void;
+    traverseChildren(node: Node): void;
+    /**
+     * Binds initialization callbacks to be executed after node structure is created
+     * @param callback - Function to run during initialization phase
+     */
+    bindInit(callback: TemplateCallback): void;
+    /**
+     * Binds data update callbacks to refresh nodes when data changes
+     * @param callback - Function to run when data is updated
+     */
+    bindData(callback: TemplateCallback): void;
+}
+/**
+ * Control flow enum for DOM traversal
+ * Allows processors to guide how traversal continues after their execution,
+ * enabling efficient skipping of branches or preventing double-processing
+ */
+export declare enum NodeProcessorResult {
+    /**
+     * Stop processing the current node, as it was fully handled
+     */
+    Stop = 0,
+    /**
+     * Process attributes but skip child nodes
+     */
+    VisitAttributesOnly = 1,
+    /**
+     * Continue normal processing (process this node and its children)
+     */
+    Continue = 2
+}
+/**
+ * Node processors form the plugin architecture of the template system
+ * Each processor examines a node for specific binding patterns and registers
+ * appropriate callbacks when matches are found
+ * @param node - Current DOM node in traversal
+ * @param context - Context for registering bindings
+ * @returns Flow control directive for traversal
+ */
+export type NodeProcessor = (node: Node, context: ParserContext) => NodeProcessorResult;
+/**
+ * Two-tiered data context for template rendering
+ * Separates component-level data (methods, properties) from
+ * template-specific data (like loop variables and conditionals)
+ */
+export interface TemplateContext {
+    node: Node;
+    component: object;
+    data: object;
+    getNode(path: number[]): Node;
+}
+/**
+ * Main entry point and API facade for the template engine
+ * Name is a playful reference to "cutting the mustard" - a progressive enhancement technique
+ * Processes templates through all registered binders in sequence
+ * @param htmlOrNode - Raw template input (string or DOM)
+ * @returns Compiled template ready for data binding
+ */
+export declare function beTheMustard(htmlOrNode: string | Node): Template;
+/**
+ * Compiles a template string into an executable rendering function
+ * Processes nested expressions and builds a composite renderer from individual part handlers
+ * Represents the core template compilation process
+ * @param text - Raw template string with expressions
+ * @returns Compiled rendering function
+ */
+export declare function createCallbackFromMustard(text: string): TemplateCallback;
+/**
+ * Processes element attributes for data binding expressions
+ * Handles both function calls and curly syntax in attributes
+ * @param node - DOM node to process
+ * @param parserContext - Parser context for callback registration
+ * @returns Processing directive for traversal control
+ */
+export declare function dataAttributeBinder(node: Node, parserContext: ParserContext): NodeProcessorResult;
+/**
+ * Function type for template rendering callbacks
+ * Takes a context (data + component) and produces output
+ */
+export type TemplateCallback = (ctx: TemplateContext) => any;
+/**
+ * Main template class that manages binding and rendering
+ * Acts as the primary interface for template usage
+ */
+export declare class Template {
+    element: HTMLElement;
+    private functionBinders;
+    private dataAssigners;
+    /**
+     * Creates a new template instance
+     * @param element - Root DOM element for this template
+     * @param context - Either a ParserContext from parsing or another Template for cloning
+     */
+    constructor(element: HTMLElement, context: ParserContext | Template);
+    /**
+     * Binds data to the template, triggering all data update callbacks
+     * @param data - Data context containing component and data objects
+     */
+    bind(data: TemplateContext): void;
+    /**
+     * Creates a clone of this template with a new root element
+     * Preserves all bindings and callbacks
+     * @param clonedElement - New element to use as root for the clone
+     * @returns New template instance with same bindings
+     */
+    clone(clonedElement: HTMLElement): Template;
+}

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

@@ -0,0 +1,4 @@
+/**
+ * Resolve a value from the context using a path array
+ */
+export declare function resolveValue(path: string[], context: Record<string, any>): any | undefined;

package/dist/_alt/tests/pipes.tests.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/_alt/tests/template.tests.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/_alt/vitest.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vite").UserConfig;
+export default _default;

package/dist/collections/Index.d.ts

@@ -0,0 +1 @@
+export { LinkedList, Node } from "./LinkedList";

package/dist/collections/LinkedList.d.ts

@@ -0,0 +1,75 @@
+/**
+ * A node in the @see LinkedList.
+ */
+export declare class Node<T> {
+    value: T;
+    private removeCallback;
+    /**
+     * Next node unless last one.
+     */
+    next: Node<T> | null;
+    /**
+     * Previous node unless first one.
+     */
+    prev: Node<T> | null;
+    /**
+     * Constructor.
+     * @param value Value contained in the node.
+     */
+    constructor(value: T, removeCallback: () => void);
+    /**
+     * Remove this node.
+     * Will notify the list of the update to ensure correct element count.
+     */
+    remove(): void;
+}
+/**
+ * A trivial linked list implementation.
+ */
+export declare class LinkedList<T> {
+    private _first?;
+    private _last?;
+    private _length;
+    /**
+     * Add a value to the beginning of the list.
+     * @param value Value that should be contained in the node.
+     */
+    addFirst(value: T): void;
+    /**
+     * Add a value to the end of the list.
+     * @param value Value that should be contained in a node.
+     */
+    addLast(value: T): void;
+    /**
+     * Remove a node from the beginning of the list.
+     * @returns Value contained in the first node.
+     */
+    removeFirst(): T;
+    /**
+     * Remove a node from the end of the list.
+     * @returns Value contained in the last node.
+     */
+    removeLast(): T;
+    /**
+     * Number of nodes in the list.
+     *
+     * The count works as long as you do not manually remove nodes (by assigning next/prev to the neighbors).
+     */
+    get length(): number;
+    /**
+     * First ndoe.
+     */
+    get first(): Node<T> | undefined;
+    /**
+     * Contained value of the first node.
+     */
+    get firstValue(): T | undefined;
+    /**
+     * Last node.
+     */
+    get last(): Node<T> | undefined;
+    /**
+     * Contained value of the last node.
+     */
+    get lastValue(): T | undefined;
+}

package/dist/collections/Pager.d.ts

@@ -0,0 +1,15 @@
+export declare class PageSelectedEvent extends CustomEvent<number> {
+    page: number;
+    constructor(page: number);
+}
+export declare class Pager {
+    private container;
+    private totalCount;
+    private pageSize;
+    private currentPage;
+    constructor(container: HTMLElement, totalCount: number, pageSize: number);
+    private render;
+    private selectPage;
+    update(totalCount: number): void;
+    getCurrentPage(): number;
+}

package/dist/collections/index.js

@@ -0,0 +1,2 @@
+var h=Object.defineProperty;var a=Object.getOwnPropertyDescriptor;var _=Object.getOwnPropertyNames;var u=Object.prototype.hasOwnProperty;var o=(s,t)=>{for(var e in t)h(s,e,{get:t[e],enumerable:!0})},f=(s,t,e,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let r of _(t))!u.call(s,r)&&r!==e&&h(s,r,{get:()=>t[r],enumerable:!(n=a(t,r))||n.enumerable});return s};var v=s=>f(h({},"__esModule",{value:!0}),s);var d={};o(d,{LinkedList:()=>l,Node:()=>i});module.exports=v(d);var i=class{constructor(t,e){this.value=t;this.removeCallback=e;this.next=null;this.prev=null}remove(){this.prev.next=this.next,this.next.prev=this.prev,this.removeCallback()}},l=class{constructor(){this._length=0}addFirst(t){let e=new i(t,()=>this._length--);this._first?(e.next=this._first,this._first.prev=e,this._first=e):(this._first=e,this._last=this._first),this._length++}addLast(t){let e=new i(t,()=>this._length--);this._first?(e.prev=this._last,this._last.next=e,this._last=e):(this._first=e,this._last=this._first),this._length++}removeFirst(){if(!this.first)throw new Error("The list is empty.");let t=this._first.value;return this._first=this._first.next,this._length--,t}removeLast(){if(!this.last)throw new Error("The list is empty.");let t=this._last.value;return this._last=this._last.prev,this._length--,t}get length(){return this._length}get first(){return this._first}get firstValue(){return this._first?.value}get last(){return this._last}get lastValue(){return this._last?.value}};
+//# sourceMappingURL=index.js.map

package/dist/collections/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/collections/Index.ts", "../../src/collections/LinkedList.ts"],
+  "sourcesContent": ["export {LinkedList, Node} from \"./LinkedList\";", "/**\r\n * A node in the @see LinkedList.\r\n */\r\nexport class Node<T> {\r\n    /**\r\n     * Next node unless last one.\r\n     */\r\n    public next: Node<T> | null = null;\r\n    /**\r\n     * Previous node unless first one.\r\n     */\r\n    public prev: Node<T> | null = null;\r\n\r\n    /**\r\n     * Constructor.\r\n     * @param value Value contained in the node.\r\n     */\r\n    constructor(public value: T, private removeCallback: () => void) {}\r\n\r\n    /**\r\n     * Remove this node.\r\n     * Will notify the list of the update to ensure correct element count.\r\n     */\r\n    remove() {\r\n        this.prev.next = this.next;\r\n        this.next.prev = this.prev;\r\n        this.removeCallback();\r\n    }\r\n}\r\n\r\n/**\r\n * A trivial linked list implementation.\r\n */\r\nexport class LinkedList<T> {\r\n    private _first?: Node<T>;\r\n    private _last?: Node<T>;\r\n    private _length = 0;\r\n\r\n    /**\r\n     * Add a value to the beginning of the list.\r\n     * @param value Value that should be contained in the node.\r\n     */\r\n    addFirst(value: T) {\r\n        const newNode = new Node(value, () => this._length--);\r\n        if (!this._first) {\r\n            this._first = newNode;\r\n            this._last = this._first;\r\n        } else {\r\n            newNode.next = this._first;\r\n            this._first.prev = newNode;\r\n            this._first = newNode;\r\n        }\r\n\r\n        this._length++;\r\n    }\r\n\r\n    /**\r\n     * Add a value to the end of the list.\r\n     * @param value Value that should be contained in a node.\r\n     */\r\n    addLast(value: T) {\r\n        const newNode = new Node(value, () => this._length--);\r\n        if (!this._first) {\r\n            this._first = newNode;\r\n            this._last = this._first;\r\n        } else {\r\n            newNode.prev = this._last;\r\n            this._last.next = newNode;\r\n            this._last = newNode;\r\n        }\r\n\r\n        this._length++;\r\n    }\r\n\r\n    /**\r\n     * Remove a node from the beginning of the list.\r\n     * @returns Value contained in the first node.\r\n     */\r\n    removeFirst(): T {\r\n        if (!this.first) {\r\n            throw new Error('The list is empty.');\r\n        }\r\n\r\n        const value = this._first.value;\r\n        this._first = this._first.next;\r\n        this._length--;\r\n        return value;\r\n    }\r\n\r\n    /**\r\n     * Remove a node from the end of the list.\r\n     * @returns Value contained in the last node.\r\n     */\r\n    removeLast(): T {\r\n        if (!this.last) {\r\n            throw new Error('The list is empty.');\r\n        }\r\n\r\n        const value = this._last.value;\r\n        this._last = this._last.prev;\r\n        this._length--;\r\n        return value;\r\n    }\r\n\r\n    /**\r\n     * Number of nodes in the list.\r\n     *\r\n     * The count works as long as you do not manually remove nodes (by assigning next/prev to the neighbors).\r\n     */\r\n    get length(): number {\r\n        return this._length;\r\n    }\r\n\r\n    /**\r\n     * First ndoe.\r\n     */\r\n    get first(): Node<T> | undefined {\r\n        return this._first;\r\n    }\r\n\r\n    /**\r\n     * Contained value of the first node.\r\n     */\r\n    get firstValue(): T | undefined {\r\n        return this._first?.value;\r\n    }\r\n\r\n    /**\r\n     * Last node.\r\n     */\r\n    get last(): Node<T> | undefined {\r\n        return this._last;\r\n    }\r\n\r\n    /**\r\n     * Contained value of the last node.\r\n     */\r\n    get lastValue(): T | undefined {\r\n        return this._last?.value;\r\n    }\r\n}\r\n"],
+  "mappings": "4ZAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,gBAAAE,EAAA,SAAAC,IAAA,eAAAC,EAAAJ,GCGO,IAAMK,EAAN,KAAc,CAcjB,YAAmBC,EAAkBC,EAA4B,CAA9C,WAAAD,EAAkB,oBAAAC,EAVrC,KAAO,KAAuB,KAI9B,KAAO,KAAuB,IAMoC,CAMlE,QAAS,CACL,KAAK,KAAK,KAAO,KAAK,KACtB,KAAK,KAAK,KAAO,KAAK,KACtB,KAAK,eAAe,CACxB,CACJ,EAKaC,EAAN,KAAoB,CAApB,cAGH,KAAQ,QAAU,EAMlB,SAASF,EAAU,CACf,IAAMG,EAAU,IAAIJ,EAAKC,EAAO,IAAM,KAAK,SAAS,EAC/C,KAAK,QAING,EAAQ,KAAO,KAAK,OACpB,KAAK,OAAO,KAAOA,EACnB,KAAK,OAASA,IALd,KAAK,OAASA,EACd,KAAK,MAAQ,KAAK,QAOtB,KAAK,SACT,CAMA,QAAQH,EAAU,CACd,IAAMG,EAAU,IAAIJ,EAAKC,EAAO,IAAM,KAAK,SAAS,EAC/C,KAAK,QAING,EAAQ,KAAO,KAAK,MACpB,KAAK,MAAM,KAAOA,EAClB,KAAK,MAAQA,IALb,KAAK,OAASA,EACd,KAAK,MAAQ,KAAK,QAOtB,KAAK,SACT,CAMA,aAAiB,CACb,GAAI,CAAC,KAAK,MACN,MAAM,IAAI,MAAM,oBAAoB,EAGxC,IAAMH,EAAQ,KAAK,OAAO,MAC1B,YAAK,OAAS,KAAK,OAAO,KAC1B,KAAK,UACEA,CACX,CAMA,YAAgB,CACZ,GAAI,CAAC,KAAK,KACN,MAAM,IAAI,MAAM,oBAAoB,EAGxC,IAAMA,EAAQ,KAAK,MAAM,MACzB,YAAK,MAAQ,KAAK,MAAM,KACxB,KAAK,UACEA,CACX,CAOA,IAAI,QAAiB,CACjB,OAAO,KAAK,OAChB,CAKA,IAAI,OAA6B,CAC7B,OAAO,KAAK,MAChB,CAKA,IAAI,YAA4B,CAC5B,OAAO,KAAK,QAAQ,KACxB,CAKA,IAAI,MAA4B,CAC5B,OAAO,KAAK,KAChB,CAKA,IAAI,WAA2B,CAC3B,OAAO,KAAK,OAAO,KACvB,CACJ",
+  "names": ["Index_exports", "__export", "LinkedList", "Node", "__toCommonJS", "Node", "value", "removeCallback", "LinkedList", "newNode"]
+}

package/dist/collections/index.mjs

@@ -0,0 +1,2 @@
+var s=class{constructor(e,t){this.value=e;this.removeCallback=t;this.next=null;this.prev=null}remove(){this.prev.next=this.next,this.next.prev=this.prev,this.removeCallback()}},i=class{constructor(){this._length=0}addFirst(e){let t=new s(e,()=>this._length--);this._first?(t.next=this._first,this._first.prev=t,this._first=t):(this._first=t,this._last=this._first),this._length++}addLast(e){let t=new s(e,()=>this._length--);this._first?(t.prev=this._last,this._last.next=t,this._last=t):(this._first=t,this._last=this._first),this._length++}removeFirst(){if(!this.first)throw new Error("The list is empty.");let e=this._first.value;return this._first=this._first.next,this._length--,e}removeLast(){if(!this.last)throw new Error("The list is empty.");let e=this._last.value;return this._last=this._last.prev,this._length--,e}get length(){return this._length}get first(){return this._first}get firstValue(){return this._first?.value}get last(){return this._last}get lastValue(){return this._last?.value}};export{i as LinkedList,s as Node};
+//# sourceMappingURL=index.mjs.map

package/dist/collections/index.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/collections/LinkedList.ts"],
+  "sourcesContent": ["/**\r\n * A node in the @see LinkedList.\r\n */\r\nexport class Node<T> {\r\n    /**\r\n     * Next node unless last one.\r\n     */\r\n    public next: Node<T> | null = null;\r\n    /**\r\n     * Previous node unless first one.\r\n     */\r\n    public prev: Node<T> | null = null;\r\n\r\n    /**\r\n     * Constructor.\r\n     * @param value Value contained in the node.\r\n     */\r\n    constructor(public value: T, private removeCallback: () => void) {}\r\n\r\n    /**\r\n     * Remove this node.\r\n     * Will notify the list of the update to ensure correct element count.\r\n     */\r\n    remove() {\r\n        this.prev.next = this.next;\r\n        this.next.prev = this.prev;\r\n        this.removeCallback();\r\n    }\r\n}\r\n\r\n/**\r\n * A trivial linked list implementation.\r\n */\r\nexport class LinkedList<T> {\r\n    private _first?: Node<T>;\r\n    private _last?: Node<T>;\r\n    private _length = 0;\r\n\r\n    /**\r\n     * Add a value to the beginning of the list.\r\n     * @param value Value that should be contained in the node.\r\n     */\r\n    addFirst(value: T) {\r\n        const newNode = new Node(value, () => this._length--);\r\n        if (!this._first) {\r\n            this._first = newNode;\r\n            this._last = this._first;\r\n        } else {\r\n            newNode.next = this._first;\r\n            this._first.prev = newNode;\r\n            this._first = newNode;\r\n        }\r\n\r\n        this._length++;\r\n    }\r\n\r\n    /**\r\n     * Add a value to the end of the list.\r\n     * @param value Value that should be contained in a node.\r\n     */\r\n    addLast(value: T) {\r\n        const newNode = new Node(value, () => this._length--);\r\n        if (!this._first) {\r\n            this._first = newNode;\r\n            this._last = this._first;\r\n        } else {\r\n            newNode.prev = this._last;\r\n            this._last.next = newNode;\r\n            this._last = newNode;\r\n        }\r\n\r\n        this._length++;\r\n    }\r\n\r\n    /**\r\n     * Remove a node from the beginning of the list.\r\n     * @returns Value contained in the first node.\r\n     */\r\n    removeFirst(): T {\r\n        if (!this.first) {\r\n            throw new Error('The list is empty.');\r\n        }\r\n\r\n        const value = this._first.value;\r\n        this._first = this._first.next;\r\n        this._length--;\r\n        return value;\r\n    }\r\n\r\n    /**\r\n     * Remove a node from the end of the list.\r\n     * @returns Value contained in the last node.\r\n     */\r\n    removeLast(): T {\r\n        if (!this.last) {\r\n            throw new Error('The list is empty.');\r\n        }\r\n\r\n        const value = this._last.value;\r\n        this._last = this._last.prev;\r\n        this._length--;\r\n        return value;\r\n    }\r\n\r\n    /**\r\n     * Number of nodes in the list.\r\n     *\r\n     * The count works as long as you do not manually remove nodes (by assigning next/prev to the neighbors).\r\n     */\r\n    get length(): number {\r\n        return this._length;\r\n    }\r\n\r\n    /**\r\n     * First ndoe.\r\n     */\r\n    get first(): Node<T> | undefined {\r\n        return this._first;\r\n    }\r\n\r\n    /**\r\n     * Contained value of the first node.\r\n     */\r\n    get firstValue(): T | undefined {\r\n        return this._first?.value;\r\n    }\r\n\r\n    /**\r\n     * Last node.\r\n     */\r\n    get last(): Node<T> | undefined {\r\n        return this._last;\r\n    }\r\n\r\n    /**\r\n     * Contained value of the last node.\r\n     */\r\n    get lastValue(): T | undefined {\r\n        return this._last?.value;\r\n    }\r\n}\r\n"],
+  "mappings": "AAGO,IAAMA,EAAN,KAAc,CAcjB,YAAmBC,EAAkBC,EAA4B,CAA9C,WAAAD,EAAkB,oBAAAC,EAVrC,KAAO,KAAuB,KAI9B,KAAO,KAAuB,IAMoC,CAMlE,QAAS,CACL,KAAK,KAAK,KAAO,KAAK,KACtB,KAAK,KAAK,KAAO,KAAK,KACtB,KAAK,eAAe,CACxB,CACJ,EAKaC,EAAN,KAAoB,CAApB,cAGH,KAAQ,QAAU,EAMlB,SAASF,EAAU,CACf,IAAMG,EAAU,IAAIJ,EAAKC,EAAO,IAAM,KAAK,SAAS,EAC/C,KAAK,QAING,EAAQ,KAAO,KAAK,OACpB,KAAK,OAAO,KAAOA,EACnB,KAAK,OAASA,IALd,KAAK,OAASA,EACd,KAAK,MAAQ,KAAK,QAOtB,KAAK,SACT,CAMA,QAAQH,EAAU,CACd,IAAMG,EAAU,IAAIJ,EAAKC,EAAO,IAAM,KAAK,SAAS,EAC/C,KAAK,QAING,EAAQ,KAAO,KAAK,MACpB,KAAK,MAAM,KAAOA,EAClB,KAAK,MAAQA,IALb,KAAK,OAASA,EACd,KAAK,MAAQ,KAAK,QAOtB,KAAK,SACT,CAMA,aAAiB,CACb,GAAI,CAAC,KAAK,MACN,MAAM,IAAI,MAAM,oBAAoB,EAGxC,IAAMH,EAAQ,KAAK,OAAO,MAC1B,YAAK,OAAS,KAAK,OAAO,KAC1B,KAAK,UACEA,CACX,CAMA,YAAgB,CACZ,GAAI,CAAC,KAAK,KACN,MAAM,IAAI,MAAM,oBAAoB,EAGxC,IAAMA,EAAQ,KAAK,MAAM,MACzB,YAAK,MAAQ,KAAK,MAAM,KACxB,KAAK,UACEA,CACX,CAOA,IAAI,QAAiB,CACjB,OAAO,KAAK,OAChB,CAKA,IAAI,OAA6B,CAC7B,OAAO,KAAK,MAChB,CAKA,IAAI,YAA4B,CAC5B,OAAO,KAAK,QAAQ,KACxB,CAKA,IAAI,MAA4B,CAC5B,OAAO,KAAK,KAChB,CAKA,IAAI,WAA2B,CAC3B,OAAO,KAAK,OAAO,KACvB,CACJ",
+  "names": ["Node", "value", "removeCallback", "LinkedList", "newNode"]
+}

package/dist/components/Table.d.ts

@@ -0,0 +1,13 @@
+import type { DataLoader } from '../lib/DataLoader';
+export declare class RelaxedTable extends HTMLElement {
+    private renderer;
+    private sorter;
+    private pager;
+    private table;
+    private template;
+    private loader;
+    private pageSize;
+    connectedCallback(): void;
+    set dataLoader(loader: DataLoader);
+    private loadPage;
+}

package/dist/components/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./menus/index";
+export * from "../lib/routing/RoutingTarget";
+export * from "../lib/routing/RouteLink";
+export * from "./lists/index";