@basmilius/http-client 1.5.5 → 1.6.0

package/dist/http-client.js

@@ -1,2 +1,3639 @@
-var Ut=Object.defineProperty;var Vt=Object.getOwnPropertyDescriptor;var bt=t=>{throw TypeError(t)};var b=(t,e,r,o)=>{for(var n=o>1?void 0:o?Vt(e,r):e,s=t.length-1,a;s>=0;s--)(a=t[s])&&(n=(o?a(e,r,n):a(n))||n);return o&&n&&Ut(e,r,n),n};var St=(t,e,r)=>e.has(t)||bt("Cannot "+r);var l=(t,e,r)=>(St(t,e,"read from private field"),r?r.call(t):e.get(t)),f=(t,e,r)=>e.has(t)?bt("Cannot add the same private member more than once"):e instanceof WeakSet?e.add(t):e.set(t,r),d=(t,e,r,o)=>(St(t,e,"write to private field"),o?o.call(t,r):e.set(t,r),r);function ft(t){return class extends t{constructor(...e){throw new Error("@adapter: cannot create instance of class.")}}}function $t(){return(t,e)=>{t[e]=t[e].bind(t)}}function Jt(t){return(e,r,o)=>{o.value=vt(o.value,t,e)}}function vt(t,e,r){let o=[],n=[],s=null;return(...a)=>(clearTimeout(s),s=setTimeout(async()=>{try{let p=await t.apply(r,a);o.forEach(g=>g(p))}catch(p){n.forEach(g=>g(p))}o=[],n=[]},e),new Promise((p,g)=>{o.push(p),n.push(g)}))}import{DateTime as Wt}from"luxon";function z(t){return t=t||Wt.now(),t.toFormat("yyyy-MM-dd HH-mm-ss")}function It(t){let e={};do{if(t.name==="")break;for(let[r,o]of Object.entries(Object.getOwnPropertyDescriptors(t.prototype)))["constructor","clone","toJSON"].includes(r)||!o.get&&!o.set||(e[r]=o)}while(t=Object.getPrototypeOf(t));return e}function j(t,e,r){t.prototype[e]=r}function q(t,e,r){Object.defineProperty(t,e,{value:r})}var O=Symbol(),w=Symbol(),T=Symbol(),y=Symbol(),u=Symbol(),m=Symbol(),c=Symbol(),N=Symbol(),I=Symbol(),tt=Symbol(),et=Symbol();function i(t){return t&&typeof t=="object"&&!!t[u]}function dt(t,e){return!i(t)||!i(e)?t===e:JSON.stringify(t)===JSON.stringify(e)}function h(t){if(!i(t))throw new Error("@dto assert given object is not a class decorated with @Dto.")}var yt=Symbol();function _(t,e=0,r){return function(...o){let n=yt in t,s=t[yt]??=new WeakMap,a=o[e],p=r!==void 0?o[r]:"self";if(typeof a!="object")return t.call(this,...o);if(s.has(a)||s.set(a,[]),s.get(a).includes(p)){!1;return}s.get(a).push(p);let g=t.call(this,...o);return!n&&delete t[yt],g}}function Et(t){return h(t),t.clone()}function H(t){return h(t),t[y]}var At=_(function(t,e,r,o){let n=t[et];n(t,e,r,o),!1,t[m]&&At(t[m],t[c],t[m][t[c]])},0,1),x=At;var Pt=_(function(t){h(t),t[y]&&(t[y]=!1,!1,x(t,y,!1,!0)),!(!t[w]||t[w].length===0)&&t[w].filter(H).forEach(Pt)}),rt=Pt;async function kt(t,e){!i(t)||!H(t)||(await e(t),rt(t))}function ht(t){return t?.value??t}function Ct(t){return h(t),!t[y]}var Ot=_(function(t,e){h(t),t[y]||(t[y]=!0,!1,x(t,y,!0,!1)),t[m]&&Ot(t[m],t[c])}),E=Ot;function Dt(t,e,r){e[w]??=[],!e[w].includes(t)&&e[w].push(t),t[m]!==e&&(t[m]=e),t[c]!==r&&(t[c]=r)}function ot(t,e,r){i(r)?Dt(r,t,e):Array.isArray(r)&&(r.some(i)&&r.filter(i).forEach(o=>Dt(o,t,e)),r[m]=t,r[c]=e)}function G(t,e){let r=t[tt];r(t,e),!1}function Rt(t,e){if(w in e){let r=e[w].indexOf(t);e[w].splice(r,1)}t[m]=void 0,t[c]=void 0}function wt(t,e){i(e)?Rt(e,t):Array.isArray(e)&&(e.some(i)&&e.filter(i).forEach(r=>Rt(r,t)),e[m]=void 0,e[c]=void 0)}var A={};import{customRef as jt,markRaw as te}from"vue";var nt={deleteProperty(t,e){if(Reflect.deleteProperty(t,e),gt(t,e))return!0;let r=t[m];return r&&x(r,t[c],r[t[c]]),r&&E(r,t[c]),!0},get(t,e,r){if(e===I)return!0;if(gt(t,e))return Reflect.get(t,e,r);let o=t[m];return o&&G(o,t[c]),Reflect.get(t,e)},set(t,e,r,o){if(gt(t,e))return Reflect.set(t,e,r,o);let n=t[m];return n&&x(n,t[c],n[t[c]]),n&&E(n,t[c]),Reflect.set(t,e,r)}};function gt(t,e){return typeof e=="symbol"||typeof t[e]=="function"||e==="length"}var Nt={get(t,e,r){if(e===I)return!0;if(typeof e=="symbol")return Reflect.get(t,e,r);let o=t[T][e];if(!o||!o.get)return Reflect.get(t,e,r);let n=o.get.call(t);return!1,G(t,e),ot(t,e,n),n},getOwnPropertyDescriptor(t,e){return t[T][e]},ownKeys(t){return t[N]},set(t,e,r,o){if(typeof e=="symbol")return Reflect.set(t,e,r,o);let n=t[T][e];if(!n||!n.set)return Reflect.set(t,e,r,o);let s=n.get?.call(t)??void 0;return dt(r,s)||(wt(t,s),Array.isArray(r)&&!r[I]&&(r=new Proxy(r,nt)),!1,n.set.call(t,r),ot(t,e,r),E(t,e),x(t,e,r,s)),!0}};var _t={get(t,e,r){return e==="__v_isRef"?!1:e===I?!0:e in t?Reflect.get(t,e,r):Reflect.get(t.value,e)},getOwnPropertyDescriptor(t,e){return Reflect.getOwnPropertyDescriptor(t.value,e)},ownKeys(t){return Reflect.ownKeys(t.value)},set(t,e,r,o){return e in t?Reflect.set(t,e,r,o):Reflect.set(t.value,e,r)}};var Ht={construct(t,e,r){e=e.map(n=>Array.isArray(n)?new Proxy(n,nt):n);let o=jt((n,s)=>{let a=te(Reflect.construct(t,e,r));a[O]=e,a[y]=!1,a[tt]=n,a[et]=s;let p=new Proxy(a,Nt);return{get:()=>(n(),p),set:()=>{}}});return new Proxy(o,_t)}};function Gt(){let t=this;h(t);let e=A[t[u]],r=new e(...t[O]);return Object.entries(this[T]).filter(([,o])=>!!o.set).map(([o])=>o).forEach(o=>r[o]=i(this[o])?this[o].clone():this[o]),r}function Bt(t){for(let e in t){let r=this[T][e];i(this[e])&&typeof t[e]=="object"?this[e].fill(t[e]):r&&r.set&&(this[e]=t[e])}}function Lt(){return Object.fromEntries(this[N].map(t=>{let e=Reflect.get.call(this,this,t,this);return i(e)&&(e=e.toJSON()),[t,e]}))}function P(t){re(t);let e=Object.freeze(It(t)),r=Object.keys(e);return q(t.prototype,T,e),q(t.prototype,u,t.name),q(t.prototype,N,r),q(t,Symbol.hasInstance,o=>typeof o=="object"&&o?.[u]===t.name),j(t,"clone",Gt),j(t,"fill",Bt),j(t,"toJSON",Lt),ee(t)}function ee(t){let e=new Proxy(t,Ht);return A[t.name]=e,e}function re(t){let e=Object.getPrototypeOf(t.prototype);if(u in e)throw new Error(`\u26D4\uFE0F @dto ${t.name} cannot extend parent class which is also decorated with @dto ${e[u]}.`)}if(!1){let t=console.error.bind(console),e=console.info.bind(console),r=console.log.bind(console),o=console.warn.bind(console),n=s=>(...a)=>{for(let p=a.length-1;p>=0;--p){let g=a[p];if(!i(g))continue;let xt=ht(g);a.splice(p,1,`\u{1F4E6} ${xt[u]}`,xt.toJSON())}return s(...a)};console.error=n(t),console.info=n(e),console.log=n(r),console.warn=n(o)}function it(t){return t.map(B)}import{DateTime as oe}from"luxon";function Ft([,t]){return oe.fromISO(t)}function st(t){return Object.fromEntries(Object.entries(t).map(([e,r])=>[e,B(r)]).filter(([,e])=>e!==void 0))}var Tt={};function Mt([,t,e,r,o]){if(!(e in A))throw new Error(`[@marveld/http] Cannot restore @dto. Dto ${e} was not found.`);if(t in Tt)return Tt[t];!1;let n=A[e],s=new n(...it(o));return s.fill(st(r)),!1,Tt[t]=s,s}function zt(t){return Array.isArray(t)&&t[0]===3058}function qt(t){return Array.isArray(t)&&t[0]===3057}function B(t){switch(!0){case t===null:return null;case Array.isArray(t):switch(!0){case zt(t):return Ft(t);case qt(t):return Mt(t);default:return it(t)}case typeof t=="object":return st(t);default:return t}}function Yt(t){return B(JSON.parse(t))}import{DateTime as ae}from"luxon";import{DateTime as se}from"luxon";function at(t){return[3058,t.toISO({extendedZone:!0,includeOffset:!0})]}import{toRaw as ie}from"vue";function ut(t){return Object.fromEntries(Object.entries(t).map(([e,r])=>[e,L(r)]).filter(([,e])=>e!==void 0))}function Kt(){return"10000000-1000-4000-8000-100000000000".replace(/[018]/g,t=>(+t^crypto.getRandomValues(new Uint8Array(1))[0]&15>>+t/4).toString(16))}function ct(t){t=ie(t);let e=t.toJSON();return[3057,Kt(),t[u],ut(e),mt(t[O])]}function mt(t){switch(!0){case t.every(i):return t.map(ct);case t.every(se.isDateTime):return t.map(at);default:return t.map(L)}}function L(t){switch(!0){case t===null:return null;case Array.isArray(t):return mt(t);case i(t):return ct(t);case ae.isDateTime(t):return at(t);case typeof t=="object":return ut(t);case typeof t=="boolean":case typeof t=="number":case typeof t=="string":return t;default:return}}function Qt(t){return JSON.stringify(L(t))}var Y,K,k=class{constructor(e,r){f(this,Y);f(this,K);d(this,Y,e),d(this,K,r)}get blob(){return l(this,Y)}get name(){return l(this,K)}};Y=new WeakMap,K=new WeakMap,k=b([P],k);var Q,U,V,$,J,C=class{constructor(e,r,o,n,s){f(this,Q);f(this,U);f(this,V);f(this,$);f(this,J);d(this,Q,e),d(this,U,r),d(this,V,o),d(this,$,n),d(this,J,s)}get items(){return l(this,Q)}get page(){return l(this,U)}get pageSize(){return l(this,V)}get pages(){return l(this,$)}get totalItems(){return l(this,J)}};Q=new WeakMap,U=new WeakMap,V=new WeakMap,$=new WeakMap,J=new WeakMap,C=b([P],C);var S=class{static parsePaginatedAdapter(e,r){return new C(e.items.map(r),e.page,e.page_size,e.pages,e.total_items)}static parseFileNameFromContentDispositionHeader(e){if(!e.startsWith("attachment"))return`download-${z()}`;let o=/filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/.exec(e);return(o?.length||0)<2?`download-${z()}`:o[1].replaceAll("'","").replaceAll('"',"").replaceAll("/","-").replaceAll(":","-")}};S=b([ft],S);var R=class{get data(){return this.#t}get headers(){return this.#e.headers}get ok(){return this.statusCode>=200&&this.statusCode<300}get response(){return this.#e}get statusCode(){return this.#e.status}#t;#e;constructor(e,r){this.#t=e,this.#e=r}};var F=class t{get authToken(){return this.#t}set authToken(e){this.#t=e}get baseUrl(){return this.#e}get dataField(){return this.#r}#t;#e;#r;constructor(e,r,o=!1){this.#t=e,this.#e=r,this.#r=o}static get instance(){if(t.#o===null)throw new Error("There is currently no HttpClient instance registered. Register one using the HttpClient.register() function.");return t.#o}static#o=null;static register(e){t.#o=e}};var v,W,X,Z,D=class{constructor(e,r,o,n){f(this,v);f(this,W);f(this,X);f(this,Z);d(this,v,e),d(this,W,r),d(this,X,o),d(this,Z,n)}get code(){return l(this,v)}get error(){return l(this,W)}get errorDescription(){return l(this,X)}get statusCode(){return l(this,Z)}};v=new WeakMap,W=new WeakMap,X=new WeakMap,Z=new WeakMap,D=b([P],D);var M=class t{get client(){return this.#t}get options(){return this.#r}get path(){return this.#e}set path(e){this.#e=e}get query(){return this.#o}set query(e){this.#o=e}#t;#e;#r={};#o=null;constructor(e,r){this.#t=r??F.instance,this.#r.cache="no-cache",this.#r.method="GET",this.#e=e}bearerToken(e){return e=e??this.#t.authToken,e?this.header("Authorization",`Bearer ${e}`):(this.#r.headers&&"Authorization"in this.#r.headers&&delete this.#r.headers.Authorization,this)}body(e,r="application/octet-stream"){return e instanceof FormData?r=null:(Array.isArray(e)||typeof e=="object")&&(e=JSON.stringify(e),r="application/json"),this.#r.body=e,r!==null?this.header("Content-Type",r):this}header(e,r){return this.#r.headers=this.#r.headers||{},this.#r.headers[e]=r,this}method(e){return this.#r.method=e.toUpperCase(),this}queryString(e){return this.#o=e,this}async fetch(){return this.#i().then(e=>e.json())}async fetchBlob(){let e=await this.#i();if(e.status!==200){let o=await e.json();throw"code"in o&&"error"in o&&"error_description"in o?new D(o.code,o.error,o.error_description,e.status):new D(-1,"failed_without_info","Request failed without any information from the backend.",e.status)}let r=e.headers.has("content-disposition")?S.parseFileNameFromContentDispositionHeader(e.headers.get("content-disposition")):`download-${z()}`;return new k(await e.blob(),r)}async run(){let{data:e,response:r}=await this.#n();return new R(e,r)}async runAdapter(e){let{data:r,response:o}=await this.#n();return new R(e(r),o)}async runArrayAdapter(e){return this.runAdapter(r=>r.map(e))}async runEmpty(){return await this.#n()}async runPaginatedAdapter(e){return this.runAdapter(r=>S.parsePaginatedAdapter(r,e))}async runData(){return await this.#n()}async runDataKey(e){let{data:r,response:o}=await this.#n();return new R(r[e],o)}async runStatusCode(){return(await this.#n()).statusCode}async#i(){let e=this.path;return this.query!==null&&(e+=`?${this.query.build()}`),await fetch(this.client.baseUrl+e,this.options)}async#n(){return await this.#i().then(e=>t.#s(e,this.client.dataField))}static async#s(e,r){if(e.status===204)return new R(null,e);if(e.headers.has("content-type")&&e.headers.get("content-type").startsWith("application/json")){let n=await e.json();if("code"in n&&"error"in n&&"error_description"in n)throw new D(n.code,n.error,n.error_description,e.status);return r&&"data"in n?new R(n.data,e):new R(n,e)}if(e.status===401||e.status===403)return new R(null,e);if((await e.text()).length===0&&e.status>=200&&e.status<300)return new R(null,e);throw new D(-1,"not_a_json_response","The response was not a JSON response.",e.status)}};var pt=class{request(e,r){return new M(e,r)}};var lt=class t{#t;constructor(){this.#t=new URLSearchParams}build(){return this.#t.toString()}append(e,r){return this.#e(this.#t.append.bind(this.#t),e,r)}appendArray(e,r){return r==null?this:(r.forEach(o=>this.append(e,o)),this)}delete(e){return this.#t.delete(e),this}get(e){return this.#t.get(e)}getAll(e){return this.#t.getAll(e)}has(e){return this.#t.has(e)}set(e,r){return this.#e(this.#t.set.bind(this.#t),e,r)}#e(e,r,o){if(!o&&o!==!1)return this;switch(typeof o){case"boolean":e(r,o?"true":"false");break;case"number":e(r,o.toString(10));break;case"string":e(r,o);break}return this}static builder(){return new t}};function ue(t){return t instanceof D}function ce(t){return t instanceof D&&(t=t.statusCode),t===403||t===401}export{R as BaseResponse,pt as BaseService,k as BlobResponse,S as HttpAdapter,F as HttpClient,C as Paginated,lt as QueryString,M as RequestBuilder,D as RequestError,ft as adapter,h as assertDto,$t as bound,Et as cloneDto,Jt as debounce,Yt as deserialize,P as dto,kt as executeIfDtoDirtyAndMarkClean,i as isDto,Ct as isDtoClean,H as isDtoDirty,ue as isRequestError,ce as isUnsanctionedRequest,rt as markDtoClean,E as markDtoDirty,Qt as serialize};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+
+// src/adapter/HttpAdapter.ts
+import { DateTime as DateTime4 } from "luxon";
+
+// src/decorator/adapter.ts
+function adapter_default(Parent) {
+  return class extends Parent {
+    constructor(...args) {
+      throw new Error("@adapter: cannot create instance of class.");
+    }
+  };
+}
+
+// src/decorator/bound.ts
+function bound_default() {
+  return (target, method) => {
+    target[method] = target[method].bind(target);
+  };
+}
+
+// src/decorator/debounce.ts
+function debounce_default(interval) {
+  return (target, _, descriptor) => {
+    descriptor.value = debounce(descriptor.value, interval, target);
+  };
+}
+function debounce(fn, interval, $this) {
+  let resolvers = [], rejecters = [], timeout = null;
+  return (...args) => {
+    clearTimeout(timeout);
+    timeout = setTimeout(async () => {
+      try {
+        let result = await fn.apply($this, args);
+        resolvers.forEach((resolve) => resolve(result));
+      } catch (err) {
+        rejecters.forEach((reject) => reject(err));
+      }
+      resolvers = [];
+      rejecters = [];
+    }, interval);
+    return new Promise((resolve, reject) => {
+      resolvers.push(resolve);
+      rejecters.push(reject);
+    });
+  };
+}
+
+// node_modules/@basmilius/utils/dist/utils.js
+import { defineStore, storeToRefs } from "pinia";
+function getPrototypeChain_default(obj) {
+  const entries = {};
+  do {
+    if (obj.name === "") {
+      break;
+    }
+    for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(obj.prototype))) {
+      if (["constructor", "clone", "toJSON"].includes(key)) {
+        continue;
+      }
+      if (!descriptor.get && !descriptor.set) {
+        continue;
+      }
+      entries[key] = descriptor;
+    }
+  } while (obj = Object.getPrototypeOf(obj));
+  return entries;
+}
+function setObjectMethod_default(obj, key, fn) {
+  obj.prototype[key] = fn;
+}
+function setObjectValue_default(obj, key, value) {
+  Object.defineProperty(obj, key, { value });
+}
+
+// src/decorator/dto/constant.ts
+var ENABLE_CIRCULAR_LOGGING = false;
+var ENABLE_DIRTY_LOGGING = false;
+var ENABLE_REACTIVE_LOGGING = false;
+var ENABLE_GET_LOGGING = false;
+var ENABLE_SET_LOGGING = false;
+var ENABLE_SERIALIZATION_LOGGING = false;
+var OVERRIDE_CONSOLE_LOG = false;
+
+// src/decorator/dto/symbols.ts
+var ARGS = Symbol();
+var CHILDREN = Symbol();
+var DESCRIPTORS = Symbol();
+var DIRTY = Symbol();
+var NAME = Symbol();
+var PARENT = Symbol();
+var PARENT_KEY = Symbol();
+var PROPERTIES = Symbol();
+var PROXY = Symbol();
+var TRACK = Symbol();
+var TRIGGER = Symbol();
+
+// src/decorator/dto/helper/isDto.ts
+function isDto_default(obj) {
+  return obj && typeof obj === "object" && !!obj[NAME];
+}
+
+// src/decorator/dto/helper/areEqual.ts
+function areEqual_default(a, b) {
+  if (!isDto_default(a) || !isDto_default(b)) {
+    return a === b;
+  }
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+
+// src/decorator/dto/helper/assertDto.ts
+function assertDto_default(obj) {
+  if (!isDto_default(obj)) {
+    throw new Error("@dto assert given object is not a class decorated with @Dto.");
+  }
+}
+
+// src/decorator/dto/helper/circularProtect.ts
+var CIRCULAR_MAP = Symbol();
+function circularProtect_default(fn, arg1 = 0, arg2) {
+  return function(...args) {
+    const hasMap = CIRCULAR_MAP in fn;
+    const map = fn[CIRCULAR_MAP] ??= new WeakMap;
+    const primary = args[arg1];
+    const secondary = arg2 !== undefined ? args[arg2] : "self";
+    if (typeof primary !== "object") {
+      return fn.call(this, ...args);
+    }
+    if (!map.has(primary)) {
+      map.set(primary, []);
+    }
+    if (map.get(primary).includes(secondary)) {
+      ENABLE_CIRCULAR_LOGGING && console.log(`%c@dto %ccircular protect %cdetected a circular reference`, "color: #0891b2", "color: #059669", "color: #1d4ed8", { fn, primary, secondary });
+      return;
+    }
+    map.get(primary).push(secondary);
+    const result = fn.call(this, ...args);
+    !hasMap && delete fn[CIRCULAR_MAP];
+    return result;
+  };
+}
+
+// src/decorator/dto/helper/cloneDto.ts
+function cloneDto_default(obj) {
+  assertDto_default(obj);
+  return obj.clone();
+}
+
+// src/decorator/dto/helper/isDtoDirty.ts
+function isDtoDirty_default(obj) {
+  assertDto_default(obj);
+  return obj[DIRTY];
+}
+
+// src/decorator/dto/helper/triggerDto.ts
+var triggerDto = circularProtect_default(function(dto, key, value, oldValue) {
+  const trigger = dto[TRIGGER];
+  trigger(dto, key, value, oldValue);
+  ENABLE_REACTIVE_LOGGING && console.log(`%c@dto %c${dto[NAME]} %ctrigger`, "color: #0891b2", "color: #059669", "color: #1d4ed8", key, { dto, value, oldValue });
+  dto[PARENT] && triggerDto(dto[PARENT], dto[PARENT_KEY], dto[PARENT][dto[PARENT_KEY]]);
+}, 0, 1);
+var triggerDto_default = triggerDto;
+
+// src/decorator/dto/helper/markDtoClean.ts
+var markDtoClean = circularProtect_default(function(obj) {
+  assertDto_default(obj);
+  if (obj[DIRTY]) {
+    obj[DIRTY] = false;
+    ENABLE_DIRTY_LOGGING && console.log(`%c@dto %c${obj[NAME]} %cdirty`, "color: #0891b2", "color: #059669", "color: #1d4ed8", "marked clean", { obj });
+    triggerDto_default(obj, DIRTY, false, true);
+  }
+  if (!obj[CHILDREN] || obj[CHILDREN].length === 0) {
+    return;
+  }
+  obj[CHILDREN].filter(isDtoDirty_default).forEach(markDtoClean);
+});
+var markDtoClean_default = markDtoClean;
+
+// src/decorator/dto/helper/executeIfDtoDirtyAndMarkClean.ts
+async function executeIfDtoDirtyAndMarkClean_default(obj, fn) {
+  if (!isDto_default(obj) || !isDtoDirty_default(obj)) {
+    return;
+  }
+  await fn(obj);
+  markDtoClean_default(obj);
+}
+
+// src/decorator/dto/helper/instance.ts
+function instance_default(dto) {
+  return dto?.value ?? dto;
+}
+
+// src/decorator/dto/helper/isDtoClean.ts
+function isDtoClean_default(obj) {
+  assertDto_default(obj);
+  return !obj[DIRTY];
+}
+
+// src/decorator/dto/helper/markDtoDirty.ts
+var markDtoDirty = circularProtect_default(function(obj, key) {
+  assertDto_default(obj);
+  if (!obj[DIRTY]) {
+    obj[DIRTY] = true;
+    ENABLE_DIRTY_LOGGING && console.log(`%c@dto %c${obj[NAME]} %cdirty`, "color: #0891b2", "color: #059669", "color: #1d4ed8", "marked dirty", { obj, key });
+    triggerDto_default(obj, DIRTY, true, false);
+  }
+  if (!obj[PARENT]) {
+    return;
+  }
+  markDtoDirty(obj[PARENT], obj[PARENT_KEY]);
+});
+var markDtoDirty_default = markDtoDirty;
+
+// src/decorator/dto/helper/relateDtoTo.ts
+function relateDtoTo_default(dto, parent, key) {
+  parent[CHILDREN] ??= [];
+  !parent[CHILDREN].includes(dto) && parent[CHILDREN].push(dto);
+  dto[PARENT] !== parent && (dto[PARENT] = parent);
+  dto[PARENT_KEY] !== key && (dto[PARENT_KEY] = key);
+}
+
+// src/decorator/dto/helper/relateValueTo.ts
+function relateValueTo_default(dto, key, value) {
+  if (isDto_default(value)) {
+    relateDtoTo_default(value, dto, key);
+  } else if (Array.isArray(value)) {
+    if (value.some(isDto_default)) {
+      value.filter(isDto_default).forEach((val) => relateDtoTo_default(val, dto, key));
+    }
+    value[PARENT] = dto;
+    value[PARENT_KEY] = key;
+  }
+}
+
+// src/decorator/dto/helper/trackDto.ts
+function trackDto(dto, key) {
+  const track = dto[TRACK];
+  track(dto, key);
+  ENABLE_REACTIVE_LOGGING && console.log(`%c@dto %c${dto[NAME]} %ctrack`, "color: #0891b2", "color: #059669", "color: #1d4ed8", key, { dto });
+}
+
+// src/decorator/dto/helper/unrelateDtoFrom.ts
+function unrelateDtoFrom_default(dto, parent) {
+  if (CHILDREN in parent) {
+    const index = parent[CHILDREN].indexOf(dto);
+    parent[CHILDREN].splice(index, 1);
+  }
+  dto[PARENT] = undefined;
+  dto[PARENT_KEY] = undefined;
+}
+
+// src/decorator/dto/helper/unrelateValueFrom.ts
+function unrelateValueFrom_default(dto, value) {
+  if (isDto_default(value)) {
+    unrelateDtoFrom_default(value, dto);
+  } else if (Array.isArray(value)) {
+    if (value.some(isDto_default)) {
+      value.filter(isDto_default).forEach((val) => unrelateDtoFrom_default(val, dto));
+    }
+    value[PARENT] = undefined;
+    value[PARENT_KEY] = undefined;
+  }
+}
+
+// src/decorator/dto/map.ts
+var DTO_CLASS_MAP = {};
+
+// node_modules/@vue/shared/dist/shared.esm-bundler.js
+/*! #__NO_SIDE_EFFECTS__ */
+function makeMap(str) {
+  const map = /* @__PURE__ */ Object.create(null);
+  for (const key of str.split(","))
+    map[key] = 1;
+  return (val) => (val in map);
+}
+var EMPTY_OBJ = Object.freeze({});
+var EMPTY_ARR = Object.freeze([]);
+var NOOP = () => {
+};
+var NO = () => false;
+var extend = Object.assign;
+var remove = (arr, el) => {
+  const i = arr.indexOf(el);
+  if (i > -1) {
+    arr.splice(i, 1);
+  }
+};
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var hasOwn = (val, key) => hasOwnProperty.call(val, key);
+var isArray = Array.isArray;
+var isMap = (val) => toTypeString(val) === "[object Map]";
+var isSet = (val) => toTypeString(val) === "[object Set]";
+var isFunction = (val) => typeof val === "function";
+var isString = (val) => typeof val === "string";
+var isSymbol = (val) => typeof val === "symbol";
+var isObject = (val) => val !== null && typeof val === "object";
+var isPromise = (val) => {
+  return (isObject(val) || isFunction(val)) && isFunction(val.then) && isFunction(val.catch);
+};
+var objectToString = Object.prototype.toString;
+var toTypeString = (value) => objectToString.call(value);
+var toRawType = (value) => {
+  return toTypeString(value).slice(8, -1);
+};
+var isPlainObject = (val) => toTypeString(val) === "[object Object]";
+var isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
+var cacheStringFunction = (fn) => {
+  const cache = /* @__PURE__ */ Object.create(null);
+  return (str) => {
+    const hit = cache[str];
+    return hit || (cache[str] = fn(str));
+  };
+};
+var camelizeRE = /-(\w)/g;
+var camelize = cacheStringFunction((str) => {
+  return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
+});
+var hyphenateRE = /\B([A-Z])/g;
+var hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
+var capitalize = cacheStringFunction((str) => {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+});
+var toHandlerKey = cacheStringFunction((str) => {
+  const s = str ? `on${capitalize(str)}` : ``;
+  return s;
+});
+var hasChanged = (value, oldValue) => !Object.is(value, oldValue);
+var def = (obj, key, value, writable = false) => {
+  Object.defineProperty(obj, key, {
+    configurable: true,
+    enumerable: false,
+    writable,
+    value
+  });
+};
+var _globalThis;
+var getGlobalThis = () => {
+  return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
+};
+var specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
+var isBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`);
+
+// node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js
+function warn(msg, ...args) {
+  console.warn(`[Vue warn] ${msg}`, ...args);
+}
+var activeEffectScope;
+function getCurrentScope() {
+  return activeEffectScope;
+}
+var activeSub;
+var pausedQueueEffects = /* @__PURE__ */ new WeakSet;
+
+class ReactiveEffect {
+  constructor(fn) {
+    this.fn = fn;
+    this.deps = undefined;
+    this.depsTail = undefined;
+    this.flags = 1 | 4;
+    this.next = undefined;
+    this.cleanup = undefined;
+    this.scheduler = undefined;
+    if (activeEffectScope && activeEffectScope.active) {
+      activeEffectScope.effects.push(this);
+    }
+  }
+  pause() {
+    this.flags |= 64;
+  }
+  resume() {
+    if (this.flags & 64) {
+      this.flags &= ~64;
+      if (pausedQueueEffects.has(this)) {
+        pausedQueueEffects.delete(this);
+        this.trigger();
+      }
+    }
+  }
+  notify() {
+    if (this.flags & 2 && !(this.flags & 32)) {
+      return;
+    }
+    if (!(this.flags & 8)) {
+      batch(this);
+    }
+  }
+  run() {
+    if (!(this.flags & 1)) {
+      return this.fn();
+    }
+    this.flags |= 2;
+    cleanupEffect(this);
+    prepareDeps(this);
+    const prevEffect = activeSub;
+    const prevShouldTrack = shouldTrack;
+    activeSub = this;
+    shouldTrack = true;
+    try {
+      return this.fn();
+    } finally {
+      if (activeSub !== this) {
+        warn("Active effect was not restored correctly - this is likely a Vue internal bug.");
+      }
+      cleanupDeps(this);
+      activeSub = prevEffect;
+      shouldTrack = prevShouldTrack;
+      this.flags &= ~2;
+    }
+  }
+  stop() {
+    if (this.flags & 1) {
+      for (let link = this.deps;link; link = link.nextDep) {
+        removeSub(link);
+      }
+      this.deps = this.depsTail = undefined;
+      cleanupEffect(this);
+      this.onStop && this.onStop();
+      this.flags &= ~1;
+    }
+  }
+  trigger() {
+    if (this.flags & 64) {
+      pausedQueueEffects.add(this);
+    } else if (this.scheduler) {
+      this.scheduler();
+    } else {
+      this.runIfDirty();
+    }
+  }
+  runIfDirty() {
+    if (isDirty(this)) {
+      this.run();
+    }
+  }
+  get dirty() {
+    return isDirty(this);
+  }
+}
+var batchDepth = 0;
+var batchedSub;
+var batchedComputed;
+function batch(sub, isComputed = false) {
+  sub.flags |= 8;
+  if (isComputed) {
+    sub.next = batchedComputed;
+    batchedComputed = sub;
+    return;
+  }
+  sub.next = batchedSub;
+  batchedSub = sub;
+}
+function startBatch() {
+  batchDepth++;
+}
+function endBatch() {
+  if (--batchDepth > 0) {
+    return;
+  }
+  if (batchedComputed) {
+    let e = batchedComputed;
+    batchedComputed = undefined;
+    while (e) {
+      const next = e.next;
+      e.next = undefined;
+      e.flags &= ~8;
+      e = next;
+    }
+  }
+  let error;
+  while (batchedSub) {
+    let e = batchedSub;
+    batchedSub = undefined;
+    while (e) {
+      const next = e.next;
+      e.next = undefined;
+      e.flags &= ~8;
+      if (e.flags & 1) {
+        try {
+          e.trigger();
+        } catch (err) {
+          if (!error)
+            error = err;
+        }
+      }
+      e = next;
+    }
+  }
+  if (error)
+    throw error;
+}
+function prepareDeps(sub) {
+  for (let link = sub.deps;link; link = link.nextDep) {
+    link.version = -1;
+    link.prevActiveLink = link.dep.activeLink;
+    link.dep.activeLink = link;
+  }
+}
+function cleanupDeps(sub) {
+  let head;
+  let tail = sub.depsTail;
+  let link = tail;
+  while (link) {
+    const prev = link.prevDep;
+    if (link.version === -1) {
+      if (link === tail)
+        tail = prev;
+      removeSub(link);
+      removeDep(link);
+    } else {
+      head = link;
+    }
+    link.dep.activeLink = link.prevActiveLink;
+    link.prevActiveLink = undefined;
+    link = prev;
+  }
+  sub.deps = head;
+  sub.depsTail = tail;
+}
+function isDirty(sub) {
+  for (let link = sub.deps;link; link = link.nextDep) {
+    if (link.dep.version !== link.version || link.dep.computed && (refreshComputed(link.dep.computed) || link.dep.version !== link.version)) {
+      return true;
+    }
+  }
+  if (sub._dirty) {
+    return true;
+  }
+  return false;
+}
+function refreshComputed(computed) {
+  if (computed.flags & 4 && !(computed.flags & 16)) {
+    return;
+  }
+  computed.flags &= ~16;
+  if (computed.globalVersion === globalVersion) {
+    return;
+  }
+  computed.globalVersion = globalVersion;
+  const dep = computed.dep;
+  computed.flags |= 2;
+  if (dep.version > 0 && !computed.isSSR && computed.deps && !isDirty(computed)) {
+    computed.flags &= ~2;
+    return;
+  }
+  const prevSub = activeSub;
+  const prevShouldTrack = shouldTrack;
+  activeSub = computed;
+  shouldTrack = true;
+  try {
+    prepareDeps(computed);
+    const value = computed.fn(computed._value);
+    if (dep.version === 0 || hasChanged(value, computed._value)) {
+      computed._value = value;
+      dep.version++;
+    }
+  } catch (err) {
+    dep.version++;
+    throw err;
+  } finally {
+    activeSub = prevSub;
+    shouldTrack = prevShouldTrack;
+    cleanupDeps(computed);
+    computed.flags &= ~2;
+  }
+}
+function removeSub(link, soft = false) {
+  const { dep, prevSub, nextSub } = link;
+  if (prevSub) {
+    prevSub.nextSub = nextSub;
+    link.prevSub = undefined;
+  }
+  if (nextSub) {
+    nextSub.prevSub = prevSub;
+    link.nextSub = undefined;
+  }
+  if (dep.subsHead === link) {
+    dep.subsHead = nextSub;
+  }
+  if (dep.subs === link) {
+    dep.subs = prevSub;
+    if (!prevSub && dep.computed) {
+      dep.computed.flags &= ~4;
+      for (let l = dep.computed.deps;l; l = l.nextDep) {
+        removeSub(l, true);
+      }
+    }
+  }
+  if (!soft && !--dep.sc && dep.map) {
+    dep.map.delete(dep.key);
+  }
+}
+function removeDep(link) {
+  const { prevDep, nextDep } = link;
+  if (prevDep) {
+    prevDep.nextDep = nextDep;
+    link.prevDep = undefined;
+  }
+  if (nextDep) {
+    nextDep.prevDep = prevDep;
+    link.nextDep = undefined;
+  }
+}
+var shouldTrack = true;
+var trackStack = [];
+function pauseTracking() {
+  trackStack.push(shouldTrack);
+  shouldTrack = false;
+}
+function resetTracking() {
+  const last = trackStack.pop();
+  shouldTrack = last === undefined ? true : last;
+}
+function cleanupEffect(e) {
+  const { cleanup } = e;
+  e.cleanup = undefined;
+  if (cleanup) {
+    const prevSub = activeSub;
+    activeSub = undefined;
+    try {
+      cleanup();
+    } finally {
+      activeSub = prevSub;
+    }
+  }
+}
+var globalVersion = 0;
+
+class Link {
+  constructor(sub, dep) {
+    this.sub = sub;
+    this.dep = dep;
+    this.version = dep.version;
+    this.nextDep = this.prevDep = this.nextSub = this.prevSub = this.prevActiveLink = undefined;
+  }
+}
+
+class Dep {
+  constructor(computed) {
+    this.computed = computed;
+    this.version = 0;
+    this.activeLink = undefined;
+    this.subs = undefined;
+    this.map = undefined;
+    this.key = undefined;
+    this.sc = 0;
+    if (true) {
+      this.subsHead = undefined;
+    }
+  }
+  track(debugInfo) {
+    if (!activeSub || !shouldTrack || activeSub === this.computed) {
+      return;
+    }
+    let link = this.activeLink;
+    if (link === undefined || link.sub !== activeSub) {
+      link = this.activeLink = new Link(activeSub, this);
+      if (!activeSub.deps) {
+        activeSub.deps = activeSub.depsTail = link;
+      } else {
+        link.prevDep = activeSub.depsTail;
+        activeSub.depsTail.nextDep = link;
+        activeSub.depsTail = link;
+      }
+      addSub(link);
+    } else if (link.version === -1) {
+      link.version = this.version;
+      if (link.nextDep) {
+        const next = link.nextDep;
+        next.prevDep = link.prevDep;
+        if (link.prevDep) {
+          link.prevDep.nextDep = next;
+        }
+        link.prevDep = activeSub.depsTail;
+        link.nextDep = undefined;
+        activeSub.depsTail.nextDep = link;
+        activeSub.depsTail = link;
+        if (activeSub.deps === link) {
+          activeSub.deps = next;
+        }
+      }
+    }
+    if (activeSub.onTrack) {
+      activeSub.onTrack(extend({
+        effect: activeSub
+      }, debugInfo));
+    }
+    return link;
+  }
+  trigger(debugInfo) {
+    this.version++;
+    globalVersion++;
+    this.notify(debugInfo);
+  }
+  notify(debugInfo) {
+    startBatch();
+    try {
+      if (true) {
+        for (let head = this.subsHead;head; head = head.nextSub) {
+          if (head.sub.onTrigger && !(head.sub.flags & 8)) {
+            head.sub.onTrigger(extend({
+              effect: head.sub
+            }, debugInfo));
+          }
+        }
+      }
+      for (let link = this.subs;link; link = link.prevSub) {
+        if (link.sub.notify()) {
+          link.sub.dep.notify();
+        }
+      }
+    } finally {
+      endBatch();
+    }
+  }
+}
+function addSub(link) {
+  link.dep.sc++;
+  if (link.sub.flags & 4) {
+    const computed = link.dep.computed;
+    if (computed && !link.dep.subs) {
+      computed.flags |= 4 | 16;
+      for (let l = computed.deps;l; l = l.nextDep) {
+        addSub(l);
+      }
+    }
+    const currentTail = link.dep.subs;
+    if (currentTail !== link) {
+      link.prevSub = currentTail;
+      if (currentTail)
+        currentTail.nextSub = link;
+    }
+    if (link.dep.subsHead === undefined) {
+      link.dep.subsHead = link;
+    }
+    link.dep.subs = link;
+  }
+}
+var targetMap = /* @__PURE__ */ new WeakMap;
+var ITERATE_KEY = Symbol("Object iterate");
+var MAP_KEY_ITERATE_KEY = Symbol("Map keys iterate");
+var ARRAY_ITERATE_KEY = Symbol("Array iterate");
+function track(target, type, key) {
+  if (shouldTrack && activeSub) {
+    let depsMap = targetMap.get(target);
+    if (!depsMap) {
+      targetMap.set(target, depsMap = /* @__PURE__ */ new Map);
+    }
+    let dep = depsMap.get(key);
+    if (!dep) {
+      depsMap.set(key, dep = new Dep);
+      dep.map = depsMap;
+      dep.key = key;
+    }
+    if (true) {
+      dep.track({
+        target,
+        type,
+        key
+      });
+    } else {
+    }
+  }
+}
+function trigger(target, type, key, newValue, oldValue, oldTarget) {
+  const depsMap = targetMap.get(target);
+  if (!depsMap) {
+    globalVersion++;
+    return;
+  }
+  const run = (dep) => {
+    if (dep) {
+      if (true) {
+        dep.trigger({
+          target,
+          type,
+          key,
+          newValue,
+          oldValue,
+          oldTarget
+        });
+      } else {
+      }
+    }
+  };
+  startBatch();
+  if (type === "clear") {
+    depsMap.forEach(run);
+  } else {
+    const targetIsArray = isArray(target);
+    const isArrayIndex = targetIsArray && isIntegerKey(key);
+    if (targetIsArray && key === "length") {
+      const newLength = Number(newValue);
+      depsMap.forEach((dep, key2) => {
+        if (key2 === "length" || key2 === ARRAY_ITERATE_KEY || !isSymbol(key2) && key2 >= newLength) {
+          run(dep);
+        }
+      });
+    } else {
+      if (key !== undefined || depsMap.has(undefined)) {
+        run(depsMap.get(key));
+      }
+      if (isArrayIndex) {
+        run(depsMap.get(ARRAY_ITERATE_KEY));
+      }
+      switch (type) {
+        case "add":
+          if (!targetIsArray) {
+            run(depsMap.get(ITERATE_KEY));
+            if (isMap(target)) {
+              run(depsMap.get(MAP_KEY_ITERATE_KEY));
+            }
+          } else if (isArrayIndex) {
+            run(depsMap.get("length"));
+          }
+          break;
+        case "delete":
+          if (!targetIsArray) {
+            run(depsMap.get(ITERATE_KEY));
+            if (isMap(target)) {
+              run(depsMap.get(MAP_KEY_ITERATE_KEY));
+            }
+          }
+          break;
+        case "set":
+          if (isMap(target)) {
+            run(depsMap.get(ITERATE_KEY));
+          }
+          break;
+      }
+    }
+  }
+  endBatch();
+}
+function reactiveReadArray(array) {
+  const raw = toRaw(array);
+  if (raw === array)
+    return raw;
+  track(raw, "iterate", ARRAY_ITERATE_KEY);
+  return isShallow(array) ? raw : raw.map(toReactive);
+}
+function shallowReadArray(arr) {
+  track(arr = toRaw(arr), "iterate", ARRAY_ITERATE_KEY);
+  return arr;
+}
+var arrayInstrumentations = {
+  __proto__: null,
+  [Symbol.iterator]() {
+    return iterator(this, Symbol.iterator, toReactive);
+  },
+  concat(...args) {
+    return reactiveReadArray(this).concat(...args.map((x) => isArray(x) ? reactiveReadArray(x) : x));
+  },
+  entries() {
+    return iterator(this, "entries", (value) => {
+      value[1] = toReactive(value[1]);
+      return value;
+    });
+  },
+  every(fn, thisArg) {
+    return apply(this, "every", fn, thisArg, undefined, arguments);
+  },
+  filter(fn, thisArg) {
+    return apply(this, "filter", fn, thisArg, (v) => v.map(toReactive), arguments);
+  },
+  find(fn, thisArg) {
+    return apply(this, "find", fn, thisArg, toReactive, arguments);
+  },
+  findIndex(fn, thisArg) {
+    return apply(this, "findIndex", fn, thisArg, undefined, arguments);
+  },
+  findLast(fn, thisArg) {
+    return apply(this, "findLast", fn, thisArg, toReactive, arguments);
+  },
+  findLastIndex(fn, thisArg) {
+    return apply(this, "findLastIndex", fn, thisArg, undefined, arguments);
+  },
+  forEach(fn, thisArg) {
+    return apply(this, "forEach", fn, thisArg, undefined, arguments);
+  },
+  includes(...args) {
+    return searchProxy(this, "includes", args);
+  },
+  indexOf(...args) {
+    return searchProxy(this, "indexOf", args);
+  },
+  join(separator) {
+    return reactiveReadArray(this).join(separator);
+  },
+  lastIndexOf(...args) {
+    return searchProxy(this, "lastIndexOf", args);
+  },
+  map(fn, thisArg) {
+    return apply(this, "map", fn, thisArg, undefined, arguments);
+  },
+  pop() {
+    return noTracking(this, "pop");
+  },
+  push(...args) {
+    return noTracking(this, "push", args);
+  },
+  reduce(fn, ...args) {
+    return reduce(this, "reduce", fn, args);
+  },
+  reduceRight(fn, ...args) {
+    return reduce(this, "reduceRight", fn, args);
+  },
+  shift() {
+    return noTracking(this, "shift");
+  },
+  some(fn, thisArg) {
+    return apply(this, "some", fn, thisArg, undefined, arguments);
+  },
+  splice(...args) {
+    return noTracking(this, "splice", args);
+  },
+  toReversed() {
+    return reactiveReadArray(this).toReversed();
+  },
+  toSorted(comparer) {
+    return reactiveReadArray(this).toSorted(comparer);
+  },
+  toSpliced(...args) {
+    return reactiveReadArray(this).toSpliced(...args);
+  },
+  unshift(...args) {
+    return noTracking(this, "unshift", args);
+  },
+  values() {
+    return iterator(this, "values", toReactive);
+  }
+};
+function iterator(self2, method, wrapValue) {
+  const arr = shallowReadArray(self2);
+  const iter = arr[method]();
+  if (arr !== self2 && !isShallow(self2)) {
+    iter._next = iter.next;
+    iter.next = () => {
+      const result = iter._next();
+      if (result.value) {
+        result.value = wrapValue(result.value);
+      }
+      return result;
+    };
+  }
+  return iter;
+}
+var arrayProto = Array.prototype;
+function apply(self2, method, fn, thisArg, wrappedRetFn, args) {
+  const arr = shallowReadArray(self2);
+  const needsWrap = arr !== self2 && !isShallow(self2);
+  const methodFn = arr[method];
+  if (methodFn !== arrayProto[method]) {
+    const result2 = methodFn.apply(self2, args);
+    return needsWrap ? toReactive(result2) : result2;
+  }
+  let wrappedFn = fn;
+  if (arr !== self2) {
+    if (needsWrap) {
+      wrappedFn = function(item, index) {
+        return fn.call(this, toReactive(item), index, self2);
+      };
+    } else if (fn.length > 2) {
+      wrappedFn = function(item, index) {
+        return fn.call(this, item, index, self2);
+      };
+    }
+  }
+  const result = methodFn.call(arr, wrappedFn, thisArg);
+  return needsWrap && wrappedRetFn ? wrappedRetFn(result) : result;
+}
+function reduce(self2, method, fn, args) {
+  const arr = shallowReadArray(self2);
+  let wrappedFn = fn;
+  if (arr !== self2) {
+    if (!isShallow(self2)) {
+      wrappedFn = function(acc, item, index) {
+        return fn.call(this, acc, toReactive(item), index, self2);
+      };
+    } else if (fn.length > 3) {
+      wrappedFn = function(acc, item, index) {
+        return fn.call(this, acc, item, index, self2);
+      };
+    }
+  }
+  return arr[method](wrappedFn, ...args);
+}
+function searchProxy(self2, method, args) {
+  const arr = toRaw(self2);
+  track(arr, "iterate", ARRAY_ITERATE_KEY);
+  const res = arr[method](...args);
+  if ((res === -1 || res === false) && isProxy(args[0])) {
+    args[0] = toRaw(args[0]);
+    return arr[method](...args);
+  }
+  return res;
+}
+function noTracking(self2, method, args = []) {
+  pauseTracking();
+  startBatch();
+  const res = toRaw(self2)[method].apply(self2, args);
+  endBatch();
+  resetTracking();
+  return res;
+}
+var isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
+var builtInSymbols = new Set(/* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol));
+function hasOwnProperty2(key) {
+  if (!isSymbol(key))
+    key = String(key);
+  const obj = toRaw(this);
+  track(obj, "has", key);
+  return obj.hasOwnProperty(key);
+}
+
+class BaseReactiveHandler {
+  constructor(_isReadonly = false, _isShallow = false) {
+    this._isReadonly = _isReadonly;
+    this._isShallow = _isShallow;
+  }
+  get(target, key, receiver) {
+    if (key === "__v_skip")
+      return target["__v_skip"];
+    const isReadonly2 = this._isReadonly, isShallow2 = this._isShallow;
+    if (key === "__v_isReactive") {
+      return !isReadonly2;
+    } else if (key === "__v_isReadonly") {
+      return isReadonly2;
+    } else if (key === "__v_isShallow") {
+      return isShallow2;
+    } else if (key === "__v_raw") {
+      if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap : readonlyMap : isShallow2 ? shallowReactiveMap : reactiveMap).get(target) || Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) {
+        return target;
+      }
+      return;
+    }
+    const targetIsArray = isArray(target);
+    if (!isReadonly2) {
+      let fn;
+      if (targetIsArray && (fn = arrayInstrumentations[key])) {
+        return fn;
+      }
+      if (key === "hasOwnProperty") {
+        return hasOwnProperty2;
+      }
+    }
+    const res = Reflect.get(target, key, isRef(target) ? target : receiver);
+    if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
+      return res;
+    }
+    if (!isReadonly2) {
+      track(target, "get", key);
+    }
+    if (isShallow2) {
+      return res;
+    }
+    if (isRef(res)) {
+      return targetIsArray && isIntegerKey(key) ? res : res.value;
+    }
+    if (isObject(res)) {
+      return isReadonly2 ? readonly(res) : reactive(res);
+    }
+    return res;
+  }
+}
+
+class MutableReactiveHandler extends BaseReactiveHandler {
+  constructor(isShallow2 = false) {
+    super(false, isShallow2);
+  }
+  set(target, key, value, receiver) {
+    let oldValue = target[key];
+    if (!this._isShallow) {
+      const isOldValueReadonly = isReadonly(oldValue);
+      if (!isShallow(value) && !isReadonly(value)) {
+        oldValue = toRaw(oldValue);
+        value = toRaw(value);
+      }
+      if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
+        if (isOldValueReadonly) {
+          return false;
+        } else {
+          oldValue.value = value;
+          return true;
+        }
+      }
+    }
+    const hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
+    const result = Reflect.set(target, key, value, isRef(target) ? target : receiver);
+    if (target === toRaw(receiver)) {
+      if (!hadKey) {
+        trigger(target, "add", key, value);
+      } else if (hasChanged(value, oldValue)) {
+        trigger(target, "set", key, value, oldValue);
+      }
+    }
+    return result;
+  }
+  deleteProperty(target, key) {
+    const hadKey = hasOwn(target, key);
+    const oldValue = target[key];
+    const result = Reflect.deleteProperty(target, key);
+    if (result && hadKey) {
+      trigger(target, "delete", key, undefined, oldValue);
+    }
+    return result;
+  }
+  has(target, key) {
+    const result = Reflect.has(target, key);
+    if (!isSymbol(key) || !builtInSymbols.has(key)) {
+      track(target, "has", key);
+    }
+    return result;
+  }
+  ownKeys(target) {
+    track(target, "iterate", isArray(target) ? "length" : ITERATE_KEY);
+    return Reflect.ownKeys(target);
+  }
+}
+
+class ReadonlyReactiveHandler extends BaseReactiveHandler {
+  constructor(isShallow2 = false) {
+    super(true, isShallow2);
+  }
+  set(target, key) {
+    if (true) {
+      warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target);
+    }
+    return true;
+  }
+  deleteProperty(target, key) {
+    if (true) {
+      warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target);
+    }
+    return true;
+  }
+}
+var mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler;
+var readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler;
+var shallowReadonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler(true);
+var toShallow = (value) => value;
+var getProto = (v) => Reflect.getPrototypeOf(v);
+function createIterableMethod(method, isReadonly2, isShallow2) {
+  return function(...args) {
+    const target = this["__v_raw"];
+    const rawTarget = toRaw(target);
+    const targetIsMap = isMap(rawTarget);
+    const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
+    const isKeyOnly = method === "keys" && targetIsMap;
+    const innerIterator = target[method](...args);
+    const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
+    !isReadonly2 && track(rawTarget, "iterate", isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
+    return {
+      next() {
+        const { value, done } = innerIterator.next();
+        return done ? { value, done } : {
+          value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
+          done
+        };
+      },
+      [Symbol.iterator]() {
+        return this;
+      }
+    };
+  };
+}
+function createReadonlyMethod(type) {
+  return function(...args) {
+    if (true) {
+      const key = args[0] ? `on key "${args[0]}" ` : ``;
+      warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));
+    }
+    return type === "delete" ? false : type === "clear" ? undefined : this;
+  };
+}
+function createInstrumentations(readonly, shallow) {
+  const instrumentations = {
+    get(key) {
+      const target = this["__v_raw"];
+      const rawTarget = toRaw(target);
+      const rawKey = toRaw(key);
+      if (!readonly) {
+        if (hasChanged(key, rawKey)) {
+          track(rawTarget, "get", key);
+        }
+        track(rawTarget, "get", rawKey);
+      }
+      const { has } = getProto(rawTarget);
+      const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive;
+      if (has.call(rawTarget, key)) {
+        return wrap(target.get(key));
+      } else if (has.call(rawTarget, rawKey)) {
+        return wrap(target.get(rawKey));
+      } else if (target !== rawTarget) {
+        target.get(key);
+      }
+    },
+    get size() {
+      const target = this["__v_raw"];
+      !readonly && track(toRaw(target), "iterate", ITERATE_KEY);
+      return Reflect.get(target, "size", target);
+    },
+    has(key) {
+      const target = this["__v_raw"];
+      const rawTarget = toRaw(target);
+      const rawKey = toRaw(key);
+      if (!readonly) {
+        if (hasChanged(key, rawKey)) {
+          track(rawTarget, "has", key);
+        }
+        track(rawTarget, "has", rawKey);
+      }
+      return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
+    },
+    forEach(callback, thisArg) {
+      const observed = this;
+      const target = observed["__v_raw"];
+      const rawTarget = toRaw(target);
+      const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive;
+      !readonly && track(rawTarget, "iterate", ITERATE_KEY);
+      return target.forEach((value, key) => {
+        return callback.call(thisArg, wrap(value), wrap(key), observed);
+      });
+    }
+  };
+  extend(instrumentations, readonly ? {
+    add: createReadonlyMethod("add"),
+    set: createReadonlyMethod("set"),
+    delete: createReadonlyMethod("delete"),
+    clear: createReadonlyMethod("clear")
+  } : {
+    add(value) {
+      if (!shallow && !isShallow(value) && !isReadonly(value)) {
+        value = toRaw(value);
+      }
+      const target = toRaw(this);
+      const proto = getProto(target);
+      const hadKey = proto.has.call(target, value);
+      if (!hadKey) {
+        target.add(value);
+        trigger(target, "add", value, value);
+      }
+      return this;
+    },
+    set(key, value) {
+      if (!shallow && !isShallow(value) && !isReadonly(value)) {
+        value = toRaw(value);
+      }
+      const target = toRaw(this);
+      const { has, get } = getProto(target);
+      let hadKey = has.call(target, key);
+      if (!hadKey) {
+        key = toRaw(key);
+        hadKey = has.call(target, key);
+      } else if (true) {
+        checkIdentityKeys(target, has, key);
+      }
+      const oldValue = get.call(target, key);
+      target.set(key, value);
+      if (!hadKey) {
+        trigger(target, "add", key, value);
+      } else if (hasChanged(value, oldValue)) {
+        trigger(target, "set", key, value, oldValue);
+      }
+      return this;
+    },
+    delete(key) {
+      const target = toRaw(this);
+      const { has, get } = getProto(target);
+      let hadKey = has.call(target, key);
+      if (!hadKey) {
+        key = toRaw(key);
+        hadKey = has.call(target, key);
+      } else if (true) {
+        checkIdentityKeys(target, has, key);
+      }
+      const oldValue = get ? get.call(target, key) : undefined;
+      const result = target.delete(key);
+      if (hadKey) {
+        trigger(target, "delete", key, undefined, oldValue);
+      }
+      return result;
+    },
+    clear() {
+      const target = toRaw(this);
+      const hadItems = target.size !== 0;
+      const oldTarget = isMap(target) ? new Map(target) : new Set(target);
+      const result = target.clear();
+      if (hadItems) {
+        trigger(target, "clear", undefined, undefined, oldTarget);
+      }
+      return result;
+    }
+  });
+  const iteratorMethods = [
+    "keys",
+    "values",
+    "entries",
+    Symbol.iterator
+  ];
+  iteratorMethods.forEach((method) => {
+    instrumentations[method] = createIterableMethod(method, readonly, shallow);
+  });
+  return instrumentations;
+}
+function createInstrumentationGetter(isReadonly2, shallow) {
+  const instrumentations = createInstrumentations(isReadonly2, shallow);
+  return (target, key, receiver) => {
+    if (key === "__v_isReactive") {
+      return !isReadonly2;
+    } else if (key === "__v_isReadonly") {
+      return isReadonly2;
+    } else if (key === "__v_raw") {
+      return target;
+    }
+    return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver);
+  };
+}
+var mutableCollectionHandlers = {
+  get: /* @__PURE__ */ createInstrumentationGetter(false, false)
+};
+var readonlyCollectionHandlers = {
+  get: /* @__PURE__ */ createInstrumentationGetter(true, false)
+};
+var shallowReadonlyCollectionHandlers = {
+  get: /* @__PURE__ */ createInstrumentationGetter(true, true)
+};
+function checkIdentityKeys(target, has, key) {
+  const rawKey = toRaw(key);
+  if (rawKey !== key && has.call(target, rawKey)) {
+    const type = toRawType(target);
+    warn(`Reactive ${type} contains both the raw and reactive versions of the same object${type === `Map` ? ` as keys` : ``}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`);
+  }
+}
+var reactiveMap = /* @__PURE__ */ new WeakMap;
+var shallowReactiveMap = /* @__PURE__ */ new WeakMap;
+var readonlyMap = /* @__PURE__ */ new WeakMap;
+var shallowReadonlyMap = /* @__PURE__ */ new WeakMap;
+function targetTypeMap(rawType) {
+  switch (rawType) {
+    case "Object":
+    case "Array":
+      return 1;
+    case "Map":
+    case "Set":
+    case "WeakMap":
+    case "WeakSet":
+      return 2;
+    default:
+      return 0;
+  }
+}
+function getTargetType(value) {
+  return value["__v_skip"] || !Object.isExtensible(value) ? 0 : targetTypeMap(toRawType(value));
+}
+function reactive(target) {
+  if (isReadonly(target)) {
+    return target;
+  }
+  return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
+}
+function readonly(target) {
+  return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
+}
+function shallowReadonly(target) {
+  return createReactiveObject(target, true, shallowReadonlyHandlers, shallowReadonlyCollectionHandlers, shallowReadonlyMap);
+}
+function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
+  if (!isObject(target)) {
+    if (true) {
+      warn(`value cannot be made ${isReadonly2 ? "readonly" : "reactive"}: ${String(target)}`);
+    }
+    return target;
+  }
+  if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
+    return target;
+  }
+  const existingProxy = proxyMap.get(target);
+  if (existingProxy) {
+    return existingProxy;
+  }
+  const targetType = getTargetType(target);
+  if (targetType === 0) {
+    return target;
+  }
+  const proxy = new Proxy(target, targetType === 2 ? collectionHandlers : baseHandlers);
+  proxyMap.set(target, proxy);
+  return proxy;
+}
+function isReactive(value) {
+  if (isReadonly(value)) {
+    return isReactive(value["__v_raw"]);
+  }
+  return !!(value && value["__v_isReactive"]);
+}
+function isReadonly(value) {
+  return !!(value && value["__v_isReadonly"]);
+}
+function isShallow(value) {
+  return !!(value && value["__v_isShallow"]);
+}
+function isProxy(value) {
+  return value ? !!value["__v_raw"] : false;
+}
+function toRaw(observed) {
+  const raw = observed && observed["__v_raw"];
+  return raw ? toRaw(raw) : observed;
+}
+function markRaw(value) {
+  if (!hasOwn(value, "__v_skip") && Object.isExtensible(value)) {
+    def(value, "__v_skip", true);
+  }
+  return value;
+}
+var toReactive = (value) => isObject(value) ? reactive(value) : value;
+var toReadonly = (value) => isObject(value) ? readonly(value) : value;
+function isRef(r) {
+  return r ? r["__v_isRef"] === true : false;
+}
+function unref(ref2) {
+  return isRef(ref2) ? ref2.value : ref2;
+}
+var shallowUnwrapHandlers = {
+  get: (target, key, receiver) => key === "__v_raw" ? target : unref(Reflect.get(target, key, receiver)),
+  set: (target, key, value, receiver) => {
+    const oldValue = target[key];
+    if (isRef(oldValue) && !isRef(value)) {
+      oldValue.value = value;
+      return true;
+    } else {
+      return Reflect.set(target, key, value, receiver);
+    }
+  }
+};
+function proxyRefs(objectWithRefs) {
+  return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers);
+}
+
+class CustomRefImpl {
+  constructor(factory) {
+    this["__v_isRef"] = true;
+    this._value = undefined;
+    const dep = this.dep = new Dep;
+    const { get, set } = factory(dep.track.bind(dep), dep.trigger.bind(dep));
+    this._get = get;
+    this._set = set;
+  }
+  get value() {
+    return this._value = this._get();
+  }
+  set value(newVal) {
+    this._set(newVal);
+  }
+}
+function customRef(factory) {
+  return new CustomRefImpl(factory);
+}
+var INITIAL_WATCHER_VALUE = {};
+var cleanupMap = /* @__PURE__ */ new WeakMap;
+var activeWatcher = undefined;
+function onWatcherCleanup(cleanupFn, failSilently = false, owner = activeWatcher) {
+  if (owner) {
+    let cleanups = cleanupMap.get(owner);
+    if (!cleanups)
+      cleanupMap.set(owner, cleanups = []);
+    cleanups.push(cleanupFn);
+  } else if (!failSilently) {
+    warn(`onWatcherCleanup() was called when there was no active watcher to associate with.`);
+  }
+}
+function watch(source, cb, options = EMPTY_OBJ) {
+  const { immediate, deep, once, scheduler, augmentJob, call } = options;
+  const warnInvalidSource = (s) => {
+    (options.onWarn || warn)(`Invalid watch source: `, s, `A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.`);
+  };
+  const reactiveGetter = (source2) => {
+    if (deep)
+      return source2;
+    if (isShallow(source2) || deep === false || deep === 0)
+      return traverse(source2, 1);
+    return traverse(source2);
+  };
+  let effect;
+  let getter;
+  let cleanup;
+  let boundCleanup;
+  let forceTrigger = false;
+  let isMultiSource = false;
+  if (isRef(source)) {
+    getter = () => source.value;
+    forceTrigger = isShallow(source);
+  } else if (isReactive(source)) {
+    getter = () => reactiveGetter(source);
+    forceTrigger = true;
+  } else if (isArray(source)) {
+    isMultiSource = true;
+    forceTrigger = source.some((s) => isReactive(s) || isShallow(s));
+    getter = () => source.map((s) => {
+      if (isRef(s)) {
+        return s.value;
+      } else if (isReactive(s)) {
+        return reactiveGetter(s);
+      } else if (isFunction(s)) {
+        return call ? call(s, 2) : s();
+      } else {
+        warnInvalidSource(s);
+      }
+    });
+  } else if (isFunction(source)) {
+    if (cb) {
+      getter = call ? () => call(source, 2) : source;
+    } else {
+      getter = () => {
+        if (cleanup) {
+          pauseTracking();
+          try {
+            cleanup();
+          } finally {
+            resetTracking();
+          }
+        }
+        const currentEffect = activeWatcher;
+        activeWatcher = effect;
+        try {
+          return call ? call(source, 3, [boundCleanup]) : source(boundCleanup);
+        } finally {
+          activeWatcher = currentEffect;
+        }
+      };
+    }
+  } else {
+    getter = NOOP;
+    warnInvalidSource(source);
+  }
+  if (cb && deep) {
+    const baseGetter = getter;
+    const depth = deep === true ? Infinity : deep;
+    getter = () => traverse(baseGetter(), depth);
+  }
+  const scope = getCurrentScope();
+  const watchHandle = () => {
+    effect.stop();
+    if (scope && scope.active) {
+      remove(scope.effects, effect);
+    }
+  };
+  if (once && cb) {
+    const _cb = cb;
+    cb = (...args) => {
+      _cb(...args);
+      watchHandle();
+    };
+  }
+  let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
+  const job = (immediateFirstRun) => {
+    if (!(effect.flags & 1) || !effect.dirty && !immediateFirstRun) {
+      return;
+    }
+    if (cb) {
+      const newValue = effect.run();
+      if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue))) {
+        if (cleanup) {
+          cleanup();
+        }
+        const currentWatcher = activeWatcher;
+        activeWatcher = effect;
+        try {
+          const args = [
+            newValue,
+            oldValue === INITIAL_WATCHER_VALUE ? undefined : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue,
+            boundCleanup
+          ];
+          call ? call(cb, 3, args) : cb(...args);
+          oldValue = newValue;
+        } finally {
+          activeWatcher = currentWatcher;
+        }
+      }
+    } else {
+      effect.run();
+    }
+  };
+  if (augmentJob) {
+    augmentJob(job);
+  }
+  effect = new ReactiveEffect(getter);
+  effect.scheduler = scheduler ? () => scheduler(job, false) : job;
+  boundCleanup = (fn) => onWatcherCleanup(fn, false, effect);
+  cleanup = effect.onStop = () => {
+    const cleanups = cleanupMap.get(effect);
+    if (cleanups) {
+      if (call) {
+        call(cleanups, 4);
+      } else {
+        for (const cleanup2 of cleanups)
+          cleanup2();
+      }
+      cleanupMap.delete(effect);
+    }
+  };
+  if (true) {
+    effect.onTrack = options.onTrack;
+    effect.onTrigger = options.onTrigger;
+  }
+  if (cb) {
+    if (immediate) {
+      job(true);
+    } else {
+      oldValue = effect.run();
+    }
+  } else if (scheduler) {
+    scheduler(job.bind(null, true), true);
+  } else {
+    effect.run();
+  }
+  watchHandle.pause = effect.pause.bind(effect);
+  watchHandle.resume = effect.resume.bind(effect);
+  watchHandle.stop = watchHandle;
+  return watchHandle;
+}
+function traverse(value, depth = Infinity, seen) {
+  if (depth <= 0 || !isObject(value) || value["__v_skip"]) {
+    return value;
+  }
+  seen = seen || /* @__PURE__ */ new Set;
+  if (seen.has(value)) {
+    return value;
+  }
+  seen.add(value);
+  depth--;
+  if (isRef(value)) {
+    traverse(value.value, depth, seen);
+  } else if (isArray(value)) {
+    for (let i = 0;i < value.length; i++) {
+      traverse(value[i], depth, seen);
+    }
+  } else if (isSet(value) || isMap(value)) {
+    value.forEach((v) => {
+      traverse(v, depth, seen);
+    });
+  } else if (isPlainObject(value)) {
+    for (const key in value) {
+      traverse(value[key], depth, seen);
+    }
+    for (const key of Object.getOwnPropertySymbols(value)) {
+      if (Object.prototype.propertyIsEnumerable.call(value, key)) {
+        traverse(value[key], depth, seen);
+      }
+    }
+  }
+  return value;
+}
+// node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js
+var stack = [];
+function pushWarningContext(vnode) {
+  stack.push(vnode);
+}
+function popWarningContext() {
+  stack.pop();
+}
+var isWarning = false;
+function warn$1(msg, ...args) {
+  if (isWarning)
+    return;
+  isWarning = true;
+  pauseTracking();
+  const instance = stack.length ? stack[stack.length - 1].component : null;
+  const appWarnHandler = instance && instance.appContext.config.warnHandler;
+  const trace = getComponentTrace();
+  if (appWarnHandler) {
+    callWithErrorHandling(appWarnHandler, instance, 11, [
+      msg + args.map((a) => {
+        var _a, _b;
+        return (_b = (_a = a.toString) == null ? undefined : _a.call(a)) != null ? _b : JSON.stringify(a);
+      }).join(""),
+      instance && instance.proxy,
+      trace.map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`).join(`
+`),
+      trace
+    ]);
+  } else {
+    const warnArgs = [`[Vue warn]: ${msg}`, ...args];
+    if (trace.length && true) {
+      warnArgs.push(`
+`, ...formatTrace(trace));
+    }
+    console.warn(...warnArgs);
+  }
+  resetTracking();
+  isWarning = false;
+}
+function getComponentTrace() {
+  let currentVNode = stack[stack.length - 1];
+  if (!currentVNode) {
+    return [];
+  }
+  const normalizedStack = [];
+  while (currentVNode) {
+    const last = normalizedStack[0];
+    if (last && last.vnode === currentVNode) {
+      last.recurseCount++;
+    } else {
+      normalizedStack.push({
+        vnode: currentVNode,
+        recurseCount: 0
+      });
+    }
+    const parentInstance = currentVNode.component && currentVNode.component.parent;
+    currentVNode = parentInstance && parentInstance.vnode;
+  }
+  return normalizedStack;
+}
+function formatTrace(trace) {
+  const logs = [];
+  trace.forEach((entry, i) => {
+    logs.push(...i === 0 ? [] : [`
+`], ...formatTraceEntry(entry));
+  });
+  return logs;
+}
+function formatTraceEntry({ vnode, recurseCount }) {
+  const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
+  const isRoot = vnode.component ? vnode.component.parent == null : false;
+  const open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`;
+  const close = `>` + postfix;
+  return vnode.props ? [open, ...formatProps(vnode.props), close] : [open + close];
+}
+function formatProps(props) {
+  const res = [];
+  const keys = Object.keys(props);
+  keys.slice(0, 3).forEach((key) => {
+    res.push(...formatProp(key, props[key]));
+  });
+  if (keys.length > 3) {
+    res.push(` ...`);
+  }
+  return res;
+}
+function formatProp(key, value, raw) {
+  if (isString(value)) {
+    value = JSON.stringify(value);
+    return raw ? value : [`${key}=${value}`];
+  } else if (typeof value === "number" || typeof value === "boolean" || value == null) {
+    return raw ? value : [`${key}=${value}`];
+  } else if (isRef(value)) {
+    value = formatProp(key, toRaw(value.value), true);
+    return raw ? value : [`${key}=Ref<`, value, `>`];
+  } else if (isFunction(value)) {
+    return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
+  } else {
+    value = toRaw(value);
+    return raw ? value : [`${key}=`, value];
+  }
+}
+var ErrorTypeStrings$1 = {
+  ["sp"]: "serverPrefetch hook",
+  ["bc"]: "beforeCreate hook",
+  ["c"]: "created hook",
+  ["bm"]: "beforeMount hook",
+  ["m"]: "mounted hook",
+  ["bu"]: "beforeUpdate hook",
+  ["u"]: "updated",
+  ["bum"]: "beforeUnmount hook",
+  ["um"]: "unmounted hook",
+  ["a"]: "activated hook",
+  ["da"]: "deactivated hook",
+  ["ec"]: "errorCaptured hook",
+  ["rtc"]: "renderTracked hook",
+  ["rtg"]: "renderTriggered hook",
+  [0]: "setup function",
+  [1]: "render function",
+  [2]: "watcher getter",
+  [3]: "watcher callback",
+  [4]: "watcher cleanup function",
+  [5]: "native event handler",
+  [6]: "component event handler",
+  [7]: "vnode hook",
+  [8]: "directive hook",
+  [9]: "transition hook",
+  [10]: "app errorHandler",
+  [11]: "app warnHandler",
+  [12]: "ref function",
+  [13]: "async component loader",
+  [14]: "scheduler flush",
+  [15]: "component update",
+  [16]: "app unmount cleanup function"
+};
+function callWithErrorHandling(fn, instance, type, args) {
+  try {
+    return args ? fn(...args) : fn();
+  } catch (err) {
+    handleError(err, instance, type);
+  }
+}
+function callWithAsyncErrorHandling(fn, instance, type, args) {
+  if (isFunction(fn)) {
+    const res = callWithErrorHandling(fn, instance, type, args);
+    if (res && isPromise(res)) {
+      res.catch((err) => {
+        handleError(err, instance, type);
+      });
+    }
+    return res;
+  }
+  if (isArray(fn)) {
+    const values = [];
+    for (let i = 0;i < fn.length; i++) {
+      values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));
+    }
+    return values;
+  } else if (true) {
+    warn$1(`Invalid value type passed to callWithAsyncErrorHandling(): ${typeof fn}`);
+  }
+}
+function handleError(err, instance, type, throwInDev = true) {
+  const contextVNode = instance ? instance.vnode : null;
+  const { errorHandler, throwUnhandledErrorInProduction } = instance && instance.appContext.config || EMPTY_OBJ;
+  if (instance) {
+    let cur = instance.parent;
+    const exposedInstance = instance.proxy;
+    const errorInfo = ErrorTypeStrings$1[type];
+    while (cur) {
+      const errorCapturedHooks = cur.ec;
+      if (errorCapturedHooks) {
+        for (let i = 0;i < errorCapturedHooks.length; i++) {
+          if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {
+            return;
+          }
+        }
+      }
+      cur = cur.parent;
+    }
+    if (errorHandler) {
+      pauseTracking();
+      callWithErrorHandling(errorHandler, null, 10, [
+        err,
+        exposedInstance,
+        errorInfo
+      ]);
+      resetTracking();
+      return;
+    }
+  }
+  logError(err, type, contextVNode, throwInDev, throwUnhandledErrorInProduction);
+}
+function logError(err, type, contextVNode, throwInDev = true, throwInProd = false) {
+  if (true) {
+    const info = ErrorTypeStrings$1[type];
+    if (contextVNode) {
+      pushWarningContext(contextVNode);
+    }
+    warn$1(`Unhandled error${info ? ` during execution of ${info}` : ``}`);
+    if (contextVNode) {
+      popWarningContext();
+    }
+    if (throwInDev) {
+      throw err;
+    } else {
+      console.error(err);
+    }
+  } else
+    ;
+}
+var queue = [];
+var flushIndex = -1;
+var pendingPostFlushCbs = [];
+var activePostFlushCbs = null;
+var postFlushIndex = 0;
+var resolvedPromise = /* @__PURE__ */ Promise.resolve();
+var currentFlushPromise = null;
+var RECURSION_LIMIT = 100;
+function nextTick(fn) {
+  const p = currentFlushPromise || resolvedPromise;
+  return fn ? p.then(this ? fn.bind(this) : fn) : p;
+}
+function findInsertionIndex(id) {
+  let start = flushIndex + 1;
+  let end = queue.length;
+  while (start < end) {
+    const middle = start + end >>> 1;
+    const middleJob = queue[middle];
+    const middleJobId = getId(middleJob);
+    if (middleJobId < id || middleJobId === id && middleJob.flags & 2) {
+      start = middle + 1;
+    } else {
+      end = middle;
+    }
+  }
+  return start;
+}
+function queueJob(job) {
+  if (!(job.flags & 1)) {
+    const jobId = getId(job);
+    const lastJob = queue[queue.length - 1];
+    if (!lastJob || !(job.flags & 2) && jobId >= getId(lastJob)) {
+      queue.push(job);
+    } else {
+      queue.splice(findInsertionIndex(jobId), 0, job);
+    }
+    job.flags |= 1;
+    queueFlush();
+  }
+}
+function queueFlush() {
+  if (!currentFlushPromise) {
+    currentFlushPromise = resolvedPromise.then(flushJobs);
+  }
+}
+function queuePostFlushCb(cb) {
+  if (!isArray(cb)) {
+    if (activePostFlushCbs && cb.id === -1) {
+      activePostFlushCbs.splice(postFlushIndex + 1, 0, cb);
+    } else if (!(cb.flags & 1)) {
+      pendingPostFlushCbs.push(cb);
+      cb.flags |= 1;
+    }
+  } else {
+    pendingPostFlushCbs.push(...cb);
+  }
+  queueFlush();
+}
+function flushPostFlushCbs(seen) {
+  if (pendingPostFlushCbs.length) {
+    const deduped = [...new Set(pendingPostFlushCbs)].sort((a, b) => getId(a) - getId(b));
+    pendingPostFlushCbs.length = 0;
+    if (activePostFlushCbs) {
+      activePostFlushCbs.push(...deduped);
+      return;
+    }
+    activePostFlushCbs = deduped;
+    if (true) {
+      seen = seen || /* @__PURE__ */ new Map;
+    }
+    for (postFlushIndex = 0;postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
+      const cb = activePostFlushCbs[postFlushIndex];
+      if (checkRecursiveUpdates(seen, cb)) {
+        continue;
+      }
+      if (cb.flags & 4) {
+        cb.flags &= ~1;
+      }
+      if (!(cb.flags & 8))
+        cb();
+      cb.flags &= ~1;
+    }
+    activePostFlushCbs = null;
+    postFlushIndex = 0;
+  }
+}
+var getId = (job) => job.id == null ? job.flags & 2 ? -1 : Infinity : job.id;
+function flushJobs(seen) {
+  if (true) {
+    seen = seen || /* @__PURE__ */ new Map;
+  }
+  const check = (job) => checkRecursiveUpdates(seen, job);
+  try {
+    for (flushIndex = 0;flushIndex < queue.length; flushIndex++) {
+      const job = queue[flushIndex];
+      if (job && !(job.flags & 8)) {
+        if (check(job)) {
+          continue;
+        }
+        if (job.flags & 4) {
+          job.flags &= ~1;
+        }
+        callWithErrorHandling(job, job.i, job.i ? 15 : 14);
+        if (!(job.flags & 4)) {
+          job.flags &= ~1;
+        }
+      }
+    }
+  } finally {
+    for (;flushIndex < queue.length; flushIndex++) {
+      const job = queue[flushIndex];
+      if (job) {
+        job.flags &= ~1;
+      }
+    }
+    flushIndex = -1;
+    queue.length = 0;
+    flushPostFlushCbs(seen);
+    currentFlushPromise = null;
+    if (queue.length || pendingPostFlushCbs.length) {
+      flushJobs(seen);
+    }
+  }
+}
+function checkRecursiveUpdates(seen, fn) {
+  const count = seen.get(fn) || 0;
+  if (count > RECURSION_LIMIT) {
+    const instance = fn.i;
+    const componentName = instance && getComponentName(instance.type);
+    handleError(`Maximum recursive updates exceeded${componentName ? ` in component <${componentName}>` : ``}. This means you have a reactive effect that is mutating its own dependencies and thus recursively triggering itself. Possible sources include component template, render function, updated hook or watcher source function.`, null, 10);
+    return true;
+  }
+  seen.set(fn, count + 1);
+  return false;
+}
+var isHmrUpdating = false;
+var hmrDirtyComponents = /* @__PURE__ */ new Map;
+if (true) {
+  getGlobalThis().__VUE_HMR_RUNTIME__ = {
+    createRecord: tryWrap(createRecord),
+    rerender: tryWrap(rerender),
+    reload: tryWrap(reload)
+  };
+}
+var map = /* @__PURE__ */ new Map;
+function createRecord(id, initialDef) {
+  if (map.has(id)) {
+    return false;
+  }
+  map.set(id, {
+    initialDef: normalizeClassComponent(initialDef),
+    instances: /* @__PURE__ */ new Set
+  });
+  return true;
+}
+function normalizeClassComponent(component) {
+  return isClassComponent(component) ? component.__vccOpts : component;
+}
+function rerender(id, newRender) {
+  const record = map.get(id);
+  if (!record) {
+    return;
+  }
+  record.initialDef.render = newRender;
+  [...record.instances].forEach((instance) => {
+    if (newRender) {
+      instance.render = newRender;
+      normalizeClassComponent(instance.type).render = newRender;
+    }
+    instance.renderCache = [];
+    isHmrUpdating = true;
+    instance.update();
+    isHmrUpdating = false;
+  });
+}
+function reload(id, newComp) {
+  const record = map.get(id);
+  if (!record)
+    return;
+  newComp = normalizeClassComponent(newComp);
+  updateComponentDef(record.initialDef, newComp);
+  const instances = [...record.instances];
+  for (let i = 0;i < instances.length; i++) {
+    const instance = instances[i];
+    const oldComp = normalizeClassComponent(instance.type);
+    let dirtyInstances = hmrDirtyComponents.get(oldComp);
+    if (!dirtyInstances) {
+      if (oldComp !== record.initialDef) {
+        updateComponentDef(oldComp, newComp);
+      }
+      hmrDirtyComponents.set(oldComp, dirtyInstances = /* @__PURE__ */ new Set);
+    }
+    dirtyInstances.add(instance);
+    instance.appContext.propsCache.delete(instance.type);
+    instance.appContext.emitsCache.delete(instance.type);
+    instance.appContext.optionsCache.delete(instance.type);
+    if (instance.ceReload) {
+      dirtyInstances.add(instance);
+      instance.ceReload(newComp.styles);
+      dirtyInstances.delete(instance);
+    } else if (instance.parent) {
+      queueJob(() => {
+        isHmrUpdating = true;
+        instance.parent.update();
+        isHmrUpdating = false;
+        dirtyInstances.delete(instance);
+      });
+    } else if (instance.appContext.reload) {
+      instance.appContext.reload();
+    } else if (typeof window !== "undefined") {
+      window.location.reload();
+    } else {
+      console.warn("[HMR] Root or manually mounted instance modified. Full reload required.");
+    }
+    if (instance.root.ce && instance !== instance.root) {
+      instance.root.ce._removeChildStyle(oldComp);
+    }
+  }
+  queuePostFlushCb(() => {
+    hmrDirtyComponents.clear();
+  });
+}
+function updateComponentDef(oldComp, newComp) {
+  extend(oldComp, newComp);
+  for (const key in oldComp) {
+    if (key !== "__file" && !(key in newComp)) {
+      delete oldComp[key];
+    }
+  }
+}
+function tryWrap(fn) {
+  return (id, arg) => {
+    try {
+      return fn(id, arg);
+    } catch (e) {
+      console.error(e);
+      console.warn(`[HMR] Something went wrong during Vue component hot-reload. Full reload required.`);
+    }
+  };
+}
+/*! #__NO_SIDE_EFFECTS__ */
+var currentRenderingInstance = null;
+var TeleportEndKey = Symbol("_vte");
+var leaveCbKey = Symbol("_leaveCb");
+var enterCbKey = Symbol("_enterCb");
+/*! #__NO_SIDE_EFFECTS__ */
+var requestIdleCallback = getGlobalThis().requestIdleCallback || ((cb) => setTimeout(cb, 1));
+var cancelIdleCallback = getGlobalThis().cancelIdleCallback || ((id) => clearTimeout(id));
+/*! #__NO_SIDE_EFFECTS__ */
+function injectHook(type, hook, target = currentInstance, prepend = false) {
+  if (target) {
+    const hooks = target[type] || (target[type] = []);
+    const wrappedHook = hook.__weh || (hook.__weh = (...args) => {
+      pauseTracking();
+      const reset = setCurrentInstance(target);
+      const res = callWithAsyncErrorHandling(hook, target, type, args);
+      reset();
+      resetTracking();
+      return res;
+    });
+    if (prepend) {
+      hooks.unshift(wrappedHook);
+    } else {
+      hooks.push(wrappedHook);
+    }
+    return wrappedHook;
+  } else if (true) {
+    const apiName = toHandlerKey(ErrorTypeStrings$1[type].replace(/ hook$/, ""));
+    warn$1(`${apiName} is called when there is no active component instance to be associated with. Lifecycle injection APIs can only be used during execution of setup().` + ` If you are using async setup(), make sure to register lifecycle hooks before the first await statement.`);
+  }
+}
+var createHook = (lifecycle) => (hook, target = currentInstance) => {
+  if (!isInSSRComponentSetup || lifecycle === "sp") {
+    injectHook(lifecycle, (...args) => hook(...args), target);
+  }
+};
+var onBeforeMount = createHook("bm");
+var onMounted = createHook("m");
+var onBeforeUpdate = createHook("bu");
+var onUpdated = createHook("u");
+var onBeforeUnmount = createHook("bum");
+var onUnmounted = createHook("um");
+var onServerPrefetch = createHook("sp");
+var onRenderTriggered = createHook("rtg");
+var onRenderTracked = createHook("rtc");
+var NULL_DYNAMIC_COMPONENT = Symbol.for("v-ndc");
+var getPublicInstance = (i) => {
+  if (!i)
+    return null;
+  if (isStatefulComponent(i))
+    return getComponentPublicInstance(i);
+  return getPublicInstance(i.parent);
+};
+var publicPropertiesMap = /* @__PURE__ */ extend(/* @__PURE__ */ Object.create(null), {
+  $: (i) => i,
+  $el: (i) => i.vnode.el,
+  $data: (i) => i.data,
+  $props: (i) => shallowReadonly(i.props),
+  $attrs: (i) => shallowReadonly(i.attrs),
+  $slots: (i) => shallowReadonly(i.slots),
+  $refs: (i) => shallowReadonly(i.refs),
+  $parent: (i) => getPublicInstance(i.parent),
+  $root: (i) => getPublicInstance(i.root),
+  $host: (i) => i.ce,
+  $emit: (i) => i.emit,
+  $options: (i) => __VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type,
+  $forceUpdate: (i) => i.f || (i.f = () => {
+    queueJob(i.update);
+  }),
+  $nextTick: (i) => i.n || (i.n = nextTick.bind(i.proxy)),
+  $watch: (i) => __VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP
+});
+var isReservedPrefix = (key) => key === "_" || key === "$";
+var hasSetupBinding = (state, key) => state !== EMPTY_OBJ && !state.__isScriptSetup && hasOwn(state, key);
+var PublicInstanceProxyHandlers = {
+  get({ _: instance }, key) {
+    if (key === "__v_skip") {
+      return true;
+    }
+    const { ctx, setupState, data, props, accessCache, type, appContext } = instance;
+    if (key === "__isVue") {
+      return true;
+    }
+    let normalizedProps;
+    if (key[0] !== "$") {
+      const n = accessCache[key];
+      if (n !== undefined) {
+        switch (n) {
+          case 1:
+            return setupState[key];
+          case 2:
+            return data[key];
+          case 4:
+            return ctx[key];
+          case 3:
+            return props[key];
+        }
+      } else if (hasSetupBinding(setupState, key)) {
+        accessCache[key] = 1;
+        return setupState[key];
+      } else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
+        accessCache[key] = 2;
+        return data[key];
+      } else if ((normalizedProps = instance.propsOptions[0]) && hasOwn(normalizedProps, key)) {
+        accessCache[key] = 3;
+        return props[key];
+      } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
+        accessCache[key] = 4;
+        return ctx[key];
+      } else if (!__VUE_OPTIONS_API__ || shouldCacheAccess) {
+        accessCache[key] = 0;
+      }
+    }
+    const publicGetter = publicPropertiesMap[key];
+    let cssModule, globalProperties;
+    if (publicGetter) {
+      if (key === "$attrs") {
+        track(instance.attrs, "get", "");
+        markAttrsAccessed();
+      } else if (key === "$slots") {
+        track(instance, "get", key);
+      }
+      return publicGetter(instance);
+    } else if ((cssModule = type.__cssModules) && (cssModule = cssModule[key])) {
+      return cssModule;
+    } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
+      accessCache[key] = 4;
+      return ctx[key];
+    } else if (globalProperties = appContext.config.globalProperties, hasOwn(globalProperties, key)) {
+      {
+        return globalProperties[key];
+      }
+    } else if (currentRenderingInstance && (!isString(key) || key.indexOf("__v") !== 0)) {
+      if (data !== EMPTY_OBJ && isReservedPrefix(key[0]) && hasOwn(data, key)) {
+        warn$1(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved character ("$" or "_") and is not proxied on the render context.`);
+      } else if (instance === currentRenderingInstance) {
+        warn$1(`Property ${JSON.stringify(key)} was accessed during render but is not defined on instance.`);
+      }
+    }
+  },
+  set({ _: instance }, key, value) {
+    const { data, setupState, ctx } = instance;
+    if (hasSetupBinding(setupState, key)) {
+      setupState[key] = value;
+      return true;
+    } else if (setupState.__isScriptSetup && hasOwn(setupState, key)) {
+      warn$1(`Cannot mutate <script setup> binding "${key}" from Options API.`);
+      return false;
+    } else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
+      data[key] = value;
+      return true;
+    } else if (hasOwn(instance.props, key)) {
+      warn$1(`Attempting to mutate prop "${key}". Props are readonly.`);
+      return false;
+    }
+    if (key[0] === "$" && key.slice(1) in instance) {
+      warn$1(`Attempting to mutate public property "${key}". Properties starting with $ are reserved and readonly.`);
+      return false;
+    } else {
+      if (key in instance.appContext.config.globalProperties) {
+        Object.defineProperty(ctx, key, {
+          enumerable: true,
+          configurable: true,
+          value
+        });
+      } else {
+        ctx[key] = value;
+      }
+    }
+    return true;
+  },
+  has({
+    _: { data, setupState, accessCache, ctx, appContext, propsOptions }
+  }, key) {
+    let normalizedProps;
+    return !!accessCache[key] || data !== EMPTY_OBJ && hasOwn(data, key) || hasSetupBinding(setupState, key) || (normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key) || hasOwn(ctx, key) || hasOwn(publicPropertiesMap, key) || hasOwn(appContext.config.globalProperties, key);
+  },
+  defineProperty(target, key, descriptor) {
+    if (descriptor.get != null) {
+      target._.accessCache[key] = 0;
+    } else if (hasOwn(descriptor, "value")) {
+      this.set(target, key, descriptor.value, null);
+    }
+    return Reflect.defineProperty(target, key, descriptor);
+  }
+};
+if (true) {
+  PublicInstanceProxyHandlers.ownKeys = (target) => {
+    warn$1(`Avoid app logic that relies on enumerating keys on a component instance. The keys will be empty in production mode to avoid performance overhead.`);
+    return Reflect.ownKeys(target);
+  };
+}
+function normalizePropsOrEmits(props) {
+  return isArray(props) ? props.reduce((normalized, p) => (normalized[p] = null, normalized), {}) : props;
+}
+var shouldCacheAccess = true;
+function resolveMergedOptions(instance) {
+  const base = instance.type;
+  const { mixins, extends: extendsOptions } = base;
+  const {
+    mixins: globalMixins,
+    optionsCache: cache,
+    config: { optionMergeStrategies }
+  } = instance.appContext;
+  const cached = cache.get(base);
+  let resolved;
+  if (cached) {
+    resolved = cached;
+  } else if (!globalMixins.length && !mixins && !extendsOptions) {
+    {
+      resolved = base;
+    }
+  } else {
+    resolved = {};
+    if (globalMixins.length) {
+      globalMixins.forEach((m) => mergeOptions(resolved, m, optionMergeStrategies, true));
+    }
+    mergeOptions(resolved, base, optionMergeStrategies);
+  }
+  if (isObject(base)) {
+    cache.set(base, resolved);
+  }
+  return resolved;
+}
+function mergeOptions(to, from, strats, asMixin = false) {
+  const { mixins, extends: extendsOptions } = from;
+  if (extendsOptions) {
+    mergeOptions(to, extendsOptions, strats, true);
+  }
+  if (mixins) {
+    mixins.forEach((m) => mergeOptions(to, m, strats, true));
+  }
+  for (const key in from) {
+    if (asMixin && key === "expose") {
+      warn$1(`"expose" option is ignored when declared in mixins or extends. It should only be declared in the base component itself.`);
+    } else {
+      const strat = internalOptionMergeStrats[key] || strats && strats[key];
+      to[key] = strat ? strat(to[key], from[key]) : from[key];
+    }
+  }
+  return to;
+}
+var internalOptionMergeStrats = {
+  data: mergeDataFn,
+  props: mergeEmitsOrPropsOptions,
+  emits: mergeEmitsOrPropsOptions,
+  methods: mergeObjectOptions,
+  computed: mergeObjectOptions,
+  beforeCreate: mergeAsArray,
+  created: mergeAsArray,
+  beforeMount: mergeAsArray,
+  mounted: mergeAsArray,
+  beforeUpdate: mergeAsArray,
+  updated: mergeAsArray,
+  beforeDestroy: mergeAsArray,
+  beforeUnmount: mergeAsArray,
+  destroyed: mergeAsArray,
+  unmounted: mergeAsArray,
+  activated: mergeAsArray,
+  deactivated: mergeAsArray,
+  errorCaptured: mergeAsArray,
+  serverPrefetch: mergeAsArray,
+  components: mergeObjectOptions,
+  directives: mergeObjectOptions,
+  watch: mergeWatchOptions,
+  provide: mergeDataFn,
+  inject: mergeInject
+};
+function mergeDataFn(to, from) {
+  if (!from) {
+    return to;
+  }
+  if (!to) {
+    return from;
+  }
+  return function mergedDataFn() {
+    return extend(isFunction(to) ? to.call(this, this) : to, isFunction(from) ? from.call(this, this) : from);
+  };
+}
+function mergeInject(to, from) {
+  return mergeObjectOptions(normalizeInject(to), normalizeInject(from));
+}
+function normalizeInject(raw) {
+  if (isArray(raw)) {
+    const res = {};
+    for (let i = 0;i < raw.length; i++) {
+      res[raw[i]] = raw[i];
+    }
+    return res;
+  }
+  return raw;
+}
+function mergeAsArray(to, from) {
+  return to ? [...new Set([].concat(to, from))] : from;
+}
+function mergeObjectOptions(to, from) {
+  return to ? extend(/* @__PURE__ */ Object.create(null), to, from) : from;
+}
+function mergeEmitsOrPropsOptions(to, from) {
+  if (to) {
+    if (isArray(to) && isArray(from)) {
+      return [.../* @__PURE__ */ new Set([...to, ...from])];
+    }
+    return extend(/* @__PURE__ */ Object.create(null), normalizePropsOrEmits(to), normalizePropsOrEmits(from != null ? from : {}));
+  } else {
+    return from;
+  }
+}
+function mergeWatchOptions(to, from) {
+  if (!to)
+    return from;
+  if (!from)
+    return to;
+  const merged = extend(/* @__PURE__ */ Object.create(null), to);
+  for (const key in from) {
+    merged[key] = mergeAsArray(to[key], from[key]);
+  }
+  return merged;
+}
+function createAppContext() {
+  return {
+    app: null,
+    config: {
+      isNativeTag: NO,
+      performance: false,
+      globalProperties: {},
+      optionMergeStrategies: {},
+      errorHandler: undefined,
+      warnHandler: undefined,
+      compilerOptions: {}
+    },
+    mixins: [],
+    components: {},
+    directives: {},
+    provides: /* @__PURE__ */ Object.create(null),
+    optionsCache: /* @__PURE__ */ new WeakMap,
+    propsCache: /* @__PURE__ */ new WeakMap,
+    emitsCache: /* @__PURE__ */ new WeakMap
+  };
+}
+var currentApp = null;
+function inject(key, defaultValue, treatDefaultAsFactory = false) {
+  const instance = currentInstance || currentRenderingInstance;
+  if (instance || currentApp) {
+    const provides = currentApp ? currentApp._context.provides : instance ? instance.parent == null ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides : undefined;
+    if (provides && key in provides) {
+      return provides[key];
+    } else if (arguments.length > 1) {
+      return treatDefaultAsFactory && isFunction(defaultValue) ? defaultValue.call(instance && instance.proxy) : defaultValue;
+    } else if (true) {
+      warn$1(`injection "${String(key)}" not found.`);
+    }
+  } else if (true) {
+    warn$1(`inject() can only be used inside setup() or functional components.`);
+  }
+}
+var queuePostRenderEffect = queueEffectWithSuspense;
+var ssrContextKey = Symbol.for("v-scx");
+var useSSRContext = () => {
+  {
+    const ctx = inject(ssrContextKey);
+    if (!ctx) {
+      warn$1(`Server rendering context not provided. Make sure to only call useSSRContext() conditionally in the server build.`);
+    }
+    return ctx;
+  }
+};
+function doWatch(source, cb, options = EMPTY_OBJ) {
+  const { immediate, deep, flush, once } = options;
+  if (!cb) {
+    if (immediate !== undefined) {
+      warn$1(`watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.`);
+    }
+    if (deep !== undefined) {
+      warn$1(`watch() "deep" option is only respected when using the watch(source, callback, options?) signature.`);
+    }
+    if (once !== undefined) {
+      warn$1(`watch() "once" option is only respected when using the watch(source, callback, options?) signature.`);
+    }
+  }
+  const baseWatchOptions = extend({}, options);
+  if (true)
+    baseWatchOptions.onWarn = warn$1;
+  const runsImmediately = cb && immediate || !cb && flush !== "post";
+  let ssrCleanup;
+  if (isInSSRComponentSetup) {
+    if (flush === "sync") {
+      const ctx = useSSRContext();
+      ssrCleanup = ctx.__watcherHandles || (ctx.__watcherHandles = []);
+    } else if (!runsImmediately) {
+      const watchStopHandle = () => {
+      };
+      watchStopHandle.stop = NOOP;
+      watchStopHandle.resume = NOOP;
+      watchStopHandle.pause = NOOP;
+      return watchStopHandle;
+    }
+  }
+  const instance = currentInstance;
+  baseWatchOptions.call = (fn, type, args) => callWithAsyncErrorHandling(fn, instance, type, args);
+  let isPre = false;
+  if (flush === "post") {
+    baseWatchOptions.scheduler = (job) => {
+      queuePostRenderEffect(job, instance && instance.suspense);
+    };
+  } else if (flush !== "sync") {
+    isPre = true;
+    baseWatchOptions.scheduler = (job, isFirstRun) => {
+      if (isFirstRun) {
+        job();
+      } else {
+        queueJob(job);
+      }
+    };
+  }
+  baseWatchOptions.augmentJob = (job) => {
+    if (cb) {
+      job.flags |= 4;
+    }
+    if (isPre) {
+      job.flags |= 2;
+      if (instance) {
+        job.id = instance.uid;
+        job.i = instance;
+      }
+    }
+  };
+  const watchHandle = watch(source, cb, baseWatchOptions);
+  if (isInSSRComponentSetup) {
+    if (ssrCleanup) {
+      ssrCleanup.push(watchHandle);
+    } else if (runsImmediately) {
+      watchHandle();
+    }
+  }
+  return watchHandle;
+}
+function instanceWatch(source, value, options) {
+  const publicThis = this.proxy;
+  const getter = isString(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis);
+  let cb;
+  if (isFunction(value)) {
+    cb = value;
+  } else {
+    cb = value.handler;
+    options = value;
+  }
+  const reset = setCurrentInstance(this);
+  const res = doWatch(getter, cb.bind(publicThis), options);
+  reset();
+  return res;
+}
+function createPathGetter(ctx, path) {
+  const segments = path.split(".");
+  return () => {
+    let cur = ctx;
+    for (let i = 0;i < segments.length && cur; i++) {
+      cur = cur[segments[i]];
+    }
+    return cur;
+  };
+}
+var accessedAttrs = false;
+function markAttrsAccessed() {
+  accessedAttrs = true;
+}
+function queueEffectWithSuspense(fn, suspense) {
+  if (suspense && suspense.pendingBranch) {
+    if (isArray(fn)) {
+      suspense.effects.push(...fn);
+    } else {
+      suspense.effects.push(fn);
+    }
+  } else {
+    queuePostFlushCb(fn);
+  }
+}
+var Fragment = Symbol.for("v-fgt");
+var Text = Symbol.for("v-txt");
+var Comment = Symbol.for("v-cmt");
+var Static = Symbol.for("v-stc");
+var emptyAppContext = createAppContext();
+var currentInstance = null;
+var internalSetCurrentInstance;
+var setInSSRSetupState;
+{
+  const g = getGlobalThis();
+  const registerGlobalSetter = (key, setter) => {
+    let setters;
+    if (!(setters = g[key]))
+      setters = g[key] = [];
+    setters.push(setter);
+    return (v) => {
+      if (setters.length > 1)
+        setters.forEach((set) => set(v));
+      else
+        setters[0](v);
+    };
+  };
+  internalSetCurrentInstance = registerGlobalSetter(`__VUE_INSTANCE_SETTERS__`, (v) => currentInstance = v);
+  setInSSRSetupState = registerGlobalSetter(`__VUE_SSR_SETTERS__`, (v) => isInSSRComponentSetup = v);
+}
+var setCurrentInstance = (instance) => {
+  const prev = currentInstance;
+  internalSetCurrentInstance(instance);
+  instance.scope.on();
+  return () => {
+    instance.scope.off();
+    internalSetCurrentInstance(prev);
+  };
+};
+function isStatefulComponent(instance) {
+  return instance.vnode.shapeFlag & 4;
+}
+var isInSSRComponentSetup = false;
+function getComponentPublicInstance(instance) {
+  if (instance.exposed) {
+    return instance.exposeProxy || (instance.exposeProxy = new Proxy(proxyRefs(markRaw(instance.exposed)), {
+      get(target, key) {
+        if (key in target) {
+          return target[key];
+        } else if (key in publicPropertiesMap) {
+          return publicPropertiesMap[key](instance);
+        }
+      },
+      has(target, key) {
+        return key in target || key in publicPropertiesMap;
+      }
+    }));
+  } else {
+    return instance.proxy;
+  }
+}
+var classifyRE = /(?:^|[-_])(\w)/g;
+var classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, "");
+function getComponentName(Component, includeInferred = true) {
+  return isFunction(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name;
+}
+function formatComponentName(instance, Component, isRoot = false) {
+  let name = getComponentName(Component);
+  if (!name && Component.__file) {
+    const match = Component.__file.match(/([^/\\]+)\.\w+$/);
+    if (match) {
+      name = match[1];
+    }
+  }
+  if (!name && instance && instance.parent) {
+    const inferFromRegistry = (registry) => {
+      for (const key in registry) {
+        if (registry[key] === Component) {
+          return key;
+        }
+      }
+    };
+    name = inferFromRegistry(instance.components || instance.parent.type.components) || inferFromRegistry(instance.appContext.components);
+  }
+  return name ? classify(name) : isRoot ? `App` : `Anonymous`;
+}
+function isClassComponent(value) {
+  return isFunction(value) && "__vccOpts" in value;
+}
+function initCustomFormatter() {
+  if (typeof window === "undefined") {
+    return;
+  }
+  const vueStyle = { style: "color:#3ba776" };
+  const numberStyle = { style: "color:#1677ff" };
+  const stringStyle = { style: "color:#f5222d" };
+  const keywordStyle = { style: "color:#eb2f96" };
+  const formatter = {
+    __vue_custom_formatter: true,
+    header(obj) {
+      if (!isObject(obj)) {
+        return null;
+      }
+      if (obj.__isVue) {
+        return ["div", vueStyle, `VueInstance`];
+      } else if (isRef(obj)) {
+        return [
+          "div",
+          {},
+          ["span", vueStyle, genRefFlag(obj)],
+          "<",
+          formatValue("_value" in obj ? obj._value : obj),
+          `>`
+        ];
+      } else if (isReactive(obj)) {
+        return [
+          "div",
+          {},
+          ["span", vueStyle, isShallow(obj) ? "ShallowReactive" : "Reactive"],
+          "<",
+          formatValue(obj),
+          `>${isReadonly(obj) ? ` (readonly)` : ``}`
+        ];
+      } else if (isReadonly(obj)) {
+        return [
+          "div",
+          {},
+          ["span", vueStyle, isShallow(obj) ? "ShallowReadonly" : "Readonly"],
+          "<",
+          formatValue(obj),
+          ">"
+        ];
+      }
+      return null;
+    },
+    hasBody(obj) {
+      return obj && obj.__isVue;
+    },
+    body(obj) {
+      if (obj && obj.__isVue) {
+        return [
+          "div",
+          {},
+          ...formatInstance(obj.$)
+        ];
+      }
+    }
+  };
+  function formatInstance(instance) {
+    const blocks = [];
+    if (instance.type.props && instance.props) {
+      blocks.push(createInstanceBlock("props", toRaw(instance.props)));
+    }
+    if (instance.setupState !== EMPTY_OBJ) {
+      blocks.push(createInstanceBlock("setup", instance.setupState));
+    }
+    if (instance.data !== EMPTY_OBJ) {
+      blocks.push(createInstanceBlock("data", toRaw(instance.data)));
+    }
+    const computed2 = extractKeys(instance, "computed");
+    if (computed2) {
+      blocks.push(createInstanceBlock("computed", computed2));
+    }
+    const injected = extractKeys(instance, "inject");
+    if (injected) {
+      blocks.push(createInstanceBlock("injected", injected));
+    }
+    blocks.push([
+      "div",
+      {},
+      [
+        "span",
+        {
+          style: keywordStyle.style + ";opacity:0.66"
+        },
+        "$ (internal): "
+      ],
+      ["object", { object: instance }]
+    ]);
+    return blocks;
+  }
+  function createInstanceBlock(type, target) {
+    target = extend({}, target);
+    if (!Object.keys(target).length) {
+      return ["span", {}];
+    }
+    return [
+      "div",
+      { style: "line-height:1.25em;margin-bottom:0.6em" },
+      [
+        "div",
+        {
+          style: "color:#476582"
+        },
+        type
+      ],
+      [
+        "div",
+        {
+          style: "padding-left:1.25em"
+        },
+        ...Object.keys(target).map((key) => {
+          return [
+            "div",
+            {},
+            ["span", keywordStyle, key + ": "],
+            formatValue(target[key], false)
+          ];
+        })
+      ]
+    ];
+  }
+  function formatValue(v, asRaw = true) {
+    if (typeof v === "number") {
+      return ["span", numberStyle, v];
+    } else if (typeof v === "string") {
+      return ["span", stringStyle, JSON.stringify(v)];
+    } else if (typeof v === "boolean") {
+      return ["span", keywordStyle, v];
+    } else if (isObject(v)) {
+      return ["object", { object: asRaw ? toRaw(v) : v }];
+    } else {
+      return ["span", stringStyle, String(v)];
+    }
+  }
+  function extractKeys(instance, type) {
+    const Comp = instance.type;
+    if (isFunction(Comp)) {
+      return;
+    }
+    const extracted = {};
+    for (const key in instance.ctx) {
+      if (isKeyOfType(Comp, key, type)) {
+        extracted[key] = instance.ctx[key];
+      }
+    }
+    return extracted;
+  }
+  function isKeyOfType(Comp, key, type) {
+    const opts = Comp[type];
+    if (isArray(opts) && opts.includes(key) || isObject(opts) && key in opts) {
+      return true;
+    }
+    if (Comp.extends && isKeyOfType(Comp.extends, key, type)) {
+      return true;
+    }
+    if (Comp.mixins && Comp.mixins.some((m) => isKeyOfType(m, key, type))) {
+      return true;
+    }
+  }
+  function genRefFlag(v) {
+    if (isShallow(v)) {
+      return `ShallowRef`;
+    }
+    if (v.effect) {
+      return `ComputedRef`;
+    }
+    return `Ref`;
+  }
+  if (window.devtoolsFormatters) {
+    window.devtoolsFormatters.push(formatter);
+  } else {
+    window.devtoolsFormatters = [formatter];
+  }
+}
+
+// node_modules/vue/dist/vue.runtime.esm-bundler.js
+function initDev() {
+  {
+    initCustomFormatter();
+  }
+}
+if (true) {
+  initDev();
+}
+
+// src/decorator/dto/arrayProxy.ts
+var arrayProxy_default = {
+  deleteProperty(target, key) {
+    Reflect.deleteProperty(target, key);
+    if (ignored(target, key)) {
+      return true;
+    }
+    const dto = target[PARENT];
+    dto && triggerDto_default(dto, target[PARENT_KEY], dto[target[PARENT_KEY]]);
+    dto && markDtoDirty_default(dto, target[PARENT_KEY]);
+    return true;
+  },
+  get(target, key, receiver) {
+    if (key === PROXY) {
+      return true;
+    }
+    if (ignored(target, key)) {
+      return Reflect.get(target, key, receiver);
+    }
+    const dto = target[PARENT];
+    dto && trackDto(dto, target[PARENT_KEY]);
+    return Reflect.get(target, key);
+  },
+  set(target, key, value, receiver) {
+    if (ignored(target, key)) {
+      return Reflect.set(target, key, value, receiver);
+    }
+    const dto = target[PARENT];
+    dto && triggerDto_default(dto, target[PARENT_KEY], dto[target[PARENT_KEY]]);
+    dto && markDtoDirty_default(dto, target[PARENT_KEY]);
+    return Reflect.set(target, key, value);
+  }
+};
+function ignored(target, key) {
+  return typeof key === "symbol" || typeof target[key] === "function" || key === "length";
+}
+
+// src/decorator/dto/instanceProxy.ts
+var instanceProxy_default = {
+  get(target, key, receiver) {
+    if (key === PROXY) {
+      return true;
+    }
+    if (typeof key === "symbol") {
+      return Reflect.get(target, key, receiver);
+    }
+    const descriptor = target[DESCRIPTORS][key];
+    if (!descriptor || !descriptor.get) {
+      return Reflect.get(target, key, receiver);
+    }
+    const value = descriptor.get.call(target);
+    ENABLE_GET_LOGGING && console.log(`%c@dto %c${target[NAME]} %cget`, "color: #0891b2", "color: #059669", "color: #1d4ed8", key);
+    trackDto(target, key);
+    relateValueTo_default(target, key, value);
+    return value;
+  },
+  getOwnPropertyDescriptor(target, key) {
+    return target[DESCRIPTORS][key];
+  },
+  ownKeys(target) {
+    return target[PROPERTIES];
+  },
+  set(target, key, value, receiver) {
+    if (typeof key === "symbol") {
+      return Reflect.set(target, key, value, receiver);
+    }
+    const descriptor = target[DESCRIPTORS][key];
+    if (!descriptor || !descriptor.set) {
+      return Reflect.set(target, key, value, receiver);
+    }
+    const oldValue = descriptor.get?.call(target) ?? undefined;
+    if (areEqual_default(value, oldValue)) {
+      return true;
+    }
+    unrelateValueFrom_default(target, oldValue);
+    if (Array.isArray(value) && !value[PROXY]) {
+      value = new Proxy(value, arrayProxy_default);
+    }
+    ENABLE_SET_LOGGING && console.log(`%c@dto %c${target[NAME]} %cset`, "color: #0891b2", "color: #059669", "color: #1d4ed8", key, { value });
+    descriptor.set.call(target, value);
+    relateValueTo_default(target, key, value);
+    markDtoDirty_default(target, key);
+    triggerDto_default(target, key, value, oldValue);
+    return true;
+  }
+};
+
+// src/decorator/dto/refProxy.ts
+var refProxy_default = {
+  get(target, key, receiver) {
+    if (key === "__v_isRef") {
+      return false;
+    }
+    if (key === PROXY) {
+      return true;
+    }
+    if (key in target) {
+      return Reflect.get(target, key, receiver);
+    }
+    return Reflect.get(target.value, key);
+  },
+  getOwnPropertyDescriptor(target, key) {
+    return Reflect.getOwnPropertyDescriptor(target.value, key);
+  },
+  ownKeys(target) {
+    return Reflect.ownKeys(target.value);
+  },
+  set(target, key, value, receiver) {
+    if (key in target) {
+      return Reflect.set(target, key, value, receiver);
+    }
+    return Reflect.set(target.value, key, value);
+  }
+};
+
+// src/decorator/dto/classProxy.ts
+var classProxy_default = {
+  construct(target, argsArray, newTarget) {
+    argsArray = argsArray.map((arg) => {
+      if (!Array.isArray(arg)) {
+        return arg;
+      }
+      return new Proxy(arg, arrayProxy_default);
+    });
+    const ref2 = customRef((track2, trigger2) => {
+      const instance = markRaw(Reflect.construct(target, argsArray, newTarget));
+      instance[ARGS] = argsArray;
+      instance[DIRTY] = false;
+      instance[TRACK] = track2;
+      instance[TRIGGER] = trigger2;
+      const proxied = new Proxy(instance, instanceProxy_default);
+      return {
+        get: () => {
+          track2();
+          return proxied;
+        },
+        set: () => {
+          return;
+        }
+      };
+    });
+    return new Proxy(ref2, refProxy_default);
+  }
+};
+
+// src/decorator/dto/clone.ts
+function clone_default() {
+  const instance = this;
+  assertDto_default(instance);
+  const clazz = DTO_CLASS_MAP[instance[NAME]];
+  const clone = new clazz(...instance[ARGS]);
+  Object.entries(this[DESCRIPTORS]).filter(([, descriptor]) => !!descriptor.set).map(([name]) => name).forEach((key) => clone[key] = isDto_default(this[key]) ? this[key].clone() : this[key]);
+  return clone;
+}
+
+// src/decorator/dto/fill.ts
+function fill_default(data) {
+  for (let key in data) {
+    const descriptor = this[DESCRIPTORS][key];
+    if (isDto_default(this[key]) && typeof data[key] === "object") {
+      this[key].fill(data[key]);
+    } else if (descriptor && descriptor.set) {
+      this[key] = data[key];
+    }
+  }
+}
+
+// src/decorator/dto/toJSON.ts
+function toJSON_default() {
+  return Object.fromEntries(this[PROPERTIES].map((property) => {
+    let value = Reflect.get.call(this, this, property, this);
+    if (isDto_default(value)) {
+      value = value.toJSON();
+    }
+    return [property, value];
+  }));
+}
+
+// src/decorator/dto/index.ts
+function dto_default(clazz) {
+  validate(clazz);
+  const descriptors = Object.freeze(getPrototypeChain_default(clazz));
+  const properties = Object.keys(descriptors);
+  setObjectValue_default(clazz.prototype, DESCRIPTORS, descriptors);
+  setObjectValue_default(clazz.prototype, NAME, clazz.name);
+  setObjectValue_default(clazz.prototype, PROPERTIES, properties);
+  setObjectValue_default(clazz, Symbol.hasInstance, (instance) => typeof instance === "object" && instance?.[NAME] === clazz.name);
+  setObjectMethod_default(clazz, "clone", clone_default);
+  setObjectMethod_default(clazz, "fill", fill_default);
+  setObjectMethod_default(clazz, "toJSON", toJSON_default);
+  return proxy(clazz);
+}
+function proxy(clazz) {
+  const proxied = new Proxy(clazz, classProxy_default);
+  DTO_CLASS_MAP[clazz.name] = proxied;
+  return proxied;
+}
+function validate(clazz) {
+  const parent = Object.getPrototypeOf(clazz.prototype);
+  if (NAME in parent) {
+    throw new Error(`⛔️ @dto ${clazz.name} cannot extend parent class which is also decorated with @dto ${parent[NAME]}.`);
+  }
+}
+if (OVERRIDE_CONSOLE_LOG) {
+  const _error = console.error.bind(console);
+  const _info = console.info.bind(console);
+  const _log = console.log.bind(console);
+  const _warn = console.warn.bind(console);
+  const override = (fn) => (...args) => {
+    for (let i = args.length - 1;i >= 0; --i) {
+      const arg = args[i];
+      if (!isDto_default(arg)) {
+        continue;
+      }
+      const dto = instance_default(arg);
+      args.splice(i, 1, `\uD83D\uDCE6 ${dto[NAME]}`, dto.toJSON());
+    }
+    return fn(...args);
+  };
+  console.error = override(_error);
+  console.info = override(_info);
+  console.log = override(_log);
+  console.warn = override(_warn);
+}
+// src/decorator/dto/serialize/deserializeArray.ts
+function deserializeArray_default(obj) {
+  return obj.map(deserializeUnknown_default);
+}
+
+// src/decorator/dto/serialize/deserializeDateTime.ts
+import { DateTime } from "luxon";
+function deserializeDateTime_default([, iso]) {
+  return DateTime.fromISO(iso);
+}
+
+// src/decorator/dto/serialize/deserializeObject.ts
+function deserializeObject_default(obj) {
+  return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, deserializeUnknown_default(value)]).filter(([, value]) => value !== undefined));
+}
+
+// src/decorator/dto/serialize/deserializeDto.ts
+var CACHE = {};
+function deserializeDto_default([, id, name, state, args]) {
+  if (!(name in DTO_CLASS_MAP)) {
+    throw new Error(`[@marveld/http] Cannot restore @dto. Dto ${name} was not found.`);
+  }
+  if (id in CACHE) {
+    return CACHE[id];
+  }
+  ENABLE_SERIALIZATION_LOGGING && console.group("⭐️", name, id);
+  const Dto = DTO_CLASS_MAP[name];
+  const instance = new Dto(...deserializeArray_default(args));
+  instance.fill(deserializeObject_default(state));
+  ENABLE_SERIALIZATION_LOGGING && console.groupEnd();
+  CACHE[id] = instance;
+  return instance;
+}
+
+// src/decorator/dto/serialize/isSerializedDateTime.ts
+function isSerializedDateTime_default(obj) {
+  return Array.isArray(obj) && obj[0] === 3058;
+}
+
+// src/decorator/dto/serialize/isSerializedDto.ts
+function isSerializedDto_default(obj) {
+  return Array.isArray(obj) && obj[0] === 3057;
+}
+
+// src/decorator/dto/serialize/deserializeUnknown.ts
+function deserializeUnknown_default(obj) {
+  switch (true) {
+    case obj === null:
+      return null;
+    case Array.isArray(obj):
+      switch (true) {
+        case isSerializedDateTime_default(obj):
+          return deserializeDateTime_default(obj);
+        case isSerializedDto_default(obj):
+          return deserializeDto_default(obj);
+        default:
+          return deserializeArray_default(obj);
+      }
+    case typeof obj === "object":
+      return deserializeObject_default(obj);
+    default:
+      return obj;
+  }
+}
+
+// src/decorator/dto/serialize/deserialize.ts
+function deserialize_default(serialized) {
+  return deserializeUnknown_default(JSON.parse(serialized));
+}
+
+// src/decorator/dto/serialize/serializeUnknown.ts
+import { DateTime as DateTime3 } from "luxon";
+
+// src/decorator/dto/serialize/serializeArray.ts
+import { DateTime as DateTime2 } from "luxon";
+
+// src/decorator/dto/serialize/serializeDateTime.ts
+function serializeDateTime_default(obj) {
+  return [3058, obj.toISO({
+    extendedZone: true,
+    includeOffset: true
+  })];
+}
+
+// src/decorator/dto/serialize/serializeObject.ts
+function serializeObject_default(obj) {
+  return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, serializeUnknown_default(value)]).filter(([, value]) => value !== undefined));
+}
+
+// src/decorator/dto/serialize/uuid.ts
+function uuid_default() {
+  return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, (c) => (+c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> +c / 4).toString(16));
+}
+
+// src/decorator/dto/serialize/serializeDto.ts
+function serializeDto_default(obj) {
+  obj = toRaw(obj);
+  const json = obj.toJSON();
+  return [
+    3057,
+    uuid_default(),
+    obj[NAME],
+    serializeObject_default(json),
+    serializeArray_default(obj[ARGS])
+  ];
+}
+
+// src/decorator/dto/serialize/serializeArray.ts
+function serializeArray_default(obj) {
+  switch (true) {
+    case obj.every(isDto_default):
+      return obj.map(serializeDto_default);
+    case obj.every(DateTime2.isDateTime):
+      return obj.map(serializeDateTime_default);
+    default:
+      return obj.map(serializeUnknown_default);
+  }
+}
+
+// src/decorator/dto/serialize/serializeUnknown.ts
+function serializeUnknown_default(obj) {
+  switch (true) {
+    case obj === null:
+      return null;
+    case Array.isArray(obj):
+      return serializeArray_default(obj);
+    case isDto_default(obj):
+      return serializeDto_default(obj);
+    case DateTime3.isDateTime(obj):
+      return serializeDateTime_default(obj);
+    case typeof obj === "object":
+      return serializeObject_default(obj);
+    case typeof obj === "boolean":
+    case typeof obj === "number":
+    case typeof obj === "string":
+      return obj;
+    default:
+      return;
+  }
+}
+
+// src/decorator/dto/serialize/serialize.ts
+function serialize_default(obj) {
+  return JSON.stringify(serializeUnknown_default(obj));
+}
+// src/dto/BlobResponse.ts
+class BlobResponse {
+  get blob() {
+    return this.#blob;
+  }
+  get name() {
+    return this.#name;
+  }
+  #blob;
+  #name;
+  constructor(blob, name) {
+    this.#blob = blob;
+    this.#name = name;
+  }
+}
+BlobResponse = __legacyDecorateClassTS([
+  dto_default
+], BlobResponse);
+// src/dto/Paginated.ts
+class Paginated {
+  get items() {
+    return this.#items;
+  }
+  get page() {
+    return this.#page;
+  }
+  get pageSize() {
+    return this.#pageSize;
+  }
+  get pages() {
+    return this.#pages;
+  }
+  get totalItems() {
+    return this.#totalItems;
+  }
+  #items;
+  #page;
+  #pageSize;
+  #pages;
+  #totalItems;
+  constructor(items, page, pageSize, pages, totalItems) {
+    this.#items = items;
+    this.#page = page;
+    this.#pageSize = pageSize;
+    this.#pages = pages;
+    this.#totalItems = totalItems;
+  }
+}
+Paginated = __legacyDecorateClassTS([
+  dto_default
+], Paginated);
+// src/adapter/HttpAdapter.ts
+class HttpAdapter {
+  static parsePaginatedAdapter(response, adapterMethod) {
+    return new Paginated(response["items"].map(adapterMethod), response["page"], response["page_size"], response["pages"], response["total_items"]);
+  }
+  static parseFileNameFromContentDispositionHeader(header) {
+    const defaultFilename = `download-${DateTime4.now().toFormat("yyyy-MM-dd HH-mm-ss")}`;
+    if (!header.startsWith("attachment")) {
+      return defaultFilename;
+    }
+    const filenameRegex = /filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/;
+    const matches = filenameRegex.exec(header);
+    if ((matches?.length || 0) < 2) {
+      return defaultFilename;
+    }
+    return matches[1].replaceAll("'", "").replaceAll('"', "").replaceAll("/", "-").replaceAll(":", "-");
+  }
+}
+HttpAdapter = __legacyDecorateClassTS([
+  adapter_default
+], HttpAdapter);
+// src/http/BaseResponse.ts
+class BaseResponse {
+  get data() {
+    return this.#data;
+  }
+  get headers() {
+    return this.#response.headers;
+  }
+  get ok() {
+    return this.statusCode >= 200 && this.statusCode < 300;
+  }
+  get response() {
+    return this.#response;
+  }
+  get statusCode() {
+    return this.#response.status;
+  }
+  #data;
+  #response;
+  constructor(data, response) {
+    this.#data = data;
+    this.#response = response;
+  }
+}
+
+// src/http/RequestBuilder.ts
+import { DateTime as DateTime5 } from "luxon";
+
+// src/http/HttpClient.ts
+class HttpClient {
+  get authToken() {
+    return this.#authToken;
+  }
+  set authToken(value) {
+    this.#authToken = value;
+  }
+  get baseUrl() {
+    return this.#baseUrl;
+  }
+  get dataField() {
+    return this.#dataField;
+  }
+  #authToken;
+  #baseUrl;
+  #dataField;
+  constructor(authToken, baseUrl, dataField = false) {
+    this.#authToken = authToken;
+    this.#baseUrl = baseUrl;
+    this.#dataField = dataField;
+  }
+  static get instance() {
+    if (HttpClient.#instance === null) {
+      throw new Error("There is currently no HttpClient instance registered. Register one using the HttpClient.register() function.");
+    }
+    return HttpClient.#instance;
+  }
+  static #instance = null;
+  static register(client) {
+    HttpClient.#instance = client;
+  }
+}
+
+// src/http/RequestError.ts
+class RequestError {
+  get code() {
+    return this.#code;
+  }
+  get error() {
+    return this.#error;
+  }
+  get errorDescription() {
+    return this.#errorDescription;
+  }
+  get statusCode() {
+    return this.#statusCode;
+  }
+  #code;
+  #error;
+  #errorDescription;
+  #statusCode;
+  constructor(code, error, errorDescription, statusCode) {
+    this.#code = code;
+    this.#error = error;
+    this.#errorDescription = errorDescription;
+    this.#statusCode = statusCode;
+  }
+}
+RequestError = __legacyDecorateClassTS([
+  dto_default
+], RequestError);
+
+// src/http/RequestBuilder.ts
+class RequestBuilder {
+  get client() {
+    return this.#client;
+  }
+  get options() {
+    return this.#options;
+  }
+  get path() {
+    return this.#path;
+  }
+  set path(value) {
+    this.#path = value;
+  }
+  get query() {
+    return this.#query;
+  }
+  set query(value) {
+    this.#query = value;
+  }
+  #client;
+  #path;
+  #options = {};
+  #query = null;
+  constructor(path, client) {
+    this.#client = client ?? HttpClient.instance;
+    this.#options.cache = "no-cache";
+    this.#options.method = "GET";
+    this.#path = path;
+  }
+  bearerToken(token) {
+    token = token ?? this.#client.authToken;
+    if (token) {
+      return this.header("Authorization", `Bearer ${token}`);
+    }
+    if (this.#options.headers && "Authorization" in this.#options.headers) {
+      delete this.#options.headers["Authorization"];
+    }
+    return this;
+  }
+  body(body, contentType = "application/octet-stream") {
+    if (body instanceof FormData) {
+      contentType = null;
+    } else if (Array.isArray(body) || typeof body === "object") {
+      body = JSON.stringify(body);
+      contentType = "application/json";
+    }
+    this.#options.body = body;
+    if (contentType !== null) {
+      return this.header("Content-Type", contentType);
+    }
+    return this;
+  }
+  header(name, value) {
+    this.#options.headers = this.#options.headers || {};
+    this.#options.headers[name] = value;
+    return this;
+  }
+  method(method) {
+    this.#options.method = method.toUpperCase();
+    return this;
+  }
+  queryString(queryString) {
+    this.#query = queryString;
+    return this;
+  }
+  async fetch() {
+    return this.#execute().then((r) => r.json());
+  }
+  async fetchBlob() {
+    let response = await this.#execute();
+    if (response.status !== 200) {
+      const data = await response.json();
+      if ("code" in data && "error" in data && "error_description" in data) {
+        throw new RequestError(data.code, data.error, data.error_description, response.status);
+      }
+      throw new RequestError(-1, "failed_without_info", "Request failed without any information from the backend.", response.status);
+    }
+    let filename = response.headers.has("content-disposition") ? HttpAdapter.parseFileNameFromContentDispositionHeader(response.headers.get("content-disposition")) : `download-${DateTime5.now().toFormat("yyyy-MM-dd HH-mm-ss")}`;
+    return new BlobResponse(await response.blob(), filename);
+  }
+  async run() {
+    const { data, response } = await this.#executeSafe();
+    return new BaseResponse(data, response);
+  }
+  async runAdapter(adapterMethod) {
+    const { data, response } = await this.#executeSafe();
+    return new BaseResponse(adapterMethod(data), response);
+  }
+  async runArrayAdapter(adapterMethod) {
+    return this.runAdapter((data) => data.map(adapterMethod));
+  }
+  async runEmpty() {
+    return await this.#executeSafe();
+  }
+  async runPaginatedAdapter(adapterMethod) {
+    return this.runAdapter((response) => HttpAdapter.parsePaginatedAdapter(response, adapterMethod));
+  }
+  async runData() {
+    return await this.#executeSafe();
+  }
+  async runDataKey(key) {
+    const { data, response } = await this.#executeSafe();
+    return new BaseResponse(data[key], response);
+  }
+  async runStatusCode() {
+    const response = await this.#executeSafe();
+    return response.statusCode;
+  }
+  async#execute() {
+    let path = this.path;
+    if (this.query !== null) {
+      path += `?${this.query.build()}`;
+    }
+    return await fetch(this.client.baseUrl + path, this.options);
+  }
+  async#executeSafe() {
+    return await this.#execute().then((response) => RequestBuilder.#handleResponse(response, this.client.dataField));
+  }
+  static async#handleResponse(response, dataField) {
+    if (response.status === 204) {
+      return new BaseResponse(null, response);
+    }
+    if (response.headers.has("content-type") && response.headers.get("content-type").startsWith("application/json")) {
+      const data2 = await response.json();
+      if ("code" in data2 && "error" in data2 && "error_description" in data2) {
+        throw new RequestError(data2.code, data2.error, data2.error_description, response.status);
+      }
+      if (dataField && "data" in data2) {
+        return new BaseResponse(data2.data, response);
+      }
+      return new BaseResponse(data2, response);
+    }
+    if (response.status === 401 || response.status === 403) {
+      return new BaseResponse(null, response);
+    }
+    const data = await response.text();
+    if (data.length === 0 && response.status >= 200 && response.status < 300) {
+      return new BaseResponse(null, response);
+    }
+    throw new RequestError(-1, "not_a_json_response", "The response was not a JSON response.", response.status);
+  }
+}
+
+// src/http/BaseService.ts
+class BaseService {
+  request(path, client) {
+    return new RequestBuilder(path, client);
+  }
+}
+
+// src/http/QueryString.ts
+class QueryString {
+  #builder;
+  constructor() {
+    this.#builder = new URLSearchParams;
+  }
+  build() {
+    return this.#builder.toString();
+  }
+  append(name, value) {
+    return this.#add(this.#builder.append.bind(this.#builder), name, value);
+  }
+  appendArray(name, values) {
+    if (values === undefined || values === null) {
+      return this;
+    }
+    values.forEach((value) => this.append(name, value));
+    return this;
+  }
+  delete(name) {
+    this.#builder.delete(name);
+    return this;
+  }
+  get(name) {
+    return this.#builder.get(name);
+  }
+  getAll(name) {
+    return this.#builder.getAll(name);
+  }
+  has(name) {
+    return this.#builder.has(name);
+  }
+  set(name, value) {
+    return this.#add(this.#builder.set.bind(this.#builder), name, value);
+  }
+  #add(fn, name, value) {
+    if (!value && value !== false) {
+      return this;
+    }
+    switch (typeof value) {
+      case "boolean":
+        fn(name, value ? "true" : "false");
+        break;
+      case "number":
+        fn(name, value.toString(10));
+        break;
+      case "string":
+        fn(name, value);
+        break;
+    }
+    return this;
+  }
+  static builder() {
+    return new QueryString;
+  }
+}
+
+// src/http/helpers.ts
+function isRequestError(obj) {
+  return obj instanceof RequestError;
+}
+function isUnsanctionedRequest(statusCode) {
+  if (statusCode instanceof RequestError) {
+    statusCode = statusCode.statusCode;
+  }
+  return statusCode === 403 || statusCode === 401;
+}
+export {
+  serialize_default as serialize,
+  markDtoDirty_default as markDtoDirty,
+  markDtoClean_default as markDtoClean,
+  isUnsanctionedRequest,
+  isRequestError,
+  isDtoDirty_default as isDtoDirty,
+  isDtoClean_default as isDtoClean,
+  isDto_default as isDto,
+  executeIfDtoDirtyAndMarkClean_default as executeIfDtoDirtyAndMarkClean,
+  dto_default as dto,
+  deserialize_default as deserialize,
+  debounce_default as debounce,
+  cloneDto_default as cloneDto,
+  bound_default as bound,
+  assertDto_default as assertDto,
+  adapter_default as adapter,
+  RequestError,
+  RequestBuilder,
+  QueryString,
+  Paginated,
+  HttpClient,
+  HttpAdapter,
+  BlobResponse,
+  BaseService,
+  BaseResponse
+};
+
+//# debugId=F0BB74B8B3687CB464756E2164756E21
 //# sourceMappingURL=http-client.js.map