rumious 0.0.13-beta.2 → 1.0.1

package/dist/index.min.js

@@ -1 +1,2658 @@
-var Rumious=function(e){"use strict";class t{constructor(e){this.target=e,this.app=e.app,this.cleans=[],this.hooks={onRendered:[],onBeforeRender:[]}}find(e){return this.target[e]}get(e){return this.target[e]}addHook(e,t){if(!this.hooks[e])throw new Error(`Hook type "${e}" is not defined!`);this.hooks[e].push(t)}async runHooks(e,...t){if(this.hooks[e])for(const n of this.hooks[e])await n(...t)}}class n{constructor(){this.renderOptions={mode:"linear"},this.element=null,this.app=null,this.props={},this.forwardRefs={},this.renderContext=new t(this),this.renderer=null,this.wrapped=null}prepare(e,t,n={},r=null){this.element=e,this.props=t,this.renderer=r,this.wrapped=n,this.renderContext.app=this.app}template(){return{}}render(e){return this.renderer(e,document.createDocumentFragment(),this.renderContext)}async requestRender(){await this.onBeforeRender();let e=this.template(),t=this.renderer(e,document.createDocumentFragment(),this.renderContext);this.element.appendChild(t),this.onRender()}async requestCleanUp(){if(this.renderContext.cleans.forEach((e=>e())),this.element){let e=this.element.cloneNode(!0);for(this.element.replaceWith(e),this.element=e;this.element.firstChild;)this.element.removeChild(this.element.firstChild)}}onInit(){}onCreate(){}async onBeforeRender(){}onRender(){}onUpdate(){}onDestroy(){}}function r(e){return Object.getPrototypeOf(e)===n}class i{constructor(e,t,n=[]){this.type=e,this.props=t,this.children=n}}class s{constructor(e){this.type="ELEMENT_LIST",this.children=e}forEach(e){this.children.forEach(e)}}function o(e){return"function"==typeof e}class a{constructor(e,t,n){this.type=e,this.name=t,this.value=n}init(){console.warn("Directive haven't handler !")}}class l extends a{async init(e,t){let n=null;const r=e=>{if(!t.find(e))return console.warn(`Missing event handler for event: ${this.name}`),null;const n=t.get(e);if(!o(n))throw new Error(`${e} is not a function!`);return n.bind(t.target)};if("string"===this.value.type)n=r(this.value.value);else if("expression"===this.value.type){if(n=this.value.value,!o(n))throw new Error("Event handler requires a function!")}else"dynamic_value"===this.value.type&&(n=r(this.value.value.objectName));n&&e.addEventListener(this.name,n)}}class c extends a{async init(e,t){if("expression"===this.value.type){let t=this.value.value;if(!t)throw new Error("Invalid props value: Directive bind requires a RumiousState Object!");t.reactor.addBinding((()=>{let n=t.get();this.bindAttr(e,n)})),this.bindAttr(e,t.get())}else if("dynamic_value"===this.value.type){let n=this.value.evaluator?.(t.target),r=t.find(this.value.value.objectName);if(!r)throw new Error("Invalid props value: Directive bind requires a RumiousState Object!");r.reactor.addBinding((()=>{let n=this.value.evaluator?.(t.target);this.bindAttr(e,n)})),this.bindAttr(e,n)}}normalizeValue(e){return"object"==typeof e?e.toString?.()??"":e}async bindAttr(e,t){switch(this.name){case"html":e.innerHTML=this.normalizeValue(t);break;case"text":e.textContent=this.normalizeValue(t);break;case"show":e.style.display=this.normalizeValue(t)?"block":"none";break;case"hide":e.style.display=this.normalizeValue(t)?"none":"block";break;case"className":e.className=this.normalizeValue(t);break;case"style":Object.assign(e.style,t);break;case"disabled":e.disabled=!!this.normalizeValue(t);break;case"visible":e.style.visibility=this.normalizeValue(t)?"visible":"hidden";break;case"value":e.value=this.normalizeValue(t);break;case"checked":e.checked=this.normalizeValue(t);break;default:e.setAttribute(this.name,this.normalizeValue(t))}}}class u extends a{async init(e,t){if("expression"===this.value.type){let t=this.value.value;if(!t)throw new Error("Invalid props value: Directive ref requires a RumiousRef Object!");t.set(e)}else if("dynamic_value"===this.value.type){let n=t.find(this.value.value.objectName);if(!n)throw new Error("Invalid props value: Directive ref requires a RumiousRef Object!");n.set(e)}}}class h extends a{async init(e,t){let n;"expression"===this.value.type?n=this.value.value:"dynamic_value"===this.value.type&&(n=t.find(this.value.value.objectName));const r=()=>{"checkbox"===e.type?n.set(e.checked):"radio"===e.type?e.checked&&n.set(e.value):n.set(e.value)};e.addEventListener("input",r),e.addEventListener("change",r)}}class p extends a{async init(e,t){if("expression"===this.value.type){let t=this.value.value;if(!t)throw new Error("Invalid props value: Directive childsRef requires a RumiousChildRef Object!");t.set(e)}else if("dynamic_value"===this.value.type){let n=t.find(this.value.value.objectName);if(!n)throw new Error("Invalid props value: Directive childsRef requires a RumiousChildRef Object!");n.set(e)}}}const f={on:(e,t)=>new l("on",e,t),bind:(e,t)=>new c("bind",e,t),ref:(e,t)=>new u("ref",e,t),childsRef:(e,t)=>new p("childsRef",e,t),model:(e,t)=>new h("model",e,t)};function d(e,t,n){return function(e,t,n){return f[e]?.(t,n)}(e,t,n)}function y(e,t,...n){return r(e)?g(e,t,n):e===m?m(...n):new i(e,t||{},b(n))}function v(e){return new i("TEXT_ELEMENT",{nodeValue:e},[])}function g(e,t,n){let r=new i("COMPONENT",{...t},new s(b(n)));return r.component=e,r}function m(...e){return new i("FRAGMENT",{},b(e))}function b(e){return e.map((e=>"object"==typeof e?e:v(e)))}window.RUMIOUS_JSX_SUPPORT={createElement:y,createFragment:m,createDirective:d};class w extends HTMLElement{constructor(){super(),this.instance=null,this.ref=null}cleanUp(){Object.setPrototypeOf(this,HTMLUnknownElement.prototype),this.remove()}init(e,t,n={},r,i){this.instance=new e,this.instance.element=this,this.instance.app=i,this.instance.prepare(this,t,n,r),this.instance.onInit()}connectedCallback(){switch(this.instance.renderOptions.mode){case"linear":this.instance.onCreate(),this.instance.requestRender();break;case"async":(async()=>{this.instance.onCreate(),this.instance.requestRender()})();break;case"animate":requestAnimationFrame((async()=>{this.instance.onCreate(),this.instance.requestRender()}));break;case"idle":requestIdleCallback((async()=>{this.instance.onCreate(),this.instance.requestRender()}));break;case"defer":setTimeout((async()=>{this.instance.onCreate(),this.instance.requestRender()}),0);break;case"delay":setTimeout((async()=>{this.instance.onCreate(),this.instance.requestRender()}),this.instance.renderOptions.time);break;case"visible":new IntersectionObserver(((e,t)=>{for(const n of e)n.isIntersecting&&(t.disconnect(),this.instance.onCreate(),this.instance.requestRender())})).observe(this)}}disconnectedCallback(){this.instance.onDestroy(),this.instance.requestCleanUp(),this.cleanUp()}}function E(e="r-component"){return window.customElements.get(e)||window.customElements.define(e,class extends w{static tag=e}),document.createElement(e)}class O{constructor(){this.contents=[],this.targets=[],this.observers=new WeakMap}commit(e=[]){this.contents=e}setTarget(e,t,n){this.targets.push({element:e,context:n,renderer:t}),this.observeTarget(e)}observeTarget(e){if(this.observers.has(e))return;const t=new MutationObserver((()=>{e.parentNode||this.removeTarget(e)}));t.observe(document.body,{childList:!0}),this.observers.set(e,t)}removeTarget(e){const t=this.observers.get(e);t&&(t.disconnect(),this.observers.delete(e)),this.targets=this.targets.filter((t=>t.element!==e))}inject(e=!1){for(let t of this.targets)e&&(t.element.textContent=""),this.contents.forEach((e=>{"html"===e.type?t.element.innerHTML=e.value:"text"===e.type?t.element.textContent=e.value:"component"===e.type&&t.renderer(y(e.value,e.props??{},e.child??{}),t.element,t.context)}))}}class k{constructor(e,t){this.state=e,this.template=t,this.target=null,this._id=Date.now()}setTarget(e,t,n){this.target={element:e,context:n,renderer:t}}clean(){this.target&&delete this.state.reactor.priorityBinding[this._id]}sync(){this.target&&(this.renderAll(),this.state.reactor.priorityBinding[this._id]=this.onChange.bind(this))}renderAll(){this.target.element.textContent="",this.state.value.forEach(((e,t)=>this.appendElement(e,t)))}appendElement(e,t){let n=this.template(e,t),r=this.target.renderer(n,document.createDocumentFragment(),this.target.context);this.target.element.appendChild(r)}onChange(e){if(this.target)switch(e.type){case"REMOVE_ELEMENT":{let t=this.target.element.children[e.index];t&&this.target.element.removeChild(t);break}case"SET_VALUE":this.renderAll();break;case"ADD_ELEMENT":this.appendElement(e.value,e.index);break;case"SET_ELEMENT":{let t=this.template(e.value,e.index),n=this.target.renderer(t,document.createDocumentFragment(),this.target.context);!function(e,t,n){let r=e.children;t>=0&&t<r.length?e.replaceChild(n,r[t]):e.appendChild(n)}(this.target.element,e.index,n);break}case"INSERT_ELEMENT":{let t=this.template(e.value,e.index),n=this.target.renderer(t,document.createDocumentFragment(),this.target.context),r=this.target.element.children;e.index>=r.length?this.target.element.appendChild(n):this.target.element.insertBefore(n.children[0],r[e.index]);break}}}}function M(e,t,n={}){if(!e)return t;if(null===(r=e)||"object"!=typeof r&&"function"!=typeof r)return M(v(e),t,n);var r;if(Array.isArray(e)){for(const r of e)M(r,t,n);return t}if(e instanceof i){let r;switch(e.type){case"COMPONENT":return function(e,t,n,r){const i=function(e,t,n,r,i=null){const s=E(e.tag??"r-component");return s.init(e,t,n,r,i?.app),s}(e.component,e.props,e.children,n,r);return t.appendChild(i),t}(e,t,M,n);case"FRAGMENT":case"ELEMENT_LIST":for(const r of e.children)M(r,t,n);return t;case"TEXT_ELEMENT":r=function(e){return document.createTextNode(e.props.nodeValue)}(e);break;default:r=function(e,t){const n=document.createElement(e.type);!function(e,t,n){for(const[r,i]of Object.entries(t||{}))i instanceof a?i.init(e,n):r.startsWith("on")&&/^[a-zA-Z]+([A-Z][a-z]*)*$/.test(r)?e.addEventListener(r.substring(2).toLowerCase(),i):e.setAttribute(r,i)}(n,e.props,t);for(const r of e.children)M(r,n,t);return n}(e,n)}return t.appendChild(r),t}if(e instanceof HTMLElement)return t.appendChild(e),t;if(e instanceof O){if(t instanceof HTMLDocument)throw"Rumious Render: Unsupported inject content in HTMLDocument!";return e.setTarget(t,M,n),e.inject(!0),t}if(e instanceof k){if(t instanceof HTMLDocument)throw"Rumious Render: Unsupported sync data of array  in HTMLDocument!";return n.cleans.push((()=>{e.clean()})),e.setTarget(t,M,n),e.sync(),t}return M(v(JSON.stringify(e)),t,n)}class R{constructor(e=null,t=[]){this.target=e,this.bindings=t,this.priorityBinding={}}react(e){Object.keys(this.priorityBinding).forEach((t=>this.priorityBinding[t]?.(e))),this.bindings.forEach((t=>t?.(e)))}removeBinding(e){for(let t=this.bindings.length-1;t>=0;t--)this.bindings[t]===e&&this.bindings.splice(t,1)}addBinding(e){this.bindings.push(e)}}class j{constructor(e,t="",n){this.state=e,this.path=t,this.fn=n}trigger(...e){let t=this.fn(...e);this.state.set(this.path,t)}}const S="remove",x="replace",T="add",C=Symbol.for("__MUTATIVE_PROXY_DRAFT__"),A=Symbol("__MUTATIVE_RAW_RETURN_SYMBOL__"),D=Symbol.iterator,P={mutable:"mutable",immutable:"immutable"},z={};function L(e,t){return e instanceof Map?e.has(t):Object.prototype.hasOwnProperty.call(e,t)}function _(e,t){if(t in e){let n=Reflect.getPrototypeOf(e);for(;n;){const e=Reflect.getOwnPropertyDescriptor(n,t);if(e)return e;n=Reflect.getPrototypeOf(n)}}}function N(e){return Object.getPrototypeOf(e)===Set.prototype}function I(e){return Object.getPrototypeOf(e)===Map.prototype}function V(e){var t;return null!==(t=e.copy)&&void 0!==t?t:e.original}function U(e){return!!q(e)}function q(e){return"object"!=typeof e?null:null==e?void 0:e[C]}function F(e){var t;const n=q(e);return n?null!==(t=n.copy)&&void 0!==t?t:n.original:e}function B(e,t){if(!e||"object"!=typeof e)return!1;let n;return Object.getPrototypeOf(e)===Object.prototype||Array.isArray(e)||e instanceof Map||e instanceof Set||!!(null==t?void 0:t.mark)&&((n=t.mark(e,P))===P.immutable||"function"==typeof n)}function H(e,t=[]){if(Object.hasOwnProperty.call(e,"key")){const n=e.parent.copy,r=q(W(n,e.key));if(null!==r&&(null==r?void 0:r.original)!==e.original)return null;const i=3===e.parent.type,s=i?Array.from(e.parent.setMap.keys()).indexOf(e.key):e.key;if(!(i&&n.size>s||L(n,s)))return null;t.push(s)}if(e.parent)return H(e.parent,t);t.reverse();try{!function(e,t){for(let n=0;n<t.length-1;n+=1){const r=t[n];if("object"!=typeof(e=W(3===$(e)?Array.from(e):e,r)))throw new Error(`Cannot resolve patch at '${t.join("/")}'.`)}}(e.copy,t)}catch(e){return null}return t}function $(e){return Array.isArray(e)?1:e instanceof Map?2:e instanceof Set?3:0}function W(e,t){return 2===$(e)?e.get(t):e[t]}function X(e,t,n){2===$(e)?e.set(t,n):e[t]=n}function K(e,t){const n=q(e);return(n?V(n):e)[t]}function G(e,t){return e===t?0!==e||1/e==1/t:e!=e&&t!=t}function Y(e){if(e)for(;e.finalities.revoke.length>0;)e.finalities.revoke.pop()()}function Z(e,t){return t?e:[""].concat(e).map((e=>{const t=`${e}`;return-1===t.indexOf("/")&&-1===t.indexOf("~")?t:t.replace(/~/g,"~0").replace(/\//g,"~1")})).join("/")}const J=Object.prototype.propertyIsEnumerable;function Q(e,t){let n;if(Array.isArray(e))return Array.prototype.concat.call(e);if(e instanceof Set)return N(e)?Set.prototype.difference?Set.prototype.difference.call(e,new Set):new Set(e.values()):new(0,Object.getPrototypeOf(e).constructor)(e.values());if(e instanceof Map)return I(e)?new Map(e):new(0,Object.getPrototypeOf(e).constructor)(e);if((null==t?void 0:t.mark)&&(n=t.mark(e,P),void 0!==n)&&n!==P.mutable){if(n===P.immutable)return function(e){const t=Object.create(Object.getPrototypeOf(e));return Reflect.ownKeys(e).forEach((n=>{let r=Reflect.getOwnPropertyDescriptor(e,n);r.enumerable&&r.configurable&&r.writable?t[n]=e[n]:(r.writable||(r.writable=!0,r.configurable=!0),(r.get||r.set)&&(r={configurable:!0,writable:!0,enumerable:r.enumerable,value:e[n]}),Reflect.defineProperty(t,n,r))})),t}(e);if("function"==typeof n){if(t.enablePatches||t.enableAutoFreeze)throw new Error("You can't use mark and patches or auto freeze together.");return n()}throw new Error(`Unsupported mark result: ${n}`)}if("object"==typeof e&&Object.getPrototypeOf(e)===Object.prototype){const t={};return Object.keys(e).forEach((n=>{t[n]=e[n]})),Object.getOwnPropertySymbols(e).forEach((n=>{J.call(e,n)&&(t[n]=e[n])})),t}throw new Error("Please check mark() to ensure that it is a stable marker draftable function.")}function ee(e){e.copy||(e.copy=Q(e.original,e.options))}function te(e){if(!B(e))return F(e);if(Array.isArray(e))return e.map(te);if(e instanceof Map){const t=Array.from(e.entries()).map((([e,t])=>[e,te(t)]));return I(e)?new Map(t):new(0,Object.getPrototypeOf(e).constructor)(t)}if(e instanceof Set){const t=Array.from(e).map(te);return N(e)?new Set(t):new(0,Object.getPrototypeOf(e).constructor)(t)}const t=Object.create(Object.getPrototypeOf(e));for(const n in e)t[n]=te(e[n]);return t}function ne(e){return U(e)?te(e):e}function re(e){var t;e.assignedMap=null!==(t=e.assignedMap)&&void 0!==t?t:new Map,e.operated||(e.operated=!0,e.parent&&re(e.parent))}function ie(){throw new Error("Cannot modify frozen object")}function se(e,t,n,r,i){{n=null!=n?n:new WeakMap,r=null!=r?r:[],i=null!=i?i:[];const s=n.has(e)?n.get(e):e;if(r.length>0){const e=r.indexOf(s);if(s&&"object"==typeof s&&-1!==e){if(r[0]===s)throw new Error("Forbids circular reference");throw new Error(`Forbids circular reference: ~/${i.slice(0,e).map(((e,t)=>{if("symbol"==typeof e)return`[${e.toString()}]`;const n=r[t];return"object"==typeof e&&(n instanceof Map||n instanceof Set)?Array.from(n.keys()).indexOf(e):e})).join("/")}`)}r.push(s),i.push(t)}else r.push(s)}if(Object.isFrozen(e)||U(e))return r.pop(),void i.pop();switch($(e)){case 2:for(const[t,s]of e)se(t,t,n,r,i),se(s,t,n,r,i);e.set=e.clear=e.delete=ie;break;case 3:for(const t of e)se(t,t,n,r,i);e.add=e.clear=e.delete=ie;break;case 1:Object.freeze(e);let t=0;for(const s of e)se(s,t,n,r,i),t+=1;break;default:Object.freeze(e),Object.keys(e).forEach((t=>{se(e[t],t,n,r,i)}))}r.pop(),i.pop()}function oe(e,t){const n=$(e);if(0===n)Reflect.ownKeys(e).forEach((n=>{t(n,e[n],e)}));else if(1===n){let n=0;for(const r of e)t(n,r,e),n+=1}else e.forEach(((n,r)=>t(r,n,e)))}function ae(e,t,n){if(U(e)||!B(e,n)||t.has(e)||Object.isFrozen(e))return;const r=e instanceof Set,i=r?new Map:void 0;if(t.add(e),oe(e,((s,o)=>{var a;if(U(o)){const t=q(o);ee(t);const n=(null===(a=t.assignedMap)||void 0===a?void 0:a.size)||t.operated?t.copy:t.original;X(r?i:e,s,n)}else ae(o,t,n)})),i){const t=e,n=Array.from(t);t.clear(),n.forEach((e=>{t.add(i.has(e)?i.get(e):e)}))}}function le(e,t){const n=3===e.type?e.setMap:e.copy;e.finalities.revoke.length>1&&e.assignedMap.get(t)&&n&&ae(W(n,t),e.finalities.handledSet,e.options)}function ce(e){3===e.type&&e.copy&&(e.copy.clear(),e.setMap.forEach((t=>{e.copy.add(F(t))})))}function ue(e,t,n,r){if(e.operated&&e.assignedMap&&e.assignedMap.size>0&&!e.finalized){if(n&&r){const i=H(e);i&&t(e,i,n,r)}e.finalized=!0}}function he(e,t,n,r){const i=q(n);i&&(i.callbacks||(i.callbacks=[]),i.callbacks.push(((s,o)=>{var a;const l=3===e.type?e.setMap:e.copy;if(G(W(l,t),n)){let n=i.original;i.copy&&(n=i.copy),ce(e),ue(e,r,s,o),e.options.enableAutoFreeze&&(e.options.updatedValues=null!==(a=e.options.updatedValues)&&void 0!==a?a:new WeakMap,e.options.updatedValues.set(n,i.original)),X(l,t,n)}})),e.options.enableAutoFreeze&&i.finalities!==e.finalities&&(e.options.enableAutoFreeze=!1)),B(n,e.options)&&e.finalities.draft.push((()=>{G(W(3===e.type?e.setMap:e.copy,t),n)&&le(e,t)}))}function pe(e,t,n,r){const{pathAsArray:i=!0}=e.options.enablePatches;switch(e.type){case 0:case 2:return function({original:e,copy:t,assignedMap:n},r,i,s,o){n.forEach(((n,a)=>{const l=W(e,a),c=ne(W(t,a)),u=n?L(e,a)?x:T:S;if(G(l,c)&&u===x)return;const h=Z(r.concat(a),o);i.push(u===S?{op:u,path:h}:{op:u,path:h,value:c}),s.push(u===T?{op:S,path:h}:u===S?{op:T,path:h,value:l}:{op:x,path:h,value:l})}))}(e,t,n,r,i);case 1:return function(e,t,n,r,i){let{original:s,assignedMap:o,options:a}=e,l=e.copy;l.length<s.length&&([s,l]=[l,s],[n,r]=[r,n]);for(let e=0;e<s.length;e+=1)if(o.get(e.toString())&&l[e]!==s[e]){const o=Z(t.concat([e]),i);n.push({op:x,path:o,value:ne(l[e])}),r.push({op:x,path:o,value:ne(s[e])})}for(let e=s.length;e<l.length;e+=1){const r=Z(t.concat([e]),i);n.push({op:T,path:r,value:ne(l[e])})}if(s.length<l.length){const{arrayLengthAssignment:e=!0}=a.enablePatches;if(e){const e=Z(t.concat(["length"]),i);r.push({op:x,path:e,value:s.length})}else for(let e=l.length;s.length<e;e-=1){const n=Z(t.concat([e-1]),i);r.push({op:S,path:n})}}}(e,t,n,r,i);case 3:return function({original:e,copy:t},n,r,i,s){let o=0;e.forEach((e=>{if(!t.has(e)){const t=Z(n.concat([o]),s);r.push({op:S,path:t,value:e}),i.unshift({op:T,path:t,value:e})}o+=1})),o=0,t.forEach((t=>{if(!e.has(t)){const e=Z(n.concat([o]),s);r.push({op:T,path:e,value:t}),i.unshift({op:S,path:e,value:t})}o+=1}))}(e,t,n,r,i)}}const fe=(e,t,n=!1)=>{if("object"==typeof e&&null!==e&&(!B(e,t)||n))throw new Error("Strict mode: Mutable data cannot be accessed directly, please use 'unsafe(callback)' wrap.")},de={get size(){return V(q(this)).size},has(e){return V(q(this)).has(e)},set(e,t){const n=q(this),r=V(n);return r.has(e)&&G(r.get(e),t)||(ee(n),re(n),n.assignedMap.set(e,!0),n.copy.set(e,t),he(n,e,t,pe)),this},delete(e){if(!this.has(e))return!1;const t=q(this);return ee(t),re(t),t.original.has(e)?t.assignedMap.set(e,!1):t.assignedMap.delete(e),t.copy.delete(e),!0},clear(){const e=q(this);if(this.size){ee(e),re(e),e.assignedMap=new Map;for(const[t]of e.original)e.assignedMap.set(t,!1);e.copy.clear()}},forEach(e,t){V(q(this)).forEach(((n,r)=>{e.call(t,this.get(r),r,this)}))},get(e){var t,n;const r=q(this),i=V(r).get(e),s=(null===(n=(t=r.options).mark)||void 0===n?void 0:n.call(t,i,P))===P.mutable;if(r.options.strict&&fe(i,r.options,s),s)return i;if(r.finalized||!B(i,r.options))return i;if(i!==r.original.get(e))return i;const o=z.createDraft({original:i,parentDraft:r,key:e,finalities:r.finalities,options:r.options});return ee(r),r.copy.set(e,o),o},keys(){return V(q(this)).keys()},values(){const e=this.keys();return{[D]:()=>this.values(),next:()=>{const t=e.next();return t.done?t:{done:!1,value:this.get(t.value)}}}},entries(){const e=this.keys();return{[D]:()=>this.entries(),next:()=>{const t=e.next();if(t.done)return t;const n=this.get(t.value);return{done:!1,value:[t.value,n]}}}},[D](){return this.entries()}},ye=Reflect.ownKeys(de),ve=(e,t,{isValuesIterator:n})=>()=>{var r,i;const s=t.next();if(s.done)return s;const o=s.value;let a=e.setMap.get(o);const l=q(a),c=(null===(i=(r=e.options).mark)||void 0===i?void 0:i.call(r,a,P))===P.mutable;if(e.options.strict&&fe(o,e.options,c),c||l||!B(o,e.options)||e.finalized||!e.original.has(o))l&&(a=l.proxy);else{const t=z.createDraft({original:o,parentDraft:e,key:o,finalities:e.finalities,options:e.options});e.setMap.set(o,t),a=t}return{done:!1,value:n?a:[a,a]}},ge={get size(){return q(this).setMap.size},has(e){const t=q(this);if(t.setMap.has(e))return!0;ee(t);const n=q(e);return!(!n||!t.setMap.has(n.original))},add(e){const t=q(this);return this.has(e)||(ee(t),re(t),t.assignedMap.set(e,!0),t.setMap.set(e,e),he(t,e,e,pe)),this},delete(e){if(!this.has(e))return!1;const t=q(this);ee(t),re(t);const n=q(e);return n&&t.setMap.has(n.original)?(t.assignedMap.set(n.original,!1),t.setMap.delete(n.original)):(!n&&t.setMap.has(e)?t.assignedMap.set(e,!1):t.assignedMap.delete(e),t.setMap.delete(e))},clear(){if(!this.size)return;const e=q(this);ee(e),re(e);for(const t of e.original)e.assignedMap.set(t,!1);e.setMap.clear()},values(){const e=q(this);ee(e);const t=e.setMap.keys();return{[Symbol.iterator]:()=>this.values(),next:ve(e,t,{isValuesIterator:!0})}},entries(){const e=q(this);ee(e);const t=e.setMap.keys();return{[Symbol.iterator]:()=>this.entries(),next:ve(e,t,{isValuesIterator:!1})}},keys(){return this.values()},[D](){return this.values()},forEach(e,t){const n=this.values();let r=n.next();for(;!r.done;)e.call(t,r.value,r.value,this),r=n.next()}};Set.prototype.difference&&Object.assign(ge,{intersection(e){return Set.prototype.intersection.call(new Set(this.values()),e)},union(e){return Set.prototype.union.call(new Set(this.values()),e)},difference(e){return Set.prototype.difference.call(new Set(this.values()),e)},symmetricDifference(e){return Set.prototype.symmetricDifference.call(new Set(this.values()),e)},isSubsetOf(e){return Set.prototype.isSubsetOf.call(new Set(this.values()),e)},isSupersetOf(e){return Set.prototype.isSupersetOf.call(new Set(this.values()),e)},isDisjointFrom(e){return Set.prototype.isDisjointFrom.call(new Set(this.values()),e)}});const me=Reflect.ownKeys(ge),be=new WeakSet,we={get(e,t,n){var r,i;const s=null===(r=e.copy)||void 0===r?void 0:r[t];if(s&&be.has(s))return s;if(t===C)return e;let o;if(e.options.mark){const r="size"===t&&(e.original instanceof Map||e.original instanceof Set)?Reflect.get(e.original,t):Reflect.get(e.original,t,n);if(o=e.options.mark(r,P),o===P.mutable)return e.options.strict&&fe(r,e.options,!0),r}const a=V(e);if(a instanceof Map&&ye.includes(t)){if("size"===t)return Object.getOwnPropertyDescriptor(de,"size").get.call(e.proxy);const n=de[t];if(n)return n.bind(e.proxy)}if(a instanceof Set&&me.includes(t)){if("size"===t)return Object.getOwnPropertyDescriptor(ge,"size").get.call(e.proxy);const n=ge[t];if(n)return n.bind(e.proxy)}if(!L(a,t)){const n=_(a,t);return n?"value"in n?n.value:null===(i=n.get)||void 0===i?void 0:i.call(e.proxy):void 0}const l=a[t];if(e.options.strict&&fe(l,e.options),e.finalized||!B(l,e.options))return l;if(l===K(e.original,t)){if(ee(e),e.copy[t]=Ee({original:e.original[t],parentDraft:e,key:1===e.type?Number(t):t,finalities:e.finalities,options:e.options}),"function"==typeof o){const n=q(e.copy[t]);return ee(n),re(n),n.copy}return e.copy[t]}return l},set(e,t,n){var r;if(3===e.type||2===e.type)throw new Error("Map/Set draft does not support any property assignment.");let i;if(1===e.type&&"length"!==t&&(!(Number.isInteger(i=Number(t))&&i>=0)||0!==t&&0!==i&&String(i)!==String(t)))throw new Error("Only supports setting array indices and the 'length' property.");const s=_(V(e),t);if(null==s?void 0:s.set)return s.set.call(e.proxy,n),!0;const o=K(V(e),t),a=q(o);return a&&G(a.original,n)?(e.copy[t]=n,e.assignedMap=null!==(r=e.assignedMap)&&void 0!==r?r:new Map,e.assignedMap.set(t,!1),!0):(G(n,o)&&(void 0!==n||L(e.original,t))||(ee(e),re(e),L(e.original,t)&&G(n,e.original[t])?e.assignedMap.delete(t):e.assignedMap.set(t,!0),e.copy[t]=n,he(e,t,n,pe)),!0)},has:(e,t)=>t in V(e),ownKeys:e=>Reflect.ownKeys(V(e)),getOwnPropertyDescriptor(e,t){const n=V(e),r=Reflect.getOwnPropertyDescriptor(n,t);return r?{writable:!0,configurable:1!==e.type||"length"!==t,enumerable:r.enumerable,value:n[t]}:r},getPrototypeOf:e=>Reflect.getPrototypeOf(e.original),setPrototypeOf(){throw new Error("Cannot call 'setPrototypeOf()' on drafts")},defineProperty(){throw new Error("Cannot call 'defineProperty()' on drafts")},deleteProperty(e,t){var n;return 1===e.type?we.set.call(this,e,t,void 0,e.proxy):(void 0!==K(e.original,t)||t in e.original?(ee(e),re(e),e.assignedMap.set(t,!1)):(e.assignedMap=null!==(n=e.assignedMap)&&void 0!==n?n:new Map,e.assignedMap.delete(t)),e.copy&&delete e.copy[t],!0)}};function Ee(e){const{original:t,parentDraft:n,key:r,finalities:i,options:s}=e,o=$(t),a={type:o,finalized:!1,parent:n,original:t,copy:null,proxy:null,finalities:i,options:s,setMap:3===o?new Map(t.entries()):void 0};(r||"key"in e)&&(a.key=r);const{proxy:l,revoke:c}=Proxy.revocable(1===o?Object.assign([],a):a,we);if(i.revoke.push(c),be.add(l),a.proxy=l,n){const e=n;e.finalities.draft.push(((t,n)=>{var i,s;const o=q(l);let a=3===e.type?e.setMap:e.copy;const c=W(a,r),u=q(c);if(u){let s=u.original;u.operated&&(s=F(c)),ce(u),ue(u,pe,t,n),e.options.enableAutoFreeze&&(e.options.updatedValues=null!==(i=e.options.updatedValues)&&void 0!==i?i:new WeakMap,e.options.updatedValues.set(s,u.original)),X(a,r,s)}null===(s=o.callbacks)||void 0===s||s.forEach((e=>{e(t,n)}))}))}else{const e=q(l);e.finalities.draft.push(((t,n)=>{ce(e),ue(e,pe,t,n)}))}return l}function Oe(e,t,n,r,i){var s;const o=q(e),a=null!==(s=null==o?void 0:o.original)&&void 0!==s?s:e,l=!!t.length;if(null==o?void 0:o.operated)for(;o.finalities.draft.length>0;)o.finalities.draft.pop()(n,r);const c=l?t[0]:o?o.operated?o.copy:o.original:e;return o&&Y(o),i&&se(c,c,null==o?void 0:o.options.updatedValues),[c,n&&l?[{op:x,path:[],value:t[0]}]:n,r&&l?[{op:x,path:[],value:a}]:r]}function ke(e){const{rootDraft:t,value:n,useRawReturn:r=!1,isRoot:i=!0}=e;oe(n,((n,r,i)=>{const s=q(r);if(s&&t&&s.finalities===t.finalities){e.isContainDraft=!0;const t=s.original;if(i instanceof Set){const e=Array.from(i);i.clear(),e.forEach((e=>i.add(n===e?t:e)))}else X(i,n,t)}else"object"==typeof r&&null!==r&&(e.value=r,e.isRoot=!1,ke(e))})),i&&(e.isContainDraft||console.warn("The return value does not contain any draft, please use 'rawReturn()' to wrap the return value to improve performance."),r&&console.warn("The return value contains drafts, please don't use 'rawReturn()' to wrap the return value."))}function Me(e){var t;const n=q(e);if(!B(e,null==n?void 0:n.options))return e;const r=$(e);if(n&&!n.operated)return n.original;let i;function s(){i=2===r?I(e)?new Map(e):new(Object.getPrototypeOf(e).constructor)(e):3===r?Array.from(n.setMap.values()):Q(e,null==n?void 0:n.options)}if(n){n.finalized=!0;try{s()}finally{n.finalized=!1}}else i=e;if(oe(i,((t,r)=>{if(n&&G(W(n.original,t),r))return;const o=Me(r);o!==r&&(i===e&&s(),X(i,t,o))})),3===r){const e=null!==(t=null==n?void 0:n.original)&&void 0!==t?t:i;return N(e)?new Set(i):new(Object.getPrototypeOf(e).constructor)(i)}return i}function Re(e){if(!U(e))throw new Error(`current() is only used for Draft, parameter: ${e}`);return Me(e)}z.createDraft=Ee;const je=function e(t,n,r){var i,s,o;if("function"==typeof t&&"function"!=typeof n)return function(r,...i){return e(r,(e=>t.call(this,e,...i)),n)};const a=t,l=n;let c=r;if("function"!=typeof n&&(c=n),void 0!==c&&"[object Object]"!==Object.prototype.toString.call(c))throw new Error(`Invalid options: ${c}, 'options' should be an object.`);c=Object.assign(Object.assign({},void 0),c);const u=U(a)?Re(a):a,h=Array.isArray(c.mark)?(e,t)=>{for(const n of c.mark){if("function"!=typeof n)throw new Error(`Invalid mark: ${n}, 'mark' should be a function.`);const r=n(e,t);if(r)return r}}:c.mark,p=null!==(i=c.enablePatches)&&void 0!==i&&i,f=null!==(s=c.strict)&&void 0!==s&&s,d={enableAutoFreeze:null!==(o=c.enableAutoFreeze)&&void 0!==o&&o,mark:h,strict:f,enablePatches:p};if(!B(u,d)&&"object"==typeof u&&null!==u)throw new Error("Invalid base state: create() only supports plain objects, arrays, Set, Map or using mark() to mark the state as immutable.");const[y,v]=function(e,t){var n;const r={draft:[],revoke:[],handledSet:new WeakSet};let i,s;t.enablePatches&&(i=[],s=[]);const o=(null===(n=t.mark)||void 0===n?void 0:n.call(t,e,P))!==P.mutable&&B(e,t)?Ee({original:e,parentDraft:null,finalities:r,options:t}):e;return[o,(e=[])=>{const[n,r,a]=Oe(o,e,i,s,t.enableAutoFreeze);return t.enablePatches?[n,r,a]:n}]}(u,d);if("function"!=typeof n){if(!B(u,d))throw new Error("Invalid base state: create() only supports plain objects, arrays, Set, Map or using mark() to mark the state as immutable.");return[y,v]}let g;try{g=l(y)}catch(e){throw Y(q(y)),e}const m=e=>{const t=q(y);if(!U(e)){if(void 0!==e&&!G(e,y)&&(null==t?void 0:t.operated))throw new Error("Either the value is returned as a new non-draft value, or only the draft is modified without returning any value.");const n=null==e?void 0:e[A];if(n){const r=n[0];return d.strict&&"object"==typeof e&&null!==e&&ke({rootDraft:t,value:e,useRawReturn:!0}),v([r])}if(void 0!==e)return"object"==typeof e&&null!==e&&ke({rootDraft:t,value:e}),v([e])}if(e===y||void 0===e)return v([]);const n=q(e);if(d===n.options){if(n.operated)throw new Error("Cannot return a modified child draft.");return v([Re(e)])}return v([e])};return g instanceof Promise?g.then(m,(e=>{throw Y(q(y)),e})):m(g)};function Se(e,t){e.set(je(e.get(),t))}Object.prototype.constructor.toString();class xe{constructor(e,t=null){this.value=e,this.reactor=t??new R(this,[])}produce(e){return Se(this,e)}reducer(...e){let t;return t=1===e.length?new j(this,"",e[0]):new j(this,e[0],e[1]),t.trigger.bind(t)}setObjectByPath(e="",t){if(0===e.length)return void(this.value=t);if("string"!=typeof e||!e)throw new Error("Invalid path");let n=e.split("."),r=this.value;for(let e=0;e<n.length-1;e++){let t=n[e];t in r||(r[t]={}),r=r[t]}r[n[n.length-1]]=t}set(...e){if(1===e.length)this.value=e[0],this.reactor.react({type:"SET_VALUE",value:e[0]});else{let t=e[0],n=e[1];this.setObjectByPath(t,n),this.reactor.react({type:"SET_VALUE",path:t,value:n})}}get(){return this.value}}class Te extends xe{constructor(e,t=null){if(!(e instanceof Array))throw Error("RumiousArrayState: The initial value must be an array.");super(e,t)}set(...e){if(1===e.length)this.value=e[0],this.reactor.react({type:"SET_VALUE",value:e[0]});else{let t=e[0],n=e[1];this.value[t]=n,this.reactor.react({type:"SET_ELEMENT",index:t,value:n})}}append(e){this.value.push(e),this.reactor.react({type:"ADD_ELEMENT",value:e,index:this.value.length-1})}index(e){return this.value[e]}remove(e){e>=0&&e<this.value.length&&(this.value.splice(e,1),this.reactor.react({type:"REMOVE_ELEMENT",index:e}))}insert(e,t){e>=0&&e<=this.value.length&&(this.value.splice(e,0,t),this.reactor.react({type:"INSERT_ELEMENT",index:e,value:t}))}find(e){return this.value.find(e)}}class Ce extends xe{constructor(e,t=null){if(!(e instanceof Object))throw Error("RumiousObjectState: The initial value must be an object.");super(e,t)}set(...e){if(1===e.length)this.value=e[0],this.reactor.react({type:"SET_VALUE",value:e[0]});else{let t=e[0],n=e[1];this.value[t]=n,this.reactor.react({type:"SET_VALUE",index:t,value:n})}}keys(){return Object.keys(this.value)}values(){return Object.values(this.value)}each(e){for(let[t,n]of Object.entries(this.value))e(n,t)}has(e){return void 0!==this.value[e]}remove(e){delete this.value[e]}entries(){return Object.entries(this.value)}clear(){this.value={},this.reactor.react({type:"CLEAR"})}merge(e){e instanceof Object&&(Object.assign(this.value,e),this.reactor.react({type:"MERGE",value:e}))}map(e){return Object.entries(this.value).map((([t,n],r)=>e(n,t,r)))}}class Ae{constructor(e){this.target=e}set html(e){this.target.innerHTML=e}query(e){return this.target.querySelectorAll(e)}set text(e){this.target.textContent=e}on(e,t){this.target.addEventListener(e,t)}off(e,t){this.target.removeEventListener(e,t)}remove(){this.target.remove()}addChild(e){this.target.appendChild(e)}set(e){this.target=e}}class De{constructor(e){this.target=e}query(e){return this.target.querySelectorAll(e)}index(e){return Array.from(this.target.children)[e]}list(){return Array.from(this.target.children)}get parent(){return this.target}remove(){this.target.remove()}addChild(e){this.target.appendChild(e)}set(e){this.target=e}}class Pe{constructor(e){this.target=e}set(e){this.target=e.forwardRefs}}window.RUMIOUS_CONTEXTS||(window.RUMIOUS_CONTEXTS={});class ze{constructor(e={}){this.data=e,this.events={}}on(e,t){this.events[e]||(this.events[e]=[]),this.events[e].push(t)}off(e,t){this.events[e]&&(this.events[e]=this.events[e].filter((e=>e!==t)))}emit(e,...t){this.events[e]&&this.events[e].forEach((e=>e(...t)))}set(e,t){return this.data[e]=t,t}get(e){return this.data[e]}}class Le{constructor(e,t={}){this.hasExecuted=!1,this.result=null,this.callback=e,this.dependents=[],this.options=t}onLoad(e){this.hasExecuted?e(this.result):this.dependents.push(e)}execute(){return new Promise(((e,t)=>{if(this.hasExecuted)return e(this.result);this.hasExecuted=!0;const n=async()=>{try{this.result=await this.callback(),e(this.result),this.dependents.forEach((e=>e(this.result)))}catch(e){t(e)}};this.options.idle&&"requestIdleCallback"in window?requestIdleCallback(n):n()}))}}const _e=new Map;return e.Pending=class extends n{static tag="r-pending";constructor(){super(),this.asynchronousRender=!0}async setLoader(e){this.loader=e;try{this.result=await this.loader.execute(),this.renderResult()}catch(e){this.error=e,this.renderError()}}renderResult(){if(!this.result)throw"Rumious Render: Cannot find component when lazy loading!";this.element.before(this.render(y(this.result,{}))),this.element.remove()}renderError(){this.element.appendChild(this.render(this.props.errorComponent??this.error))}onRender(){let{loader:e}=this.props;this.setLoader(e)}template(){return this.props.fallback}},e.RumiousApp=class{constructor(e=document.createElement("span"),n={}){this.root=e,this.app=this,this.modules=[],this.configs=n,this.renderContext=new t(this)}render(e){this.renderContext.runHooks("onBeforeRender",this.renderContext),M(e,this.root,this.renderContext),this.renderContext.runHooks("onRendered",this.renderContext)}addModule(e,t={}){return e.init(this,t)}},e.RumiousArraySync=k,e.RumiousChildrensRef=De,e.RumiousComponent=n,e.RumiousComponentElement=w,e.RumiousComponentRef=Pe,e.RumiousContext=ze,e.RumiousDymanicInjector=O,e.RumiousElementRef=Ae,e.RumiousLazyLoader=Le,e.RumiousReactor=R,e.RumiousReducer=j,e.RumiousState=xe,e.createArrayState=function(e=[]){return new Te(e)},e.createChildrensRef=function(e){return new De(e)},e.createComponent=g,e.createComponentElement=E,e.createComponentRef=function(e){return new Pe(e)},e.createContext=function(e="",t={}){if(!t||"object"!=typeof t)throw new Error("Rumious context: Initial value must be an object!");return window.RUMIOUS_CONTEXTS[e]||(window.RUMIOUS_CONTEXTS[e]=new ze(t)),window.RUMIOUS_CONTEXTS[e]},e.createDirective=d,e.createElement=y,e.createElementRef=function(e){return new Ae(e)},e.createObjectState=function(e={}){return new Ce(e)},e.createState=function(e){return new xe(e)},e.createTextElement=v,e.denounce=function(e,t){let n;return function(...r){clearTimeout(n),n=setTimeout((()=>e.apply(this,r)),t)}},e.injectHTML=function(e){let t=new O;return t.commit([{type:"html",value:e}]),t},e.injectText=function(e){let t=new O;return t.commit([{type:"text",value:e}]),t},e.isComponent=r,e.isState=function(e){return e instanceof xe},e.lazyLoad=function(e,t={}){const n=t.key||e.toString();return _e.has(n)||_e.set(n,new Le(e,t)),_e.get(n)},e.leadingTrailingDebounce=function(e,t){let n,r=!0;return function(...i){r&&(e.apply(this,i),r=!1),clearTimeout(n),n=setTimeout((()=>{e.apply(this,i),r=!0}),t)}},e.produceState=Se,e.rafThrottle=function(e){let t=!1;return function(...n){t||(t=!0,requestAnimationFrame((()=>{e.apply(this,n),t=!1})))}},e.styleHelper=function(e){let t="";for(const n in e)if(Object.prototype.hasOwnProperty.call(e,n)){t+=`${n} {`;const r=e[n];for(const e in r)Object.prototype.hasOwnProperty.call(r,e)&&(t+=`${e.replace(/[A-Z]/g,(e=>`-${e.toLowerCase()}`))}: ${r[e]};`);t+="} "}return t.trim()},e.syncArray=function(e,t){return new k(e,t)},e.tholle=function(e,t){let n=0;return function(...r){const i=Date.now();i-n>=t&&(n=i,e.apply(this,r))}},e.trailingThrottle=function(e,t){let n=0,r=null,i=null;function s(){n=Date.now(),e.apply(this,r),r=null}return function(...e){const o=Date.now();r=e,o-n>=t?s():i||(i=setTimeout((()=>{i=null,s()}),t-(o-n)))}},e.unwatch=function(e,t){e.reactor.removeBinding(t)},e.watch=function(e,t){e.reactor.addBinding(t)},e}({});
+var Rumious = (function () {
+  'use strict';
+
+  class RumiousRenderContext {
+    constructor(target, app) {
+      this.target = target;
+      this.app = app;
+      this.onRenderFinished = [];
+    }
+    findName(name) {
+      return this.target[name];
+    }
+  }
+
+  function render(context, template, target) {
+    let generator = template.generator.bind(context.target);
+    context.renderHelper = render;
+    generator(target, context);
+    setTimeout(async () => {
+      const callbacks = [...context.onRenderFinished];
+      context.onRenderFinished = [];
+      for (const callback of callbacks) {
+        await callback();
+      }
+    }, 0);
+  }
+
+  class RumiousComponent {
+    static classNames = "";
+    static tagName = "rumious-component";
+    constructor() {
+      this.renderOptions = {
+        mode: "idle"
+      };
+    }
+    onCreate() {}
+    onRender() {}
+    onDestroy() {}
+    async onBeforeRender() {}
+    prepare(currentContext, props) {
+      this.props = props;
+      this.context = new RumiousRenderContext(this, currentContext.app);
+    }
+    async requestRender() {
+      await this.onBeforeRender();
+      let template = this.template();
+      render(this.context, template, this.element);
+      this.onRender();
+    }
+    requestCleanup() {}
+  }
+
+  class RumiousComponentElement extends HTMLElement {
+    constructor() {
+      super();
+      this.props = {};
+    }
+    setup(context, componentConstructor) {
+      this.context = context;
+      this.componentConstructor = componentConstructor;
+    }
+    connectedCallback() {
+      if (!this.componentConstructor) {
+        console.warn("Rumious: Cannot find matching component constructor.");
+        return;
+      }
+      this.componentInstance = new this.componentConstructor();
+      this.componentInstance.element = this;
+      if (this.componentConstructor.classNames) {
+        this.className = this.componentConstructor.classNames;
+      }
+      this.componentInstance.prepare(this.context, this.props);
+      this.componentInstance.onCreate();
+      this.componentInstance.requestRender();
+    }
+    disconnectedCallback() {
+      this.componentInstance?.onDestroy();
+    }
+  }
+
+  var Component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    RumiousComponent: RumiousComponent,
+    RumiousComponentElement: RumiousComponentElement
+  });
+
+  class RumiousApp {
+    constructor(root, options = {}) {
+      this.root = root;
+      this.options = options;
+      this.modules = [];
+      this.context = new RumiousRenderContext(this, this);
+    }
+    addModule(module, options) {
+      let instance = module.init(this, options);
+      this.modules.push(instance);
+      return instance;
+    }
+    render(template) {
+      render(this.context, template, this.root);
+    }
+  }
+  function createApp(root, options) {
+    return new RumiousApp(root, options);
+  }
+
+  var App = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    RumiousApp: RumiousApp,
+    createApp: createApp
+  });
+
+  class RumiousRenderTemplate {
+    constructor(generator) {
+      this.generator = generator;
+    }
+  }
+
+  class RumiousDymanicInjector {
+    constructor(contents) {
+      this.contents = contents;
+      this.targets = new Map();
+      if (!contents || contents.length === 0) {
+        throw new Error("Injector must be initialized with non-empty content");
+      }
+      const first = contents[0];
+      this.type = typeof first === "string" ? "string" : "element";
+    }
+    addTarget(element) {
+      this.targets.set(element, 1);
+    }
+    inject(element) {
+      if (!this.targets.has(element)) return;
+      if (!this.contents) return;
+      element.innerHTML = "";
+      if (this.type === "string") {
+        for (const content of this.contents) {
+          element.insertAdjacentHTML("beforeend", content);
+        }
+      } else {
+        for (const content of this.contents) {
+          element.appendChild(content);
+        }
+      }
+    }
+    injectAll() {
+      for (const target of this.targets.keys()) {
+        this.inject(target);
+      }
+    }
+    removeTarget(element) {
+      this.targets.delete(element);
+    }
+    clear() {
+      this.targets.clear();
+    }
+  }
+  function createHTMLInjector(html) {
+    return new RumiousDymanicInjector([html]);
+  }
+
+  class RumiousElementRef {
+    constructor(target) {
+      this.target = target;
+    }
+    getElement() {
+      return this.target;
+    }
+    remove() {
+      this.target.remove();
+    }
+    addChild(child) {
+      this.target.appendChild(child);
+    }
+    listChild() {
+      return this.target.childNodes;
+    }
+    querySelector(query) {
+      return this.target.querySelector(query);
+    }
+    querySelectorAll(query) {
+      return this.target.querySelectorAll(query);
+    }
+    set text(t) {
+      this.target.textContent = t;
+    }
+    get text() {
+      return this.target.textContent;
+    }
+    set value(v) {
+      if (this.target instanceof HTMLInputElement || this.target instanceof HTMLTextAreaElement) {
+        this.target.value = v;
+      }
+    }
+    get value() {
+      if (this.target instanceof HTMLInputElement || this.target instanceof HTMLTextAreaElement) {
+        return this.target.value;
+      }
+      return undefined;
+    }
+    addClassName(className) {
+      this.target.classList.add(className);
+    }
+    removeClassName(className) {
+      this.target.classList.remove(className);
+    }
+    hasClassName(className) {
+      return this.target.classList.contains(className);
+    }
+    toggleClass(className, force) {
+      return this.target.classList.toggle(className, force);
+    }
+    setStyle(styles) {
+      Object.assign(this.target.style, styles);
+    }
+    getStyle(property) {
+      return getComputedStyle(this.target).getPropertyValue(property);
+    }
+    setAttribute(key, value) {
+      this.target.setAttribute(key, value);
+    }
+    getAttribute(key) {
+      return this.target.getAttribute(key);
+    }
+    removeAttribute(key) {
+      this.target.removeAttribute(key);
+    }
+    on(event, callback, options) {
+      this.target.addEventListener(event, callback, options);
+    }
+    off(event, callback, options) {
+      this.target.removeEventListener(event, callback, options);
+    }
+    set html(t) {
+      this.target.innerHTML = t;
+    }
+    get html() {
+      return this.target.innerHTML;
+    }
+    getBoundingRect() {
+      return this.target.getBoundingClientRect();
+    }
+    isInViewport() {
+      const rect = this.target.getBoundingClientRect();
+      return rect.top >= 0 && rect.left >= 0 && rect.bottom <= (window.innerHeight || document.documentElement.clientHeight) && rect.right <= (window.innerWidth || document.documentElement.clientWidth);
+    }
+    prependChild(child) {
+      this.target.prepend(child);
+    }
+    setDisabled(disabled) {
+      if (this.target instanceof HTMLButtonElement || this.target instanceof HTMLInputElement || this.target instanceof HTMLTextAreaElement) {
+        this.target.disabled = disabled;
+      }
+    }
+    addClasses(...classNames) {
+      this.target.classList.add(...classNames);
+    }
+    removeClasses(...classNames) {
+      this.target.classList.remove(...classNames);
+    }
+    replaceClass(oldClass, newClass) {
+      this.target.classList.replace(oldClass, newClass);
+    }
+    moveTo(newParent) {
+      newParent.appendChild(this.target);
+    }
+    getParent() {
+      return this.target.parentElement;
+    }
+    getNextSibling() {
+      return this.target.nextElementSibling;
+    }
+    getPreviousSibling() {
+      return this.target.previousElementSibling;
+    }
+    hide() {
+      this.target.style.display = 'none';
+    }
+    show() {
+      this.target.style.removeProperty('display');
+    }
+    isHidden() {
+      return window.getComputedStyle(this.target).display === 'none';
+    }
+    scrollIntoView(options = {
+      behavior: 'smooth'
+    }) {
+      this.target.scrollIntoView(options);
+    }
+    matches(selector) {
+      return this.target.matches(selector);
+    }
+    getChildren() {
+      return Array.from(this.target.children);
+    }
+    insertAfter(newNode) {
+      if (this.target.parentNode) {
+        this.target.parentNode.insertBefore(newNode, this.target.nextSibling);
+      }
+    }
+    insertBefore(newNode) {
+      if (this.target.parentNode) {
+        this.target.parentNode.insertBefore(newNode, this.target);
+      }
+    }
+    clearChildren() {
+      while (this.target.firstChild) {
+        this.target.removeChild(this.target.firstChild);
+      }
+    }
+    animate(keyframes, options) {
+      return this.target.animate(keyframes, options);
+    }
+  }
+  function createElementRef() {
+    return new RumiousElementRef(document.createElement("span"));
+  }
+
+  function extractName(str) {
+    const index = str.indexOf('$');
+    if (index !== -1) {
+      return str.slice(index + 1);
+    }
+    return '';
+  }
+  function generateName(prefix = "_") {
+    return `${prefix}${(Math.floor(Math.random() * 9999) * Date.now()).toString(32)}`;
+  }
+
+  class RumiousReactor {
+    constructor(target) {
+      this.target = target;
+      this.bindings = [];
+    }
+    addBinding(bind) {
+      this.bindings.push(bind);
+    }
+    removeBinding(bind) {
+      this.bindings = this.bindings.filter(_ => _ !== bind);
+    }
+    async emit(commit) {
+      await Promise.allSettled(this.bindings.map(bind => {
+        try {
+          const result = bind(commit);
+          return result instanceof Promise ? result : Promise.resolve(result);
+        } catch (err) {
+          return Promise.reject(err);
+        }
+      }));
+    }
+  }
+
+  const Operation = {
+      Remove: 'remove',
+      Replace: 'replace',
+      Add: 'add',
+  };
+
+  // Don't use `Symbol()` just for 3rd party access the draft
+  const PROXY_DRAFT = Symbol.for('__MUTATIVE_PROXY_DRAFT__');
+  const RAW_RETURN_SYMBOL = Symbol('__MUTATIVE_RAW_RETURN_SYMBOL__');
+  const iteratorSymbol = Symbol.iterator;
+  const dataTypes = {
+      mutable: 'mutable',
+      immutable: 'immutable',
+  };
+
+  const internal = {};
+
+  function has(target, key) {
+      return target instanceof Map
+          ? target.has(key)
+          : Object.prototype.hasOwnProperty.call(target, key);
+  }
+  function getDescriptor(target, key) {
+      if (key in target) {
+          let prototype = Reflect.getPrototypeOf(target);
+          while (prototype) {
+              const descriptor = Reflect.getOwnPropertyDescriptor(prototype, key);
+              if (descriptor)
+                  return descriptor;
+              prototype = Reflect.getPrototypeOf(prototype);
+          }
+      }
+      return;
+  }
+  function isBaseSetInstance(obj) {
+      return Object.getPrototypeOf(obj) === Set.prototype;
+  }
+  function isBaseMapInstance(obj) {
+      return Object.getPrototypeOf(obj) === Map.prototype;
+  }
+
+  function latest(proxyDraft) {
+      var _a;
+      return (_a = proxyDraft.copy) !== null && _a !== undefined ? _a : proxyDraft.original;
+  }
+  /**
+   * Check if the value is a draft
+   */
+  function isDraft(target) {
+      return !!getProxyDraft(target);
+  }
+  function getProxyDraft(value) {
+      if (typeof value !== 'object')
+          return null;
+      return value === null || value === undefined ? undefined : value[PROXY_DRAFT];
+  }
+  function getValue(value) {
+      var _a;
+      const proxyDraft = getProxyDraft(value);
+      return proxyDraft ? (_a = proxyDraft.copy) !== null && _a !== undefined ? _a : proxyDraft.original : value;
+  }
+  /**
+   * Check if a value is draftable
+   */
+  function isDraftable(value, options) {
+      if (!value || typeof value !== 'object')
+          return false;
+      let markResult;
+      return (Object.getPrototypeOf(value) === Object.prototype ||
+          Array.isArray(value) ||
+          value instanceof Map ||
+          value instanceof Set ||
+          (!!(options === null || options === undefined ? undefined : options.mark) &&
+              ((markResult = options.mark(value, dataTypes)) === dataTypes.immutable ||
+                  typeof markResult === 'function')));
+  }
+  function getPath(target, path = []) {
+      if (Object.hasOwnProperty.call(target, 'key')) {
+          // check if the parent is a draft and the original value is not equal to the current value
+          const parentCopy = target.parent.copy;
+          const proxyDraft = getProxyDraft(get(parentCopy, target.key));
+          if (proxyDraft !== null && (proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.original) !== target.original) {
+              return null;
+          }
+          const isSet = target.parent.type === 3 /* DraftType.Set */;
+          const key = isSet
+              ? Array.from(target.parent.setMap.keys()).indexOf(target.key)
+              : target.key;
+          // check if the key is still in the next state parent
+          if (!((isSet && parentCopy.size > key) || has(parentCopy, key)))
+              return null;
+          path.push(key);
+      }
+      if (target.parent) {
+          return getPath(target.parent, path);
+      }
+      // `target` is root draft.
+      path.reverse();
+      try {
+          // check if the path is valid
+          resolvePath(target.copy, path);
+      }
+      catch (e) {
+          return null;
+      }
+      return path;
+  }
+  function getType(target) {
+      if (Array.isArray(target))
+          return 1 /* DraftType.Array */;
+      if (target instanceof Map)
+          return 2 /* DraftType.Map */;
+      if (target instanceof Set)
+          return 3 /* DraftType.Set */;
+      return 0 /* DraftType.Object */;
+  }
+  function get(target, key) {
+      return getType(target) === 2 /* DraftType.Map */ ? target.get(key) : target[key];
+  }
+  function set(target, key, value) {
+      const type = getType(target);
+      if (type === 2 /* DraftType.Map */) {
+          target.set(key, value);
+      }
+      else {
+          target[key] = value;
+      }
+  }
+  function peek(target, key) {
+      const state = getProxyDraft(target);
+      const source = state ? latest(state) : target;
+      return source[key];
+  }
+  function isEqual(x, y) {
+      if (x === y) {
+          return x !== 0 || 1 / x === 1 / y;
+      }
+      else {
+          return x !== x && y !== y;
+      }
+  }
+  function revokeProxy(proxyDraft) {
+      if (!proxyDraft)
+          return;
+      while (proxyDraft.finalities.revoke.length > 0) {
+          const revoke = proxyDraft.finalities.revoke.pop();
+          revoke();
+      }
+  }
+  // handle JSON Pointer path with spec https://www.rfc-editor.org/rfc/rfc6901
+  function escapePath(path, pathAsArray) {
+      return pathAsArray
+          ? path
+          : ['']
+              .concat(path)
+              .map((_item) => {
+              const item = `${_item}`;
+              if (item.indexOf('/') === -1 && item.indexOf('~') === -1)
+                  return item;
+              return item.replace(/~/g, '~0').replace(/\//g, '~1');
+          })
+              .join('/');
+  }
+  function resolvePath(base, path) {
+      for (let index = 0; index < path.length - 1; index += 1) {
+          const key = path[index];
+          // use `index` in Set draft
+          base = get(getType(base) === 3 /* DraftType.Set */ ? Array.from(base) : base, key);
+          if (typeof base !== 'object') {
+              throw new Error(`Cannot resolve patch at '${path.join('/')}'.`);
+          }
+      }
+      return base;
+  }
+
+  function strictCopy(target) {
+      const copy = Object.create(Object.getPrototypeOf(target));
+      Reflect.ownKeys(target).forEach((key) => {
+          let desc = Reflect.getOwnPropertyDescriptor(target, key);
+          if (desc.enumerable && desc.configurable && desc.writable) {
+              copy[key] = target[key];
+              return;
+          }
+          // for freeze
+          if (!desc.writable) {
+              desc.writable = true;
+              desc.configurable = true;
+          }
+          if (desc.get || desc.set)
+              desc = {
+                  configurable: true,
+                  writable: true,
+                  enumerable: desc.enumerable,
+                  value: target[key],
+              };
+          Reflect.defineProperty(copy, key, desc);
+      });
+      return copy;
+  }
+  const propIsEnum = Object.prototype.propertyIsEnumerable;
+  function shallowCopy(original, options) {
+      let markResult;
+      if (Array.isArray(original)) {
+          return Array.prototype.concat.call(original);
+      }
+      else if (original instanceof Set) {
+          if (!isBaseSetInstance(original)) {
+              const SubClass = Object.getPrototypeOf(original).constructor;
+              return new SubClass(original.values());
+          }
+          return Set.prototype.difference
+              ? Set.prototype.difference.call(original, new Set())
+              : new Set(original.values());
+      }
+      else if (original instanceof Map) {
+          if (!isBaseMapInstance(original)) {
+              const SubClass = Object.getPrototypeOf(original).constructor;
+              return new SubClass(original);
+          }
+          return new Map(original);
+      }
+      else if ((options === null || options === undefined ? undefined : options.mark) &&
+          ((markResult = options.mark(original, dataTypes)),
+              markResult !== undefined) &&
+          markResult !== dataTypes.mutable) {
+          if (markResult === dataTypes.immutable) {
+              return strictCopy(original);
+          }
+          else if (typeof markResult === 'function') {
+              if ((options.enablePatches || options.enableAutoFreeze)) {
+                  throw new Error(`You can't use mark and patches or auto freeze together.`);
+              }
+              return markResult();
+          }
+          throw new Error(`Unsupported mark result: ${markResult}`);
+      }
+      else if (typeof original === 'object' &&
+          Object.getPrototypeOf(original) === Object.prototype) {
+          // For best performance with shallow copies,
+          // don't use `Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));` by default.
+          const copy = {};
+          Object.keys(original).forEach((key) => {
+              copy[key] = original[key];
+          });
+          Object.getOwnPropertySymbols(original).forEach((key) => {
+              if (propIsEnum.call(original, key)) {
+                  copy[key] = original[key];
+              }
+          });
+          return copy;
+      }
+      else {
+          throw new Error(`Please check mark() to ensure that it is a stable marker draftable function.`);
+      }
+  }
+  function ensureShallowCopy(target) {
+      if (target.copy)
+          return;
+      target.copy = shallowCopy(target.original, target.options);
+  }
+  function deepClone(target) {
+      if (!isDraftable(target))
+          return getValue(target);
+      if (Array.isArray(target))
+          return target.map(deepClone);
+      if (target instanceof Map) {
+          const iterable = Array.from(target.entries()).map(([k, v]) => [
+              k,
+              deepClone(v),
+          ]);
+          if (!isBaseMapInstance(target)) {
+              const SubClass = Object.getPrototypeOf(target).constructor;
+              return new SubClass(iterable);
+          }
+          return new Map(iterable);
+      }
+      if (target instanceof Set) {
+          const iterable = Array.from(target).map(deepClone);
+          if (!isBaseSetInstance(target)) {
+              const SubClass = Object.getPrototypeOf(target).constructor;
+              return new SubClass(iterable);
+          }
+          return new Set(iterable);
+      }
+      const copy = Object.create(Object.getPrototypeOf(target));
+      for (const key in target)
+          copy[key] = deepClone(target[key]);
+      return copy;
+  }
+  function cloneIfNeeded(target) {
+      return isDraft(target) ? deepClone(target) : target;
+  }
+
+  function markChanged(proxyDraft) {
+      var _a;
+      proxyDraft.assignedMap = (_a = proxyDraft.assignedMap) !== null && _a !== undefined ? _a : new Map();
+      if (!proxyDraft.operated) {
+          proxyDraft.operated = true;
+          if (proxyDraft.parent) {
+              markChanged(proxyDraft.parent);
+          }
+      }
+  }
+
+  function throwFrozenError() {
+      throw new Error('Cannot modify frozen object');
+  }
+  function deepFreeze(target, subKey, updatedValues, stack, keys) {
+      {
+          updatedValues = updatedValues !== null && updatedValues !== undefined ? updatedValues : new WeakMap();
+          stack = stack !== null && stack !== undefined ? stack : [];
+          keys = keys !== null && keys !== undefined ? keys : [];
+          const value = updatedValues.has(target)
+              ? updatedValues.get(target)
+              : target;
+          if (stack.length > 0) {
+              const index = stack.indexOf(value);
+              if (value && typeof value === 'object' && index !== -1) {
+                  if (stack[0] === value) {
+                      throw new Error(`Forbids circular reference`);
+                  }
+                  throw new Error(`Forbids circular reference: ~/${keys
+                    .slice(0, index)
+                    .map((key, index) => {
+                    if (typeof key === 'symbol')
+                        return `[${key.toString()}]`;
+                    const parent = stack[index];
+                    if (typeof key === 'object' &&
+                        (parent instanceof Map || parent instanceof Set))
+                        return Array.from(parent.keys()).indexOf(key);
+                    return key;
+                })
+                    .join('/')}`);
+              }
+              stack.push(value);
+              keys.push(subKey);
+          }
+          else {
+              stack.push(value);
+          }
+      }
+      if (Object.isFrozen(target) || isDraft(target)) {
+          {
+              stack.pop();
+              keys.pop();
+          }
+          return;
+      }
+      const type = getType(target);
+      switch (type) {
+          case 2 /* DraftType.Map */:
+              for (const [key, value] of target) {
+                  deepFreeze(key, key, updatedValues, stack, keys);
+                  deepFreeze(value, key, updatedValues, stack, keys);
+              }
+              target.set = target.clear = target.delete = throwFrozenError;
+              break;
+          case 3 /* DraftType.Set */:
+              for (const value of target) {
+                  deepFreeze(value, value, updatedValues, stack, keys);
+              }
+              target.add = target.clear = target.delete = throwFrozenError;
+              break;
+          case 1 /* DraftType.Array */:
+              Object.freeze(target);
+              let index = 0;
+              for (const value of target) {
+                  deepFreeze(value, index, updatedValues, stack, keys);
+                  index += 1;
+              }
+              break;
+          default:
+              Object.freeze(target);
+              // ignore non-enumerable or symbol properties
+              Object.keys(target).forEach((name) => {
+                  const value = target[name];
+                  deepFreeze(value, name, updatedValues, stack, keys);
+              });
+      }
+      {
+          stack.pop();
+          keys.pop();
+      }
+  }
+
+  function forEach(target, iter) {
+      const type = getType(target);
+      if (type === 0 /* DraftType.Object */) {
+          Reflect.ownKeys(target).forEach((key) => {
+              iter(key, target[key], target);
+          });
+      }
+      else if (type === 1 /* DraftType.Array */) {
+          let index = 0;
+          for (const entry of target) {
+              iter(index, entry, target);
+              index += 1;
+          }
+      }
+      else {
+          target.forEach((entry, index) => iter(index, entry, target));
+      }
+  }
+
+  function handleValue(target, handledSet, options) {
+      if (isDraft(target) ||
+          !isDraftable(target, options) ||
+          handledSet.has(target) ||
+          Object.isFrozen(target))
+          return;
+      const isSet = target instanceof Set;
+      const setMap = isSet ? new Map() : undefined;
+      handledSet.add(target);
+      forEach(target, (key, value) => {
+          var _a;
+          if (isDraft(value)) {
+              const proxyDraft = getProxyDraft(value);
+              ensureShallowCopy(proxyDraft);
+              // A draft where a child node has been changed, or assigned a value
+              const updatedValue = ((_a = proxyDraft.assignedMap) === null || _a === undefined ? undefined : _a.size) || proxyDraft.operated
+                  ? proxyDraft.copy
+                  : proxyDraft.original;
+              // final update value
+              set(isSet ? setMap : target, key, updatedValue);
+          }
+          else {
+              handleValue(value, handledSet, options);
+          }
+      });
+      if (setMap) {
+          const set = target;
+          const values = Array.from(set);
+          set.clear();
+          values.forEach((value) => {
+              set.add(setMap.has(value) ? setMap.get(value) : value);
+          });
+      }
+  }
+  function finalizeAssigned(proxyDraft, key) {
+      // handle the draftable assigned values， and the value is not a draft
+      const copy = proxyDraft.type === 3 /* DraftType.Set */ ? proxyDraft.setMap : proxyDraft.copy;
+      if (proxyDraft.finalities.revoke.length > 1 &&
+          proxyDraft.assignedMap.get(key) &&
+          copy) {
+          handleValue(get(copy, key), proxyDraft.finalities.handledSet, proxyDraft.options);
+      }
+  }
+  function finalizeSetValue(target) {
+      if (target.type === 3 /* DraftType.Set */ && target.copy) {
+          target.copy.clear();
+          target.setMap.forEach((value) => {
+              target.copy.add(getValue(value));
+          });
+      }
+  }
+  function finalizePatches(target, generatePatches, patches, inversePatches) {
+      const shouldFinalize = target.operated &&
+          target.assignedMap &&
+          target.assignedMap.size > 0 &&
+          !target.finalized;
+      if (shouldFinalize) {
+          if (patches && inversePatches) {
+              const basePath = getPath(target);
+              if (basePath) {
+                  generatePatches(target, basePath, patches, inversePatches);
+              }
+          }
+          target.finalized = true;
+      }
+  }
+  function markFinalization(target, key, value, generatePatches) {
+      const proxyDraft = getProxyDraft(value);
+      if (proxyDraft) {
+          // !case: assign the draft value
+          if (!proxyDraft.callbacks) {
+              proxyDraft.callbacks = [];
+          }
+          proxyDraft.callbacks.push((patches, inversePatches) => {
+              var _a;
+              const copy = target.type === 3 /* DraftType.Set */ ? target.setMap : target.copy;
+              if (isEqual(get(copy, key), value)) {
+                  let updatedValue = proxyDraft.original;
+                  if (proxyDraft.copy) {
+                      updatedValue = proxyDraft.copy;
+                  }
+                  finalizeSetValue(target);
+                  finalizePatches(target, generatePatches, patches, inversePatches);
+                  if (target.options.enableAutoFreeze) {
+                      target.options.updatedValues =
+                          (_a = target.options.updatedValues) !== null && _a !== undefined ? _a : new WeakMap();
+                      target.options.updatedValues.set(updatedValue, proxyDraft.original);
+                  }
+                  // final update value
+                  set(copy, key, updatedValue);
+              }
+          });
+          if (target.options.enableAutoFreeze) {
+              // !case: assign the draft value in cross draft tree
+              if (proxyDraft.finalities !== target.finalities) {
+                  target.options.enableAutoFreeze = false;
+              }
+          }
+      }
+      if (isDraftable(value, target.options)) {
+          // !case: assign the non-draft value
+          target.finalities.draft.push(() => {
+              const copy = target.type === 3 /* DraftType.Set */ ? target.setMap : target.copy;
+              if (isEqual(get(copy, key), value)) {
+                  finalizeAssigned(target, key);
+              }
+          });
+      }
+  }
+
+  function generateArrayPatches(proxyState, basePath, patches, inversePatches, pathAsArray) {
+      let { original, assignedMap, options } = proxyState;
+      let copy = proxyState.copy;
+      if (copy.length < original.length) {
+          [original, copy] = [copy, original];
+          [patches, inversePatches] = [inversePatches, patches];
+      }
+      for (let index = 0; index < original.length; index += 1) {
+          if (assignedMap.get(index.toString()) && copy[index] !== original[index]) {
+              const _path = basePath.concat([index]);
+              const path = escapePath(_path, pathAsArray);
+              patches.push({
+                  op: Operation.Replace,
+                  path,
+                  // If it is a draft, it needs to be deep cloned, and it may also be non-draft.
+                  value: cloneIfNeeded(copy[index]),
+              });
+              inversePatches.push({
+                  op: Operation.Replace,
+                  path,
+                  // If it is a draft, it needs to be deep cloned, and it may also be non-draft.
+                  value: cloneIfNeeded(original[index]),
+              });
+          }
+      }
+      for (let index = original.length; index < copy.length; index += 1) {
+          const _path = basePath.concat([index]);
+          const path = escapePath(_path, pathAsArray);
+          patches.push({
+              op: Operation.Add,
+              path,
+              // If it is a draft, it needs to be deep cloned, and it may also be non-draft.
+              value: cloneIfNeeded(copy[index]),
+          });
+      }
+      if (original.length < copy.length) {
+          // https://www.rfc-editor.org/rfc/rfc6902#appendix-A.4
+          // For performance, here we only generate an operation that replaces the length of the array,
+          // which is inconsistent with JSON Patch specification
+          const { arrayLengthAssignment = true } = options.enablePatches;
+          if (arrayLengthAssignment) {
+              const _path = basePath.concat(['length']);
+              const path = escapePath(_path, pathAsArray);
+              inversePatches.push({
+                  op: Operation.Replace,
+                  path,
+                  value: original.length,
+              });
+          }
+          else {
+              for (let index = copy.length; original.length < index; index -= 1) {
+                  const _path = basePath.concat([index - 1]);
+                  const path = escapePath(_path, pathAsArray);
+                  inversePatches.push({
+                      op: Operation.Remove,
+                      path,
+                  });
+              }
+          }
+      }
+  }
+  function generatePatchesFromAssigned({ original, copy, assignedMap }, basePath, patches, inversePatches, pathAsArray) {
+      assignedMap.forEach((assignedValue, key) => {
+          const originalValue = get(original, key);
+          const value = cloneIfNeeded(get(copy, key));
+          const op = !assignedValue
+              ? Operation.Remove
+              : has(original, key)
+                  ? Operation.Replace
+                  : Operation.Add;
+          if (isEqual(originalValue, value) && op === Operation.Replace)
+              return;
+          const _path = basePath.concat(key);
+          const path = escapePath(_path, pathAsArray);
+          patches.push(op === Operation.Remove ? { op, path } : { op, path, value });
+          inversePatches.push(op === Operation.Add
+              ? { op: Operation.Remove, path }
+              : op === Operation.Remove
+                  ? { op: Operation.Add, path, value: originalValue }
+                  : { op: Operation.Replace, path, value: originalValue });
+      });
+  }
+  function generateSetPatches({ original, copy }, basePath, patches, inversePatches, pathAsArray) {
+      let index = 0;
+      original.forEach((value) => {
+          if (!copy.has(value)) {
+              const _path = basePath.concat([index]);
+              const path = escapePath(_path, pathAsArray);
+              patches.push({
+                  op: Operation.Remove,
+                  path,
+                  value,
+              });
+              inversePatches.unshift({
+                  op: Operation.Add,
+                  path,
+                  value,
+              });
+          }
+          index += 1;
+      });
+      index = 0;
+      copy.forEach((value) => {
+          if (!original.has(value)) {
+              const _path = basePath.concat([index]);
+              const path = escapePath(_path, pathAsArray);
+              patches.push({
+                  op: Operation.Add,
+                  path,
+                  value,
+              });
+              inversePatches.unshift({
+                  op: Operation.Remove,
+                  path,
+                  value,
+              });
+          }
+          index += 1;
+      });
+  }
+  function generatePatches(proxyState, basePath, patches, inversePatches) {
+      const { pathAsArray = true } = proxyState.options.enablePatches;
+      switch (proxyState.type) {
+          case 0 /* DraftType.Object */:
+          case 2 /* DraftType.Map */:
+              return generatePatchesFromAssigned(proxyState, basePath, patches, inversePatches, pathAsArray);
+          case 1 /* DraftType.Array */:
+              return generateArrayPatches(proxyState, basePath, patches, inversePatches, pathAsArray);
+          case 3 /* DraftType.Set */:
+              return generateSetPatches(proxyState, basePath, patches, inversePatches, pathAsArray);
+      }
+  }
+  const checkReadable = (value, options, ignoreCheckDraftable = false) => {
+      if (typeof value === 'object' &&
+          value !== null &&
+          (!isDraftable(value, options) || ignoreCheckDraftable) &&
+          true) {
+          throw new Error(`Strict mode: Mutable data cannot be accessed directly, please use 'unsafe(callback)' wrap.`);
+      }
+  };
+
+  const mapHandler = {
+      get size() {
+          const current = latest(getProxyDraft(this));
+          return current.size;
+      },
+      has(key) {
+          return latest(getProxyDraft(this)).has(key);
+      },
+      set(key, value) {
+          const target = getProxyDraft(this);
+          const source = latest(target);
+          if (!source.has(key) || !isEqual(source.get(key), value)) {
+              ensureShallowCopy(target);
+              markChanged(target);
+              target.assignedMap.set(key, true);
+              target.copy.set(key, value);
+              markFinalization(target, key, value, generatePatches);
+          }
+          return this;
+      },
+      delete(key) {
+          if (!this.has(key)) {
+              return false;
+          }
+          const target = getProxyDraft(this);
+          ensureShallowCopy(target);
+          markChanged(target);
+          if (target.original.has(key)) {
+              target.assignedMap.set(key, false);
+          }
+          else {
+              target.assignedMap.delete(key);
+          }
+          target.copy.delete(key);
+          return true;
+      },
+      clear() {
+          const target = getProxyDraft(this);
+          if (!this.size)
+              return;
+          ensureShallowCopy(target);
+          markChanged(target);
+          target.assignedMap = new Map();
+          for (const [key] of target.original) {
+              target.assignedMap.set(key, false);
+          }
+          target.copy.clear();
+      },
+      forEach(callback, thisArg) {
+          const target = getProxyDraft(this);
+          latest(target).forEach((_value, _key) => {
+              callback.call(thisArg, this.get(_key), _key, this);
+          });
+      },
+      get(key) {
+          var _a, _b;
+          const target = getProxyDraft(this);
+          const value = latest(target).get(key);
+          const mutable = ((_b = (_a = target.options).mark) === null || _b === undefined ? undefined : _b.call(_a, value, dataTypes)) === dataTypes.mutable;
+          if (target.options.strict) {
+              checkReadable(value, target.options, mutable);
+          }
+          if (mutable) {
+              return value;
+          }
+          if (target.finalized || !isDraftable(value, target.options)) {
+              return value;
+          }
+          // drafted or reassigned
+          if (value !== target.original.get(key)) {
+              return value;
+          }
+          const draft = internal.createDraft({
+              original: value,
+              parentDraft: target,
+              key,
+              finalities: target.finalities,
+              options: target.options,
+          });
+          ensureShallowCopy(target);
+          target.copy.set(key, draft);
+          return draft;
+      },
+      keys() {
+          return latest(getProxyDraft(this)).keys();
+      },
+      values() {
+          const iterator = this.keys();
+          return {
+              [iteratorSymbol]: () => this.values(),
+              next: () => {
+                  const result = iterator.next();
+                  if (result.done)
+                      return result;
+                  const value = this.get(result.value);
+                  return {
+                      done: false,
+                      value,
+                  };
+              },
+          };
+      },
+      entries() {
+          const iterator = this.keys();
+          return {
+              [iteratorSymbol]: () => this.entries(),
+              next: () => {
+                  const result = iterator.next();
+                  if (result.done)
+                      return result;
+                  const value = this.get(result.value);
+                  return {
+                      done: false,
+                      value: [result.value, value],
+                  };
+              },
+          };
+      },
+      [iteratorSymbol]() {
+          return this.entries();
+      },
+  };
+  const mapHandlerKeys = Reflect.ownKeys(mapHandler);
+
+  const getNextIterator = (target, iterator, { isValuesIterator }) => () => {
+      var _a, _b;
+      const result = iterator.next();
+      if (result.done)
+          return result;
+      const key = result.value;
+      let value = target.setMap.get(key);
+      const currentDraft = getProxyDraft(value);
+      const mutable = ((_b = (_a = target.options).mark) === null || _b === undefined ? undefined : _b.call(_a, value, dataTypes)) === dataTypes.mutable;
+      if (target.options.strict) {
+          checkReadable(key, target.options, mutable);
+      }
+      if (!mutable &&
+          !currentDraft &&
+          isDraftable(key, target.options) &&
+          !target.finalized &&
+          target.original.has(key)) {
+          // draft a draftable original set item
+          const proxy = internal.createDraft({
+              original: key,
+              parentDraft: target,
+              key,
+              finalities: target.finalities,
+              options: target.options,
+          });
+          target.setMap.set(key, proxy);
+          value = proxy;
+      }
+      else if (currentDraft) {
+          // drafted
+          value = currentDraft.proxy;
+      }
+      return {
+          done: false,
+          value: isValuesIterator ? value : [value, value],
+      };
+  };
+  const setHandler = {
+      get size() {
+          const target = getProxyDraft(this);
+          return target.setMap.size;
+      },
+      has(value) {
+          const target = getProxyDraft(this);
+          // reassigned or non-draftable values
+          if (target.setMap.has(value))
+              return true;
+          ensureShallowCopy(target);
+          const valueProxyDraft = getProxyDraft(value);
+          // drafted
+          if (valueProxyDraft && target.setMap.has(valueProxyDraft.original))
+              return true;
+          return false;
+      },
+      add(value) {
+          const target = getProxyDraft(this);
+          if (!this.has(value)) {
+              ensureShallowCopy(target);
+              markChanged(target);
+              target.assignedMap.set(value, true);
+              target.setMap.set(value, value);
+              markFinalization(target, value, value, generatePatches);
+          }
+          return this;
+      },
+      delete(value) {
+          if (!this.has(value)) {
+              return false;
+          }
+          const target = getProxyDraft(this);
+          ensureShallowCopy(target);
+          markChanged(target);
+          const valueProxyDraft = getProxyDraft(value);
+          if (valueProxyDraft && target.setMap.has(valueProxyDraft.original)) {
+              // delete drafted
+              target.assignedMap.set(valueProxyDraft.original, false);
+              return target.setMap.delete(valueProxyDraft.original);
+          }
+          if (!valueProxyDraft && target.setMap.has(value)) {
+              // non-draftable values
+              target.assignedMap.set(value, false);
+          }
+          else {
+              // reassigned
+              target.assignedMap.delete(value);
+          }
+          // delete reassigned or non-draftable values
+          return target.setMap.delete(value);
+      },
+      clear() {
+          if (!this.size)
+              return;
+          const target = getProxyDraft(this);
+          ensureShallowCopy(target);
+          markChanged(target);
+          for (const value of target.original) {
+              target.assignedMap.set(value, false);
+          }
+          target.setMap.clear();
+      },
+      values() {
+          const target = getProxyDraft(this);
+          ensureShallowCopy(target);
+          const iterator = target.setMap.keys();
+          return {
+              [Symbol.iterator]: () => this.values(),
+              next: getNextIterator(target, iterator, { isValuesIterator: true }),
+          };
+      },
+      entries() {
+          const target = getProxyDraft(this);
+          ensureShallowCopy(target);
+          const iterator = target.setMap.keys();
+          return {
+              [Symbol.iterator]: () => this.entries(),
+              next: getNextIterator(target, iterator, {
+                  isValuesIterator: false,
+              }),
+          };
+      },
+      keys() {
+          return this.values();
+      },
+      [iteratorSymbol]() {
+          return this.values();
+      },
+      forEach(callback, thisArg) {
+          const iterator = this.values();
+          let result = iterator.next();
+          while (!result.done) {
+              callback.call(thisArg, result.value, result.value, this);
+              result = iterator.next();
+          }
+      },
+  };
+  if (Set.prototype.difference) {
+      // for compatibility with new Set methods
+      // https://github.com/tc39/proposal-set-methods
+      // And `https://github.com/tc39/proposal-set-methods/blob/main/details.md#symbolspecies` has some details about the `@@species` symbol.
+      // So we can't use SubSet instance constructor to get the constructor of the SubSet instance.
+      Object.assign(setHandler, {
+          intersection(other) {
+              return Set.prototype.intersection.call(new Set(this.values()), other);
+          },
+          union(other) {
+              return Set.prototype.union.call(new Set(this.values()), other);
+          },
+          difference(other) {
+              return Set.prototype.difference.call(new Set(this.values()), other);
+          },
+          symmetricDifference(other) {
+              return Set.prototype.symmetricDifference.call(new Set(this.values()), other);
+          },
+          isSubsetOf(other) {
+              return Set.prototype.isSubsetOf.call(new Set(this.values()), other);
+          },
+          isSupersetOf(other) {
+              return Set.prototype.isSupersetOf.call(new Set(this.values()), other);
+          },
+          isDisjointFrom(other) {
+              return Set.prototype.isDisjointFrom.call(new Set(this.values()), other);
+          },
+      });
+  }
+  const setHandlerKeys = Reflect.ownKeys(setHandler);
+
+  const draftsCache = new WeakSet();
+  const proxyHandler = {
+      get(target, key, receiver) {
+          var _a, _b;
+          const copy = (_a = target.copy) === null || _a === undefined ? undefined : _a[key];
+          // Improve draft reading performance by caching the draft copy.
+          if (copy && draftsCache.has(copy)) {
+              return copy;
+          }
+          if (key === PROXY_DRAFT)
+              return target;
+          let markResult;
+          if (target.options.mark) {
+              // handle `Uncaught TypeError: Method get Map.prototype.size called on incompatible receiver #<Map>`
+              // or `Uncaught TypeError: Method get Set.prototype.size called on incompatible receiver #<Set>`
+              const value = key === 'size' &&
+                  (target.original instanceof Map || target.original instanceof Set)
+                  ? Reflect.get(target.original, key)
+                  : Reflect.get(target.original, key, receiver);
+              markResult = target.options.mark(value, dataTypes);
+              if (markResult === dataTypes.mutable) {
+                  if (target.options.strict) {
+                      checkReadable(value, target.options, true);
+                  }
+                  return value;
+              }
+          }
+          const source = latest(target);
+          if (source instanceof Map && mapHandlerKeys.includes(key)) {
+              if (key === 'size') {
+                  return Object.getOwnPropertyDescriptor(mapHandler, 'size').get.call(target.proxy);
+              }
+              const handle = mapHandler[key];
+              if (handle) {
+                  return handle.bind(target.proxy);
+              }
+          }
+          if (source instanceof Set && setHandlerKeys.includes(key)) {
+              if (key === 'size') {
+                  return Object.getOwnPropertyDescriptor(setHandler, 'size').get.call(target.proxy);
+              }
+              const handle = setHandler[key];
+              if (handle) {
+                  return handle.bind(target.proxy);
+              }
+          }
+          if (!has(source, key)) {
+              const desc = getDescriptor(source, key);
+              return desc
+                  ? `value` in desc
+                      ? desc.value
+                      : // !case: support for getter
+                          (_b = desc.get) === null || _b === undefined ? undefined : _b.call(target.proxy)
+                  : undefined;
+          }
+          const value = source[key];
+          if (target.options.strict) {
+              checkReadable(value, target.options);
+          }
+          if (target.finalized || !isDraftable(value, target.options)) {
+              return value;
+          }
+          // Ensure that the assigned values are not drafted
+          if (value === peek(target.original, key)) {
+              ensureShallowCopy(target);
+              target.copy[key] = createDraft({
+                  original: target.original[key],
+                  parentDraft: target,
+                  key: target.type === 1 /* DraftType.Array */ ? Number(key) : key,
+                  finalities: target.finalities,
+                  options: target.options,
+              });
+              // !case: support for custom shallow copy function
+              if (typeof markResult === 'function') {
+                  const subProxyDraft = getProxyDraft(target.copy[key]);
+                  ensureShallowCopy(subProxyDraft);
+                  // Trigger a custom shallow copy to update to a new copy
+                  markChanged(subProxyDraft);
+                  return subProxyDraft.copy;
+              }
+              return target.copy[key];
+          }
+          return value;
+      },
+      set(target, key, value) {
+          var _a;
+          if (target.type === 3 /* DraftType.Set */ || target.type === 2 /* DraftType.Map */) {
+              throw new Error(`Map/Set draft does not support any property assignment.`);
+          }
+          let _key;
+          if (target.type === 1 /* DraftType.Array */ &&
+              key !== 'length' &&
+              !(Number.isInteger((_key = Number(key))) &&
+                  _key >= 0 &&
+                  (key === 0 || _key === 0 || String(_key) === String(key)))) {
+              throw new Error(`Only supports setting array indices and the 'length' property.`);
+          }
+          const desc = getDescriptor(latest(target), key);
+          if (desc === null || desc === undefined ? undefined : desc.set) {
+              // !case: cover the case of setter
+              desc.set.call(target.proxy, value);
+              return true;
+          }
+          const current = peek(latest(target), key);
+          const currentProxyDraft = getProxyDraft(current);
+          if (currentProxyDraft && isEqual(currentProxyDraft.original, value)) {
+              // !case: ignore the case of assigning the original draftable value to a draft
+              target.copy[key] = value;
+              target.assignedMap = (_a = target.assignedMap) !== null && _a !== undefined ? _a : new Map();
+              target.assignedMap.set(key, false);
+              return true;
+          }
+          // !case: handle new props with value 'undefined'
+          if (isEqual(value, current) &&
+              (value !== undefined || has(target.original, key)))
+              return true;
+          ensureShallowCopy(target);
+          markChanged(target);
+          if (has(target.original, key) && isEqual(value, target.original[key])) {
+              // !case: handle the case of assigning the original non-draftable value to a draft
+              target.assignedMap.delete(key);
+          }
+          else {
+              target.assignedMap.set(key, true);
+          }
+          target.copy[key] = value;
+          markFinalization(target, key, value, generatePatches);
+          return true;
+      },
+      has(target, key) {
+          return key in latest(target);
+      },
+      ownKeys(target) {
+          return Reflect.ownKeys(latest(target));
+      },
+      getOwnPropertyDescriptor(target, key) {
+          const source = latest(target);
+          const descriptor = Reflect.getOwnPropertyDescriptor(source, key);
+          if (!descriptor)
+              return descriptor;
+          return {
+              writable: true,
+              configurable: target.type !== 1 /* DraftType.Array */ || key !== 'length',
+              enumerable: descriptor.enumerable,
+              value: source[key],
+          };
+      },
+      getPrototypeOf(target) {
+          return Reflect.getPrototypeOf(target.original);
+      },
+      setPrototypeOf() {
+          throw new Error(`Cannot call 'setPrototypeOf()' on drafts`);
+      },
+      defineProperty() {
+          throw new Error(`Cannot call 'defineProperty()' on drafts`);
+      },
+      deleteProperty(target, key) {
+          var _a;
+          if (target.type === 1 /* DraftType.Array */) {
+              return proxyHandler.set.call(this, target, key, undefined, target.proxy);
+          }
+          if (peek(target.original, key) !== undefined || key in target.original) {
+              // !case: delete an existing key
+              ensureShallowCopy(target);
+              markChanged(target);
+              target.assignedMap.set(key, false);
+          }
+          else {
+              target.assignedMap = (_a = target.assignedMap) !== null && _a !== undefined ? _a : new Map();
+              // The original non-existent key has been deleted
+              target.assignedMap.delete(key);
+          }
+          if (target.copy)
+              delete target.copy[key];
+          return true;
+      },
+  };
+  function createDraft(createDraftOptions) {
+      const { original, parentDraft, key, finalities, options } = createDraftOptions;
+      const type = getType(original);
+      const proxyDraft = {
+          type,
+          finalized: false,
+          parent: parentDraft,
+          original,
+          copy: null,
+          proxy: null,
+          finalities,
+          options,
+          // Mapping of draft Set items to their corresponding draft values.
+          setMap: type === 3 /* DraftType.Set */
+              ? new Map(original.entries())
+              : undefined,
+      };
+      // !case: undefined as a draft map key
+      if (key || 'key' in createDraftOptions) {
+          proxyDraft.key = key;
+      }
+      const { proxy, revoke } = Proxy.revocable(type === 1 /* DraftType.Array */ ? Object.assign([], proxyDraft) : proxyDraft, proxyHandler);
+      finalities.revoke.push(revoke);
+      draftsCache.add(proxy);
+      proxyDraft.proxy = proxy;
+      if (parentDraft) {
+          const target = parentDraft;
+          target.finalities.draft.push((patches, inversePatches) => {
+              var _a, _b;
+              const oldProxyDraft = getProxyDraft(proxy);
+              // if target is a Set draft, `setMap` is the real Set copies proxy mapping.
+              let copy = target.type === 3 /* DraftType.Set */ ? target.setMap : target.copy;
+              const draft = get(copy, key);
+              const proxyDraft = getProxyDraft(draft);
+              if (proxyDraft) {
+                  // assign the updated value to the copy object
+                  let updatedValue = proxyDraft.original;
+                  if (proxyDraft.operated) {
+                      updatedValue = getValue(draft);
+                  }
+                  finalizeSetValue(proxyDraft);
+                  finalizePatches(proxyDraft, generatePatches, patches, inversePatches);
+                  if (target.options.enableAutoFreeze) {
+                      target.options.updatedValues =
+                          (_a = target.options.updatedValues) !== null && _a !== undefined ? _a : new WeakMap();
+                      target.options.updatedValues.set(updatedValue, proxyDraft.original);
+                  }
+                  // final update value
+                  set(copy, key, updatedValue);
+              }
+              // !case: handle the deleted key
+              (_b = oldProxyDraft.callbacks) === null || _b === undefined ? undefined : _b.forEach((callback) => {
+                  callback(patches, inversePatches);
+              });
+          });
+      }
+      else {
+          // !case: handle the root draft
+          const target = getProxyDraft(proxy);
+          target.finalities.draft.push((patches, inversePatches) => {
+              finalizeSetValue(target);
+              finalizePatches(target, generatePatches, patches, inversePatches);
+          });
+      }
+      return proxy;
+  }
+  internal.createDraft = createDraft;
+  function finalizeDraft(result, returnedValue, patches, inversePatches, enableAutoFreeze) {
+      var _a;
+      const proxyDraft = getProxyDraft(result);
+      const original = (_a = proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.original) !== null && _a !== undefined ? _a : result;
+      const hasReturnedValue = !!returnedValue.length;
+      if (proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.operated) {
+          while (proxyDraft.finalities.draft.length > 0) {
+              const finalize = proxyDraft.finalities.draft.pop();
+              finalize(patches, inversePatches);
+          }
+      }
+      const state = hasReturnedValue
+          ? returnedValue[0]
+          : proxyDraft
+              ? proxyDraft.operated
+                  ? proxyDraft.copy
+                  : proxyDraft.original
+              : result;
+      if (proxyDraft)
+          revokeProxy(proxyDraft);
+      if (enableAutoFreeze) {
+          deepFreeze(state, state, proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.options.updatedValues);
+      }
+      return [
+          state,
+          patches && hasReturnedValue
+              ? [{ op: Operation.Replace, path: [], value: returnedValue[0] }]
+              : patches,
+          inversePatches && hasReturnedValue
+              ? [{ op: Operation.Replace, path: [], value: original }]
+              : inversePatches,
+      ];
+  }
+
+  function draftify(baseState, options) {
+      var _a;
+      const finalities = {
+          draft: [],
+          revoke: [],
+          handledSet: new WeakSet(),
+      };
+      let patches;
+      let inversePatches;
+      if (options.enablePatches) {
+          patches = [];
+          inversePatches = [];
+      }
+      const isMutable = ((_a = options.mark) === null || _a === undefined ? undefined : _a.call(options, baseState, dataTypes)) === dataTypes.mutable ||
+          !isDraftable(baseState, options);
+      const draft = isMutable
+          ? baseState
+          : createDraft({
+              original: baseState,
+              parentDraft: null,
+              finalities,
+              options,
+          });
+      return [
+          draft,
+          (returnedValue = []) => {
+              const [finalizedState, finalizedPatches, finalizedInversePatches] = finalizeDraft(draft, returnedValue, patches, inversePatches, options.enableAutoFreeze);
+              return (options.enablePatches
+                  ? [finalizedState, finalizedPatches, finalizedInversePatches]
+                  : finalizedState);
+          },
+      ];
+  }
+
+  function handleReturnValue(options) {
+      const { rootDraft, value, useRawReturn = false, isRoot = true } = options;
+      forEach(value, (key, item, source) => {
+          const proxyDraft = getProxyDraft(item);
+          // just handle the draft which is created by the same rootDraft
+          if (proxyDraft &&
+              rootDraft &&
+              proxyDraft.finalities === rootDraft.finalities) {
+              options.isContainDraft = true;
+              const currentValue = proxyDraft.original;
+              // final update value, but just handle return value
+              if (source instanceof Set) {
+                  const arr = Array.from(source);
+                  source.clear();
+                  arr.forEach((_item) => source.add(key === _item ? currentValue : _item));
+              }
+              else {
+                  set(source, key, currentValue);
+              }
+          }
+          else if (typeof item === 'object' && item !== null) {
+              options.value = item;
+              options.isRoot = false;
+              handleReturnValue(options);
+          }
+      });
+      if (isRoot) {
+          if (!options.isContainDraft)
+              console.warn(`The return value does not contain any draft, please use 'rawReturn()' to wrap the return value to improve performance.`);
+          if (useRawReturn) {
+              console.warn(`The return value contains drafts, please don't use 'rawReturn()' to wrap the return value.`);
+          }
+      }
+  }
+  function getCurrent(target) {
+      var _a;
+      const proxyDraft = getProxyDraft(target);
+      if (!isDraftable(target, proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.options))
+          return target;
+      const type = getType(target);
+      if (proxyDraft && !proxyDraft.operated)
+          return proxyDraft.original;
+      let currentValue;
+      function ensureShallowCopy() {
+          currentValue =
+              type === 2 /* DraftType.Map */
+                  ? !isBaseMapInstance(target)
+                      ? new (Object.getPrototypeOf(target).constructor)(target)
+                      : new Map(target)
+                  : type === 3 /* DraftType.Set */
+                      ? Array.from(proxyDraft.setMap.values())
+                      : shallowCopy(target, proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.options);
+      }
+      if (proxyDraft) {
+          // It's a proxy draft, let's create a shallow copy eagerly
+          proxyDraft.finalized = true;
+          try {
+              ensureShallowCopy();
+          }
+          finally {
+              proxyDraft.finalized = false;
+          }
+      }
+      else {
+          // It's not a proxy draft, let's use the target directly and let's see
+          // lazily if we need to create a shallow copy
+          currentValue = target;
+      }
+      forEach(currentValue, (key, value) => {
+          if (proxyDraft && isEqual(get(proxyDraft.original, key), value))
+              return;
+          const newValue = getCurrent(value);
+          if (newValue !== value) {
+              if (currentValue === target)
+                  ensureShallowCopy();
+              set(currentValue, key, newValue);
+          }
+      });
+      if (type === 3 /* DraftType.Set */) {
+          const value = (_a = proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.original) !== null && _a !== undefined ? _a : currentValue;
+          return !isBaseSetInstance(value)
+              ? new (Object.getPrototypeOf(value).constructor)(currentValue)
+              : new Set(currentValue);
+      }
+      return currentValue;
+  }
+  function current(target) {
+      if (!isDraft(target)) {
+          throw new Error(`current() is only used for Draft, parameter: ${target}`);
+      }
+      return getCurrent(target);
+  }
+
+  /**
+   * `makeCreator(options)` to make a creator function.
+   *
+   * ## Example
+   *
+   * ```ts
+   * import { makeCreator } from '../index';
+   *
+   * const baseState = { foo: { bar: 'str' }, arr: [] };
+   * const create = makeCreator({ enableAutoFreeze: true });
+   * const state = create(
+   *   baseState,
+   *   (draft) => {
+   *     draft.foo.bar = 'str2';
+   *   },
+   * );
+   *
+   * expect(state).toEqual({ foo: { bar: 'str2' }, arr: [] });
+   * expect(state).not.toBe(baseState);
+   * expect(state.foo).not.toBe(baseState.foo);
+   * expect(state.arr).toBe(baseState.arr);
+   * expect(Object.isFrozen(state)).toBeTruthy();
+   * ```
+   */
+  const makeCreator = (arg) => {
+      return function create(arg0, arg1, arg2) {
+          var _a, _b, _c;
+          if (typeof arg0 === 'function' && typeof arg1 !== 'function') {
+              return function (base, ...args) {
+                  return create(base, (draft) => arg0.call(this, draft, ...args), arg1);
+              };
+          }
+          const base = arg0;
+          const mutate = arg1;
+          let options = arg2;
+          if (typeof arg1 !== 'function') {
+              options = arg1;
+          }
+          if (options !== undefined &&
+              Object.prototype.toString.call(options) !== '[object Object]') {
+              throw new Error(`Invalid options: ${options}, 'options' should be an object.`);
+          }
+          options = Object.assign(Object.assign({}, arg), options);
+          const state = isDraft(base) ? current(base) : base;
+          const mark = Array.isArray(options.mark)
+              ? ((value, types) => {
+                  for (const mark of options.mark) {
+                      if (typeof mark !== 'function') {
+                          throw new Error(`Invalid mark: ${mark}, 'mark' should be a function.`);
+                      }
+                      const result = mark(value, types);
+                      if (result) {
+                          return result;
+                      }
+                  }
+                  return;
+              })
+              : options.mark;
+          const enablePatches = (_a = options.enablePatches) !== null && _a !== undefined ? _a : false;
+          const strict = (_b = options.strict) !== null && _b !== undefined ? _b : false;
+          const enableAutoFreeze = (_c = options.enableAutoFreeze) !== null && _c !== undefined ? _c : false;
+          const _options = {
+              enableAutoFreeze,
+              mark,
+              strict,
+              enablePatches,
+          };
+          if (!isDraftable(state, _options) &&
+              typeof state === 'object' &&
+              state !== null) {
+              throw new Error(`Invalid base state: create() only supports plain objects, arrays, Set, Map or using mark() to mark the state as immutable.`);
+          }
+          const [draft, finalize] = draftify(state, _options);
+          if (typeof arg1 !== 'function') {
+              if (!isDraftable(state, _options)) {
+                  throw new Error(`Invalid base state: create() only supports plain objects, arrays, Set, Map or using mark() to mark the state as immutable.`);
+              }
+              return [draft, finalize];
+          }
+          let result;
+          try {
+              result = mutate(draft);
+          }
+          catch (error) {
+              revokeProxy(getProxyDraft(draft));
+              throw error;
+          }
+          const returnValue = (value) => {
+              const proxyDraft = getProxyDraft(draft);
+              if (!isDraft(value)) {
+                  if (value !== undefined &&
+                      !isEqual(value, draft) &&
+                      (proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.operated)) {
+                      throw new Error(`Either the value is returned as a new non-draft value, or only the draft is modified without returning any value.`);
+                  }
+                  const rawReturnValue = value === null || value === undefined ? undefined : value[RAW_RETURN_SYMBOL];
+                  if (rawReturnValue) {
+                      const _value = rawReturnValue[0];
+                      if (_options.strict && typeof value === 'object' && value !== null) {
+                          handleReturnValue({
+                              rootDraft: proxyDraft,
+                              value,
+                              useRawReturn: true,
+                          });
+                      }
+                      return finalize([_value]);
+                  }
+                  if (value !== undefined) {
+                      if (typeof value === 'object' && value !== null) {
+                          handleReturnValue({ rootDraft: proxyDraft, value });
+                      }
+                      return finalize([value]);
+                  }
+              }
+              if (value === draft || value === undefined) {
+                  return finalize([]);
+              }
+              const returnedProxyDraft = getProxyDraft(value);
+              if (_options === returnedProxyDraft.options) {
+                  if (returnedProxyDraft.operated) {
+                      throw new Error(`Cannot return a modified child draft.`);
+                  }
+                  return finalize([current(value)]);
+              }
+              return finalize([value]);
+          };
+          if (result instanceof Promise) {
+              return result.then(returnValue, (error) => {
+                  revokeProxy(getProxyDraft(draft));
+                  throw error;
+              });
+          }
+          return returnValue(result);
+      };
+  };
+
+  /**
+   * `create(baseState, callback, options)` to create the next state
+   *
+   * ## Example
+   *
+   * ```ts
+   * import { create } from '../index';
+   *
+   * const baseState = { foo: { bar: 'str' }, arr: [] };
+   * const state = create(
+   *   baseState,
+   *   (draft) => {
+   *     draft.foo.bar = 'str2';
+   *   },
+   * );
+   *
+   * expect(state).toEqual({ foo: { bar: 'str2' }, arr: [] });
+   * expect(state).not.toBe(baseState);
+   * expect(state.foo).not.toBe(baseState.foo);
+   * expect(state.arr).toBe(baseState.arr);
+   * ```
+   */
+  const create = makeCreator();
+
+  Object.prototype.constructor.toString();
+
+  class RumiousState {
+    constructor(value, reactor) {
+      this.value = value;
+      this.reactor = reactor ?? new RumiousReactor(this);
+    }
+    set(value) {
+      this.value = value;
+      this.reactor.emit({
+        type: "SET",
+        target: this,
+        value: value
+      });
+    }
+    get() {
+      return this.value;
+    }
+    increase(count = 1) {
+      if (typeof this.value === "number") {
+        this.set(this.value + count);
+      }
+    }
+    produce(callback) {
+      const [draft, finalize] = create(this.value);
+      callback(draft);
+      this.set(finalize());
+    }
+  }
+  function watch(state, fn) {
+    state.reactor.addBinding(fn);
+  }
+  function unwatch(state, fn) {
+    state.reactor.removeBinding(fn);
+  }
+  function createState(value) {
+    return new RumiousState(value);
+  }
+
+  function eventBindingDirective(context, target, modifier, data) {
+    if (typeof data === "string") {
+      data = context.findName(extractName(data));
+    }
+    target.addEventListener(modifier, data);
+  }
+  function refBindingDirective(context, target, modifier, data) {
+    if (typeof data === "string") {
+      data = context.findName(extractName(data));
+    }
+    if (data instanceof RumiousElementRef) {
+      data.target = target;
+    } else {
+      throw Error("Rumious: ref directive required RumiousElementRef !");
+    }
+  }
+  function injectDirective(context, target, modifier, data) {
+    if (typeof data === "string") {
+      data = context.findName(extractName(data));
+    }
+    if (data instanceof RumiousDymanicInjector) {
+      data.addTarget(target);
+      data.inject(target);
+    } else {
+      throw Error("Rumious: inject directive required RumiousInjector !");
+    }
+  }
+  function bindDirective(context, target, modifier, data) {
+    if (typeof data === "string") {
+      data = context.findName(extractName(data));
+    }
+    if (data instanceof RumiousState) {
+      target.setAttribute(modifier, data.value);
+      data.reactor.addBinding(({}) => {
+        target.setAttribute(modifier, data.value);
+      });
+    } else {
+      throw Error("Rumious: bind directive required RumiousState !");
+    }
+  }
+  function modelDirective(context, target, modifier, data) {
+    if (typeof data === "string") {
+      data = context.findName(extractName(data));
+    }
+    if (data instanceof RumiousState && (target instanceof HTMLInputElement || target instanceof HTMLSelectElement || target instanceof HTMLTextAreaElement)) {
+      const type = target.type;
+      target.addEventListener("input", () => {
+        if (target instanceof HTMLInputElement) {
+          switch (type) {
+            case "checkbox":
+              data.set(target.checked);
+              break;
+            case "radio":
+              if (target.checked) data.set(target.value);
+              break;
+            default:
+              data.set(target.value);
+          }
+        } else if (target instanceof HTMLSelectElement || target instanceof HTMLTextAreaElement) {
+          data.set(target.value);
+        }
+      });
+    } else {
+      throw Error("Rumious: model directive requires RumiousState and a valid form element!");
+    }
+  }
+  const directives = {
+    "on": eventBindingDirective,
+    "ref": refBindingDirective,
+    "inject": injectDirective,
+    "bind": bindDirective,
+    "model": modelDirective
+  };
+
+  class RumiousDynamicArrayRenderer {
+    domMap = new Map();
+    constructor(state, callback, keyFn) {
+      this.state = state;
+      this.callback = callback;
+      this.keyFn = keyFn ?? ((_, i) => i);
+    }
+    prepare(anchor, context) {
+      this.anchorElement = anchor;
+      this.context = context;
+    }
+    async render() {
+      await this.reconcile(this.state.value);
+      this.state.reactor.addBinding(this.onStateChange.bind(this));
+    }
+    async onStateChange(commit) {
+      if (commit.type === "APPEND") {
+        const key = this.keyFn(commit.item, commit.key);
+        if (!this.domMap.has(key)) {
+          const template = await this.callback(commit.item, commit.key);
+          const frag = document.createDocumentFragment();
+          this.context.renderHelper(this.context, template, frag);
+          this.anchorElement.appendChild(frag);
+          this.domMap.set(key, frag);
+        }
+      } else if (commit.type === "SET_BY_KEY") {
+        const key = this.keyFn(commit.item, commit.key);
+        const oldNode = this.anchorElement.childNodes[commit.key];
+        if (oldNode) {
+          const template = await this.callback(commit.item, commit.key);
+          const frag = document.createDocumentFragment();
+          this.context.renderHelper(this.context, template, frag);
+          this.anchorElement.replaceChild(frag, oldNode);
+          this.domMap.set(key, frag);
+        }
+      } else if (commit.type === "REMOVE_BY_KEY") {
+        const node = this.anchorElement.childNodes[commit.key];
+        if (node) {
+          this.anchorElement.removeChild(node);
+          const entry = [...this.domMap.entries()].find(([, n]) => n === node);
+          if (entry) this.domMap.delete(entry[0]);
+        }
+      } else if (commit.type === "INSERT_BY_KEY") {
+        const key = this.keyFn(commit.item, commit.key);
+        if (!this.domMap.has(key)) {
+          const template = await this.callback(commit.item, commit.key);
+          const frag = document.createDocumentFragment();
+          this.context.renderHelper(this.context, template, frag);
+          const refNode = this.anchorElement.childNodes[commit.key] ?? null;
+          this.anchorElement.insertBefore(frag, refNode);
+          this.domMap.set(key, frag);
+        }
+      } else {
+        await this.reconcile(this.state.value);
+      }
+    }
+    async reconcile(nextItems) {
+      const oldMap = this.domMap;
+      const newMap = new Map();
+      const newNodes = [];
+      for (let i = 0; i < nextItems.length; i++) {
+        const item = nextItems[i];
+        const key = this.keyFn(item, i);
+        let node = oldMap.get(key);
+        if (!node) {
+          const template = await this.callback(item, i);
+          const frag = document.createDocumentFragment();
+          this.context.renderHelper(this.context, template, frag);
+          node = frag;
+        }
+        newMap.set(key, node);
+        newNodes.push(node);
+      }
+      this.anchorElement.textContent = "";
+      for (const node of newNodes) {
+        this.anchorElement.appendChild(node);
+      }
+      this.domMap = newMap;
+    }
+  }
+  function renderDynamicArray(state, callback) {
+    return new RumiousDynamicArrayRenderer(state, callback);
+  }
+
+  function isPrimitive(value) {
+    return value !== Object(value);
+  }
+
+  async function dynamicValue$1(target, textNode, value, context) {
+    const parent = textNode.parentNode;
+    if (!parent) return;
+    if (isPrimitive(value)) {
+      textNode.textContent = String(value);
+    } else if (value && value instanceof RumiousState) {
+      textNode.textContent = value.value;
+      function onValueChange({}) {
+        if (document.contains(textNode)) {
+          textNode.textContent = value.value;
+        } else {
+          value.reactor.removeBinding(onValueChange);
+        }
+      }
+      value.reactor.addBinding(onValueChange);
+    } else if (Array.isArray(value)) {
+      textNode.textContent = value.map(String).join("");
+    } else if (value instanceof RumiousDynamicArrayRenderer) {
+      value.prepare(textNode.parentElement, context);
+      value.render();
+    } else if (value instanceof HTMLElement) {
+      textNode.replaceWith(value);
+    } else if (value instanceof RumiousRenderTemplate) {
+      let fragment = document.createDocumentFragment();
+      context.renderHelper?.(context, value, fragment);
+      textNode.replaceWith(fragment);
+    } else if (value instanceof NodeList || value instanceof HTMLCollection) {
+      if (value.length === 0) {
+        textNode.remove();
+        return;
+      }
+      const fragment = document.createDocumentFragment();
+      for (const node of Array.from(value)) {
+        fragment.appendChild(node.cloneNode(true));
+      }
+      textNode.replaceWith(fragment);
+      textNode.remove();
+    } else if (value && typeof value.toString === "function") {
+      try {
+        textNode.textContent = value.toString();
+      } catch {
+        textNode.textContent = "";
+      }
+    } else {
+      textNode.textContent = "";
+    }
+  }
+
+  function template(generator) {
+    return new RumiousRenderTemplate(generator);
+  }
+  function addDirective(element, context, name, modifier = "", data) {
+    let callback = directives[name];
+    if (callback) {
+      callback(context, element, modifier, data);
+    } else {
+      throw Error("Rumious: Cannot solve directive !");
+    }
+  }
+  function dynamicValue(target, textNode, value, context) {
+    dynamicValue$1(target, textNode, value, context);
+  }
+  function createComponent(componentConstructor) {
+    let tagName = componentConstructor.tagName;
+    if (!window.customElements.get(tagName)) {
+      window.customElements.define(tagName, class extends RumiousComponentElement {
+        static tag = tagName;
+      });
+    }
+    return document.createElement(tagName);
+  }
+
+  // This is just to satisfy TypeScript's JSX requirement.
+  // Rumious doesn't use createElement — we do things differently.
+
+  function createElement(...args) {
+    throw Error("Rumious doesn't use createElement !");
+  }
+  window.RUMIOUS_JSX = {
+    template,
+    createElement,
+    addDirective,
+    dynamicValue,
+    createComponent
+  };
+
+  var JSX = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    template: template
+  });
+
+  var Render = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    RumiousDymanicInjector: RumiousDymanicInjector,
+    RumiousRenderTemplate: RumiousRenderTemplate,
+    createHTMLInjector: createHTMLInjector,
+    renderDynamicArray: renderDynamicArray
+  });
+
+  class RumiousChildrenRef {
+    constructor(target) {
+      this.target = target;
+    }
+    list() {
+      return Array.from(this.target.children);
+    }
+    getChild(index) {
+      return this.list()[index];
+    }
+    remove(index) {
+      this.list()[index]?.remove();
+    }
+    add(child) {
+      this.target.appendChild(child);
+    }
+    querySelector(query) {
+      return this.target.querySelector(query);
+    }
+    querySelectorAll(query) {
+      return this.target.querySelectorAll(query);
+    }
+    clear() {
+      this.target.innerHTML = '';
+    }
+    replaceChild(index, newChild) {
+      const oldChild = this.getChild(index);
+      if (oldChild) {
+        this.target.replaceChild(newChild, oldChild);
+      }
+    }
+    insertBefore(newChild, index) {
+      const referenceChild = this.getChild(index);
+      if (referenceChild) {
+        this.target.insertBefore(newChild, referenceChild);
+      } else {
+        this.add(newChild);
+      }
+    }
+    prepend(child) {
+      this.target.prepend(child);
+    }
+    getFirstChild() {
+      return this.list()[0];
+    }
+    getLastChild() {
+      return this.list()[this.list().length - 1];
+    }
+    hasChildren() {
+      return this.target.hasChildNodes();
+    }
+    count() {
+      return this.target.children.length;
+    }
+    find(predicate) {
+      return this.list().find(predicate);
+    }
+    forEach(callback) {
+      this.list().forEach(callback);
+    }
+    removeAllMatching(query) {
+      this.querySelectorAll(query).forEach(element => element.remove());
+    }
+    toggleClass(className) {
+      this.list().forEach(child => child.classList.toggle(className));
+    }
+    setAttribute(key, value) {
+      this.list().forEach(child => child.setAttribute(key, value));
+    }
+  }
+
+  var Ref = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    RumiousChildrenRef: RumiousChildrenRef,
+    RumiousElementRef: RumiousElementRef,
+    createElementRef: createElementRef
+  });
+
+  class RumiousArrayState extends RumiousState {
+    constructor(value, reactor) {
+      super(value, reactor);
+    }
+    set(arg1, arg2) {
+      if (typeof arg1 === "number" && arg2 !== undefined) {
+        const index = arg1;
+        const newValue = arg2;
+        this.value[index] = newValue;
+        this.reactor.emit({
+          type: "SET_BY_KEY",
+          value: [...this.value],
+          target: this,
+          key: index,
+          item: newValue
+        });
+      } else if (Array.isArray(arg1)) {
+        super.set(arg1);
+      } else {
+        throw new Error("Invalid arguments passed to set()");
+      }
+    }
+    get(arg) {
+      return typeof arg === "number" ? this.value[arg] : this.value;
+    }
+    insert(index, newItem) {
+      this.value.splice(index, 0, newItem);
+      this.reactor.emit({
+        type: "INSERT_BY_KEY",
+        value: this.value,
+        target: this,
+        key: index,
+        item: newItem
+      });
+      return this;
+    }
+    remove(index) {
+      this.value.splice(index, 1);
+      this.reactor.emit({
+        type: "REMOVE_BY_KEY",
+        value: this.value,
+        target: this,
+        key: index
+      });
+      return this;
+    }
+    append(value) {
+      this.value.push(value);
+      this.reactor.emit({
+        type: "APPEND",
+        value: this.value,
+        target: this,
+        item: value
+      });
+      return this;
+    }
+    clear() {
+      this.value.length = 0;
+      this.reactor.emit({
+        type: "SET",
+        value: [],
+        target: this
+      });
+      return this;
+    }
+    replace(index, newItem) {
+      if (index < 0 || index >= this.value.length) {
+        throw new Error("Index out of bounds");
+      }
+      this.value[index] = newItem;
+      this.reactor.emit({
+        type: "SET_BY_KEY",
+        value: [...this.value],
+        target: this,
+        key: index,
+        item: newItem
+      });
+      return this;
+    }
+    filter(callback) {
+      this.value = this.value.filter(callback);
+      this.reactor.emit({
+        type: "SET",
+        value: this.value,
+        target: this
+      });
+      return this;
+    }
+    map(callback) {
+      this.value = this.value.map(callback);
+      this.reactor.emit({
+        type: "SET",
+        value: this.value,
+        target: this
+      });
+      return this;
+    }
+    sort(compareFn) {
+      this.value.sort(compareFn);
+      this.reactor.emit({
+        type: "SET",
+        value: this.value,
+        target: this
+      });
+      return this;
+    }
+    reverse() {
+      this.value.reverse();
+      this.reactor.emit({
+        type: "SET",
+        value: this.value,
+        target: this
+      });
+      return this;
+    }
+    get length() {
+      return this.value.length;
+    }
+    forEach(callback) {
+      this.value.forEach(callback);
+    }
+  }
+  function createArrayState(value) {
+    return new RumiousArrayState(value);
+  }
+
+  class RumiousObjectState extends RumiousState {
+    #locked = false;
+    constructor(value, reactor) {
+      super(value, reactor);
+    }
+    set(arg1, arg2) {
+      if (this.#locked) throw new Error("Object is locked");
+      if (typeof arg1 === "string") {
+        const key = arg1;
+        const newValue = arg2;
+        this.value[key] = newValue;
+        this.reactor.emit({
+          type: "SET_BY_KEY",
+          value: {
+            ...this.value
+          },
+          target: this,
+          key,
+          item: newValue
+        });
+        return this;
+      } else if (typeof arg1 === "object") {
+        super.set(arg1);
+      } else {
+        throw new Error("Invalid arguments passed to set()");
+      }
+    }
+    remove(key) {
+      if (this.#locked) throw new Error("Object is locked");
+      if (key in this.value) {
+        delete this.value[key];
+        this.reactor.emit({
+          type: "REMOVE_BY_KEY",
+          value: {
+            ...this.value
+          },
+          target: this,
+          key
+        });
+      }
+      return this;
+    }
+    merge(partial) {
+      if (this.#locked) throw new Error("Object is locked");
+      Object.assign(this.value, partial);
+      this.reactor.emit({
+        type: "SET",
+        value: {
+          ...this.value
+        },
+        target: this
+      });
+      return this;
+    }
+    assign(obj) {
+      if (this.#locked) throw new Error("Object is locked");
+      this.value = {
+        ...this.value,
+        ...obj
+      };
+      this.reactor.emit({
+        type: "SET",
+        value: {
+          ...this.value
+        },
+        target: this
+      });
+      return this;
+    }
+    clear() {
+      if (this.#locked) throw new Error("Object is locked");
+      for (const key in this.value) {
+        delete this.value[key];
+      }
+      this.reactor.emit({
+        type: "SET",
+        value: {},
+        target: this
+      });
+      return this;
+    }
+    get(arg) {
+      return typeof arg === "string" ? this.value[arg] : this.value;
+    }
+    keys() {
+      return Object.keys(this.value);
+    }
+    values() {
+      return Object.values(this.value);
+    }
+    entries() {
+      return Object.entries(this.value);
+    }
+    has(key) {
+      return key in this.value;
+    }
+    get size() {
+      return Object.keys(this.value).length;
+    }
+    forEach(callback) {
+      Object.entries(this.value).forEach(([key, value]) => {
+        callback(value, key, this.value);
+      });
+    }
+    map(callback) {
+      const result = {};
+      Object.entries(this.value).forEach(([key, value]) => {
+        result[key] = callback(value, key, this.value);
+      });
+      return result;
+    }
+    clone() {
+      return JSON.parse(JSON.stringify(this.value));
+    }
+    toJSON() {
+      return JSON.parse(JSON.stringify(this.value));
+    }
+    toObject() {
+      return this.get();
+    }
+    lock() {
+      this.#locked = true;
+      return this;
+    }
+    unlock() {
+      this.#locked = false;
+      return this;
+    }
+    get isLocked() {
+      return this.#locked;
+    }
+    freeze() {
+      Object.freeze(this.value);
+      return this;
+    }
+    unfreeze() {
+      this.value = JSON.parse(JSON.stringify(this.value));
+      return this;
+    }
+    get isFrozen() {
+      return Object.isFrozen(this.value);
+    }
+  }
+  function createObjectState(value) {
+    return new RumiousObjectState(value);
+  }
+
+  var State = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    RumiousArrayState: RumiousArrayState,
+    RumiousObjectState: RumiousObjectState,
+    RumiousState: RumiousState,
+    createArrayState: createArrayState,
+    createObjectState: createObjectState,
+    createState: createState,
+    unwatch: unwatch,
+    watch: watch
+  });
+
+  window.RUMIOUS_CONTEXTS = {};
+  class RumiousContext {
+    constructor(initialValues = {}) {
+      this.events = {};
+      this.values = initialValues;
+    }
+    has(key) {
+      return key in this.values;
+    }
+    set(key, value) {
+      this.values[key] = value;
+    }
+    get(key) {
+      return this.values[key];
+    }
+    on(event, callback) {
+      if (!this.events[event]) this.events[event] = [];
+      this.events[event].push(callback);
+    }
+    off(event, callback) {
+      if (!this.events[event]) return;
+      this.events[event] = this.events[event].filter(fn => fn !== callback);
+    }
+    emit(event, payload) {
+      if (!this.events[event]) return;
+      this.events[event].forEach(fn => fn(payload));
+    }
+  }
+  function createContext(values, name = generateName("rctx_")) {
+    if (window.RUMIOUS_CONTEXTS[name]) return window.RUMIOUS_CONTEXTS[name];else {
+      let context = new RumiousContext(values);
+      window.RUMIOUS_CONTEXTS[name] = context;
+      return context;
+    }
+  }
+
+  var Context = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    RumiousContext: RumiousContext,
+    createContext: createContext
+  });
+
+  function tholle(func, limit) {
+    let lastCall = 0;
+    return function (...args) {
+      const now = Date.now();
+      if (now - lastCall >= limit) {
+        lastCall = now;
+        func.apply(this, args);
+      }
+    };
+  }
+  function denounce(func, delay) {
+    let timer;
+    return function (...args) {
+      clearTimeout(timer);
+      timer = setTimeout(() => func.apply(this, args), delay);
+    };
+  }
+  function trailingThrottle(func, limit) {
+    let lastCall = 0;
+    let lastArgs = null;
+    let timeout = null;
+    function invoke() {
+      lastCall = Date.now();
+      func.apply(this, lastArgs);
+      lastArgs = null;
+    }
+    return function (...args) {
+      const now = Date.now();
+      lastArgs = args;
+      if (now - lastCall >= limit) {
+        invoke.call(this);
+      } else if (!timeout) {
+        timeout = setTimeout(() => {
+          timeout = null;
+          invoke.call(this);
+        }, limit - (now - lastCall));
+      }
+    };
+  }
+  function leadingTrailingDebounce(func, delay) {
+    let timer;
+    let isFirstCall = true;
+    return function (...args) {
+      if (isFirstCall) {
+        func.apply(this, args);
+        isFirstCall = false;
+      }
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        func.apply(this, args);
+        isFirstCall = true;
+      }, delay);
+    };
+  }
+  function rafThrottle(func) {
+    let ticking = false;
+    return function (...args) {
+      if (!ticking) {
+        ticking = true;
+        requestAnimationFrame(() => {
+          func.apply(this, args);
+          ticking = false;
+        });
+      }
+    };
+  }
+
+  var Performance = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    denounce: denounce,
+    leadingTrailingDebounce: leadingTrailingDebounce,
+    rafThrottle: rafThrottle,
+    tholle: tholle,
+    trailingThrottle: trailingThrottle
+  });
+
+  const Rumious = {
+    ...Component,
+    ...App,
+    ...JSX,
+    ...Render,
+    ...Ref,
+    ...State,
+    ...Context,
+    ...Performance
+  };
+  window.Rumious = Rumious;
+
+  return Rumious;
+
+})();