defuss 2.0.2 → 2.0.4

package/dist/index.d.ts

@@ -1,15 +1,13 @@
-import { f as VNode, e as VNodeAttributes, R as RenderInput, G as Globals, o as Props, l as VNodeChild, d as Ref } from './index-S3MRf--S.js';
-export { $, A as AllHTMLElements, C as CSSProperties, n as Children, Y as D, Z as Dequery, W as DequeryChain, Q as DequeryOptions, D as DomAbstractionImpl, U as ElementCreationOptions, F as FontFaceProperties, M as FormFieldValue, O as FormKeyValues, E as Fragment, K as KeyFrameProperties, a6 as Listener, N as NodeType, P as ParentElementInput, b as ParentElementInputAsync, c as RefUpdateFn, p as RenderNodeInput, a as RenderResult, q as RenderResultNode, a7 as Store, S as SyncRenderInput, w as SyncRenderResult, V as VAttributes, m as VNodeChildren, h as VNodeKey, k as VNodeRef, j as VNodeRefCallback, i as VNodeRefObject, g as VNodeType, T as adefaultConfig, r as createInPlaceErrorMessageVNode, L as createRef, a8 as createStore, X as dequery, v as getRenderer, z as globalScopeDomApis, u as handleLifecycleEventsForOnMount, _ as isDequery, B as isJSX, J as isRef, s as jsx, I as jsxDEV, H as jsxs, t as observeUnmount, a3 as renderHTML, y as renderIsomorphicAsync, x as renderIsomorphicSync, a5 as runWithTimeGuard, a4 as sleep, a2 as waitForRefWithPolling, a1 as waitForSelectorWithPolling, a0 as waitForWithPolling } from './index-S3MRf--S.js';
+import { Q as PersistenceProviderType, T as PersistenceProviderOptions, U as PersistenceProviderImpl, h as VNode, g as VNodeAttributes, R as RenderInput, G as Globals, N as NodeType, q as Props, n as VNodeChild, f as Ref } from './index-B2aNqkPk.js';
+export { a4 as $, A as AllHTMLElements, C as CSSProperties, W as Call, Z as CallChainImpl, _ as CallChainImplThenable, p as Children, a2 as Dequery, D as DomAbstractionImpl, F as FontFaceProperties, I as Fragment, K as KeyFrameProperties, ak as Listener, ai as MemoryStorage, ah as MiddlewareFn, X as NonChainedReturnCallNames, P as ParentElementInput, b as ParentElementInputAsync, d as RefUpdateFn, e as RefUpdateRenderFn, c as RefUpdateRenderFnInput, r as RenderNodeInput, a as RenderResult, s as RenderResultNode, al as Store, S as SyncRenderInput, y as SyncRenderResult, V as VAttributes, o as VNodeChildren, j as VNodeKey, m as VNodeRef, l as VNodeRefCallback, k as VNodeRefObject, i as VNodeType, aj as WebStorage, a9 as createCall, aa as createGetterSetterCall, t as createInPlaceErrorMessageVNode, O as createRef, am as createStore, ab as createSubChain, a1 as delayedAutoStart, a3 as dequery, Y as emptyImpl, a0 as getAllFormValues, a7 as getDefaultDequeryOptions, x as getRenderer, E as globalScopeDomApis, w as handleLifecycleEventsForOnMount, a5 as isDequery, a6 as isDequeryOptionsObject, H as isJSX, M as isRef, u as jsx, L as jsxDEV, J as jsxs, a8 as mapArrayIndexAccess, v as observeUnmount, B as renderIsomorphicAsync, z as renderIsomorphicSync, ae as renderNode, af as resolveNodes, ad as runWithTimeGuard, $ as scrollHelper, ac as subChainForNextAwait, ag as traverse } from './index-B2aNqkPk.js';
 import * as CSS from 'csstype';
 export { CSS };
 
-declare const getAllKeysFromPath: (path: string) => Array<string | number>;
-declare const ensureKey: (obj: Record<string, any>, key: string | number, nextKey?: string | number) => void;
-declare const getByPath: (obj: any, path: string) => any;
-declare const setByPath: (obj: any, path: string, value: any) => any;
-
 declare const inDevMode = true;
 
+/** returns the persistence provider (isomorphic) */
+declare const webstorage: <T>(provider?: PersistenceProviderType, options?: PersistenceProviderOptions) => PersistenceProviderImpl<T>;
+
 /**
  * Compares two DOM nodes for equality with performance optimizations.
  * 1. Checks for reference equality.
@@ -22,7 +20,7 @@ declare const areDomNodesEqual: (oldNode: Node, newNode: Node) => boolean;
  * Partially updates a DOM subtree by comparing `targetElement` to
  * newly parsed HTML. No `.innerHTML` is used here; we parse via DOMParser.
  */
-declare const updateDom: (targetElement: Element, newHTML: string) => void;
+declare const updateDom: (targetElement: Element, newHTML: string, Parser: typeof DOMParser) => void;
 /********************************************************
  * 1) Define a "valid" child type & utility
  ********************************************************/
@@ -37,29 +35,23 @@ declare function updateDomWithVdom(parentElement: Element, newVDOM: RenderInput,
  * at the cost of losing partial update performance.
  */
 declare function replaceDomWithVdom(parentElement: Element, newVDOM: RenderInput, globals: Globals): void;
-
-type MemoryProviderOptions = {};
-interface MemoryStorage<T> extends PersistenceProviderImpl<T> {
-    backendApi: Omit<Omit<Storage, 'key'>, 'length'>;
-}
-interface WebStorage<T> extends PersistenceProviderImpl<T> {
-    backendApi: Storage;
-}
-
-type MiddlewareFn<T> = (key: string, value: T) => T;
-/** a simple key/value persistence interface */
-interface PersistenceProviderImpl<T> {
-    get: (key: string, defaultValue: T, middlewareFn?: MiddlewareFn<T>) => T;
-    set: (key: string, value: T, middlewareFn?: MiddlewareFn<T>) => void;
-    remove: (key: string) => void;
-    removeAll: () => void;
-    backendApi: any;
-}
-type PersistenceProvider = 'session' | 'local' | 'memory';
-type PersistenceProviderOptions = MemoryProviderOptions;
-
-/** returns the persistence provider (isomorphic) */
-declare const webstorage: <T>(provider?: PersistenceProvider, options?: PersistenceProviderOptions) => PersistenceProviderImpl<T>;
+declare function waitForDOM(check: () => Array<NodeType>, timeout: number, document?: Document): Promise<Array<NodeType>>;
+declare function parseDOM(input: string, type: DOMParserSupportedType, Parser: typeof DOMParser): Document;
+declare function isSVG(input: string, Parser: typeof DOMParser): boolean;
+declare function isHTML(input: string, Parser: typeof DOMParser): boolean;
+declare const isMarkup: (input: string, Parser: typeof DOMParser) => boolean;
+declare function renderMarkup(markup: string, Parser: typeof DOMParser, doc?: Document): ChildNode[];
+declare function getMimeType(input: string, Parser: typeof DOMParser): DOMParserSupportedType;
+/**
+ * Enhanced version of processFormElements that handles all form control types
+ * including multiple select elements and radio button groups
+ */
+declare function processAllFormElements(node: NodeType, callback: (input: HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement, key: string) => void): void;
+declare function checkElementVisibility(element: HTMLElement, window: Window, document: Document): boolean;
+declare function getEventMap(element: HTMLElement): Map<string, Set<EventListener>>;
+declare function addElementEvent(element: HTMLElement, eventType: string, handler: EventListener): void;
+declare function removeElementEvent(element: HTMLElement, eventType: string, handler?: EventListener): void;
+declare function clearElementEvents(element: HTMLElement): void;
 
 type TranslationObject = {
     [key: string]: string | VNode | TranslationObject;
@@ -89,125 +81,9 @@ interface TransProps extends Props {
 }
 declare const Trans: ({ path, replacements, tag, ...attrs }: TransProps) => VNodeChild;
 
-/**
- * custom headers class to manage HTTP headers with case-insensitive keys.
- * simplifies header manipulation by providing utility methods.
- */
-declare class Headers {
-    private map;
-    /**
-     * initializes the Headers instance with provided headers or another Headers object.
-     * ensures all header keys are stored in lowercase for consistent access.
-     * @param init initial headers as a record or another Headers instance
-     */
-    constructor(init?: Record<string, string> | Headers);
-    /**
-     * appends or sets the value for a specific header key.
-     * stores the key in lowercase to maintain case-insensitivity.
-     * @param key header name
-     * @param value header value
-     */
-    append(key: string, value: string): void;
-    /**
-     * retrieves the value of a specific header key.
-     * @param key header name
-     * @returns the header value or null if not found
-     */
-    get(key: string): string | null;
-    /**
-     * checks if a specific header key exists.
-     * @param key header name
-     * @returns boolean indicating existence of the header
-     */
-    has(key: string): boolean;
-    /**
-     * iterates over all headers and executes the provided callback for each.
-     * @param callback function to execute for each header
-     */
-    forEach(callback: (value: string, key: string) => void): void;
-}
-/**
- * ProgressSignal extends EventTarget to dispatch and track progress events.
- * useful for monitoring the progress of network requests.
- */
-declare class ProgressSignal extends EventTarget {
-    private _progress;
-    /**
-     * initializes the ProgressSignal with zero progress.
-     */
-    constructor();
-    /**
-     * retrieves the current progress.
-     * @returns an object containing loaded and total bytes
-     */
-    get progress(): {
-        loaded: number;
-        total: number;
-    };
-    /**
-     * dispatches a progress event with updated loaded and total bytes.
-     * updates the internal progress state.
-     * @param event the ProgressEvent containing progress information
-     */
-    dispatchProgress(event: ProgressEvent): void;
-}
-/**
- * ProgressController manages a ProgressSignal for tracking request progress.
- * provides a centralized way to handle progress events.
- */
-declare class ProgressController {
-    signal: ProgressSignal;
-    /**
-     * initializes the ProgressController with a new ProgressSignal.
-     */
-    constructor();
-}
-/**
- * serializes the request body into a format suitable for XMLHttpRequest.
- * handles various body types including JSON objects and FormData.
- * @param body the body to serialize
- * @returns the serialized body or null if no body is provided
- */
-declare function serializeBody(body: BodyInit | Record<string, unknown> | null | undefined): XMLHttpRequestBodyInit | Document | null;
-/**
- * parses a raw header string from an XMLHttpRequest into a Headers instance.
- * @param headerStr the raw header string
- * @returns a Headers instance containing parsed headers
- */
-declare function parseHeaders(headerStr: string): Headers;
-/**
- * extends the standard RequestInit to include an optional ProgressSignal.
- * allows tracking the progress of the network request.
- */
-interface FetchWithControllersInit extends RequestInit {
-    progressSignal?: ProgressSignal;
-}
-/**
- * represents the response from a fetch operation, mirroring the native Response interface.
- * includes methods to access the response body in various formats.
- */
-interface FetchResponse {
-    ok: boolean;
-    status: number;
-    statusText: string;
-    headers: Headers;
-    url: string;
-    text: () => Promise<string>;
-    json: () => Promise<unknown>;
-    blob: () => Promise<Blob>;
-}
-/**
- * performs a network fetch request with support for progress tracking using XMLHttpRequest.
- * falls back to the native fetch implementation if no ProgressSignal is provided.
- * @param input the resource to fetch, typically a URL string
- * @param init optional configuration for the request, including method, headers, body, credentials, and progressSignal
- * @returns a promise resolving to a FetchResponse containing the response details
- */
-declare function fetch(input: string | URL, init?: FetchWithControllersInit): Promise<FetchResponse>;
-
 type OnHandleRouteChangeFn = (newRoute: string, oldRoute: string) => void;
 type OnRouteChangeFn = (cb: OnHandleRouteChangeFn) => void;
-type RouterStrategy = 'page-refresh' | 'slot-refresh';
+type RouterStrategy = "page-refresh" | "slot-refresh";
 interface RouterConfig {
     strategy?: RouterStrategy;
 }
@@ -257,7 +133,7 @@ declare const Route: ({ path, exact, children, router }: RouteProps) => VNodeChi
 interface RedirectProps extends RouteProps {
     to: string;
 }
-declare const Redirect: ({ path, to, router, exact }: RedirectProps) => VNodeChild;
+declare const Redirect: ({ path, to, router, exact, }: RedirectProps) => VNodeChild;
 
 declare const RouterSlotId = "router-slot";
 interface RouterSlotProps extends Props {
@@ -279,7 +155,7 @@ interface RouterSlotProps extends Props {
  */
 declare const RouterSlot: ({ router, children, RouterOutlet, ...attributes }: RouterSlotProps) => VNodeChild;
 
-type AsyncState = 'loading' | 'loaded' | 'error';
+type AsyncState = "loading" | "loaded" | "error";
 interface AsyncStateRef extends Ref<HTMLElement> {
     /** The state of the async content */
     state?: AsyncState;
@@ -306,7 +182,7 @@ interface AsyncProps extends Props {
     /** to override the name of the .suspense-error transition CSS class name */
     errorClassName?: string;
 }
-declare const Async: ({ fallback, ref, children, class: _class, className, id, loadingClassName, loadedClassName, errorClassName, onError }: AsyncProps) => {
+declare const Async: ({ fallback, ref, children, class: _class, className, id, loadingClassName, loadedClassName, errorClassName, onError, }: AsyncProps) => {
     type: string;
     attributes: {
         id: string | undefined;
@@ -317,7 +193,7 @@ declare const Async: ({ fallback, ref, children, class: _class, className, id, l
     };
     children: VNode<VNodeAttributes>[];
 };
-declare const Suspense: ({ fallback, ref, children, class: _class, className, id, loadingClassName, loadedClassName, errorClassName, onError }: AsyncProps) => {
+declare const Suspense: ({ fallback, ref, children, class: _class, className, id, loadingClassName, loadedClassName, errorClassName, onError, }: AsyncProps) => {
     type: string;
     attributes: {
         id: string | undefined;
@@ -329,4 +205,4 @@ declare const Suspense: ({ fallback, ref, children, class: _class, className, id
     children: VNode<VNodeAttributes>[];
 };
 
-export { Async, type AsyncProps, type AsyncState, type AsyncStateRef, type FetchResponse, type FetchWithControllersInit, Globals, Headers, type I18nStore, type MemoryStorage, type MiddlewareFn, type OnHandleRouteChangeFn, type OnLanguageChangeListener, type OnRouteChangeFn, type PersistenceProvider, type PersistenceProviderImpl, type PersistenceProviderOptions, ProgressController, ProgressSignal, Props, Redirect, type RedirectProps, Ref, RenderInput, type Replacements, Route, type RouteHandler, type RouteParams, type RouteProps, type RouteRegistration, type RouteRequest, Router, type RouterConfig, RouterSlot, RouterSlotId, type RouterSlotProps, type RouterStrategy, Suspense, type TokenizedPath, Trans, type TransProps, type TranslationObject, type Translations, VNode, VNodeAttributes, VNodeChild, type ValidChild, type WebStorage, areDomNodesEqual, createI18n, ensureKey, fetch, getAllKeysFromPath, getByPath, i18n, inDevMode, matchRouteRegistrations, parseHeaders, replaceDomWithVdom, serializeBody, setByPath, setupRouter, tokenizePath, updateDom, updateDomWithVdom, webstorage };
+export { Async, type AsyncProps, type AsyncState, type AsyncStateRef, Globals, type I18nStore, NodeType, type OnHandleRouteChangeFn, type OnLanguageChangeListener, type OnRouteChangeFn, PersistenceProviderImpl, PersistenceProviderOptions, PersistenceProviderType, Props, Redirect, type RedirectProps, Ref, RenderInput, type Replacements, Route, type RouteHandler, type RouteParams, type RouteProps, type RouteRegistration, type RouteRequest, Router, type RouterConfig, RouterSlot, RouterSlotId, type RouterSlotProps, type RouterStrategy, Suspense, type TokenizedPath, Trans, type TransProps, type TranslationObject, type Translations, VNode, VNodeAttributes, VNodeChild, type ValidChild, addElementEvent, areDomNodesEqual, checkElementVisibility, clearElementEvents, createI18n, getEventMap, getMimeType, i18n, inDevMode, isHTML, isMarkup, isSVG, matchRouteRegistrations, parseDOM, processAllFormElements, removeElementEvent, renderMarkup, replaceDomWithVdom, setupRouter, tokenizePath, updateDom, updateDomWithVdom, waitForDOM, webstorage };

package/dist/index.mjs

@@ -1,3 +1,339 @@
-var O=Object.defineProperty;var n=(r,e)=>O(r,"name",{value:e,configurable:!0});import{l as A,k as R,$ as p,f as v}from"./dom-Cm_LuWlw.mjs";import{y as se,D as re,F as oe,w as ne,q as ae,c as ie,x as ce,n as ue,m as le,p as de,b as pe,g as fe,h as ge,z as he,i as me,j as ye,e as we,d as Se,o as xe,E as Re,a as Pe,r as Ee,v as be,H as Ae,s as ve,G as Ce,u as Te,t as De,C as Me,B as qe,A as Le}from"./dom-Cm_LuWlw.mjs";const C=!0,F=n(()=>{const r=new Map;return{clear:n(()=>{r.clear()},"clear"),getItem:n(e=>r.get(String(e))??null,"getItem"),removeItem:n(e=>{r.delete(String(e))},"removeItem"),setItem:n((e,o)=>{r.set(String(e),o)},"setItem")}},"newInMemoryGenericStorageBackend"),W=F();class y{static{n(this,"WebStorageProvider")}storage;constructor(e){this.storage=e||W}get(e,o,t){const s=this.storage.getItem(e);if(s===null)return o;let a=JSON.parse(s);return t&&(a=t(e,a)),a}set(e,o,t){t&&(o=t(e,o)),this.storage.setItem(e,JSON.stringify(o))}remove(e){this.storage.removeItem(e)}removeAll(){this.storage.clear()}get backendApi(){return this.storage}}const $=n((r,e)=>{switch(r){case"session":return new y(window.sessionStorage);case"local":return new y(window.localStorage)}return new y},"getPersistenceProvider$1"),H=n((r,e)=>new y,"getPersistenceProvider"),V=n(()=>typeof window>"u"||typeof window.document>"u","isServer"),k=n((r="local",e)=>V()?H():$(r),"webstorage"),z=/{([^}]*)}/g,G=n((r,e)=>r.replace(z,(o,t)=>e[t]||`{${t}}`),"interpolate"),T=n(()=>{const r=A({});let e="en";const o=[];return{language:e,changeLanguage(t){e=t,o.forEach(s=>s(t))},t(t,s={}){const a=r.get(`${e}.${t}`)||t;return typeof a!="string"?a:G(a,s)},load(t,s){r.set(t,{...r.get(t),...s})},subscribe(t){return o.push(t),()=>{const s=o.indexOf(t);s>=0&&o.splice(s,1)}}}},"createI18n"),w=T(),J=n(({path:r,replacements:e,tag:o,...t})=>{const s={};return w.subscribe(()=>{const a=w.t(r,e);console.log("new val",a)}),{tag:o||"span",attributes:{ref:s,...t},children:w.t(r,e)}},"Trans");class m{static{n(this,"Headers")}map;constructor(e={}){this.map=new Map,e instanceof m?e.forEach((o,t)=>this.map.set(t,o)):Object.entries(e).forEach(([o,t])=>this.map.set(o.toLowerCase(),t))}append(e,o){this.map.set(e.toLowerCase(),o)}get(e){return this.map.get(e.toLowerCase())||null}has(e){return this.map.has(e.toLowerCase())}forEach(e){this.map.forEach((o,t)=>e(o,t))}}class D extends EventTarget{static{n(this,"ProgressSignal")}_progress;constructor(){super(),this._progress={loaded:0,total:0}}get progress(){return this._progress}dispatchProgress(e){this._progress={loaded:e.loaded,total:e.total},this.dispatchEvent(new ProgressEvent("progress",{loaded:e.loaded,total:e.total}))}}class U{static{n(this,"ProgressController")}signal;constructor(){this.signal=new D}}function M(r){return r?r instanceof FormData||r instanceof Blob||r instanceof URLSearchParams||r instanceof ArrayBuffer||ArrayBuffer.isView(r)||typeof r=="string"?r:typeof r=="object"?JSON.stringify(r):String(r):null}n(M,"serializeBody");function q(r){const e=new m;return r.split(`\r
-`).forEach(o=>{const[t,...s]=o.split(": ");t&&e.append(t,s.join(": "))}),e}n(q,"parseHeaders");async function L(r,e={}){return!e.progressSignal&&typeof globalThis.fetch=="function"?L(r,e):new Promise((o,t)=>{const s=new XMLHttpRequest,a=(e.method||"GET").toUpperCase(),l=M(e.body||null),f=e.progressSignal,g=e.signal;if(g){const u=n(()=>{s.abort(),t(new DOMException("The operation was aborted.","AbortError"))},"abortHandler");g.addEventListener("abort",u,{once:!0})}s.open(a,r.toString(),!0),e.credentials==="include"?s.withCredentials=!0:e.credentials==="omit"&&(s.withCredentials=!1),e.headers instanceof m?e.headers.forEach((u,h)=>s.setRequestHeader(h,u)):e.headers&&Object.entries(e.headers).forEach(([u,h])=>{s.setRequestHeader(u,h)}),f&&(s.upload&&(s.upload.onprogress=u=>f.dispatchProgress(u)),s.onprogress=u=>f.dispatchProgress(u)),s.onload=()=>{const u={ok:s.status>=200&&s.status<300,status:s.status,statusText:s.statusText,headers:q(s.getAllResponseHeaders()),url:s.responseURL,text:n(()=>Promise.resolve(s.responseText),"text"),json:n(()=>Promise.resolve(JSON.parse(s.responseText)),"json"),blob:n(()=>Promise.resolve(new Blob([s.response])),"blob")};o(u)},s.onerror=()=>t(new TypeError("Network request failed")),s.ontimeout=()=>t(new TypeError("Network request timed out")),s.onabort=()=>t(new DOMException("The operation was aborted.","AbortError")),s.send(l)})}n(L,"fetch");const P=n(r=>{const e=/:([^\/\.\\]+)/g,o={};let t=1;const s=r.replace(e,(a,l)=>(o[l]=t++,"([^/.\\]+)"));return{groups:o,regexp:new RegExp(`^${s}$`)}},"tokenizePath"),I=n((r,e,o)=>{for(const t of r){if(o&&t.path!==o||t.exact&&t.path!==e)continue;const s=t.tokenizedPath.regexp.exec(e);if(!s)continue;const a={};for(const[f,g]of Object.entries(t.tokenizedPath.groups))a[f]=s[g];const l={url:e,params:a};return typeof t.handler=="function"&&t.handler(l),l}return!1},"matchRouteRegistrations"),_=n((r={strategy:"page-refresh"},e)=>{const o=[];typeof window<"u"&&!e&&(e=globalThis.__defuss_window||window),e||console.warn("Router requires a Window API implementation!");const t={...r,listeners:[],onRouteChange:n(s=>{t.listeners.push(s)},"onRouteChange"),tokenizePath:P,add(s){return o.some(l=>l.path===s.path)||o.push({...s,tokenizedPath:P(s.path)}),t},match(s){return I(o,e.document.location.pathname,s)},navigate(s){const a=t.strategy||"page-refresh",l=e?e.document.location.pathname:"";if(a==="page-refresh")document.location.href=s;else if(a==="slot-refresh"){typeof e<"u"&&e.history.pushState({},"",s);for(const f of t.listeners)f(s,l)}},getRoutes(){return o}};return t},"setupRouter"),S=_(),j=n(({path:r,exact:e,children:o,router:t=S})=>(t.add({path:r,exact:e||!1}),t.match(r)?o[0]:null),"Route"),N=n(({path:r,to:e,router:o=S,exact:t})=>(requestAnimationFrame(()=>{j({path:r,router:o,exact:t,children:[!0]})&&o.navigate(e)}),null),"Redirect"),x="router-slot",X=n(({router:r=S,children:e,RouterOutlet:o,...t})=>{const{tag:s,...a}=t,l=R();return r.strategy="slot-refresh",r.onRouteChange(()=>{p(l).update(o())}),document.getElementById(x)&&console.warn(`It seems there's more than one <RouterSlot /> components defined as an element with id #${x} already exists in the DOM.`),{children:o()||[],type:t.tag||"div",attributes:{...a,id:x,ref:l}}},"RouterSlot"),B=n(({fallback:r,ref:e,children:o,class:t,className:s,id:a,loadingClassName:l,loadedClassName:f,errorClassName:g,onError:u})=>{let h=o;const i=R(n(function(d){try{if(!i.current){C&&console.warn("Suspense container is not mounted yet, but a state update demands a render. State is:",d);return}p(i.current).removeClass(l||"suspense-loading"),p(i.current).removeClass(f||"suspense-loaded"),p(i.current).removeClass(g||"suspense-error"),!o||d==="error"?(p(i.current).addClass(g||"suspense-error"),p(i).jsx({type:"div",children:["Loading error!"]})):d==="loading"?(p(i.current).addClass(l||"suspense-loading"),p(i).jsx(r)):d==="loaded"&&(p(i.current).addClass(f||"suspense-loaded"),console.log("[Async render] start"),p(i).jsx(h),console.log("[Async render] finished"))}catch(b){i.update("error"),i.error=b,typeof u=="function"&&u(b)}},"onSuspenseUpdate"),"loading");if(v(e)){let c=!0;e.update=d=>{c||i.update(d)},e.update("loading"),c=!1}const E=(o||[]).map(c=>{try{if(!c||c&&!c.type)return Promise.resolve("");if(c.type.constructor.name==="AsyncFunction"){const d={...c.attributes,children:c.children};return c.type(d)}return Promise.resolve(c)}catch(d){i.update("error"),i.error=d,typeof u=="function"&&u(d)}});return{type:"div",attributes:{id:a,class:t,className:s,ref:i,onMount:n(()=>{E.length&&(i.update("loading"),Promise.all(E).then(c=>{h=c.flatMap(d=>d?.type==="Fragment"?d.children:d),i.update("loaded")}).catch(c=>{i.update("error"),i.error=c,console.error("SuspenseLoadingError",c),p(i).jsx(`SuspenseLoadingError: ${c}`),typeof u=="function"&&u(c)}))},"onMount")},children:r?[r]:[]}},"Async"),K=B;export{p as $,B as Async,se as D,re as DequeryChain,oe as Fragment,m as Headers,U as ProgressController,D as ProgressSignal,N as Redirect,j as Route,S as Router,X as RouterSlot,x as RouterSlotId,K as Suspense,J as Trans,ne as adefaultConfig,ae as areDomNodesEqual,T as createI18n,ie as createInPlaceErrorMessageVNode,R as createRef,A as createStore,ce as dequery,ue as ensureKey,L as fetch,le as getAllKeysFromPath,de as getByPath,pe as getRenderer,fe as globalScopeDomApis,ge as handleLifecycleEventsForOnMount,w as i18n,C as inDevMode,he as isDequery,me as isJSX,v as isRef,ye as jsx,we as jsxDEV,Se as jsxs,I as matchRouteRegistrations,xe as observeUnmount,q as parseHeaders,Re as renderHTML,Pe as renderIsomorphicAsync,Ee as renderIsomorphicSync,be as replaceDomWithVdom,Ae as runWithTimeGuard,M as serializeBody,ve as setByPath,_ as setupRouter,Ce as sleep,P as tokenizePath,Te as updateDom,De as updateDomWithVdom,Me as waitForRefWithPolling,qe as waitForSelectorWithPolling,Le as waitForWithPolling,k as webstorage};
-//# sourceMappingURL=index.mjs.map
+import { l as createStore, m as isServer, k as createRef, $, f as isRef } from './dom-DtgVTMnb.mjs';
+export { H as Call, J as CallChainImpl, K as CallChainImplThenable, F as Fragment, N as NonChainedReturnCallNames, D as addElementEvent, n as areDomNodesEqual, B as checkElementVisibility, G as clearElementEvents, U as createCall, V as createGetterSetterCall, c as createInPlaceErrorMessageVNode, W as createSubChain, O as delayedAutoStart, P as dequery, I as emptyImpl, M as getAllFormValues, S as getDefaultDequeryOptions, C as getEventMap, z as getMimeType, g as getRenderer, b as globalScopeDomApis, h as handleLifecycleEventsForOnMount, Q as isDequery, R as isDequeryOptionsObject, v as isHTML, i as isJSX, x as isMarkup, t as isSVG, j as jsx, e as jsxDEV, d as jsxs, T as mapArrayIndexAccess, o as observeUnmount, s as parseDOM, A as processAllFormElements, E as removeElementEvent, a as renderIsomorphicAsync, r as renderIsomorphicSync, y as renderMarkup, Z as renderNode, q as replaceDomWithVdom, _ as resolveNodes, Y as runWithTimeGuard, L as scrollHelper, X as subChainForNextAwait, a0 as traverse, u as updateDom, p as updateDomWithVdom, w as waitForDOM, a1 as webstorage } from './dom-DtgVTMnb.mjs';
+import 'defuss-runtime';
+
+const inDevMode = true;
+
+const VARIABLE_REGEX = /{([^}]*)}/g;
+const interpolate = (template, replacements) => template.replace(VARIABLE_REGEX, (_, key) => replacements[key] || `{${key}}`);
+const createI18n = () => {
+  const translationsStore = createStore({});
+  let language = "en";
+  const onLanguageChangeCallbacks = [];
+  return {
+    language,
+    changeLanguage(newLanguage) {
+      language = newLanguage;
+      onLanguageChangeCallbacks.forEach((callback) => callback(newLanguage));
+    },
+    // example usage of the t function with placeholders:
+    // const translatedString = t('greeting', { name: 'John', age: '30' }, 'common');
+    // this would replace placeholders {name} and {age} in the translation string with 'John' and '30' respectively.
+    t(path, replacements = {}) {
+      const template = translationsStore.get(`${language}.${path}`) || path;
+      if (typeof template !== "string") {
+        return template;
+      }
+      return interpolate(template, replacements);
+    },
+    load(newLanguage, namespaceTranslations) {
+      translationsStore.set(newLanguage, {
+        ...translationsStore.get(newLanguage),
+        ...namespaceTranslations
+      });
+    },
+    subscribe(onLanguageChange) {
+      onLanguageChangeCallbacks.push(onLanguageChange);
+      return () => {
+        const index = onLanguageChangeCallbacks.indexOf(onLanguageChange);
+        if (index >= 0) onLanguageChangeCallbacks.splice(index, 1);
+      };
+    }
+  };
+};
+const i18n = createI18n();
+
+const Trans = ({ path, replacements, tag, ...attrs }) => {
+  const ref = {};
+  i18n.subscribe(() => {
+    const value = i18n.t(path, replacements);
+    console.log("new val", value);
+  });
+  return {
+    tag: tag || "span",
+    attributes: {
+      ref,
+      ...attrs
+    },
+    // initially render
+    children: i18n.t(path, replacements)
+  };
+};
+
+const tokenizePath = (path) => {
+  const paramNameRegexp = /:([^\/\.\\]+)/g;
+  const groups = {};
+  let groupIndex = 1;
+  const pattern = path.replace(paramNameRegexp, (_, paramName) => {
+    groups[paramName] = groupIndex++;
+    return "([^/.\\]+)";
+  });
+  return {
+    groups,
+    regexp: new RegExp(`^${pattern}$`)
+  };
+};
+const matchRouteRegistrations = (routeRegistrations, actualPathName, haystackPathName) => {
+  for (const route of routeRegistrations) {
+    if (haystackPathName && route.path !== haystackPathName) {
+      continue;
+    }
+    if (route.exact && route.path !== actualPathName) {
+      continue;
+    }
+    const match = route.tokenizedPath.regexp.exec(actualPathName);
+    if (!match) continue;
+    const params = {};
+    for (const [paramName, groupIndex] of Object.entries(
+      route.tokenizedPath.groups
+    )) {
+      params[paramName] = match[groupIndex];
+    }
+    const request = { url: actualPathName, params };
+    if (typeof route.handler === "function") {
+      route.handler(request);
+    }
+    return request;
+  }
+  return false;
+};
+const setupRouter = (config = {
+  strategy: "page-refresh"
+  // default
+}, windowImpl) => {
+  const routeRegistrations = [];
+  if (typeof window !== "undefined" && !windowImpl) {
+    windowImpl = globalThis.__defuss_window || window;
+  }
+  if (!windowImpl && !isServer()) {
+    console.warn("Router requires a Window API implementation!");
+  }
+  const api = {
+    ...config,
+    listeners: [],
+    onRouteChange: (cb) => {
+      api.listeners.push(cb);
+    },
+    tokenizePath,
+    add(registration) {
+      const isAlreadyRegistered = routeRegistrations.some(
+        (registeredRoute) => registeredRoute.path === registration.path
+      );
+      if (!isAlreadyRegistered) {
+        routeRegistrations.push({
+          ...registration,
+          tokenizedPath: tokenizePath(registration.path)
+        });
+      }
+      return api;
+    },
+    match(path) {
+      return matchRouteRegistrations(
+        routeRegistrations,
+        windowImpl.document.location.pathname,
+        path
+      );
+    },
+    navigate(newPath) {
+      const strategy = api.strategy || "page-refresh";
+      const oldPath = windowImpl ? windowImpl.document.location.pathname : "";
+      if (strategy === "page-refresh") {
+        document.location.href = newPath;
+      } else if (strategy === "slot-refresh") {
+        if (typeof windowImpl !== "undefined") {
+          windowImpl.history.pushState({}, "", newPath);
+        }
+        for (const listener of api.listeners) {
+          listener(newPath, oldPath);
+        }
+      }
+    },
+    getRoutes() {
+      return routeRegistrations;
+    }
+  };
+  return api;
+};
+const Router = setupRouter();
+
+const Route = ({ path, exact, children, router = Router }) => {
+  router.add({
+    path,
+    exact: exact || false
+  });
+  return router.match(path) ? children[0] : null;
+};
+
+const Redirect = ({
+  path,
+  to,
+  router = Router,
+  exact
+}) => {
+  queueMicrotask(() => {
+    if (Route({ path, router, exact, children: [true] })) {
+      router.navigate(to);
+    }
+  });
+  return null;
+};
+
+const RouterSlotId = "router-slot";
+const RouterSlot = ({
+  router = Router,
+  children,
+  RouterOutlet,
+  ...attributes
+}) => {
+  const { tag, ...attributesWithoutTag } = attributes;
+  const ref = createRef();
+  router.strategy = "slot-refresh";
+  router.onRouteChange(async () => {
+    await $(ref).update(RouterOutlet());
+  });
+  if (document.getElementById(RouterSlotId)) {
+    console.warn(
+      `It seems there's more than one <RouterSlot /> components defined as an element with id #${RouterSlotId} already exists in the DOM.`
+    );
+  }
+  return {
+    children: RouterOutlet() || [],
+    type: attributes.tag || "div",
+    attributes: {
+      ...attributesWithoutTag,
+      id: RouterSlotId,
+      ref
+    }
+  };
+};
+
+const Async = ({
+  fallback,
+  ref,
+  children,
+  class: _class,
+  className,
+  id,
+  loadingClassName,
+  loadedClassName,
+  errorClassName,
+  onError
+}) => {
+  let childrenToRender = children;
+  const containerRef = createRef(
+    function onSuspenseUpdate(state) {
+      try {
+        if (!containerRef.current) {
+          if (inDevMode) {
+            console.warn(
+              "Suspense container is not mounted yet, but a state update demands a render. State is:",
+              state
+            );
+          }
+          return;
+        }
+        (async () => {
+          await $(containerRef.current).removeClass(
+            loadingClassName || "suspense-loading"
+          );
+          await $(containerRef.current).removeClass(
+            loadedClassName || "suspense-loaded"
+          );
+          await $(containerRef.current).removeClass(
+            errorClassName || "suspense-error"
+          );
+          if (!children || state === "error") {
+            await $(containerRef.current).addClass(
+              errorClassName || "suspense-error"
+            );
+            await $(containerRef).jsx({
+              type: "div",
+              children: ["Loading error!"]
+            });
+          } else if (state === "loading") {
+            await $(containerRef.current).addClass(
+              loadingClassName || "suspense-loading"
+            );
+            await $(containerRef).jsx(fallback);
+          } else if (state === "loaded") {
+            await $(containerRef.current).addClass(
+              loadedClassName || "suspense-loaded"
+            );
+            console.log("[Async render] start");
+            await $(containerRef).jsx(childrenToRender);
+            console.log("[Async render] finished");
+          }
+        })();
+      } catch (error) {
+        containerRef.update("error");
+        containerRef.error = error;
+        if (typeof onError === "function") {
+          onError(error);
+        }
+      }
+    },
+    "loading"
+  );
+  if (isRef(ref)) {
+    let isInitial = true;
+    ref.updateState = (state) => {
+      if (!isInitial) {
+        containerRef.updateState(state);
+      }
+    };
+    ref.updateState("loading");
+    isInitial = false;
+  }
+  const promisedChildren = (children || []).map((vnode) => {
+    try {
+      if (!vnode || vnode && !vnode.type) {
+        return Promise.resolve("");
+      }
+      if (vnode.type.constructor.name === "AsyncFunction") {
+        const props = {
+          ...vnode.attributes,
+          children: vnode.children
+        };
+        return vnode.type(props);
+      }
+      return Promise.resolve(vnode);
+    } catch (error) {
+      containerRef.updateState("error");
+      containerRef.error = error;
+      if (typeof onError === "function") {
+        onError(error);
+      }
+    }
+  });
+  const onMount = () => {
+    if (promisedChildren.length) {
+      containerRef.updateState("loading");
+      Promise.all(promisedChildren).then((awaitedVnodes) => {
+        childrenToRender = awaitedVnodes.flatMap(
+          (vnode) => vnode?.type === "Fragment" ? vnode.children : vnode
+        );
+        containerRef.updateState("loaded");
+      }).catch((error) => {
+        containerRef.updateState("error");
+        containerRef.error = error;
+        {
+          console.error("SuspenseLoadingError", error);
+        }
+        (async () => {
+          await $(containerRef).jsx(`SuspenseLoadingError: ${error}`);
+        })();
+        if (typeof onError === "function") {
+          onError(error);
+        }
+      });
+    }
+  };
+  return {
+    type: "div",
+    attributes: { id, class: _class, className, ref: containerRef, onMount },
+    children: fallback ? [fallback] : []
+  };
+};
+const Suspense = Async;
+
+export { $, Async, Redirect, Route, Router, RouterSlot, RouterSlotId, Suspense, Trans, createI18n, createRef, createStore, i18n, inDevMode, isRef, matchRouteRegistrations, setupRouter, tokenizePath };