@calmdown/pyxis 1.0.0-rc.2 → 1.0.0-rc.4

package/dist/core.js

@@ -1,2 +1,2029 @@
-function e(e){return e.$fn(e.$a0,e.$a1)}function t(e,t=s()){n(t,{$fn:r,$a0:t,$a1:e})}function n(e,t){(e.$onMount??=[]).push(t)}function r(e,t){let n=t();n&&a(e,{$fn:n})}function i(e,t=s()){a(t,{$fn:e})}function a(e,t){(e.$onUnmount??=[]).push(t)}let o=null;function s(){return o}function c(e){let t=o;return o=e,t}function l(e,t,n){let r=o;o=e;try{return t(n)}finally{o=r}}function u(e,t,n){d(e,t,{$fn:n}),n()}function d(e,t,n){t.$dt?(t.$dt.$an=n,n.$ap=t.$dt):t.$dh=n,n.$target=t,t.$dt=n,e.$dt?(e.$dt.$ln=n,n.$lp=e.$dt):e.$dh=n,n.$lifecycle=e,e.$dt=n}function f(e){let t=e.$target;if(!t)return;e.$ap?e.$ap.$an=e.$an:t.$dh===e&&(t.$dh=e.$an),e.$an?e.$an.$ap=e.$ap:t.$dt===e&&(t.$dt=e.$ap),e.$target=null,e.$ap=null,e.$an=null;let n=e.$lifecycle;e.$lp?e.$lp.$ln=e.$ln:n.$dh===e&&(n.$dh=e.$ln),e.$ln?e.$ln.$lp=e.$lp:n.$dt===e&&(n.$dt=e.$lp),e.$lifecycle=null,e.$lp=null,e.$ln=null}function p(e){let t=e.$dh,n,r;for(;t;)n=t.$target,t.$ap?t.$ap.$an=t.$an:n.$dh===t&&(n.$dh=t.$an),t.$an?t.$an.$ap=t.$ap:n.$dt===t&&(n.$dt=t.$ap),r=t.$ln,t.$lifecycle=null,t.$target=null,t.$ap=null,t.$an=null,t.$lp=null,t.$ln=null,t=r;e.$dh=null,e.$dt=null}function m(t){let n=!1,r=[],i=[],a={$epoch:1,$onTick:r,$onTock:i,$scheduleTick:()=>{n||(n=!0,t(o))}},o=()=>{try{let t=0,n;for(;t<r.length;t+=1)n=r[t],n.$life===n.$lifecycle.$life&&e(n);for(t=0;t<i.length;t+=1)n=i[t],n.$life===n.$lifecycle.$life&&e(n)}finally{n=!1,r.length=0,i.length=0,a.$epoch+=1}};return a}function h(e,t,n){let r=e.$scheduler;n.$se!==r.$epoch&&(n.$lifecycle=e,n.$life=e.$life,n.$se=r.$epoch,t.push(n),r.$scheduleTick())}function g(e,t){h(e,e.$scheduler.$onTick,t)}function _(e,t=s()){h(t,t.$scheduler.$onTick,{$fn:e})}function v(e,t){h(e,e.$scheduler.$onTock,t)}function y(e,t=s()){h(t,t.$scheduler.$onTock,{$fn:e})}function b(e,t=s()){S({$lifecycle:t,$life:t.$life,$block:e,$react:x,$cycle:0})}function x(e,t){if(e.$cycle>t){f(this);return}g(e.$lifecycle,e.$resolve??={$fn:S,$a0:e})}function S(e){e.$life===e.$lifecycle.$life&&(e.$dispose?.(),e.$dispose=T(e),!e.$tracksUnmount&&e.$dispose&&(e.$tracksUnmount=!0,a(e.$lifecycle,{$fn:C,$a0:e})))}function C(e){e.$dispose?.(),e.$dispose=null}let w=null;function T(e){e.$deps??=new WeakMap,e.$cycle+=1;let t=w,n=c(e.$lifecycle);w=e;try{return e.$block()}finally{c(n),w=t}}function E(e){if(!w||w.$life!==w.$lifecycle.$life)return;let t=w.$deps.get(e);t?(t.$a1=w.$cycle,t.$lifecycle||d(w.$lifecycle,e,t)):(d(w.$lifecycle,e,t={$fn:w.$react,$a0:w,$a1:w.$cycle}),w.$deps.set(e,t))}function D(e){let t=w;w=null;try{return e()}finally{w=t}}const O=Symbol();function k(e,t=s()){return M(e)?e:{[O]:!0,$value:e,$tracksValue:!0,$lifecycle:t,$lastValue:e,get:A,set:j}}function A(){return this.$value}function j(e){return Object.is(this.$value,e)?!1:(this.$value=e,!0)}function M(e){return typeof e==`object`&&!!e&&e[O]===!0}function N(e){return M(e)?(E(e),e.get()):e}function ee(e){return M(e)?e.get():e}function te(e,t,n=!1){return M(e)?((e.set(t)||n)&&(e.$force||=n,g(e.$lifecycle,e.$notify??={$fn:P,$a0:e})),e.get()):e}function ne(e,t,n=!1){return M(e)?((e.set(t(e.get()))||n)&&(e.$force||=n,g(e.$lifecycle,e.$notify??={$fn:P,$a0:e})),e.get()):e}function P(t){if(t.$tracksValue){let e=t.get();if(Object.is(t.$lastValue,e)&&!t.$force)return;t.$lastValue=e}t.$force=!1;let n=t.$dh,r;for(;n;)r=n.$an,e(n),n=r}function re(e,t,n,r,i,a){let{adapter:o}=t.$ng,s=null;M(e)?u(t.$ng,e,()=>{s=o.text(e.get()?.toString()??``,s)}):s=o.text(e.toString(),null),H(s,null,t,n,i,a)}const F=Symbol();function ie(e,t){let n={adapter:e,mounted:!1,$isGroup:!0,$scheduler:m(e.tick),$extensions:t,$life:1,$pg:null,$ng:null,unmount:()=>B(n),mount:(t,r)=>{let i=!!e.batch,a=i?e.batch():t;z(r,n,a,t,null,i),i&&e.insert(a,t,null)}};return n.$ng=n,n}function I(e,t=null){let n=e.$ng,r={adapter:n.adapter,mounted:!1,$isGroup:!0,$scheduler:n.$scheduler,$extensions:n.$extensions,$life:1,$pg:n,$ng:null};return r.$ng=r,L(r,e,t),r}function L(e,t,n=null){n?.$pg===t?n.$hp?(e.$hp=n.$hp,e.$hn=n,n.$hp.$hn=e,n.$hp=e):(e.$hp=null,e.$hn=t.$hh,t.$hh===n&&(n.$hp=e),t.$hh=e):(t.$ht?(t.$ht.$hn=e,e.$hp=t.$ht):t.$hh=e,t.$ht=e)}function R(e){e.$hp?e.$hp.$hn=e.$hn:e.$pg?.$hh===e&&(e.$pg.$hh=e.$hn),e.$hn?e.$hn.$hp=e.$hp:e.$pg?.$ht===e&&(e.$pg.$ht=e.$hp),e.$hp=null,e.$hn=null}function z(e,t,n,r,i,a){if(t.mounted){oe(t,n,i);return}let o=c(t);try{V(e,t,n,r,i,a)}finally{c(o),t.mounted=!0,t.$pg?.mounted!==!1&&ae(t)}}function ae(t){let n=t.$hh;for(;n;)ae(n),n=n.$hn;let r;if(t.$isGroup&&t.mounted&&(r=t.$onMount)){let n=c(t);try{r.forEach(e)}finally{r.length=0,c(n)}}}function oe(e,t,n){let{adapter:r}=e,i=e.$hh;for(;i;)i.$isNative?r.insert(i.$nn,t,n):oe(i,t,n),i=i.$hn}function B(t,n=!0){if(t.$isGroup){if(t.mounted){let n;if(n=t.$onUnmount){let r=c(t);try{n.forEach(e)}finally{n.length=0,c(r)}}t.mounted=!1,t.$life+=1}p(t)}let{adapter:r}=t.$ng,i=t.$hh,a;for(;i;)i.$isNative&&n?(r.remove(i.$nn),B(i,!1)):B(i,n),a=i.$hn,i.$hp=null,i.$hn=null,i=a;t.$hh=null,t.$ht=null}function V(e,t,n,r,i,a){switch(typeof e){case`object`:if(e===null)break;if(Array.isArray(e)){let{length:o}=e,s=0;for(;s<o;s+=1)V(e[s],t,n,r,i,a);break}if(!M(e)){e[F]?.(e,t,n,r,i,a);break}case`string`:case`number`:case`boolean`:case`bigint`:re(e,t,n,r,i,a);break}}function H(e,t,n,r,i,a){let o=n;if(o.$isGroup){let t=null;if(i){let e=n.$ht;for(;e;){if(e.$isNative&&e.$nn===i){t=e;break}e=e.$hp}}L(o={$isNative:!0,$pg:o,$ng:o,$nn:e},n,t)}V(t,o,e,e,null,a),n.$ng.adapter.insert(e,r,i)}function se(e,t,n,r,i,a){V(e.children,t,n,r,i,a)}function ce(){return{$symbol:Symbol()}}let U=null,W=!1;function G(){return U}function K(e){U=e,W=!1}function le(e){let{$symbol:t}=e,n=U,r;for(;n&&!(r=n[t]);)n=n.$parent;return r??null}function ue(e,t){(!W||!U)&&(W=!0,U={$parent:U});let n=s(),r={[O]:!0,$lifecycle:n,$tracksValue:!0,$value:t,get:fe,set:pe};if(t===void 0){let t=le(e);t&&(r.get=de,r.$ancestor=t,d(n,t,r.$dep={$fn:P,$a0:r}))}return U[e.$symbol]=r,r}function de(){return this.$ancestor.get()}function fe(){return this.$value}function pe(e){let t;return this.$ancestor?(t=this.$ancestor.get(),f(this.$dep),this.$dep=null,this.$ancestor=null,this.get=fe):t=this.$value,this.$value=e,!Object.is(t,e)}let me=function(e){return e[e.Change=1]=`Change`,e[e.Insert=2]=`Insert`,e[e.Remove=3]=`Remove`,e[e.Clear=4]=`Clear`,e}({});function q(){return{changes:[],lengthChange:0}}function he({changes:e},t,n,r){let i=J(e,t,be);if(i<0)e.splice(~i,0,{kind:1,index:t,oldItem:n,newItem:r});else{let a=e[i];switch(a.kind){case 1:case 2:a.newItem=r;break;case 3:e.splice(i+1,0,{kind:1,index:t,oldItem:n,newItem:r});break}}}function ge(e,t,n){let{changes:r}=e,i=J(r,t,xe);if(i<0)i=~i,r.splice(i,0,{kind:2,index:t,newItem:n});else{let e=r[i];switch(e.kind){case 1:case 2:r.splice(i,0,{kind:2,index:t,newItem:n});break;case 3:e.kind=1,e.newItem=n;break}}let{length:a}=r;for(;++i<a;)r[i].index+=1;e.lengthChange+=1}function _e(e,t,n){let{changes:r}=e,i=J(r,t,be);if(i<0)i=~i,r.splice(i,0,{kind:3,index:t,oldItem:n});else{let e=r[i];switch(e.kind){case 1:e.kind=3,e.newItem=void 0;break;case 2:r.splice(i--,1);break;case 3:r.splice(++i,0,{kind:3,index:t,oldItem:n});break}}let{length:a}=r;for(;++i<a;)--r[i].index;--e.lengthChange}function ve(e,t){let{changes:n}=e;n.length=0,n.push({kind:4,index:-1}),e.lengthChange-=t}function ye(e,t,n,r){let i=0,a=t.length,o=n.length;for(;i<a&&i<o&&r(t[i],n[i]);)i+=1;if(i===a&&i===o)return;for(;a>i&&o>i&&r(t[a-1],n[o-1]);)--a,--o;let s=(Math.min(a,o)+1)*2,c=a+o,l={$eq:r,$list0:t,$list1:n,$index0:i,$index1:i,$N:a,$M:o,$Z:s,$c:0,$buffer:new(c<=255?Uint8Array:c<=65535?Uint16Array:Uint32Array)(s+s),$stack:[],$stackTop:0,$pxs:-1,$pxe:-1,$pys:-1,$pye:-1,$oxs:-1,$oxe:-1,$oys:-1,$oye:-1},u=0,d,f,p,m,h,g;do{if(Se(l),l.$c===1)d=l.$oxs,f=l.$oxe,p=l.$oys,m=l.$oye;else if(l.$pxs>=0)d=l.$pxs,f=l.$pxe,p=l.$pys,m=l.$pye;else break;for(h=d;h<f;h+=1)_e(e,d+u,t[h]);for(g=p;g<m;g+=1)ge(e,d+u,n[g]),u+=1;u-=f-d}while(l.$c<2)}const be=(e,t,n,r,i)=>{let a=n;for(;++a<i&&e[a].index===t;);return a-1},xe=(e,t,n,r,i)=>{let a=n;for(;--a>=r&&e[a].index===t;);return a+1};function J(e,t,n){let r=0,i=e.length,a,o;for(;r<i;)if(a=r+i>>>1,o=e[a].index,t<o)i=a;else if(t>o)r=a+1;else return n(e,t,a,r,i);return~r}function Se(e){let{$list0:t,$list1:n,$buffer:r,$stack:i,$eq:a}=e,{$index0:o,$index1:s,$N:c,$M:l,$Z:u,$c:d,$stackTop:f}=e,p,m,h,g,_,v,y,b,x,S,C,w,T,E,D,O,k,A,j,M;for(;;)switch(d){case 0:Z_block:for(;c>0&&l>0;){p=c-l,m=c+l,h=m&1,g=o+c-1,_=s+l-1,b=(m+h)/2,r.fill(0,0,u+u);h_loop:for(y=0;y<=b;y+=1){for(S=2*Math.max(0,y-l)-y,C=y-2*Math.max(0,y-c),x=S;x<=C;x+=2){for(w=r[x-1-u*Math.floor((x-1)/u)],T=r[x+1-u*Math.floor((x+1)/u)],E=x===-y||x!==y&&w<T?T:w+1,D=E-x,O=E,k=D;O<c&&k<l&&a(t[o+O],n[s+k]);)O+=1,k+=1;if(r[x-u*Math.floor(x/u)]=O,h===1&&(v=p-x)>=1-y&&v<y&&O+r[u+v-u*Math.floor(v/u)]>=c)if(y>1||O!==E){i[f++]=o+O,i[f++]=s+k,i[f++]=c-O,i[f++]=l-k,c=E,l=D,u=2*(Math.min(c,l)+1);continue Z_block}else break h_loop}for(x=S;x<=C;x+=2){for(A=r[u+x-1-u*Math.floor((x-1)/u)],j=r[u+x+1-u*Math.floor((x+1)/u)],E=x===-y||x!==y&&A<j?j:A+1,D=E-x,O=E,k=D;O<c&&k<l&&a(t[g-O],n[_-k]);)O+=1,k+=1;if(r[u+x-u*Math.floor(x/u)]=O,h===0&&(v=p-x)>=-y&&v<=y&&O+r[v-u*Math.floor(v/u)]>=c)if(y>0||O!==E){i[f++]=o+c-E,i[f++]=s+l-D,i[f++]=E,i[f++]=D,c-=O,l-=k,u=2*(Math.min(c,l)+1);continue Z_block}else break h_loop}}if(c!==l){l>c?(o+=c,s+=c,l-=c,c=0):(o+=l,s+=l,c-=l,l=0);break}}if(c+l!==0){if(e.$pxe===o||e.$pye===s)e.$pxe=o+c,e.$pye=s+l;else if(M=e.$pxs,e.$oxs=e.$pxs,e.$oxe=e.$pxe,e.$oys=e.$pys,e.$oye=e.$pye,e.$pxs=o,e.$pxe=o+c,e.$pys=s,e.$pye=s+l,M>=0){e.$index0=o,e.$index1=s,e.$N=c,e.$M=l,e.$Z=u,e.$stackTop=f,e.$c=1;return}}case 1:if(f===0){e.$c=2;return}l=i[--f],c=i[--f],s=i[--f],o=i[--f],u=2*(Math.min(c,l)+1),d=0}}function Ce(e,t=s()){let n={[O]:!0,$lifecycle:t,use:we,get:De};return n.use(e,!1),n}function we(e,t=!0){this.$dep&&f(this.$dep);let n=this.get();M(e)?(this.$bound=e,this.$value=null,this.get=Te,this.set=Ee,d(this.$lifecycle,e,this.$dep??={$fn:P,$a0:this})):(this.$bound=null,this.$value=e,this.get=De,this.set=Oe),t&&!Object.is(n,this.get())&&g(this.$lifecycle,this.$notify??={$fn:P,$a0:this})}function Te(){return this.$bound.get()}function Ee(e){let t=this.$bound;return t.set(e)&&g(t.$lifecycle,t.$notify??={$fn:P,$a0:t}),!1}function De(){return this.$value}function Oe(){return!1}const ke={};function Y(e,t,n){let r=Ae(t)?t:ke,i={},{length:a}=n,o=0,s;for(;o<a;o+=1)s=n[o],i[s]=Ce(r[s],e);return i.proxied=t,i}function X(e,t,n){let r=Ae(t)?t:ke,{length:i}=n;e.proxied=t;let a=0,o;for(;a<i;a+=1)o=n[a],e[o].use(r[o])}function Ae(e){return typeof e==`object`&&!!e}function je(e,t,n,r,i,a){let o=e.source,s=e.proxy,c=s!==void 0,u=e.children[0],f=I(t),p=G(),{adapter:m}=f,h=!!m.batch,g=m.marker(),_,v=!!o.$delta;d(f,o,{$fn:()=>{if(v){v=!1;return}let{changes:e,lengthChange:t}=o.$delta,n=e.length,i=_.length+t,a=Array(i),d=[],y=[],b,x=0,S=0,C=0,w=0,T,E,D,O=!1,k=r,A=null;for(;S<n;S+=1){for(T=e[S];w<T.index;)a[w++]=_[C++];switch(T.kind){case 1:b=a[w++]=_[C++],c?X(b.$data,T.newItem,s):(B(b),E=_[C]?.$marker??g,H(b.$marker,null,b,r,E,!1),K(p),z(l(b,u,b.$data=T.newItem),b,r,r,E,!1));break;case 2:!c||x<t?(b=a[w++]=I(f,_[C]),b.$marker=m.marker(),b.$data=c?Y(b,T.newItem,s):T.newItem,x+=1,E=_[C]?.$marker??g,O||(h?(O=!0,k=m.batch(),A=null):A=E),H(b.$marker,null,b,k,A,O),K(p),z(l(b,u,b.$data),b,k,r,A,O),O&&(x>=t||!(D=e[S+1])||D.kind!==2||D.index!==w)&&(m.insert(k,r,E),k=r,O=!1)):d.push({$index:w++,$item:T.newItem});break;case 3:b=_[C++],c?y.push(b):B(b),R(b);break;case 4:if(c)y=_,y.forEach(R),C=_.length;else for(;C<_.length;)b=_[C++],B(b),R(b);break}}for(;w<i;)a[w++]=_[C++];let j=d.length-1,M=y.length-1;for(;j>=0;)D=d[j--],b=a[D.$index]=y[M--],X(b.$data,D.$item,s),L(b,f,E=a[D.$index+1]),K(p),z(l(b,u,b.$data),b,r,r,E?.$marker??g,!1);for(;M>=0;)b=y[M--],B(b),R(b);_=a}});{let e=n,t=i,d=h&&!a&&o.$items.length>0;d&&(e=m.batch(),t=null);let p=d||a;_=o.$items.map(n=>{let i=I(f);return i.$marker=m.marker(),i.$data=c?Y(i,n,s):n,H(i.$marker,null,i,e,t,p),z(l(i,u,i.$data),i,e,r,t,p),i}),H(g,null,f,e,t,p),d&&m.insert(e,n,i)}z(null,f,n,r,i,a)}const Me=/^([^:]+?):(.+)$/,Z=Symbol();function Q(e,t,n,r,i,a){let o=t.$ng,{adapter:s,$extensions:c}=o,l=s.element(e[Z]),d,f,p;for(d in e)if(f=Me.exec(d),p=e[d],f)c[f[1]]?.set(l,f[2],p,o);else if(d!==`children`)if(M(p)){let e=d,t=p;u(o,t,()=>{s.set(l,e,t.get())})}else s.set(l,d,p);H(l,e.children,t,n,i,a)}function Ne(e,t,n,r,i,a){let o=e.when;if(!M(o)&&o===!1)return;let{children:s,data:c}=e,u=e.proxy,f=Object.hasOwn(e,`data`)?s[0]:()=>s,p=c;u&&(M(c)?(p=Y(t.$ng,c.get(),u),d(t.$ng,c,{$fn:()=>{X(p,c.get(),u)}})):p=Y(t.$ng,c,u));let m=t.$ng.adapter,h=!!m.batch;if(!(M(o)||M(f)||!u&&M(c))){let e=h&&!a,o=n,s=i;e&&(o=m.batch(),s=null),V(f(p),t,o,r,s,e||a),e&&m.insert(o,n,i);return}let g=I(t),_=G(),v=i;b(()=>{if(N(o)===!1)return;let e=h&&!a,t=n,i=v;return e&&(t=m.batch(),i=null),K(_),z(l(g,N(f),N(p)),g,t,r,i,e||a),e&&m.insert(t,n,v),()=>B(g)},t.$ng),v=m.marker(),H(v,null,t,n,i,a),a=!1,n=r}function Pe(e,t=s()){let n={[O]:!0,$dirty:!1,$value:null,$tracksValue:!0,$lifecycle:t,$life:t.$life,$lastValue:null,$cycle:0,$block:e,$react:Fe,get:Ie,set:Le},r=T(n);return n.$value=r,n.$lastValue=r,n}function Fe(e,t){if(e.$life!==e.$lifecycle.$life||e.$cycle>t){f(this);return}e.$dirty=!0,g(e.$lifecycle,e.$notify??={$fn:P,$a0:e})}function Ie(){return this.$dirty&&this.$life===this.$lifecycle.$life&&(this.$value=T(this),this.$dirty=!1),this.$value}function Le(){return!1}function Re(e,t=s()){return{$lifecycle:t,$items:e?Array.from(e):[],$delta:null,[Symbol.iterator]:Ge,size:Be,get:Ve,delta:He,raw:Ue,forEach:We,set:Ke,clear:qe,insertAt:Je,insertFirst:Ye,insertLast:Xe,remove:Ze,removeAt:Qe,removeFirst:$e,removeLast:et}}function ze(e,t,n=nt){let r=e.$items;e.$items=t.slice(),ye(e.$delta??=q(),r,t,n),$(e)}function Be(){return E(this),this.$items.length}function Ve(e){return E(this),this.$items[e]}function He(){return E(this),this.$delta}function Ue(){return this.$items}function We(e,t){E(this),this.$items.forEach(e,t)}function Ge(){return E(this),this.$items[Symbol.iterator]()}function Ke(e,t){tt(this,e);let n=this.$items[e];Object.is(t,n)||(this.$items[e]=t,this.$dh&&(he(this.$delta??=q(),e,n,t),$(this)))}function qe(){let e=this.$items.length;this.$items.length=0,this.$dh&&(ve(this.$delta??=q(),e),$(this))}function Je(e,t){let{$items:n}=this;e===n.length?n.push(t):(tt(this,e),this.$items.splice(e,0,t)),this.$dh&&(ge(this.$delta??=q(),e,t),$(this))}function Ye(e){this.insertAt(0,e)}function Xe(e){this.insertAt(this.$items.length,e)}function Ze(e){let t=this.$items.indexOf(e);return t===-1?!1:(this.removeAt(t),!0)}function Qe(e){tt(this,e);let t=this.$items.splice(e,1)[0];return this.$dh&&(_e(this.$delta??=q(),e,t),$(this)),t}function $e(){return this.$items.length>0?this.removeAt(0):void 0}function et(){let{length:e}=this.$items;return e>0?this.removeAt(e-1):void 0}function tt(e,t){if(t>=e.$items.length||t<0)throw RangeError()}function nt(e,t){return Object.is(e,t)}function $(e){g(e.$lifecycle,e.$notify??={$fn:rt,$a0:e}),v(e.$lifecycle,e.$cleanup??={$fn:it,$a0:e})}function rt(t){let n=t.$dh,r;for(;n;)r=n.$an,e(n),n=r}function it(e){e.$delta=null}const at={set:(e,t,r)=>{let i;switch(t){case`atom`:if(!M(r))return;i=ot;break;case`call`:if(typeof r!=`function`)return;i=st;break;default:return}let o=s();n(o,{$fn:i,$a0:r,$a1:e}),a(o,{$fn:i,$a0:r,$a1:null})}};function ot(e,t){e.set(t)}function st(e,t){e(t)}function ct(e,t,n){let{length:r}=n,i=0,a=t[0];for(;i<r;)a+=e(n[i])+t[++i];return a}function lt(e,...t){return ct(N,e,t)}function ut(e,...t){return ct(ee,e,t)}function dt(e){let t={},n={build:()=>ie(e,t),extend:(e,r)=>(t[e]=r,n)};return n}function ft(e){return(t,n,r,i,a,o)=>{let s=G();try{K(s),V(e(t),n,r,i,a,o)}finally{K(s)}}}const pt=Object.freeze([]);function mt(e,t,n){let{children:r}=t;return t.children=r===void 0?pt:Array.isArray(r)?r:[r],t.key??=n,typeof e==`string`?(t[F]=Q,t[Z]=e):t[F]=e,t}function ht(e,t,n){return t.key??=n,typeof e==`string`?(t[F]=Q,t[Z]=e):t[F]=e,t}export{me as ChangeKind,se as Fragment,je as Iterator,Q as Native,at as RefExtension,Ne as Show,k as atomOf,u as bind,ft as component,le as consumerOf,ce as createContext,Pe as derived,b as effect,I as fork,s as getLifecycle,ue as host,H as insert,M as isAtom,mt as jsx,ht as jsxs,Re as listOf,z as mount,V as mountJsx,t as mounted,D as noEffect,ee as peek,ut as peeks,Ce as proxyOf,dt as pyxis,N as read,lt as reads,ze as sync,_ as tick,y as tock,L as track,B as unmount,i as unmounted,R as untrack,ne as update,l as withLifecycle,te as write};
+//#region src/symbols.ts
+const S_ATOM = Symbol.for("pyxis:atom");
+const S_COMPONENT = Symbol.for("pyxis:component");
+const S_TAG_NAME = Symbol.for("pyxis:tagName");
+const S_RUNTIME = Symbol.for("pyxis:runtime");
+//#endregion
+//#region src/Runtime.ts
+const runtime = globalThis[S_RUNTIME] ??= {
+	x: {},
+	$extIndex: 0,
+	$currentLifecycle: null,
+	$currentEffect: null,
+	$currentContext: null,
+	$currentContextNew: false
+};
+//#endregion
+//#region src/support/common.ts
+function invoke(callback) {
+	return callback.fn(callback.a0, callback.a1, callback.a2);
+}
+function noop() {}
+function rethrow(errors) {
+	if (errors) {
+		if (errors.length > 1) throw new AggregateError(errors);
+		if (errors.length === 1) throw errors[0];
+	}
+}
+const UNIQUE_VALUE = Object.create(null);
+//#endregion
+//#region src/data/Dependency.ts
+function bind(lifecycle, target, dependency) {
+	link(lifecycle, target, dependency);
+	return invoke(dependency);
+}
+function link(lifecycle, target, dep) {
+	if (target.$dt) {
+		target.$dt.$an = dep;
+		dep.$ap = target.$dt;
+	} else target.$dh = dep;
+	dep.$target = target;
+	target.$dt = dep;
+	if (lifecycle.$dt) {
+		lifecycle.$dt.$ln = dep;
+		dep.$lp = lifecycle.$dt;
+	} else lifecycle.$dh = dep;
+	dep.$lifecycle = lifecycle;
+	lifecycle.$dt = dep;
+	if (target.$xa && !target.$xn) target.$xn = dep;
+	let update;
+	do {
+		update = target.$notify;
+		if (update && update.$se === update.$lifecycle.$scheduler.$epoch) target.$force = true;
+		target = target.$upstream;
+	} while (target);
+}
+function unlink(dep) {
+	const target = dep.$target;
+	if (!target) return;
+	if (target.$xa && target.$xn === dep) target.$xn = dep.$an;
+	if (dep.$ap) dep.$ap.$an = dep.$an;
+	else if (target.$dh === dep) target.$dh = dep.$an;
+	if (dep.$an) dep.$an.$ap = dep.$ap;
+	else if (target.$dt === dep) target.$dt = dep.$ap;
+	dep.$target = null;
+	dep.$ap = null;
+	dep.$an = null;
+	const lifecycle = dep.$lifecycle;
+	if (dep.$lp) dep.$lp.$ln = dep.$ln;
+	else if (lifecycle.$dh === dep) lifecycle.$dh = dep.$ln;
+	if (dep.$ln) dep.$ln.$lp = dep.$lp;
+	else if (lifecycle.$dt === dep) lifecycle.$dt = dep.$lp;
+	dep.$lifecycle = null;
+	dep.$lp = null;
+	dep.$ln = null;
+}
+function teardown(lifecycle) {
+	let dep = lifecycle.$dh;
+	let target;
+	let next;
+	while (dep) {
+		target = dep.$target;
+		if (target.$xa && target.$xn === dep) target.$xn = dep.$an;
+		if (dep.$ap) dep.$ap.$an = dep.$an;
+		else if (target.$dh === dep) target.$dh = dep.$an;
+		if (dep.$an) dep.$an.$ap = dep.$ap;
+		else if (target.$dt === dep) target.$dt = dep.$ap;
+		next = dep.$ln;
+		dep.$lifecycle = null;
+		dep.$target = null;
+		dep.$ap = null;
+		dep.$an = null;
+		dep.$lp = null;
+		dep.$ln = null;
+		dep = next;
+	}
+	lifecycle.$dh = null;
+	lifecycle.$dt = null;
+	lifecycle.$life += 1;
+	let callbacks;
+	if (callbacks = lifecycle.$onMount) callbacks.length = 0;
+	if (callbacks = lifecycle.$onUnmount) callbacks.length = 0;
+}
+function notify(list) {
+	list.$xa = true;
+	list.$xn = list.$dh;
+	let errors;
+	let current;
+	while (current = list.$xn) {
+		list.$xn = current.$an;
+		try {
+			invoke(current);
+		} catch (ex) {
+			(errors ??= []).push(ex);
+		}
+	}
+	list.$xa = false;
+	list.$xn = null;
+	rethrow(errors);
+}
+//#endregion
+//#region src/Component.ts
+/*@__NO_SIDE_EFFECTS__*/
+function component(block) {
+	return (props, hParent, hBefore, nUsedParent, nRealParent, isBatch) => {
+		const capturedContext = runtime.$currentContext;
+		const capturedContextNew = runtime.$currentContextNew;
+		try {
+			runtime.$currentContextNew = false;
+			mountJsx(block(props), hParent, hBefore, nUsedParent, nRealParent, isBatch);
+		} finally {
+			runtime.$currentContext = capturedContext;
+			runtime.$currentContextNew = capturedContextNew;
+		}
+	};
+}
+//#endregion
+//#region src/data/Lifecycle.ts
+function mounted(block, lifecycle) {
+	lifecycle ??= getLifecycle();
+	onceMounted(lifecycle, {
+		fn: invokeMountedCallback,
+		a0: lifecycle,
+		a1: block
+	});
+}
+function onceMounted(lifecycle, callback) {
+	(lifecycle.$onMount ??= []).push(callback);
+}
+function invokeMountedCallback(lifecycle, block, arg) {
+	const life = lifecycle.$life;
+	const dispose = block(arg);
+	if (dispose) {
+		if (lifecycle.$life > life) {
+			dispose();
+			return;
+		}
+		onceUnmounted(lifecycle, { fn: dispose });
+	}
+}
+function unmounted(block, lifecycle) {
+	onceUnmounted(lifecycle ?? getLifecycle(), { fn: block });
+}
+function onceUnmounted(lifecycle, callback) {
+	(lifecycle.$onUnmount ??= []).push(callback);
+}
+function getLifecycle() {
+	return runtime.$currentLifecycle;
+}
+function withLifecycle(lifecycle, block, a0, a1, a2) {
+	const prevLifecycle = runtime.$currentLifecycle;
+	runtime.$currentLifecycle = lifecycle;
+	try {
+		return block(a0, a1, a2);
+	} finally {
+		runtime.$currentLifecycle = prevLifecycle;
+	}
+}
+//#endregion
+//#region src/data/Scheduler.ts
+/*@__NO_SIDE_EFFECTS__*/
+function createScheduler(tick) {
+	const effects = [];
+	const ticks = [];
+	let tocks = [];
+	let tocksParked = [];
+	let isPending = false;
+	const scheduler = {
+		$epoch: 1,
+		$onEffect: effects,
+		$onTick: ticks,
+		$onTock: tocks,
+		$scheduleTick: () => {
+			if (isPending) return;
+			isPending = true;
+			tick(update);
+		}
+	};
+	const update = () => {
+		const prevLifecycle = runtime.$currentLifecycle;
+		const epoch = scheduler.$epoch;
+		let errors;
+		let effectIndex = 0;
+		let tickIndex = 0;
+		let callback;
+		do {
+			while (tickIndex < ticks.length) {
+				callback = ticks[tickIndex++];
+				callback.$se = 0;
+				if (callback.$life === callback.$lifecycle.$life) try {
+					runtime.$currentLifecycle = callback.$lifecycle;
+					invoke(callback);
+				} catch (ex) {
+					(errors ??= []).push(ex);
+				}
+			}
+			if (effectIndex < effects.length) {
+				callback = effects[effectIndex++];
+				callback.$se = 0;
+				if (callback.$life === callback.$lifecycle.$life) try {
+					runtime.$currentLifecycle = callback.$lifecycle;
+					invoke(callback);
+				} catch (ex) {
+					(errors ??= []).push(ex);
+				}
+			}
+		} while (tickIndex < ticks.length || effectIndex < effects.length);
+		effects.length = 0;
+		ticks.length = 0;
+		scheduler.$onTock = tocksParked;
+		scheduler.$epoch = epoch + 1;
+		const { length } = tocks;
+		let tockIndex = 0;
+		for (; tockIndex < length; tockIndex += 1) {
+			callback = tocks[tockIndex];
+			if (callback.$se === epoch) callback.$se = 0;
+			if (callback.$life === callback.$lifecycle.$life) try {
+				runtime.$currentLifecycle = callback.$lifecycle;
+				invoke(callback);
+			} catch (ex) {
+				(errors ??= []).push(ex);
+			}
+		}
+		const tmp = tocksParked;
+		tocksParked = tocks;
+		tocks = tmp;
+		tocksParked.length = 0;
+		isPending = false;
+		if (ticks.length || tocks.length) scheduler.$scheduleTick();
+		runtime.$currentLifecycle = prevLifecycle;
+		rethrow(errors);
+	};
+	return scheduler;
+}
+function schedule(lifecycle, queue, callback) {
+	callback.$lifecycle = lifecycle;
+	callback.$life = lifecycle.$life;
+	const scheduler = lifecycle.$scheduler;
+	if (callback.$se === scheduler.$epoch) return;
+	callback.$se = scheduler.$epoch;
+	queue.push(callback);
+	scheduler.$scheduleTick();
+}
+function scheduleEffect(lifecycle, callback) {
+	schedule(lifecycle, lifecycle.$scheduler.$onEffect, callback);
+}
+function tick(block, lifecycle = getLifecycle()) {
+	schedule(lifecycle, lifecycle.$scheduler.$onTick, { fn: block });
+}
+function scheduleTick(lifecycle, callback) {
+	schedule(lifecycle, lifecycle.$scheduler.$onTick, callback);
+}
+function tock(block, lifecycle = getLifecycle()) {
+	schedule(lifecycle, lifecycle.$scheduler.$onTock, { fn: block });
+}
+function scheduleTock(lifecycle, callback) {
+	schedule(lifecycle, lifecycle.$scheduler.$onTock, callback);
+}
+//#endregion
+//#region src/data/Effect.ts
+function effect(block, lifecycle = getLifecycle()) {
+	runEffect({
+		$lifecycle: lifecycle,
+		$life: lifecycle.$life,
+		$block: block,
+		$react: scheduleReaction$1,
+		$cycle: 0
+	});
+}
+function scheduleReaction$1(effect, cycle) {
+	if (effect.$cycle > cycle) {
+		unlinkEffectDep(effect, this);
+		return;
+	}
+	scheduleEffect(effect.$lifecycle, effect.$resolve ??= {
+		fn: runEffect,
+		a0: effect
+	});
+}
+function runEffect(effect) {
+	const lifecycle = effect.$lifecycle;
+	if (effect.$life !== lifecycle.$life) return;
+	teardownEffect(effect);
+	if (effect.$life !== lifecycle.$life) return;
+	effect.$dispose = resolve(effect);
+	if (effect.$life !== lifecycle.$life) {
+		teardownEffect(effect);
+		return;
+	}
+	if (!effect.$tracksUnmount && effect.$dispose) {
+		effect.$tracksUnmount = true;
+		onceUnmounted(lifecycle, {
+			fn: teardownEffect,
+			a0: effect
+		});
+	}
+}
+function teardownEffect(effect) {
+	const fn = effect.$dispose;
+	if (!fn) return;
+	const prevLifecycle = runtime.$currentLifecycle;
+	runtime.$currentLifecycle = effect.$lifecycle;
+	effect.$dispose = null;
+	try {
+		fn();
+	} finally {
+		runtime.$currentLifecycle = prevLifecycle;
+	}
+}
+function resolve(effect) {
+	effect.$rc = 0;
+	const cycle = effect.$cycle += 1;
+	const prevLifecycle = runtime.$currentLifecycle;
+	const prevEffect = runtime.$currentEffect;
+	const prevTail = effect.$et;
+	runtime.$currentLifecycle = effect.$lifecycle;
+	runtime.$currentEffect = effect;
+	try {
+		return effect.$block();
+	} finally {
+		runtime.$currentLifecycle = prevLifecycle;
+		runtime.$currentEffect = prevEffect;
+		if (cycle > 1 && effect.$rc > 0 && prevTail) {
+			let current = effect.$eh;
+			let next;
+			while (current) {
+				next = current.$en;
+				if (current.a1 < cycle) unlinkEffectDep(effect, current);
+				if (current === prevTail) break;
+				current = next;
+			}
+		}
+	}
+}
+function unlinkEffectDep(effect, dep) {
+	if (dep.$ep) dep.$ep.$en = dep.$en;
+	else if (effect.$eh === dep) effect.$eh = dep.$en;
+	if (dep.$en) dep.$en.$ep = dep.$ep;
+	else if (effect.$et === dep) effect.$et = dep.$ep;
+	dep.$ep = null;
+	dep.$en = null;
+	effect.$deps?.delete(dep.$target);
+	unlink(dep);
+}
+function reportAccess(atom) {
+	const currentEffect = runtime.$currentEffect;
+	if (!currentEffect || currentEffect.$life !== currentEffect.$lifecycle.$life) return;
+	const deps = currentEffect.$deps;
+	let dep;
+	let count = 0;
+	if (deps) dep = deps.get(atom);
+	else {
+		dep = currentEffect.$eh;
+		while (dep) {
+			count += 1;
+			if (dep.$target === atom) break;
+			dep = dep.$en;
+		}
+	}
+	if (dep) {
+		dep.a1 = currentEffect.$cycle;
+		if (!dep.$lifecycle) link(currentEffect.$lifecycle, atom, dep);
+	} else {
+		link(currentEffect.$lifecycle, atom, dep = {
+			fn: currentEffect.$react,
+			a0: currentEffect,
+			a1: currentEffect.$cycle
+		});
+		if (deps) deps.set(atom, dep);
+		else if (count >= 5) {
+			const map = currentEffect.$deps = /* @__PURE__ */ new WeakMap();
+			let current = currentEffect.$eh;
+			do
+				map.set(current.$target, current);
+			while (current = current.$en);
+			map.set(atom, dep);
+		}
+		if (currentEffect.$et) {
+			currentEffect.$et.$en = dep;
+			dep.$ep = currentEffect.$et;
+		} else currentEffect.$eh = dep;
+		currentEffect.$et = dep;
+		currentEffect.$rc += 1;
+	}
+}
+function noEffect(block, a0, a1, a2) {
+	const prevEffect = runtime.$currentEffect;
+	runtime.$currentEffect = null;
+	try {
+		return block(a0, a1, a2);
+	} finally {
+		runtime.$currentEffect = prevEffect;
+	}
+}
+//#endregion
+//#region src/data/Atom.ts
+function atomOf(initialValue, lifecycle = getLifecycle()) {
+	if (isAtom(initialValue)) initialValue = initialValue.get();
+	return {
+		[S_ATOM]: true,
+		$value: initialValue,
+		$tracksValue: true,
+		$lifecycle: lifecycle,
+		$lastValue: initialValue,
+		get: getValue$1,
+		set: setValue$1
+	};
+}
+function getValue$1() {
+	return this.$value;
+}
+function setValue$1(value) {
+	if (Object.is(this.$value, value)) return false;
+	this.$value = value;
+	return true;
+}
+function isAtom(input) {
+	return input !== null && typeof input === "object" && input[S_ATOM] === true;
+}
+function read(input) {
+	if (isAtom(input)) {
+		reportAccess(input);
+		return input.get();
+	}
+	return input;
+}
+function peek(input) {
+	if (isAtom(input)) return input.get();
+	return input;
+}
+function write(input, value, force = false) {
+	if (!isAtom(input)) return input;
+	if (input.set(value) || force) {
+		if (input.$dh) {
+			input.$force ||= force;
+			scheduleAtomNotification(input);
+		} else if (input.$tracksValue) return input.$lastValue = input.get();
+	}
+	return input.get();
+}
+function update(input, transform, force = false) {
+	if (!isAtom(input)) return input;
+	const value = transform(input.get());
+	if (input.set(value) || force) {
+		if (input.$dh) {
+			input.$force ||= force;
+			scheduleAtomNotification(input);
+		} else if (input.$tracksValue) return input.$lastValue = input.get();
+	}
+	return input.get();
+}
+function scheduleAtomNotification(atom) {
+	scheduleTick(atom.$lifecycle, atom.$notify ??= {
+		fn: notifyAtomObservers,
+		a0: atom
+	});
+}
+function notifyAtomObservers(atom) {
+	if (atom.$tracksValue) {
+		const newValue = atom.get();
+		if (!atom.$force && Object.is(atom.$lastValue, newValue)) return;
+		atom.$lastValue = newValue;
+	}
+	atom.$force = false;
+	notify(atom);
+}
+//#endregion
+//#region src/Renderer.ts
+/*@__NO_SIDE_EFFECTS__*/
+function createRenderer(adapter, extensions) {
+	const hRoot = {
+		adapter,
+		mounted: true,
+		$isGroup: true,
+		$scheduler: /* @__PURE__ */ createScheduler(adapter.tick),
+		$extensions: extensions,
+		$context: null,
+		$depth: 0,
+		$life: 1,
+		$ng: null,
+		$ph: null,
+		unmount: destroy,
+		mount: (nRoot, jsx) => {
+			const hGroup = fork(hRoot, null, null);
+			try {
+				willMount(hGroup, () => {
+					const isBatch = !!adapter.batch;
+					const nParent = isBatch ? adapter.batch() : nRoot;
+					mount(jsx, hGroup, null, nParent, nRoot, isBatch);
+					if (isBatch) {
+						adapter.insert(nParent, nRoot, null);
+						flush(hGroup);
+					}
+				})();
+				return hGroup;
+			} catch (ex) {
+				destroy(hGroup, [ex]);
+			}
+		}
+	};
+	hRoot.$ng = hRoot;
+	return hRoot;
+}
+function destroy(hGroup, errors) {
+	if (!hGroup.$isUnmounting && !deferUnmount(hGroup, true)) {
+		errors = doUnmount(hGroup, errors);
+		untrack(hGroup);
+		hGroup.$ph = null;
+	}
+	rethrow(errors);
+}
+function fork(hParent, hBefore = null, context = runtime.$currentContext) {
+	const ng = hParent.$ng;
+	const hGroup = {
+		adapter: ng.adapter,
+		mounted: false,
+		$isGroup: true,
+		$scheduler: ng.$scheduler,
+		$extensions: ng.$extensions,
+		$context: context,
+		$depth: 0,
+		$life: 1,
+		$ng: null,
+		$ph: hParent
+	};
+	hGroup.$ng = hGroup;
+	track(hGroup, hParent, hBefore);
+	return hGroup;
+}
+function track(hNode, hParent, hBefore = null) {
+	if (hBefore?.$ph === hParent) if (hBefore.$hp) {
+		hNode.$hp = hBefore.$hp;
+		hNode.$hn = hBefore;
+		hBefore.$hp.$hn = hNode;
+		hBefore.$hp = hNode;
+	} else {
+		hNode.$hp = null;
+		hNode.$hn = hParent.$hh;
+		if (hParent.$hh === hBefore) hBefore.$hp = hNode;
+		hParent.$hh = hNode;
+	}
+	else {
+		if (hParent.$ht) {
+			hParent.$ht.$hn = hNode;
+			hNode.$hp = hParent.$ht;
+		} else hParent.$hh = hNode;
+		hParent.$ht = hNode;
+	}
+	hNode.$ph = hParent;
+}
+function untrack(hNode) {
+	if (hNode.$hp) hNode.$hp.$hn = hNode.$hn;
+	else if (hNode.$ph?.$hh === hNode) hNode.$ph.$hh = hNode.$hn;
+	if (hNode.$hn) hNode.$hn.$hp = hNode.$hp;
+	else if (hNode.$ph?.$ht === hNode) hNode.$ph.$ht = hNode.$hp;
+	hNode.$hp = null;
+	hNode.$hn = null;
+}
+function willMount(hGroup, block) {
+	return (a0, a1, a2) => {
+		const mounts = runtime.$mounts ??= [];
+		if (++hGroup.$depth === 1) mounts.push(hGroup);
+		let errors;
+		try {
+			return block(a0, a1, a2);
+		} catch (ex) {
+			(errors ??= []).push(ex);
+		} finally {
+			if (--hGroup.$depth === 0) mounts.pop();
+			finishMount(errors);
+		}
+	};
+}
+function mount(jsx, hParent, hBefore, nUsedParent, nRealParent, isBatch) {
+	if (hParent.mounted) return;
+	const mounts = runtime.$mounts ??= [];
+	if (++hParent.$depth === 1) mounts.push(hParent);
+	const prevLifecycle = runtime.$currentLifecycle;
+	const prevEffect = runtime.$currentEffect;
+	const prevContext = runtime.$currentContext;
+	const prevContextNew = runtime.$currentContextNew;
+	runtime.$currentLifecycle = hParent;
+	runtime.$currentContext = hParent.$context;
+	runtime.$currentContextNew = false;
+	runtime.$currentEffect = null;
+	let errors;
+	try {
+		mountJsx(jsx, hParent, hBefore, nUsedParent, nRealParent, isBatch);
+		hParent.$canMount = true;
+		if (!isBatch) flush(hParent);
+	} catch (ex) {
+		(errors ??= []).push(ex);
+	}
+	runtime.$currentLifecycle = prevLifecycle;
+	runtime.$currentEffect = prevEffect;
+	runtime.$currentContext = prevContext;
+	runtime.$currentContextNew = prevContextNew;
+	if (--hParent.$depth === 0) mounts.pop();
+	if (errors?.length && !deferUnmount(hParent)) errors = doUnmount(hParent, errors);
+	finishMount(errors);
+}
+function finishMount(errors) {
+	if (!runtime.$mounts.length) {
+		const pending = runtime.$unmounts;
+		runtime.$unmounts = null;
+		if (pending) {
+			const { length } = pending;
+			let index = 0;
+			let request;
+			for (; index < length; index += 1) {
+				request = pending[index];
+				if (request.$life !== request.$group.$life) continue;
+				errors = doUnmount(request.$group, errors);
+				if (request.$destroy) {
+					untrack(request.$group);
+					request.$group.$ph = null;
+				}
+			}
+		}
+	}
+	rethrow(errors);
+}
+function deferUnmount(hGroup, isDestroy = false) {
+	const mounts = runtime.$mounts;
+	if (!mounts?.length) return false;
+	const lifecycle = runtime.$currentLifecycle;
+	const { length } = mounts;
+	let index = 0;
+	let active;
+	for (; index < length; index += 1) {
+		active = mounts[index];
+		if (ancestorContainsNode(hGroup, active) || lifecycle?.$isGroup && ancestorContainsNode(active, lifecycle) && ancestorContainsNode(hGroup, lifecycle)) break;
+	}
+	if (index === length) return false;
+	const pending = runtime.$unmounts ??= [];
+	const pendingLength = pending.length;
+	let pendingIndex = 0;
+	let request;
+	for (; pendingIndex < pendingLength; pendingIndex += 1) {
+		request = pending[pendingIndex];
+		if (request.$group === hGroup && request.$life === hGroup.$life) {
+			request.$destroy ||= isDestroy;
+			return true;
+		}
+	}
+	pending.push({
+		$group: hGroup,
+		$life: hGroup.$life,
+		$destroy: isDestroy
+	});
+	return true;
+}
+function ancestorContainsNode(hAncestor, hNode) {
+	while (hNode) {
+		if (hNode === hAncestor) return true;
+		hNode = hNode.$ph;
+	}
+	return false;
+}
+function flush(hGroup) {
+	if (hGroup.$ph?.$ng.mounted !== false) {
+		const prevLifecycle = runtime.$currentLifecycle;
+		const prevEffect = runtime.$currentEffect;
+		runtime.$currentEffect = null;
+		const mounts = runtime.$mounts ??= [];
+		if (++hGroup.$depth === 1) mounts.push(hGroup);
+		const errors = doFlush(hGroup, void 0);
+		runtime.$currentLifecycle = prevLifecycle;
+		runtime.$currentEffect = prevEffect;
+		if (--hGroup.$depth === 0) mounts.pop();
+		finishMount(errors);
+	}
+}
+function doFlush(hNode, errors) {
+	let current = hNode.$hh;
+	while (current) {
+		errors = doFlush(current, errors);
+		current = current.$hn;
+	}
+	if (hNode.$isGroup && hNode.$canMount && !hNode.mounted) {
+		hNode.mounted = true;
+		if (hNode.$onMount?.length) {
+			const callbacks = hNode.$onMount;
+			let index = 0;
+			runtime.$currentLifecycle = hNode;
+			for (; index < callbacks.length; index += 1) try {
+				invoke(callbacks[index]);
+			} catch (ex) {
+				(errors ??= []).push(ex);
+			}
+			callbacks.length = 0;
+		}
+	}
+	return errors;
+}
+function reinsertNodes(hParent, hBefore, nParent) {
+	if (!hParent.mounted) return;
+	const { adapter } = hParent;
+	const nAnchor = hBefore?.$nn ?? null;
+	let current = hParent.$hh;
+	while (current) {
+		if (current.$isNative) adapter.insert(current.$nn, nParent, nAnchor);
+		else reinsertNodes(current, hBefore, nParent);
+		current = current.$hn;
+	}
+}
+function unmount(hGroup, errors) {
+	if (deferUnmount(hGroup)) {
+		rethrow(errors);
+		return;
+	}
+	errors = doUnmount(hGroup, errors);
+	rethrow(errors);
+}
+function doUnmount(hGroup, errors) {
+	const prevLifecycle = runtime.$currentLifecycle;
+	const prevEffect = runtime.$currentEffect;
+	runtime.$currentEffect = null;
+	errors = unmountNode(hGroup, errors, true);
+	runtime.$currentLifecycle = prevLifecycle;
+	runtime.$currentEffect = prevEffect;
+	return errors;
+}
+function unmountNode(hNode, errors, top) {
+	if (hNode.$isUnmounting) return errors;
+	hNode.$isUnmounting = true;
+	if (hNode.$isGroup) {
+		if (hNode.$onUnmount?.length) {
+			const callbacks = hNode.$onUnmount;
+			let index = 0;
+			runtime.$currentLifecycle = hNode;
+			for (; index < callbacks.length; index += 1) try {
+				invoke(callbacks[index]);
+			} catch (ex) {
+				(errors ??= []).push(ex);
+			}
+		}
+		teardown(hNode);
+		hNode.mounted = false;
+		hNode.$canMount = false;
+	}
+	const { adapter } = hNode.$ng;
+	let current = hNode.$hh;
+	let next;
+	while (current) {
+		if (current.$isNative && top) {
+			try {
+				adapter.remove(current.$nn);
+			} catch (ex) {
+				(errors ??= []).push(ex);
+			}
+			errors = unmountNode(current, errors, false);
+		} else errors = unmountNode(current, errors, top);
+		next = current.$hn;
+		current.$hp = null;
+		current.$hn = null;
+		current.$ph = null;
+		current = next;
+	}
+	hNode.$hh = null;
+	hNode.$ht = null;
+	hNode.$isUnmounting = false;
+	return errors;
+}
+function mountJsx(jsx, hParent, hBefore, nUsedParent, nRealParent, isBatch) {
+	switch (typeof jsx) {
+		case "object":
+			if (jsx === null) break;
+			if (Array.isArray(jsx)) {
+				const text = mountJsxArray(jsx, hParent, hBefore, nUsedParent, nRealParent, isBatch);
+				if (text) mountStaticText(text, hParent, hBefore, nUsedParent, isBatch);
+				break;
+			}
+			if (isAtom(jsx)) mountDynamicText(jsx, hParent, hBefore, nUsedParent, isBatch);
+			else jsx[S_COMPONENT]?.(jsx, hParent, hBefore, nUsedParent, nRealParent, isBatch);
+			break;
+		case "string": if (jsx === "") break;
+		case "number":
+		case "bigint":
+			mountStaticText("" + jsx, hParent, hBefore, nUsedParent, isBatch);
+			break;
+	}
+}
+function mountJsxArray(jsx, hParent, hBefore, nUsedParent, nRealParent, isBatch, text = "") {
+	const { length } = jsx;
+	let index = 0;
+	let item;
+	for (; index < length; index += 1) {
+		item = jsx[index];
+		switch (typeof item) {
+			case "string":
+			case "number":
+			case "bigint":
+				text += item;
+				break;
+			case "boolean": break;
+			default:
+				if (item === null || item === void 0) break;
+				if (Array.isArray(item)) {
+					text = mountJsxArray(item, hParent, hBefore, nUsedParent, nRealParent, isBatch, text);
+					break;
+				}
+				if (text) {
+					mountStaticText(text, hParent, hBefore, nUsedParent, isBatch);
+					text = "";
+				}
+				mountJsx(item, hParent, hBefore, nUsedParent, nRealParent, isBatch);
+				break;
+		}
+	}
+	return text;
+}
+function mountStaticText(text, hParent, hBefore, nUsedParent, isBatch) {
+	insert(hParent.$ng.adapter.text(text, null), null, hParent, hBefore, nUsedParent, isBatch);
+}
+function mountDynamicText(atom, hParent, hBefore, nUsedParent, isBatch) {
+	insert(bind(hParent.$ng, atom, {
+		fn: setBoundText,
+		a0: hParent.$ng.adapter,
+		a1: null
+	}), null, hParent, hBefore, nUsedParent, isBatch);
+}
+function setBoundText(adapter, node) {
+	const value = this.$target.get();
+	return this.a1 = adapter.text(value === null || value === void 0 || typeof value === "boolean" ? "" : "" + value, node);
+}
+function insert(nNode, children, hParent, hBefore, nUsedParent, isBatch, forceTrack = false) {
+	let hNative = hParent;
+	if (hNative.$isGroup || forceTrack) track(hNative = {
+		$isNative: true,
+		$ng: hParent.$ng,
+		$nn: nNode,
+		$ph: hParent
+	}, hParent, hBefore);
+	mountJsx(children, hNative, null, nNode, nNode, isBatch);
+	hParent.$ng.adapter.insert(nNode, nUsedParent, isBatch ? null : hBefore?.$nn ?? null);
+	return hNative === hParent ? null : hNative;
+}
+//#endregion
+//#region src/component/Fragment.ts
+function Fragment(jsx, hParent, hBefore, nUsedParent, nRealParent, isBatch) {
+	mountJsx(jsx.children, hParent, hBefore, nUsedParent, nRealParent, isBatch);
+}
+//#endregion
+//#region src/data/ListDelta.ts
+const LC_CHANGE = 1;
+const LC_INSERT = 2;
+const LC_REMOVE = 3;
+const LC_CLEAR = 4;
+function itemChanged({ changes: $changes }, at, oldItem, newItem) {
+	const ci = binarySearch($changes, at, latest);
+	if (ci < 0) $changes.splice(~ci, 0, {
+		kind: 1,
+		index: at,
+		oldItem,
+		newItem
+	});
+	else {
+		const current = $changes[ci];
+		switch (current.kind) {
+			case 1:
+			case 2:
+				current.newItem = newItem;
+				break;
+			case 3:
+				$changes.splice(ci + 1, 0, {
+					kind: 1,
+					index: at,
+					oldItem,
+					newItem
+				});
+				break;
+		}
+	}
+}
+function itemInserted(delta, at, item) {
+	const { changes: $changes } = delta;
+	let ci = binarySearch($changes, at, earliest);
+	if (ci < 0) {
+		ci = ~ci;
+		$changes.splice(ci, 0, {
+			kind: 2,
+			index: at,
+			newItem: item
+		});
+	} else {
+		const current = $changes[ci];
+		switch (current.kind) {
+			case 1:
+			case 2:
+				$changes.splice(ci, 0, {
+					kind: 2,
+					index: at,
+					newItem: item
+				});
+				break;
+			case 3:
+				if (Object.is(current.oldItem, item)) $changes.splice(ci--, 1);
+				else {
+					current.kind = 1;
+					current.newItem = item;
+				}
+				break;
+		}
+	}
+	const { length } = $changes;
+	while (++ci < length) $changes[ci].index += 1;
+	delta.relSize += 1;
+}
+function itemRemoved(delta, at, item) {
+	const { changes: $changes } = delta;
+	let ci = binarySearch($changes, at, latest);
+	if (ci < 0) {
+		ci = ~ci;
+		$changes.splice(ci, 0, {
+			kind: 3,
+			index: at,
+			oldItem: item
+		});
+	} else {
+		const current = $changes[ci];
+		switch (current.kind) {
+			case 1:
+				current.kind = 3;
+				current.newItem = void 0;
+				break;
+			case 2:
+				$changes.splice(ci--, 1);
+				break;
+			case 3:
+				$changes.splice(++ci, 0, {
+					kind: 3,
+					index: at,
+					oldItem: item
+				});
+				break;
+		}
+	}
+	const { length } = $changes;
+	while (++ci < length) $changes[ci].index -= 1;
+	delta.relSize -= 1;
+}
+function listCleared(delta, count) {
+	delta.changes.length = 0;
+	delta.relSize -= count;
+	if (delta.relSize === 0) return;
+	delta.changes.push({
+		kind: 4,
+		index: -1
+	});
+}
+function listSynced(delta, oldState, newState, eq) {
+	let index = 0;
+	let N = oldState.length;
+	let M = newState.length;
+	while (index < N && index < M && eq(oldState[index], newState[index])) index += 1;
+	if (index === N && index === M) return false;
+	while (N > index && M > index && eq(oldState[N - 1], newState[M - 1])) {
+		N -= 1;
+		M -= 1;
+	}
+	N -= index;
+	M -= index;
+	const Z = (Math.min(N, M) + 1) * 2;
+	const L = N + M;
+	const state = {
+		$eq: eq,
+		$list0: oldState,
+		$list1: newState,
+		$index0: index,
+		$index1: index,
+		$N: N,
+		$M: M,
+		$Z: Z,
+		$c: 0,
+		$buffer: new (L <= 255 ? Uint8Array : L <= 65535 ? Uint16Array : Uint32Array)(Z + Z),
+		$stack: [],
+		$stackTop: 0,
+		$pxs: -1,
+		$pxe: -1,
+		$pys: -1,
+		$pye: -1,
+		$oxs: -1,
+		$oxe: -1,
+		$oys: -1,
+		$oye: -1
+	};
+	let offset = 0;
+	let hasChanges = false;
+	let rs, re, is, ie, r, i;
+	do {
+		myersDiff(state);
+		if (state.$c === 1) {
+			rs = state.$oxs;
+			re = state.$oxe;
+			is = state.$oys;
+			ie = state.$oye;
+		} else if (state.$pxs >= 0) {
+			rs = state.$pxs;
+			re = state.$pxe;
+			is = state.$pys;
+			ie = state.$pye;
+		} else break;
+		for (r = rs; r < re; r += 1) {
+			itemRemoved(delta, rs + offset, oldState[r]);
+			hasChanges = true;
+		}
+		for (i = is; i < ie; i += 1) {
+			itemInserted(delta, rs + offset, newState[i]);
+			hasChanges = true;
+			offset += 1;
+		}
+		offset -= re - rs;
+	} while (state.$c < 2);
+	return hasChanges;
+}
+const latest = (changes, index, mid, _min, max) => {
+	let i = mid;
+	while (++i < max && changes[i].index === index);
+	return i - 1;
+};
+const earliest = (changes, index, mid, min, _max) => {
+	let i = mid;
+	while (--i >= min && changes[i].index === index);
+	return i + 1;
+};
+function binarySearch(changes, index, bias) {
+	let min = 0;
+	let max = changes.length;
+	let mid;
+	let tmp;
+	while (min < max) {
+		mid = min + max >>> 1;
+		tmp = changes[mid].index;
+		if (index < tmp) max = mid;
+		else if (index > tmp) min = mid + 1;
+		else return bias(changes, index, mid, min, max);
+	}
+	return ~min;
+}
+function myersDiff(state) {
+	const { $list0, $list1, $buffer, $stack, $eq } = state;
+	let { $index0, $index1, $N, $M, $Z, $c, $stackTop } = state;
+	let W, L, parity, offsetX, offsetY, z, h, hMax, k, kMin, kMax, gkm, gkp, u, v, x, y, pkm, pkp, sx;
+	while (true) switch ($c) {
+		case 0:
+			Z_block: while ($N > 0 && $M > 0) {
+				W = $N - $M;
+				L = $N + $M;
+				parity = L & 1;
+				offsetX = $index0 + $N - 1;
+				offsetY = $index1 + $M - 1;
+				hMax = (L + parity) / 2;
+				$buffer.fill(0, 0, $Z + $Z);
+				h_loop: for (h = 0; h <= hMax; h += 1) {
+					kMin = 2 * Math.max(0, h - $M) - h;
+					kMax = h - 2 * Math.max(0, h - $N);
+					for (k = kMin; k <= kMax; k += 2) {
+						gkm = $buffer[k - 1 - $Z * Math.floor((k - 1) / $Z)];
+						gkp = $buffer[k + 1 - $Z * Math.floor((k + 1) / $Z)];
+						u = k === -h || k !== h && gkm < gkp ? gkp : gkm + 1;
+						v = u - k;
+						x = u;
+						y = v;
+						while (x < $N && y < $M && $eq($list0[$index0 + x], $list1[$index1 + y])) {
+							x += 1;
+							y += 1;
+						}
+						$buffer[k - $Z * Math.floor(k / $Z)] = x;
+						if (parity === 1 && (z = W - k) >= 1 - h && z < h && x + $buffer[$Z + z - $Z * Math.floor(z / $Z)] >= $N) if (h > 1 || x !== u) {
+							$stack[$stackTop++] = $index0 + x;
+							$stack[$stackTop++] = $index1 + y;
+							$stack[$stackTop++] = $N - x;
+							$stack[$stackTop++] = $M - y;
+							$N = u;
+							$M = v;
+							$Z = 2 * (Math.min($N, $M) + 1);
+							continue Z_block;
+						} else break h_loop;
+					}
+					for (k = kMin; k <= kMax; k += 2) {
+						pkm = $buffer[$Z + k - 1 - $Z * Math.floor((k - 1) / $Z)];
+						pkp = $buffer[$Z + k + 1 - $Z * Math.floor((k + 1) / $Z)];
+						u = k === -h || k !== h && pkm < pkp ? pkp : pkm + 1;
+						v = u - k;
+						x = u;
+						y = v;
+						while (x < $N && y < $M && $eq($list0[offsetX - x], $list1[offsetY - y])) {
+							x += 1;
+							y += 1;
+						}
+						$buffer[$Z + k - $Z * Math.floor(k / $Z)] = x;
+						if (parity === 0 && (z = W - k) >= -h && z <= h && x + $buffer[z - $Z * Math.floor(z / $Z)] >= $N) if (h > 0 || x !== u) {
+							$stack[$stackTop++] = $index0 + $N - u;
+							$stack[$stackTop++] = $index1 + $M - v;
+							$stack[$stackTop++] = u;
+							$stack[$stackTop++] = v;
+							$N = $N - x;
+							$M = $M - y;
+							$Z = 2 * (Math.min($N, $M) + 1);
+							continue Z_block;
+						} else break h_loop;
+					}
+				}
+				if ($N === $M) continue;
+				if ($M > $N) {
+					$index0 += $N;
+					$index1 += $N;
+					$M -= $N;
+					$N = 0;
+				} else {
+					$index0 += $M;
+					$index1 += $M;
+					$N -= $M;
+					$M = 0;
+				}
+				break;
+			}
+			if ($N + $M !== 0) if (state.$pxe === $index0 || state.$pye === $index1) {
+				state.$pxe = $index0 + $N;
+				state.$pye = $index1 + $M;
+			} else {
+				sx = state.$pxs;
+				state.$oxs = state.$pxs;
+				state.$oxe = state.$pxe;
+				state.$oys = state.$pys;
+				state.$oye = state.$pye;
+				state.$pxs = $index0;
+				state.$pxe = $index0 + $N;
+				state.$pys = $index1;
+				state.$pye = $index1 + $M;
+				if (sx >= 0) {
+					state.$index0 = $index0;
+					state.$index1 = $index1;
+					state.$N = $N;
+					state.$M = $M;
+					state.$Z = $Z;
+					state.$stackTop = $stackTop;
+					state.$c = 1;
+					return;
+				}
+			}
+		case 1:
+			if ($stackTop === 0) {
+				state.$c = 2;
+				return;
+			}
+			$M = $stack[--$stackTop];
+			$N = $stack[--$stackTop];
+			$index1 = $stack[--$stackTop];
+			$index0 = $stack[--$stackTop];
+			$Z = 2 * (Math.min($N, $M) + 1);
+			$c = 0;
+	}
+}
+//#endregion
+//#region src/data/ProxyAtom.ts
+function proxyOf(initialValue, lifecycle = getLifecycle()) {
+	const self = {
+		[S_ATOM]: true,
+		$lifecycle: lifecycle,
+		use
+	};
+	self.use(initialValue, true);
+	return self;
+}
+function use(value, isInit = false) {
+	if (value === this) return;
+	const upstream = this.$upstream;
+	if (upstream && upstream === value) return;
+	let shouldNotify = true;
+	if (isAtom(value)) {
+		if (!upstream || isInit) {
+			this.$value = null;
+			this.$tracksValue = false;
+			this.$lastValue = null;
+			this.get = getUpstreamValue$1;
+			this.set = setUpstreamValue;
+		} else unlink(this.$dep);
+		this.$upstream = value;
+		link(this.$lifecycle, value, this.$dep ??= {
+			fn: scheduleAtomNotification,
+			a0: this
+		});
+	} else {
+		if (upstream || isInit) {
+			this.$upstream = null;
+			this.$tracksValue = true;
+			this.$lastValue = UNIQUE_VALUE;
+			this.get = getStaticValue;
+			this.set = setStaticValue;
+			if (!isInit) unlink(this.$dep);
+		} else shouldNotify = !Object.is(this.$value, value);
+		this.$value = value;
+	}
+	if (this.$dh) {
+		if (shouldNotify) scheduleAtomNotification(this);
+	} else if (this.$tracksValue) this.$lastValue = value;
+}
+function getUpstreamValue$1() {
+	return this.$upstream.get();
+}
+function setUpstreamValue(value) {
+	const atom = this.$upstream;
+	if (atom.set(value) && atom.$dh) scheduleAtomNotification(atom);
+	return false;
+}
+function getStaticValue() {
+	return this.$value;
+}
+function setStaticValue() {
+	return false;
+}
+function createProxy(lifecycle, data, keys) {
+	const source = isObject(data) ? data : UNIQUE_VALUE;
+	const proxy = Object.create(null);
+	const { length } = keys;
+	let index = 0;
+	let key;
+	for (; index < length; index += 1) {
+		key = keys[index];
+		proxy[key] = proxyOf(source[key], lifecycle);
+	}
+	proxy.proxied = data;
+	return proxy;
+}
+function updateProxy(proxy, data, keys) {
+	const source = isObject(data) ? data : UNIQUE_VALUE;
+	const { length } = keys;
+	proxy.proxied = data;
+	let index = 0;
+	let key;
+	for (; index < length; index += 1) {
+		key = keys[index];
+		proxy[key].use(source[key]);
+	}
+}
+function isObject(value) {
+	return value !== null && typeof value === "object";
+}
+//#endregion
+//#region src/support/template.ts
+function Template(jsx, hParent, hBefore, nUsedParent, nRealParent, isBatch) {
+	mountJsx(jsx.t?.(jsx.d), hParent, hBefore, nUsedParent, nRealParent, isBatch);
+}
+const REUSED_JSX = { [S_COMPONENT]: Template };
+function mountTemplate(template, data, hParent, hBefore, nUsedParent, nRealParent, isBatch) {
+	REUSED_JSX.t = template;
+	REUSED_JSX.d = data;
+	try {
+		mount(REUSED_JSX, hParent, hBefore, nUsedParent, nRealParent, isBatch);
+	} finally {
+		REUSED_JSX.t = null;
+		REUSED_JSX.d = null;
+	}
+}
+//#endregion
+//#region src/component/Iterator.ts
+function Iterator(jsx, hParent, hBefore, nUsedParent, nRealParent, isBatch) {
+	const source = jsx.source;
+	const proxyKeys = jsx.proxy;
+	const isProxy = proxyKeys !== void 0;
+	const template = jsx.children[0];
+	const hGroup = fork(hParent, hBefore);
+	const { adapter } = hGroup;
+	const shouldBatch = !!adapter.batch;
+	const nListEndMarker = adapter.marker();
+	let renderedItems;
+	let hListEndMarker = null;
+	const renderInitialItems = (initItems, hInitBefore, nInitParent, initIsBatch) => {
+		let nBatchParent = nInitParent;
+		const isLocalBatch = shouldBatch && !initIsBatch && initItems.length > 0;
+		const isAnyBatch = isLocalBatch || initIsBatch;
+		if (isLocalBatch) nBatchParent = adapter.batch();
+		let errors;
+		renderedItems = initItems.map((data) => {
+			const item = createItem(hGroup, hListEndMarker ?? hInitBefore, nBatchParent, isAnyBatch, data, proxyKeys);
+			try {
+				mountTemplate(template, item.$data, item, hInitBefore, nBatchParent, nRealParent, isAnyBatch);
+			} catch (ex) {
+				(errors ??= []).push(ex);
+			}
+			return item;
+		});
+		if (isLocalBatch) {
+			adapter.insert(nBatchParent, nInitParent, hInitBefore?.$nn ?? null);
+			errors = flushItems(renderedItems, 0, renderedItems.length, errors);
+		}
+		rethrow(errors);
+	};
+	source.delta(willMount(hGroup, (delta) => {
+		if (!renderedItems) {
+			renderInitialItems(delta.snapshot, hListEndMarker, nRealParent, false);
+			return;
+		}
+		const { changes, relSize } = delta;
+		const cMax = changes.length;
+		const iMax = renderedItems.length + relSize;
+		let newItems = renderedItems;
+		let errors;
+		let pending;
+		let recycled;
+		let item;
+		let inserted = 0;
+		let ci = 0;
+		let oi = 0;
+		let ni = 0;
+		let change;
+		let ref;
+		let tmp;
+		let isLocalBatch = false;
+		let nBatchParent = nRealParent;
+		let batchStart = 0;
+		for (; ci < cMax; ci += 1) {
+			change = changes[ci];
+			if (newItems === renderedItems) if (change.kind === 1) oi = ni = change.index;
+			else {
+				newItems = new Array(iMax);
+				oi = ni = 0;
+			}
+			while (ni < change.index) newItems[ni++] = renderedItems[oi++];
+			switch (change.kind) {
+				case 1:
+					item = newItems[ni++] = renderedItems[oi++];
+					if (isProxy) updateProxy(item.$data, change.newItem, proxyKeys);
+					else {
+						try {
+							unmount(item);
+						} catch (ex) {
+							(errors ??= []).push(ex);
+						}
+						ref = renderedItems[oi]?.$marker ?? hListEndMarker;
+						try {
+							mountTemplate(template, item.$data = change.newItem, item, ref, nRealParent, nRealParent, false);
+						} catch (ex) {
+							(errors ??= []).push(ex);
+						}
+					}
+					break;
+				case 2:
+					if (!isProxy || inserted < relSize) {
+						ref = renderedItems[oi]?.$marker ?? hListEndMarker;
+						if (!isLocalBatch) {
+							if (shouldBatch) {
+								isLocalBatch = true;
+								batchStart = ni;
+								nBatchParent = adapter.batch();
+							}
+						}
+						inserted += 1;
+						item = newItems[ni++] = createItem(hGroup, renderedItems[oi]?.$marker ?? hListEndMarker, nBatchParent, isLocalBatch, change.newItem, proxyKeys);
+						try {
+							mountTemplate(template, item.$data, item, ref, nBatchParent, nRealParent, isLocalBatch);
+						} catch (ex) {
+							(errors ??= []).push(ex);
+						}
+						if (isLocalBatch && (inserted >= relSize || !(tmp = changes[ci + 1]) || tmp.kind !== 2 || tmp.index !== ni)) {
+							adapter.insert(nBatchParent, nRealParent, ref.$nn);
+							errors = flushItems(newItems, batchStart, ni, errors);
+							nBatchParent = nRealParent;
+							isLocalBatch = false;
+						}
+					} else {
+						(pending ??= []).push(ci);
+						ni += 1;
+					}
+					break;
+				case 3:
+					item = renderedItems[oi++];
+					if (isProxy) {
+						(recycled ??= []).push(item);
+						untrackItem(item);
+					} else try {
+						destroyItem(item);
+					} catch (ex) {
+						(errors ??= []).push(ex);
+					}
+					break;
+				case 4:
+					if (isProxy) {
+						recycled = renderedItems;
+						recycled.forEach(untrackItem);
+						oi = renderedItems.length;
+					} else while (oi < renderedItems.length) {
+						item = renderedItems[oi++];
+						try {
+							destroyItem(item);
+						} catch (ex) {
+							(errors ??= []).push(ex);
+						}
+					}
+					break;
+			}
+		}
+		if (newItems !== renderedItems) while (ni < iMax) newItems[ni++] = renderedItems[oi++];
+		let pi = pending ? pending.length - 1 : -1;
+		let ri = recycled ? recycled.length - 1 : -1;
+		while (pi >= 0) {
+			tmp = changes[pending[pi--]];
+			item = newItems[tmp.index] = recycled[ri--];
+			updateProxy(item.$data, tmp.newItem, proxyKeys);
+			ref = newItems[tmp.index + 1];
+			track(item.$marker, hGroup, ref?.$marker ?? hListEndMarker);
+			track(item, hGroup, ref?.$marker ?? hListEndMarker);
+			adapter.insert(item.$marker.$nn, nRealParent, ref?.$marker.$nn ?? nListEndMarker);
+			reinsertNodes(item, ref?.$marker ?? hListEndMarker, nRealParent);
+		}
+		while (ri >= 0) {
+			item = recycled[ri--];
+			try {
+				destroyItem(item);
+			} catch (ex) {
+				(errors ??= []).push(ex);
+			}
+		}
+		renderedItems = newItems;
+		rethrow(errors);
+	}), hGroup);
+	if (!source.dirty()) source.stable((snapshot) => {
+		renderInitialItems(snapshot, hBefore, nUsedParent, isBatch);
+	});
+	hListEndMarker = insert(nListEndMarker, null, hGroup, hBefore, nUsedParent, isBatch, true);
+	mount(null, hGroup, hBefore, nUsedParent, nRealParent, isBatch);
+}
+function flushItems(items, start, end, errors) {
+	let index = start;
+	for (; index < end; index += 1) try {
+		flush(items[index]);
+	} catch (ex) {
+		(errors ??= []).push(ex);
+	}
+	return errors;
+}
+function createItem(hParent, hBefore, nParent, isBatch, data, proxyKeys) {
+	const marker = insert(hParent.adapter.marker(), null, hParent, hBefore, nParent, isBatch, true);
+	const item = fork(hParent, hBefore, hParent.$context);
+	item.$marker = marker;
+	item.$data = proxyKeys !== void 0 ? createProxy(item, data, proxyKeys) : data;
+	return item;
+}
+function untrackItem(item) {
+	untrack(item.$marker);
+	untrack(item);
+}
+function destroyItem(item) {
+	try {
+		destroy(item);
+	} finally {
+		const marker = item.$marker;
+		item.adapter.remove(marker.$nn);
+		untrack(marker);
+		marker.$ph = null;
+	}
+}
+//#endregion
+//#region src/component/Native.ts
+function Native(jsx, hParent, hBefore, nUsedParent, _nRealParent, isBatch) {
+	const hGroup = hParent.$ng;
+	const { adapter, $extensions } = hGroup;
+	const nNode = adapter.element(jsx[S_TAG_NAME]);
+	let name;
+	let index;
+	let value;
+	let target;
+	for (name in jsx) {
+		index = name.indexOf(":");
+		value = jsx[name];
+		if (index === 0) {
+			if (target = runtime.x[name]) target.$ext.set(nNode, target.$prop, value, hGroup);
+		} else if (index > 0) $extensions[name.slice(0, index)]?.set(nNode, name.slice(index + 1), value, hGroup);
+		else if (name !== "children") {
+			if (isAtom(value)) {
+				link(hGroup, value, {
+					fn: setBoundProp,
+					a0: adapter,
+					a1: nNode,
+					a2: name
+				});
+				value = value.get();
+			}
+			adapter.set(nNode, name, value);
+		}
+	}
+	insert(nNode, jsx.children, hParent, hBefore, nUsedParent, isBatch);
+	return nNode;
+}
+function setBoundProp(adapter, node, prop) {
+	adapter.set(node, prop, this.$target.get());
+}
+//#endregion
+//#region src/component/Show.ts
+function Show(props, hParent, hBefore, nUsedParent, nRealParent, isBatch) {
+	const when = props.when;
+	if (!isAtom(when) && when === false) return;
+	const { children, data } = props;
+	const proxyKeys = props.proxy;
+	const template = Object.hasOwn(props, "data") ? children[0] : () => children;
+	let dataOrProxy = data;
+	if (proxyKeys) if (isAtom(data)) {
+		dataOrProxy = createProxy(hParent.$ng, data.get(), proxyKeys);
+		link(hParent.$ng, data, {
+			fn: updateShowProxy,
+			a0: dataOrProxy,
+			a1: data,
+			a2: proxyKeys
+		});
+	} else dataOrProxy = createProxy(hParent.$ng, data, proxyKeys);
+	const adapter = hParent.$ng.adapter;
+	const shouldBatch = !!adapter.batch;
+	if (!(isAtom(when) || isAtom(template) || !proxyKeys && isAtom(data))) {
+		const isLocalBatch = shouldBatch && !isBatch;
+		let nBatchParent = nUsedParent;
+		if (isLocalBatch) nBatchParent = adapter.batch();
+		mountJsx(template(dataOrProxy), hParent, hBefore, nBatchParent, nRealParent, isLocalBatch || isBatch);
+		if (isLocalBatch) adapter.insert(nBatchParent, nUsedParent, hBefore?.$nn ?? null);
+		return;
+	}
+	const hGroup = fork(hParent, hBefore);
+	const dispose = () => unmount(hGroup);
+	let hMarker = hBefore;
+	effect(willMount(hGroup, () => {
+		if (read(when) === false) return;
+		const isLocalBatch = shouldBatch && !isBatch;
+		let nBatchParent = nUsedParent;
+		if (isLocalBatch) nBatchParent = adapter.batch();
+		mountTemplate(read(template), read(dataOrProxy), hGroup, hMarker, nBatchParent, nRealParent, isLocalBatch || isBatch);
+		if (isLocalBatch) {
+			adapter.insert(nBatchParent, nUsedParent, hMarker?.$nn ?? null);
+			try {
+				flush(hGroup);
+			} catch (ex) {
+				unmount(hGroup, [ex]);
+			}
+		}
+		return dispose;
+	}), hParent.$ng);
+	hMarker = insert(adapter.marker(), null, hParent, hBefore, nUsedParent, isBatch, true);
+	isBatch = false;
+	nUsedParent = nRealParent;
+}
+function updateShowProxy(proxy, source, keys) {
+	updateProxy(proxy, source.get(), keys);
+}
+//#endregion
+//#region src/data/Context.ts
+/*@__NO_SIDE_EFFECTS__*/
+function contextOf() {
+	return { $symbol: Symbol() };
+}
+function host(context, defaultValue, lifecycle = getLifecycle()) {
+	if (!runtime.$currentContextNew || !runtime.$currentContext) {
+		runtime.$currentContextNew = true;
+		runtime.$currentContext = { $parent: runtime.$currentContext };
+	}
+	let isUndefined = defaultValue === void 0;
+	const localAtom = {
+		[S_ATOM]: true,
+		$lifecycle: lifecycle,
+		$value: defaultValue,
+		get: getHostedValue,
+		set: setHostedValue
+	};
+	let upstream;
+	if (isUndefined && (upstream = lookupUpstream(context))) {
+		localAtom.get = getUpstreamValue;
+		localAtom.$upstream = upstream;
+		link(lifecycle, upstream, localAtom.$dep = {
+			fn: scheduleAtomNotification,
+			a0: localAtom
+		});
+	} else {
+		localAtom.$tracksValue = true;
+		localAtom.$lastValue = defaultValue;
+	}
+	runtime.$currentContext[context.$symbol] = localAtom;
+	return localAtom;
+}
+function contextual(context) {
+	return lookupUpstream(context);
+}
+function lookupUpstream(context) {
+	const { $symbol } = context;
+	let ptr = runtime.$currentContext;
+	let atom;
+	while (ptr && !(atom = ptr[$symbol])) ptr = ptr.$parent;
+	return atom;
+}
+function getUpstreamValue() {
+	return this.$upstream.get();
+}
+function getHostedValue() {
+	return this.$value;
+}
+function setHostedValue(value) {
+	let didChange = true;
+	if (this.$upstream) {
+		unlink(this.$dep);
+		this.$upstream = null;
+		this.$dep = null;
+		this.$tracksValue = true;
+		this.$lastValue = UNIQUE_VALUE;
+		this.get = getHostedValue;
+	} else didChange = !Object.is(this.$value, value);
+	this.$value = value;
+	return didChange;
+}
+//#endregion
+//#region src/data/Derivation.ts
+function derived(block, lifecycle = getLifecycle()) {
+	const atom = {
+		[S_ATOM]: true,
+		$dirty: false,
+		$value: null,
+		$tracksValue: true,
+		$lifecycle: lifecycle,
+		$life: lifecycle.$life,
+		$lastValue: null,
+		$cycle: 0,
+		$block: block,
+		$react: scheduleReaction,
+		get: getValue,
+		set: setValue
+	};
+	const value = resolve(atom);
+	atom.$value = value;
+	atom.$lastValue = value;
+	return atom;
+}
+function scheduleReaction(derivation, cycle) {
+	if (derivation.$life !== derivation.$lifecycle.$life || derivation.$cycle > cycle) {
+		unlinkEffectDep(derivation, this);
+		return;
+	}
+	derivation.$dirty = true;
+	scheduleAtomNotification(derivation);
+}
+function getValue() {
+	if (this.$dirty && this.$life === this.$lifecycle.$life) {
+		this.$value = resolve(this);
+		this.$dirty = false;
+	}
+	return this.$value;
+}
+function setValue() {
+	return false;
+}
+//#endregion
+//#region src/data/List.ts
+function listOf(source, lifecycle = getLifecycle()) {
+	return {
+		$items: source ? Array.from(source) : [],
+		$lifecycle: lifecycle,
+		$committedDelta: null,
+		$pendingDelta: null,
+		$lock: 0,
+		[Symbol.iterator]: getIterator,
+		size,
+		get,
+		dirty,
+		delta,
+		raw,
+		forEach,
+		stable,
+		set,
+		clear,
+		insertAt,
+		insertFirst,
+		insertLast,
+		remove,
+		removeAt,
+		removeFirst,
+		removeLast
+	};
+}
+function sync(list, source, eq = Object.is) {
+	const oldItems = list.$items;
+	const newItems = Array.from(source);
+	list.$items = newItems;
+	if (!list.$dh && !list.$xa) return;
+	const delta = initDelta(list);
+	if (listSynced(delta, oldItems, newItems, eq)) {
+		list.$pendingDelta = delta;
+		scheduleListNotification(list);
+	}
+}
+function size() {
+	reportAccess(this);
+	return this.$items.length;
+}
+function get(index) {
+	reportAccess(this);
+	return this.$items[index];
+}
+function dirty() {
+	if (this.$xa) return true;
+	const delta = this.$pendingDelta;
+	if (!delta) return false;
+	const pending = this.$notify;
+	return (!pending || pending.$life === pending.$lifecycle.$life) && delta.changes.length > 0;
+}
+function delta(block, lifecycle = getLifecycle()) {
+	link(lifecycle, this, {
+		fn: invokeDeltaBlock,
+		a0: this,
+		a1: lifecycle,
+		a2: block
+	});
+}
+function raw() {
+	return this.$items;
+}
+function forEach(callback) {
+	reportAccess(this);
+	this.$items.forEach(callback);
+}
+function stable(block) {
+	try {
+		this.$lock += 1;
+		return block(this.$items);
+	} finally {
+		this.$lock = Math.max(this.$lock - 1, 0);
+	}
+}
+function getIterator() {
+	reportAccess(this);
+	return this.$items[Symbol.iterator]();
+}
+function set(index, newItem) {
+	assertIndex(this, index);
+	const oldItem = this.$items[index];
+	if (Object.is(newItem, oldItem)) return;
+	copyOnWrite(this);
+	this.$items[index] = newItem;
+	if (this.$dh || this.$xa) {
+		itemChanged(this.$pendingDelta = initDelta(this), index, oldItem, newItem);
+		scheduleListNotification(this);
+	}
+}
+function clear() {
+	const count = this.$items.length;
+	if (this.$lock > 0) {
+		this.$items = [];
+		this.$lock = 0;
+	} else this.$items.length = 0;
+	if (this.$dh || this.$xa) {
+		listCleared(this.$pendingDelta = initDelta(this), count);
+		scheduleListNotification(this);
+	}
+}
+function insertAt(index, item) {
+	if (index === this.$items.length) {
+		copyOnWrite(this);
+		this.$items.push(item);
+	} else {
+		assertIndex(this, index);
+		copyOnWrite(this);
+		this.$items.splice(index, 0, item);
+	}
+	if (this.$dh || this.$xa) {
+		itemInserted(this.$pendingDelta = initDelta(this), index, item);
+		scheduleListNotification(this);
+	}
+}
+function insertFirst(item) {
+	this.insertAt(0, item);
+}
+function insertLast(item) {
+	this.insertAt(this.$items.length, item);
+}
+function remove(item) {
+	const index = this.$items.indexOf(item);
+	if (index === -1) return false;
+	this.removeAt(index);
+	return true;
+}
+function removeAt(index) {
+	assertIndex(this, index);
+	copyOnWrite(this);
+	const item = this.$items.splice(index, 1)[0];
+	if (this.$dh || this.$xa) {
+		itemRemoved(this.$pendingDelta = initDelta(this), index, item);
+		scheduleListNotification(this);
+	}
+	return item;
+}
+function removeFirst() {
+	return this.$items.length > 0 ? this.removeAt(0) : void 0;
+}
+function removeLast() {
+	const { length } = this.$items;
+	return length > 0 ? this.removeAt(length - 1) : void 0;
+}
+function assertIndex(list, index) {
+	if (!Number.isInteger(index)) throw new TypeError();
+	if (index >= list.$items.length || index < 0) throw new RangeError();
+}
+function initDelta(list) {
+	if (list.$pendingDelta) {
+		const pending = list.$notify;
+		if (!pending || pending.$life === pending.$lifecycle.$life) return list.$pendingDelta;
+	}
+	return {
+		changes: [],
+		relSize: 0
+	};
+}
+function copyOnWrite(list) {
+	if (list.$lock > 0) {
+		list.$items = list.$items.slice();
+		list.$lock = 0;
+	}
+}
+function scheduleListNotification(list) {
+	scheduleTick(list.$lifecycle, list.$notify ??= {
+		fn: notifyListObservers,
+		a0: list
+	});
+}
+function notifyListObservers(list) {
+	const delta = list.$pendingDelta;
+	list.$pendingDelta = null;
+	if (list.$force || delta.changes.length > 0) {
+		delta.snapshot = list.$items;
+		list.$committedDelta = delta;
+		list.$lock += 1;
+		list.$force = false;
+		try {
+			notify(list);
+		} finally {
+			list.$committedDelta = null;
+			list.$lock = Math.max(list.$lock - 1, 0);
+		}
+	}
+}
+function invokeDeltaBlock(list, lifecycle, block) {
+	withLifecycle(lifecycle, block, list.$committedDelta);
+}
+//#endregion
+//#region src/Adapter.ts
+/*@__NO_SIDE_EFFECTS__*/
+function extension(propSetter) {
+	return {
+		$prefix: `:${(++runtime.$extIndex).toString(16)}:`,
+		set: propSetter
+	};
+}
+function ext(extension, extensionProps, targetPropsObject = {}) {
+	const prefix = extension.$prefix;
+	const routing = runtime.x;
+	let prop;
+	let route;
+	for (prop in extensionProps) {
+		route = prefix + prop;
+		routing[route] ??= {
+			$ext: extension,
+			$prop: prop
+		};
+		targetPropsObject[route] = extensionProps[prop];
+	}
+	return targetPropsObject;
+}
+//#endregion
+//#region src/extension/RefExtension.ts
+const RefExtension = /*@__PURE__*/ extension((node, prop, value, group) => {
+	switch (prop) {
+		case "atom":
+			if (isAtom(value)) {
+				onceMounted(group, {
+					fn: write,
+					a0: value,
+					a1: node
+				});
+				onceUnmounted(group, {
+					fn: write,
+					a0: value,
+					a1: null
+				});
+			}
+			break;
+		case "call":
+			if (typeof value === "function") onceMounted(group, {
+				fn: invokeMountedCallback,
+				a0: group,
+				a1: value,
+				a2: node
+			});
+			break;
+	}
+});
+//#endregion
+//#region src/support/atoms.ts
+function text(strings, ...values) {
+	const { length } = values;
+	return derived(() => {
+		let result = strings[0];
+		let index = 0;
+		let value;
+		while (index < length) {
+			value = read(values[index]);
+			try {
+				value = String(value);
+			} catch {
+				value = "[error]";
+			}
+			result += value + strings[++index];
+		}
+		return result;
+	});
+}
+/*@__NO_SIDE_EFFECTS__*/
+function writes(input, value, force) {
+	return isAtom(input) ? () => void write(input, value, force) : noop;
+}
+/*@__NO_SIDE_EFFECTS__*/
+function updates(input, transform, force) {
+	return isAtom(input) ? () => void update(input, transform, force) : noop;
+}
+function atomsOf(data, keysOrLifecycle, maybeLifecycle) {
+	let keys;
+	let lifecycle;
+	if (keysOrLifecycle === void 0 || Array.isArray(keysOrLifecycle)) {
+		keys = keysOrLifecycle;
+		lifecycle = maybeLifecycle;
+	} else lifecycle = keysOrLifecycle;
+	lifecycle ??= getLifecycle();
+	const result = Object.create(null);
+	if (keys) {
+		const { length } = keys;
+		let index = 0;
+		let key;
+		for (; index < length; index += 1) {
+			key = keys[index];
+			result[key] = atomOf(data[key], lifecycle);
+		}
+		for (key in data) if (result[key] === void 0) result[key] = data[key];
+	} else {
+		let key;
+		for (key in data) result[key] = atomOf(data[key], lifecycle);
+	}
+	return result;
+}
+function assign(store, data, keysOrLifecycle, maybeLifecycle) {
+	let keys;
+	let lifecycle;
+	if (keysOrLifecycle === void 0 || Array.isArray(keysOrLifecycle)) {
+		keys = keysOrLifecycle;
+		lifecycle = maybeLifecycle;
+	} else lifecycle = keysOrLifecycle;
+	if (keys) {
+		const { length } = keys;
+		const visited = Object.create(null);
+		let index = 0;
+		let key;
+		for (; index < length; index += 1) {
+			key = keys[index];
+			write(store[key], peek(data[key]));
+			visited[key] = true;
+		}
+		for (key in data) if (!visited[key]) store[key] = data[key];
+	} else {
+		let key;
+		let atom;
+		for (key in store) {
+			atom = store[key];
+			if (isAtom(atom)) write(atom, peek(data[key]));
+			else store[key] = atomOf(data[key], lifecycle ??= getLifecycle());
+		}
+		for (key in data) if (!Object.hasOwn(store, key)) store[key] = atomOf(data[key], lifecycle ??= getLifecycle());
+	}
+	return store;
+}
+//#endregion
+//#region src/jsx.ts
+const EMPTY_ARRAY = [];
+function jsx(componentOrTagName, props, key) {
+	const { children } = props;
+	props.children = children === void 0 ? EMPTY_ARRAY : Array.isArray(children) ? children : [children];
+	props.key ??= key;
+	if (typeof componentOrTagName === "string") {
+		props[S_COMPONENT] = Native;
+		props[S_TAG_NAME] = componentOrTagName;
+	} else props[S_COMPONENT] = componentOrTagName;
+	return props;
+}
+function jsxs(componentOrTagName, props, key) {
+	props.key ??= key;
+	if (typeof componentOrTagName === "string") {
+		props[S_COMPONENT] = Native;
+		props[S_TAG_NAME] = componentOrTagName;
+	} else props[S_COMPONENT] = componentOrTagName;
+	return props;
+}
+//#endregion
+//#region src/RendererBuilder.ts
+/*@__NO_SIDE_EFFECTS__*/
+function renderer(adapter) {
+	const extensions = {};
+	const builder = {
+		create: () => /* @__PURE__ */ createRenderer(adapter, extensions),
+		extend: (extensionKey, extension) => {
+			extensions[extensionKey] = extension;
+			return builder;
+		}
+	};
+	return builder;
+}
+//#endregion
+export { Fragment, Iterator, LC_CHANGE, LC_CLEAR, LC_INSERT, LC_REMOVE, Native, RefExtension, S_ATOM, S_COMPONENT, S_TAG_NAME, Show, assign, atomOf, atomsOf, bind, component, contextOf, contextual, derived, destroy, effect, ext, extension, flush, fork, getLifecycle, host, insert, invoke, isAtom, jsx, jsxs, link, listOf, mount, mountJsx, mounted, noEffect, onceMounted, onceUnmounted, peek, proxyOf, read, renderer, scheduleTick, scheduleTock, sync, text, tick, tock, track, unlink, unmount, unmounted, untrack, update, updates, willMount, withLifecycle, write, writes };
+
 //# sourceMappingURL=core.js.map