miqro 7.3.0 → 7.3.2

package/build/lib.cjs

@@ -32,165 +32,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// node_modules/cookie/dist/index.js
-var require_dist = __commonJS({
-  "node_modules/cookie/dist/index.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.parse = parse2;
-    exports2.serialize = serialize2;
-    var cookieNameRegExp = /^[\u0021-\u003A\u003C\u003E-\u007E]+$/;
-    var cookieValueRegExp = /^[\u0021-\u003A\u003C-\u007E]*$/;
-    var domainValueRegExp = /^([.]?[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)([.][a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)*$/i;
-    var pathValueRegExp = /^[\u0020-\u003A\u003D-\u007E]*$/;
-    var __toString = Object.prototype.toString;
-    var NullObject = /* @__PURE__ */ (() => {
-      const C = function() {
-      };
-      C.prototype = /* @__PURE__ */ Object.create(null);
-      return C;
-    })();
-    function parse2(str, options) {
-      const obj = new NullObject();
-      const len = str.length;
-      if (len < 2)
-        return obj;
-      const dec = options?.decode || decode2;
-      let index = 0;
-      do {
-        const eqIdx = str.indexOf("=", index);
-        if (eqIdx === -1)
-          break;
-        const colonIdx = str.indexOf(";", index);
-        const endIdx = colonIdx === -1 ? len : colonIdx;
-        if (eqIdx > endIdx) {
-          index = str.lastIndexOf(";", eqIdx - 1) + 1;
-          continue;
-        }
-        const keyStartIdx = startIndex(str, index, eqIdx);
-        const keyEndIdx = endIndex(str, eqIdx, keyStartIdx);
-        const key = str.slice(keyStartIdx, keyEndIdx);
-        if (obj[key] === void 0) {
-          let valStartIdx = startIndex(str, eqIdx + 1, endIdx);
-          let valEndIdx = endIndex(str, endIdx, valStartIdx);
-          const value = dec(str.slice(valStartIdx, valEndIdx));
-          obj[key] = value;
-        }
-        index = endIdx + 1;
-      } while (index < len);
-      return obj;
-    }
-    function startIndex(str, index, max) {
-      do {
-        const code = str.charCodeAt(index);
-        if (code !== 32 && code !== 9)
-          return index;
-      } while (++index < max);
-      return max;
-    }
-    function endIndex(str, index, min) {
-      while (index > min) {
-        const code = str.charCodeAt(--index);
-        if (code !== 32 && code !== 9)
-          return index + 1;
-      }
-      return min;
-    }
-    function serialize2(name, val, options) {
-      const enc = options?.encode || encodeURIComponent;
-      if (!cookieNameRegExp.test(name)) {
-        throw new TypeError(`argument name is invalid: ${name}`);
-      }
-      const value = enc(val);
-      if (!cookieValueRegExp.test(value)) {
-        throw new TypeError(`argument val is invalid: ${val}`);
-      }
-      let str = name + "=" + value;
-      if (!options)
-        return str;
-      if (options.maxAge !== void 0) {
-        if (!Number.isInteger(options.maxAge)) {
-          throw new TypeError(`option maxAge is invalid: ${options.maxAge}`);
-        }
-        str += "; Max-Age=" + options.maxAge;
-      }
-      if (options.domain) {
-        if (!domainValueRegExp.test(options.domain)) {
-          throw new TypeError(`option domain is invalid: ${options.domain}`);
-        }
-        str += "; Domain=" + options.domain;
-      }
-      if (options.path) {
-        if (!pathValueRegExp.test(options.path)) {
-          throw new TypeError(`option path is invalid: ${options.path}`);
-        }
-        str += "; Path=" + options.path;
-      }
-      if (options.expires) {
-        if (!isDate(options.expires) || !Number.isFinite(options.expires.valueOf())) {
-          throw new TypeError(`option expires is invalid: ${options.expires}`);
-        }
-        str += "; Expires=" + options.expires.toUTCString();
-      }
-      if (options.httpOnly) {
-        str += "; HttpOnly";
-      }
-      if (options.secure) {
-        str += "; Secure";
-      }
-      if (options.partitioned) {
-        str += "; Partitioned";
-      }
-      if (options.priority) {
-        const priority = typeof options.priority === "string" ? options.priority.toLowerCase() : void 0;
-        switch (priority) {
-          case "low":
-            str += "; Priority=Low";
-            break;
-          case "medium":
-            str += "; Priority=Medium";
-            break;
-          case "high":
-            str += "; Priority=High";
-            break;
-          default:
-            throw new TypeError(`option priority is invalid: ${options.priority}`);
-        }
-      }
-      if (options.sameSite) {
-        const sameSite = typeof options.sameSite === "string" ? options.sameSite.toLowerCase() : options.sameSite;
-        switch (sameSite) {
-          case true:
-          case "strict":
-            str += "; SameSite=Strict";
-            break;
-          case "lax":
-            str += "; SameSite=Lax";
-            break;
-          case "none":
-            str += "; SameSite=None";
-            break;
-          default:
-            throw new TypeError(`option sameSite is invalid: ${options.sameSite}`);
-        }
-      }
-      return str;
-    }
-    function decode2(str) {
-      if (str.indexOf("%") === -1)
-        return str;
-      try {
-        return decodeURIComponent(str);
-      } catch (e) {
-        return str;
-      }
-    }
-    function isDate(val) {
-      return __toString.call(val) === "[object Date]";
-    }
-  }
-});
-
 // node_modules/@miqro/parser/build/built-in-parsers.js
 function newParseOptionsError(baseOption, option, name) {
   return new ParseOptionsError(option.usage ? String(option.usage) : `${name ? `${name} ` : ""}not ${baseOption.type}${option.type === "number" && option.numberMin !== void 0 ? `${option.numberMin}:` : ""}${option.type === "number" && option.numberMax !== void 0 ? `:${option.numberMax}` : ""}${option.numberMinDecimals !== void 0 ? ` min decimals[${option.numberMinDecimals}]` : ""}${option.numberMaxDecimals !== void 0 ? ` max decimals[${option.numberMaxDecimals}]` : ""}${option.type === "string" && option.stringMinLength !== void 0 ? `${option.stringMinLength}:` : ""}${option.type === "string" && option.stringMaxLength !== void 0 ? `:${option.stringMaxLength}` : ""}${option.type === "array" && option.arrayMinLength !== void 0 ? `${option.arrayMinLength}:` : ""}${option.type === "array" && option.arrayMaxLength !== void 0 ? `:${option.arrayMaxLength}` : ""}${option.type === "array" && option.arrayType ? option.arrayType !== "enum" ? ` of ${option.arrayType}` : ` of ${option.arrayType} as defined. valid values [${option.enumValues}]` : ""}${option.type === "enum" ? ` as defined. valid values [${option.enumValues}]` : ""}`, name);
@@ -688,103 +529,262 @@ var init_lib = __esm({
   }
 });
 
-// node_modules/@miqro/core/build/middleware/body-parser.js
-function ReadBuffer(options) {
-  let limit = DEFAULT_READ_BUFFER_LIMIT;
-  let timeout = DEFAULT_READ_BUFFER_TIMEOUT;
-  if (options) {
-    limit = options.limit !== void 0 ? options.limit : limit;
-    timeout = options.timeout !== void 0 ? options.timeout : timeout;
-  } else {
-    const [limitS, timeoutS] = checkEnvVariables(["READ_BUFFER_LIMIT", "READ_BUFFER_TIMEOUT"], [String(DEFAULT_READ_BUFFER_LIMIT), String(DEFAULT_READ_BUFFER_TIMEOUT)]);
-    limit = parseInt(limitS, 10);
-    timeout = parseInt(timeoutS, 10);
-  }
-  return async function ReadBuffer3(req, res) {
-    return new Promise((resolve24, reject) => {
-      try {
-        const readTimeout = setTimeout(() => {
-          clearTimeout(readTimeout);
-          req.removeListener("error", errorListener);
-          req.removeListener("data", chunkListener);
-          req.removeListener("end", endListener);
-          reject(new BadRequestError(`Read Timeout`));
-          return;
-        }, timeout);
-        let cLength = 0;
-        const buffers = [];
-        const endListener = () => {
-          clearTimeout(readTimeout);
-          req.removeListener("error", errorListener);
-          req.removeListener("data", chunkListener);
-          req.removeListener("end", endListener);
-          try {
-            const concatBuffers = Buffer.concat(buffers);
-            const responseBuffer = req.headers["content-encoding"] === "gzip" ? (0, import_zlib.gunzipSync)(concatBuffers) : concatBuffers;
-            req.logger.trace("ctx.buffer %o", responseBuffer);
-            req.buffer = responseBuffer;
-            resolve24();
-          } catch (e) {
-            reject(e);
-          }
-        };
-        const errorListener = (err) => {
-          clearTimeout(readTimeout);
-          req.removeListener("error", errorListener);
-          req.removeListener("data", chunkListener);
-          req.removeListener("end", endListener);
-          reject(err);
-        };
-        const chunkListener = (chunk) => {
-          cLength += chunk.length;
-          if (cLength > limit) {
-            clearTimeout(readTimeout);
-            req.removeListener("error", errorListener);
-            req.removeListener("data", chunkListener);
-            req.removeListener("end", endListener);
-            req.logger.error(`ctx.buffer.length ${cLength} > ${limit}. To accept this body set READ_BUFFER_LIMIT to a higher value.`);
-            reject(new BadRequestError(`buffer.length ${cLength} > ${limit}`));
-            return;
-          }
-          buffers.push(chunk);
-        };
-        req.on("error", errorListener);
-        req.on("data", chunkListener);
-        req.on("end", endListener);
-      } catch (e) {
-        reject(e);
-      }
-    });
-  };
-}
-function URLEncodedParser(options) {
-  let maxKeys = DEFAULT_FORM_MAX_KEYS;
-  let limit = DEFAULT_READ_BUFFER_LIMIT;
-  let type = "application/x-www-form-urlencoded";
-  if (options) {
-    limit = options.limit !== void 0 ? options.limit : limit;
-    type = options.type !== void 0 ? options.type : type;
-    maxKeys = options.maxKeys !== void 0 ? options.maxKeys : maxKeys;
-  } else {
-    const [limitS, typeS, maxKeysS] = checkEnvVariables(["BODY_PARSER_URL_ENCODED_LIMIT", "BODY_PARSER_URL_ENCODED_TYPE", "BODY_PARSER_URL_ENCODED_MAX_KEYS"], [String(DEFAULT_READ_BUFFER_LIMIT), "application/x-www-form-urlencoded", String(DEFAULT_FORM_MAX_KEYS)]);
-    limit = parseInt(limitS, 10);
-    type = typeS;
-    maxKeys = maxKeysS !== "undefined" ? parseInt(maxKeysS, 10) : DEFAULT_FORM_MAX_KEYS;
-  }
-  const readBuffer = ReadBuffer({
-    limit
-  });
-  return async function URLEncodedParser3(req, res) {
-    try {
-      const isType = req.body === void 0 && req.headers["content-type"] ? req.headers["content-type"].toLocaleLowerCase().indexOf(type.toLocaleLowerCase()) !== -1 : false;
-      if (isType && !req.buffer) {
-        await readBuffer(req, res);
-      }
-      if (isType && req.buffer && req.buffer.length <= limit) {
-        const string = req.buffer.toString();
-        if (string) {
-          const body = {
-            ...(0, import_querystring.parse)(string, void 0, void 0, {
+// node_modules/cookie/dist/index.js
+var require_dist = __commonJS({
+  "node_modules/cookie/dist/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.parse = parse2;
+    exports2.serialize = serialize2;
+    var cookieNameRegExp = /^[\u0021-\u003A\u003C\u003E-\u007E]+$/;
+    var cookieValueRegExp = /^[\u0021-\u003A\u003C-\u007E]*$/;
+    var domainValueRegExp = /^([.]?[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)([.][a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)*$/i;
+    var pathValueRegExp = /^[\u0020-\u003A\u003D-\u007E]*$/;
+    var __toString = Object.prototype.toString;
+    var NullObject = /* @__PURE__ */ (() => {
+      const C = function() {
+      };
+      C.prototype = /* @__PURE__ */ Object.create(null);
+      return C;
+    })();
+    function parse2(str, options) {
+      const obj = new NullObject();
+      const len = str.length;
+      if (len < 2)
+        return obj;
+      const dec = options?.decode || decode2;
+      let index = 0;
+      do {
+        const eqIdx = str.indexOf("=", index);
+        if (eqIdx === -1)
+          break;
+        const colonIdx = str.indexOf(";", index);
+        const endIdx = colonIdx === -1 ? len : colonIdx;
+        if (eqIdx > endIdx) {
+          index = str.lastIndexOf(";", eqIdx - 1) + 1;
+          continue;
+        }
+        const keyStartIdx = startIndex(str, index, eqIdx);
+        const keyEndIdx = endIndex(str, eqIdx, keyStartIdx);
+        const key = str.slice(keyStartIdx, keyEndIdx);
+        if (obj[key] === void 0) {
+          let valStartIdx = startIndex(str, eqIdx + 1, endIdx);
+          let valEndIdx = endIndex(str, endIdx, valStartIdx);
+          const value = dec(str.slice(valStartIdx, valEndIdx));
+          obj[key] = value;
+        }
+        index = endIdx + 1;
+      } while (index < len);
+      return obj;
+    }
+    function startIndex(str, index, max) {
+      do {
+        const code = str.charCodeAt(index);
+        if (code !== 32 && code !== 9)
+          return index;
+      } while (++index < max);
+      return max;
+    }
+    function endIndex(str, index, min) {
+      while (index > min) {
+        const code = str.charCodeAt(--index);
+        if (code !== 32 && code !== 9)
+          return index + 1;
+      }
+      return min;
+    }
+    function serialize2(name, val, options) {
+      const enc = options?.encode || encodeURIComponent;
+      if (!cookieNameRegExp.test(name)) {
+        throw new TypeError(`argument name is invalid: ${name}`);
+      }
+      const value = enc(val);
+      if (!cookieValueRegExp.test(value)) {
+        throw new TypeError(`argument val is invalid: ${val}`);
+      }
+      let str = name + "=" + value;
+      if (!options)
+        return str;
+      if (options.maxAge !== void 0) {
+        if (!Number.isInteger(options.maxAge)) {
+          throw new TypeError(`option maxAge is invalid: ${options.maxAge}`);
+        }
+        str += "; Max-Age=" + options.maxAge;
+      }
+      if (options.domain) {
+        if (!domainValueRegExp.test(options.domain)) {
+          throw new TypeError(`option domain is invalid: ${options.domain}`);
+        }
+        str += "; Domain=" + options.domain;
+      }
+      if (options.path) {
+        if (!pathValueRegExp.test(options.path)) {
+          throw new TypeError(`option path is invalid: ${options.path}`);
+        }
+        str += "; Path=" + options.path;
+      }
+      if (options.expires) {
+        if (!isDate(options.expires) || !Number.isFinite(options.expires.valueOf())) {
+          throw new TypeError(`option expires is invalid: ${options.expires}`);
+        }
+        str += "; Expires=" + options.expires.toUTCString();
+      }
+      if (options.httpOnly) {
+        str += "; HttpOnly";
+      }
+      if (options.secure) {
+        str += "; Secure";
+      }
+      if (options.partitioned) {
+        str += "; Partitioned";
+      }
+      if (options.priority) {
+        const priority = typeof options.priority === "string" ? options.priority.toLowerCase() : void 0;
+        switch (priority) {
+          case "low":
+            str += "; Priority=Low";
+            break;
+          case "medium":
+            str += "; Priority=Medium";
+            break;
+          case "high":
+            str += "; Priority=High";
+            break;
+          default:
+            throw new TypeError(`option priority is invalid: ${options.priority}`);
+        }
+      }
+      if (options.sameSite) {
+        const sameSite = typeof options.sameSite === "string" ? options.sameSite.toLowerCase() : options.sameSite;
+        switch (sameSite) {
+          case true:
+          case "strict":
+            str += "; SameSite=Strict";
+            break;
+          case "lax":
+            str += "; SameSite=Lax";
+            break;
+          case "none":
+            str += "; SameSite=None";
+            break;
+          default:
+            throw new TypeError(`option sameSite is invalid: ${options.sameSite}`);
+        }
+      }
+      return str;
+    }
+    function decode2(str) {
+      if (str.indexOf("%") === -1)
+        return str;
+      try {
+        return decodeURIComponent(str);
+      } catch (e) {
+        return str;
+      }
+    }
+    function isDate(val) {
+      return __toString.call(val) === "[object Date]";
+    }
+  }
+});
+
+// node_modules/@miqro/core/build/middleware/body-parser.js
+function ReadBuffer(options) {
+  let limit = DEFAULT_READ_BUFFER_LIMIT;
+  let timeout = DEFAULT_READ_BUFFER_TIMEOUT;
+  if (options) {
+    limit = options.limit !== void 0 ? options.limit : limit;
+    timeout = options.timeout !== void 0 ? options.timeout : timeout;
+  } else {
+    const [limitS, timeoutS] = checkEnvVariables(["READ_BUFFER_LIMIT", "READ_BUFFER_TIMEOUT"], [String(DEFAULT_READ_BUFFER_LIMIT), String(DEFAULT_READ_BUFFER_TIMEOUT)]);
+    limit = parseInt(limitS, 10);
+    timeout = parseInt(timeoutS, 10);
+  }
+  return async function ReadBuffer3(req, res) {
+    return new Promise((resolve24, reject) => {
+      try {
+        const readTimeout = setTimeout(() => {
+          clearTimeout(readTimeout);
+          req.removeListener("error", errorListener);
+          req.removeListener("data", chunkListener);
+          req.removeListener("end", endListener);
+          reject(new BadRequestError(`Read Timeout`));
+          return;
+        }, timeout);
+        let cLength = 0;
+        const buffers = [];
+        const endListener = () => {
+          clearTimeout(readTimeout);
+          req.removeListener("error", errorListener);
+          req.removeListener("data", chunkListener);
+          req.removeListener("end", endListener);
+          try {
+            const concatBuffers = Buffer.concat(buffers);
+            const responseBuffer = req.headers["content-encoding"] === "gzip" ? (0, import_zlib.gunzipSync)(concatBuffers) : concatBuffers;
+            req.logger.trace("ctx.buffer %o", responseBuffer);
+            req.buffer = responseBuffer;
+            resolve24();
+          } catch (e) {
+            reject(e);
+          }
+        };
+        const errorListener = (err) => {
+          clearTimeout(readTimeout);
+          req.removeListener("error", errorListener);
+          req.removeListener("data", chunkListener);
+          req.removeListener("end", endListener);
+          reject(err);
+        };
+        const chunkListener = (chunk) => {
+          cLength += chunk.length;
+          if (cLength > limit) {
+            clearTimeout(readTimeout);
+            req.removeListener("error", errorListener);
+            req.removeListener("data", chunkListener);
+            req.removeListener("end", endListener);
+            req.logger.error(`ctx.buffer.length ${cLength} > ${limit}. To accept this body set READ_BUFFER_LIMIT to a higher value.`);
+            reject(new BadRequestError(`buffer.length ${cLength} > ${limit}`));
+            return;
+          }
+          buffers.push(chunk);
+        };
+        req.on("error", errorListener);
+        req.on("data", chunkListener);
+        req.on("end", endListener);
+      } catch (e) {
+        reject(e);
+      }
+    });
+  };
+}
+function URLEncodedParser(options) {
+  let maxKeys = DEFAULT_FORM_MAX_KEYS;
+  let limit = DEFAULT_READ_BUFFER_LIMIT;
+  let type = "application/x-www-form-urlencoded";
+  if (options) {
+    limit = options.limit !== void 0 ? options.limit : limit;
+    type = options.type !== void 0 ? options.type : type;
+    maxKeys = options.maxKeys !== void 0 ? options.maxKeys : maxKeys;
+  } else {
+    const [limitS, typeS, maxKeysS] = checkEnvVariables(["BODY_PARSER_URL_ENCODED_LIMIT", "BODY_PARSER_URL_ENCODED_TYPE", "BODY_PARSER_URL_ENCODED_MAX_KEYS"], [String(DEFAULT_READ_BUFFER_LIMIT), "application/x-www-form-urlencoded", String(DEFAULT_FORM_MAX_KEYS)]);
+    limit = parseInt(limitS, 10);
+    type = typeS;
+    maxKeys = maxKeysS !== "undefined" ? parseInt(maxKeysS, 10) : DEFAULT_FORM_MAX_KEYS;
+  }
+  const readBuffer = ReadBuffer({
+    limit
+  });
+  return async function URLEncodedParser3(req, res) {
+    try {
+      const isType = req.body === void 0 && req.headers["content-type"] ? req.headers["content-type"].toLocaleLowerCase().indexOf(type.toLocaleLowerCase()) !== -1 : false;
+      if (isType && !req.buffer) {
+        await readBuffer(req, res);
+      }
+      if (isType && req.buffer && req.buffer.length <= limit) {
+        const string = req.buffer.toString();
+        if (string) {
+          const body = {
+            ...(0, import_querystring.parse)(string, void 0, void 0, {
               maxKeys
             })
           };
@@ -1439,7 +1439,7 @@ function getSlashIndex(input) {
   }
   return slashIndex;
 }
-function normalizePath2(path) {
+function normalizePath3(path) {
   if (typeof path !== "string") {
     throw new Error("path not string");
   }
@@ -1656,7 +1656,7 @@ var init_types = __esm({
             vURL = v;
             const url = newURL2(vURL ? vURL : "/");
             this.searchParams = url.searchParams;
-            this.path = normalizePath2(url.pathname);
+            this.path = normalizePath3(url.pathname);
             this.hash = url.hash;
             this.query = parseSearchParams(this.searchParams);
           }
@@ -1779,9 +1779,9 @@ var init_types = __esm({
       }
       async asyncWrite(chunk) {
         return new Promise((resolve24, reject) => {
-          this.write(chunk, function(error2) {
-            if (error2) {
-              reject(error2);
+          this.write(chunk, function(error3) {
+            if (error3) {
+              reject(error3);
             } else {
               resolve24();
             }
@@ -1808,7 +1808,10 @@ var init_types = __esm({
                   return;
                 } else {
                   if (this.useETag) {
-                    const incomingETag = this.req.headers["if-none-match"];
+                    let incomingETag = this.req.headers["if-none-match"];
+                    if (incomingETag && incomingETag.indexOf("W/") === 0) {
+                      incomingETag = incomingETag.substring("W/".length);
+                    }
                     const etag = typeof this.useETag === "function" ? await this.useETag(args) : defaultETag({ body: nBody });
                     if (incomingETag && etag && etag === incomingETag && nStatus >= 200 && nStatus < 300) {
                       this.statusCode = 304;
@@ -1946,7 +1949,7 @@ function routerDefaultLoggerFactory(uuid, req) {
   try {
     const url = newURL2(req.url ? req.url : "/");
     query = url.searchParams.toString();
-    path = normalizePath2(url.pathname);
+    path = normalizePath3(url.pathname);
     method = req.method ? req.method.toUpperCase() : "GET";
     remoteAddress = req.socket.remoteAddress;
   } catch (e) {
@@ -2271,7 +2274,7 @@ var init_common = __esm({
 });
 
 // node_modules/@miqro/core/build/middleware/router.js
-var Router2, RouterHandler;
+var Router3, RouterHandler;
 var init_router = __esm({
   "node_modules/@miqro/core/build/middleware/router.js"() {
     init_common();
@@ -2280,7 +2283,7 @@ var init_router = __esm({
     init_body_parser();
     init_lib2();
     init_built_in_parsers();
-    Router2 = class {
+    Router3 = class {
       constructor(config) {
         this.config = config;
         this.handlers = [];
@@ -2322,7 +2325,7 @@ var init_router = __esm({
         return this.use(handler, path, "options", options);
       }
       use(handler, path, method, options) {
-        const nPath = path !== void 0 ? normalizePath2(path) : void 0;
+        const nPath = path !== void 0 ? normalizePath3(path) : void 0;
         const nMethod = method ? method.toLowerCase() : method;
         this.handlers.push(new RouterHandler(handler, nPath, nMethod, options));
         return this;
@@ -2462,7 +2465,7 @@ ${tab}${tab}${methodData.description}` : ""}`;
         this.handler = handlers;
       }
       getJSONDoc(doc = {}, prePath = "") {
-        const pp = normalizePath2(removeStartingBackSlashes(this.path ? this.path : "/"));
+        const pp = normalizePath3(removeStartingBackSlashes(this.path ? this.path : "/"));
         const nPath = pp.length > 1 ? pp.substring(1) : "";
         const nMethod = this.method ? this.method : "";
         if (this.isRouter) {
@@ -2563,7 +2566,7 @@ var init_app = __esm({
     init_router();
     init_common();
     import_crypto = require("crypto");
-    App = class extends Router2 {
+    App = class extends Router3 {
       constructor(config) {
         super(config);
         this.shouldCloseConnection = false;
@@ -2922,12 +2925,12 @@ var init_websocket = __esm({
                 socket.destroy();
               }
             });
-            socket.on("error", async (error2) => {
+            socket.on("error", async (error3) => {
               req.logger.debug("upgraded connection error!");
-              req.logger.error(error2);
+              req.logger.error(error3);
               if (this.options.onError) {
                 try {
-                  await this.options.onError(client, error2);
+                  await this.options.onError(client, error3);
                 } catch (e) {
                   req.logger.error(e);
                 }
@@ -7026,10 +7029,10 @@ __export(restart_api_exports, {
   parseInflateErrors: () => parseInflateErrors
 });
 function parseInflateErrors(errors) {
-  return errors?.map((error2) => {
+  return errors?.map((error3) => {
     return {
-      filePath: (0, import_node_path24.relative)(BASE_PATH, error2.filePath),
-      error: error2.error.message
+      filePath: (0, import_node_path24.relative)(BASE_PATH, error3.filePath),
+      error: error3.error.message
     };
   });
 }
@@ -7084,10 +7087,10 @@ __export(reload_api_exports, {
   parseInflateErrors: () => parseInflateErrors2
 });
 function parseInflateErrors2(errors) {
-  return errors?.map((error2) => {
+  return errors?.map((error3) => {
     return {
-      filePath: (0, import_node_path25.relative)(BASE_PATH, error2.filePath),
-      error: error2.error.message
+      filePath: (0, import_node_path25.relative)(BASE_PATH, error3.filePath),
+      error: error3.error.message
     };
   });
 }
@@ -7147,108 +7150,1541 @@ function HTMLEncode2(str) {
       aRet[i] = str[i];
     }
   }
-  return aRet.join("");
+  return aRet.join("");
+}
+var init_html_encode = __esm({
+  "editor/common/html-encode.ts"() {
+  }
+});
+
+// editor/common/editor-index.tsx
+var editor_index_exports = {};
+__export(editor_index_exports, {
+  EditorIndex: () => EditorIndex
+});
+function EditorIndex(editorCSS, editorJS, enableHotReload) {
+  return async function editorIndex(req, res) {
+    const admin = req.editor;
+    const errors = parseInflateErrors(admin ? admin.getInflateErrors() : []);
+    const files = scanDir(req);
+    const migrations = admin ? admin.getMigrations().map((m) => m.name) : [];
+    const services = admin ? admin.getServices() : ["."];
+    const hotReload = enableHotReload ? admin ? admin.getHotReloadHTML() : "" : "";
+    res.html(`<!DOCTYPE html><html><body><style>${editorCSS}</style><script type="module">${editorJS}</script><editor-component class="main-container" reloadstring="${req.uuid}" migrations="${HTMLEncode2(JSON.stringify(migrations))}" services="${HTMLEncode2(JSON.stringify(services))}" errors="${HTMLEncode2(JSON.stringify(errors))}" files="${HTMLEncode2(JSON.stringify(files))}"><noscript>Enable JavaScript</noscript></editor-component>${hotReload}</body></html>`);
+  };
+}
+var init_editor_index = __esm({
+  "editor/common/editor-index.tsx"() {
+    init_scan_api();
+    init_restart_api();
+    init_html_encode();
+  }
+});
+
+// src/lib.ts
+var lib_exports3 = {};
+__export(lib_exports3, {
+  App: () => App,
+  ClusterCache: () => ClusterCache,
+  ClusterWebSocketServer2: () => ClusterWebSocketServer2,
+  DBManager: () => DBManager,
+  JSX: () => JSX3,
+  LocalCache: () => LocalCache,
+  LogProvider: () => LogProvider,
+  LoggerHandler: () => LoggerHandler,
+  Miqro: () => Miqro,
+  Router: () => Router3,
+  ServerRequestHandler: () => ServerRequestHandler,
+  WebSocketManager: () => WebSocketManager,
+  appendAPIModule: () => appendAPIModule,
+  createLogProviderOptions: () => createLogProviderOptions,
+  createServerInterface: () => createServerInterface,
+  defineRoute: () => defineRoute2,
+  jsx: () => lib_exports,
+  jsx2HTML: () => jsx2HTML,
+  jwt: () => jwt,
+  middleware: () => middleware,
+  migration: () => lib_exports2
+});
+module.exports = __toCommonJS(lib_exports3);
+
+// node_modules/@miqro/jsx/build/esm/lib.js
+var lib_exports = {};
+__export(lib_exports, {
+  Fragment: () => Fragment,
+  JSX: () => JSX,
+  Link: () => Link,
+  Router: () => Router,
+  createContainer: () => createContainer,
+  createContext: () => createContext,
+  createElement: () => createElement,
+  default: () => lib_default,
+  enableDebugLog: () => enableDebugLog,
+  isPathLocation: () => isPathLocation,
+  setDefaultOptions: () => setDefaultOptions,
+  useAllQuery: () => useAllQuery,
+  useConditional: () => useConditional,
+  useContext: () => useContext,
+  useEffect: () => useEffect,
+  useElement: () => useElement,
+  useIsLocationPathNameActive: () => useIsLocationPathNameActive,
+  usePathname: () => usePathname,
+  useQuery: () => useQuery,
+  useRef: () => useRef,
+  useRefresh: () => useRefresh,
+  useRuntime: () => useRuntime,
+  useState: () => useState
+});
+
+// node_modules/@miqro/jsx/build/esm/vdom/log.js
+var debugLogEnabled = false;
+function debug(runtime, message2, ...args) {
+  if (debugLogEnabled) {
+    runtime.consoleLog(message2, ...args);
+  }
+}
+function error(runtime, message2, ...args) {
+  runtime.consoleError(message2, ...args);
+}
+function enableDebugLog() {
+  debugLogEnabled = true;
+}
+
+// node_modules/@miqro/jsx/build/esm/vdom/actions.js
+function createAppendAction(node, runtime) {
+  return {
+    isDestructive: true,
+    execute: () => {
+      const parent = node.parent;
+      const nodeRef = node.ref;
+      let changes = 0;
+      if (parent) {
+        debug(runtime, "%s.children.add(%s)", parent.getName(), node.getName());
+        parent.children.add(node);
+        if (nodeRef) {
+          let currentParent = parent;
+          if (currentParent.ref) {
+            debug(runtime, "%s.appendChild(%s)", currentParent.getName(), node.getName());
+            if (currentParent.state?.shadowRoot) {
+              currentParent.state.shadowRoot.appendChild(nodeRef);
+            } else {
+              currentParent.ref.appendChild(nodeRef);
+            }
+            changes++;
+            return changes;
+          } else {
+            while (currentParent !== null) {
+              currentParent = currentParent.parent;
+              if (currentParent && currentParent.ref) {
+                debug(runtime, "%s.appendChild(%s)", currentParent.getName(), node.getName());
+                if (currentParent.state?.shadowRoot) {
+                  currentParent.state.shadowRoot.appendChild(nodeRef);
+                } else {
+                  currentParent.ref.appendChild(nodeRef);
+                }
+                changes++;
+                return changes;
+              }
+            }
+          }
+        } else {
+          return changes;
+        }
+      }
+      throw new Error("cannot find real parent(3)");
+    }
+  };
+}
+function createRemoveAttributesAction(node, toRemove, runtime) {
+  return {
+    execute: () => {
+      const ref = node.ref;
+      let changes = 0;
+      if (ref) {
+        const element = ref;
+        for (const name of toRemove) {
+          debug(runtime, "%s.removeAttribute(%s)", node.getName(), name);
+          element.removeAttribute(name);
+          changes++;
+          if (name === "checked") {
+            debug(runtime, "%s.%s=...", node.getName(), "checked");
+            element.checked = false;
+            changes++;
+          }
+        }
+      }
+      return changes;
+    }
+  };
+}
+function createSetAttributesAction(node, toSet, runtime) {
+  return {
+    execute: () => {
+      const ref = node.ref;
+      let changes = 0;
+      if (ref) {
+        const element = ref;
+        for (const s of toSet) {
+          if (s.name === "className") {
+            s.name = "class";
+          }
+          debug(runtime, "%s.setAttribute(%s, ...)", node.getName(), s.name);
+          element.setAttribute(s.name, s.value);
+          changes++;
+          if (s.name === "value") {
+            debug(runtime, "%s.%s=...", node.getName(), s.name);
+            element.value = s.value;
+            changes++;
+          } else if (s.name === "checked") {
+            debug(runtime, "%s.%s=...", node.getName(), s.name);
+            element.checked = true;
+            changes++;
+          }
+        }
+      }
+      return changes;
+    }
+  };
+}
+function createFlushEffects(node, options, runtime) {
+  return {
+    postExecute: () => {
+      const meta = node.state;
+      const func = node.component;
+      const changes = 0;
+      if (func && meta) {
+        debug(runtime, "flush effects callbacks for [%s]", node.getName());
+        flushEffectCallbacks(meta.effectCallbacks, options.disableEffects, runtime);
+        debug(runtime, "flush effects for [%s]", node.getName());
+        flushEffects(meta.effects, meta.effectQueueCallbacks, options.disableEffects, runtime);
+      }
+      return changes;
+    }
+  };
+}
+function createFlushEffectsRemove(node, options, runtime) {
+  return {
+    execute: () => {
+      const meta = node.state;
+      const changes = 0;
+      if (node.component && meta) {
+        debug(runtime, "flush effects callbacks for [%s]", node.getName());
+        flushEffectCallbacks(meta.effectCallbacks, options.disableEffects, runtime);
+        debug(runtime, "flush effects for [%s]", node.getName());
+        flushEffectCallbacks(meta.effectQueueCallbacks, options.disableEffects, runtime);
+      }
+      return changes;
+    }
+  };
+}
+function flushEffectCallbacks(callbacks, disableEffects, runtime) {
+  const keys = Object.keys(callbacks);
+  for (const key of keys) {
+    if (!disableEffects) {
+      try {
+        callbacks[key]();
+      } catch (e) {
+        error(runtime, e);
+      }
+    }
+    delete callbacks[key];
+  }
+}
+function flushEffects(effects, callbacks, disableEffects, runtime) {
+  const keys = Object.keys(effects);
+  for (const key of keys) {
+    if (!disableEffects) {
+      try {
+        const callback = effects[key]();
+        if (callback) {
+          callbacks[key] = callback;
+        }
+      } catch (e) {
+        error(runtime, e);
+      }
+    }
+    delete effects[key];
+  }
+}
+function createRemoveListeners(node, runtime) {
+  return {
+    execute: () => {
+      const ref = node.ref;
+      let changes = 0;
+      if (!ref) {
+        throw new Error("cannot update listeners without a ref");
+      }
+      const element = ref;
+      for (const listener of node.currentEventListeners) {
+        debug(runtime, "%s.removeEventListener(%s, ...)", node.getName(), listener.eventName);
+        element.removeEventListener(listener.eventName, listener.listener);
+        changes++;
+      }
+      node.currentEventListeners = [];
+      return changes;
+    }
+  };
+}
+function createUpdateListeners(node, listeners, runtime) {
+  return {
+    execute: () => {
+      const ref = node.ref;
+      let changes = 0;
+      if (!ref) {
+        throw new Error("cannot update listeners without a ref");
+      }
+      const element = ref;
+      for (const listener of node.currentEventListeners) {
+        debug(runtime, "%s.removeEventListener(%s, ...)", node.getName(), listener.eventName);
+        element.removeEventListener(listener.eventName, listener.listener);
+        changes++;
+      }
+      node.currentEventListeners = [];
+      for (const listener of listeners) {
+        debug(runtime, "%s.addEventListener(%s, ...)", node.getName(), listener.eventName);
+        element.addEventListener(listener.eventName, listener.listener);
+        changes++;
+      }
+      node.currentEventListeners = listeners;
+      return changes;
+    }
+  };
+}
+function createNotifyRef(node, refListener, runtime) {
+  return {
+    postExecute: () => {
+      const ref = node.ref;
+      let changes = 0;
+      if (!ref) {
+        throw new Error("cannot notify ref without a ref");
+      }
+      debug(runtime, "calling ref [%s]", node.getName());
+      refListener(ref);
+      return changes;
+    }
+  };
+}
+function createRemoveNode(node, options, runtime) {
+  return {
+    isDestructive: true,
+    execute: () => {
+      const meta = node.state;
+      let changes = 0;
+      if (node.component && meta) {
+        debug(runtime, "[%s].remove()", node.getName());
+      }
+      const parent = node.parent;
+      if (!parent) {
+        throw new Error(`cannot remove from tree ${node.type} ${node.textContent}`);
+      }
+      parent.children.delete(node);
+      const nodeRef = node.ref;
+      if (nodeRef) {
+        changes++;
+        debug(runtime, "%s.remove()", node.getName());
+        nodeRef.remove();
+      }
+      node.parent = null;
+      return changes;
+    }
+  };
+}
+function createSetTextAction(node, textContent, runtime) {
+  return {
+    execute: () => {
+      const ref = node.ref;
+      let changes = 0;
+      if (ref) {
+        debug(runtime, "%s.textContent = ...", node.getName());
+        ref.textContent = textContent ? textContent : "";
+        node.textContent = textContent;
+        changes++;
+      }
+      return changes;
+    }
+  };
+}
+function createUpdateLastRenderArgs(node, options, runtime, props, children) {
+  return {
+    postExecute: () => {
+      node.lastRenderArgs = {
+        props,
+        children
+      };
+      return 0;
+    }
+  };
+}
+function createSetInnerHTMLAction(node, innerHTML, runtime) {
+  return {
+    execute: () => {
+      const ref = node.ref;
+      let changes = 0;
+      if (ref) {
+        debug(runtime, "%s.innerHTML = ...", node.getName());
+        if (innerHTML !== null && innerHTML !== void 0) {
+          ref.innerHTML = String(innerHTML);
+          changes++;
+        }
+        node.innerHTML = innerHTML;
+      }
+      return changes;
+    }
+  };
+}
+
+// node_modules/@miqro/jsx/build/esm/vdom/nodes/base-node.js
+function setDefaultOptions(options) {
+  if (defaultOptionsFuse) {
+    throw new Error("cannot override default options once and before an element has been created!");
+  }
+  defaultOptionsFuse = true;
+  DEFAULT_OPTIONS = options;
+  Object.freeze(DEFAULT_OPTIONS);
+}
+var BaseNode = class {
+  type;
+  parent;
+  children = /* @__PURE__ */ new Set();
+  currentEventListeners = [];
+  contextKey;
+  contextValue;
+  state;
+  tagName;
+  lastRenderArgs = {};
+  component;
+  textContent;
+  innerHTML;
+  ref;
+  isRoot;
+  constructor(type, parent) {
+    this.type = type;
+    this.parent = parent;
+  }
+  create(runtime, options, change, parent, list) {
+    this.parent = parent;
+    this.update(runtime, options, change, list, true);
+    list.push(createAppendAction(this, runtime));
+    this.lastRenderArgs = {
+      props: change.props,
+      children: change.children
+    };
+    return this;
+  }
+  update(runtime, options, change, list, initial) {
+    return this;
+  }
+  compare(change) {
+    return this.type === change.type && this.component === change.func && this.tagName === change.tagName && this.contextKey === change.contextKey;
+  }
+  remove(runtime, options, list) {
+    if (this.children) {
+      for (const child of this.children) {
+        child.remove(runtime, options, list);
+      }
+    }
+    if (this.state && this.component) {
+      list.push(createFlushEffectsRemove(this, options, runtime));
+    }
+    list.push(createRemoveNode(this, options, runtime));
+    return this;
+  }
+  calculateChildren(runtime, options, change, list) {
+    return change.children ? change.children : [];
+  }
+  getName() {
+    return this.component ? this.component.name : this.tagName ? this.tagName : this.type;
+  }
+  initComponentState(runtime, options) {
+    if (this.state) {
+      throw new Error("already initialized");
+    }
+    const ref = this.ref;
+    const o = options ? {
+      ...getDefaultOptions(),
+      ...options ? options : {}
+    } : {
+      ...getDefaultOptions()
+    };
+    const shadowInit = o.shadowInit;
+    const renderAsFragment = o.asFragment;
+    if (!ref && !renderAsFragment) {
+      throw new Error("createMeta without ref");
+    }
+    this.state = {
+      effectConditions: {},
+      effectCallbacks: {},
+      effectQueueCallbacks: {},
+      effects: {},
+      shadowRoot: renderAsFragment || !runtime.isIntanceOfHTMLElement(ref) || shadowInit === false ? void 0 : runtime.attachShadow(ref, shadowInit === void 0 || shadowInit === true ? {
+        mode: "closed"
+      } : shadowInit)
+    };
+    return this;
+  }
+  abortApply(runtime) {
+    if (!this.state) {
+      throw new Error("no meta");
+    }
+    runtime.clearTimeout(this.state.refreshTimeout);
+    if (this.state.abort) {
+      this.state.abort.abort("abortApply!");
+    }
+    this.state.abort = runtime.createAbortController();
+    return this.state.abort;
+  }
+};
+var DEFAULT_OPTIONS = {
+  /*shadowInit: {
+    mode: "closed"
+  },
+  asFragment: false*/
+  /*shadowInit: false*/
+  shadowInit: false,
+  asFragment: true
+};
+var defaultOptionsFuse = false;
+function getDefaultOptions() {
+  defaultOptionsFuse = true;
+  return DEFAULT_OPTIONS;
+}
+
+// node_modules/@miqro/jsx/build/esm/jsx.js
+var Fragment = /* @__PURE__ */ Symbol("Fragment");
+function createElement(tag2, attributes, ...children) {
+  if (!tag2) {
+    throw new Error(`cannot call createElement with [${String(tag2)}] `);
+  }
+  const isFragment = tag2 === Fragment;
+  const fAsFragment = typeof tag2 === "string" || isFragment ? getDefaultOptions().asFragment : tag2.asFragment !== void 0 ? tag2.asFragment : getDefaultOptions().asFragment;
+  const tagName = typeof tag2 === "string" ? tag2 : isFragment ? "Fragment" : `${!tag2.name ? "no-name" : tag2.name}-component`.toLowerCase();
+  return isFragment ? {
+    type: "Fragment",
+    children
+  } : typeof tag2 === "function" ? {
+    type: fAsFragment ? "FragmentComponent" : "Component",
+    tagName: !fAsFragment ? tagName : void 0,
+    props: attributes ? attributes : /* @__PURE__ */ Object.create(null),
+    func: tag2,
+    children
+  } : {
+    type: "Element",
+    tagName,
+    props: attributes ? attributes : /* @__PURE__ */ Object.create(null),
+    children
+  };
+}
+var JSX = /* @__PURE__ */ Object.create(null);
+var objectDefineProperty = Object.defineProperty;
+objectDefineProperty(JSX, "createElement", {
+  configurable: false,
+  enumerable: true,
+  writable: false,
+  value: createElement
+});
+objectDefineProperty(JSX, "jsxFactory", {
+  configurable: false,
+  enumerable: true,
+  writable: false,
+  value: createElement
+});
+objectDefineProperty(JSX, "Fragment", {
+  configurable: false,
+  enumerable: true,
+  writable: false,
+  value: Fragment
+});
+objectDefineProperty(JSX, "jsxFragmentFactory", {
+  configurable: false,
+  enumerable: true,
+  writable: false,
+  value: Fragment
+});
+Object.freeze(JSX);
+
+// node_modules/@miqro/jsx/build/esm/vdom/types.js
+var CHANGE_TYPES_SET = /* @__PURE__ */ new Set(["FragmentComponent", "Component", "Element", "Ref", "Fragment", "ContextProvider"]);
+
+// node_modules/@miqro/jsx/build/esm/vdom/nodes/context-provider.js
+var ContextProvider = class extends BaseNode {
+  constructor(parent) {
+    super("ContextProvider", parent);
+  }
+  create(runtime, options, change, parent, list) {
+    if (!change.contextKey) {
+      throw new Error("cannot create ContextProvider without contextKey");
+    }
+    this.contextKey = change.contextKey;
+    this.contextValue = change.contextValue;
+    this.parent = parent;
+    const children = this.calculateChildren(runtime, options, change, list);
+    for (const child of children) {
+      createNewNodeFromChange(runtime, options, normalizeChild(runtime, child), this, list);
+    }
+    return super.create(runtime, options, change, parent, list);
+  }
+  update(runtime, options, change, list, initial) {
+    this.contextValue = change.contextValue;
+    return this;
+  }
+};
+
+// node_modules/@miqro/jsx/build/esm/vdom/nodes/fragment.js
+var Fragment2 = class extends BaseNode {
+  constructor(parent) {
+    super("Fragment", parent);
+  }
+  create(runtime, options, change, parent, list) {
+    this.parent = parent;
+    const children = this.calculateChildren(runtime, options, change, list);
+    for (const child of children) {
+      createNewNodeFromChange(runtime, options, normalizeChild(runtime, child), this, list);
+    }
+    super.create(runtime, options, change, parent, list);
+    return this;
+  }
+};
+
+// node_modules/@miqro/jsx/build/esm/component/render.js
+var currentContext = null;
+function useConditional(name) {
+  return pushContextCall(currentContext, name);
+}
+function useRenderContext() {
+  if (!currentContext) {
+    throw new Error("useContext not in render");
+  }
+  return currentContext;
+}
+function renderComponent(runtime, component, options, list, props, children) {
+  try {
+    const meta = component.state;
+    const func = component.component;
+    if (!meta || !func) {
+      throw new Error("meta not found!");
+    }
+    if (meta.conditionalUseDetected) {
+      throw new Error("conditional this.use calls detected(4)!");
+    }
+    const context = {
+      calls: [],
+      node: component,
+      options,
+      runtime
+    };
+    list.push(createUpdateLastRenderArgs(component, options, runtime, props, children));
+    currentContext = null;
+    currentContext = context;
+    const output = func(props, children);
+    currentContext = null;
+    if (meta.lastContextCalls && meta.lastContextCalls.length !== context.calls.length) {
+      meta.conditionalUseDetected = true;
+      throw new Error("conditional this.use calls detected(3)!");
+    }
+    meta.lastContextCalls = context.calls;
+    return [output];
+  } catch (e) {
+    currentContext = null;
+    throw e;
+  }
+}
+function pushContextCall(context, name) {
+  if (!context) {
+    throw new Error("not in render(7)");
+  }
+  const meta = context.node.state;
+  if (!meta) {
+    throw new Error("not in render(-1)");
+  }
+  const callIndex = context.calls.length;
+  const key = `${callIndex}-${name}`;
+  context.calls.push({
+    key
+  });
+  if (!meta.lastContextCalls) {
+    return key;
+  }
+  if (context.calls > meta.lastContextCalls) {
+    meta.conditionalUseDetected = true;
+    throw new Error("conditional this.use calls detected(1)!");
+  }
+  const lastCall = meta.lastContextCalls[callIndex];
+  if (lastCall === void 0 || lastCall.key !== key) {
+    meta.conditionalUseDetected = true;
+    throw new Error("conditional this.use calls detected(2)!");
+  }
+  return key;
+}
+
+// node_modules/@miqro/jsx/build/esm/vdom/nodes/component-fragment.js
+var FragmentComponent = class extends Fragment2 {
+  constructor(parent) {
+    super(parent);
+    this.type = "FragmentComponent";
+  }
+  create(runtime, options, change, parent, list) {
+    if (change.func === void 0) {
+      throw new Error("cannot create FragmentFunction without func");
+    }
+    this.component = change.func;
+    const o = {
+      asFragment: true
+    };
+    if (this.component.shadowInit !== void 0) {
+      o.shadowInit = this.component.shadowInit;
+    }
+    this.initComponentState(runtime, o);
+    this.parent = parent;
+    this.lastRenderArgs = {
+      props: change.props,
+      children: change.children
+    };
+    return super.create(runtime, options, change, parent, list);
+  }
+  calculateChildren(runtime, options, change, list) {
+    if (this.component && this.state) {
+      list.push(createFlushEffects(this, options, runtime));
+      const out = renderComponent(runtime, this, options, list, change.props, change.children);
+      return out ? out : [];
+    } else {
+      return change.children ? change.children : [];
+    }
+  }
+};
+
+// node_modules/@miqro/jsx/build/esm/vdom/nodes/element.js
+var ATTRIBUTES_WITHOUT_VALUE = /* @__PURE__ */ new Set([
+  "disabled",
+  "checked",
+  "selected",
+  "hidden"
+]);
+var Element = class extends BaseNode {
+  constructor(parent) {
+    super("Element", parent);
+  }
+  create(runtime, options, change, parent, list) {
+    if (change.tagName === void 0) {
+      throw new Error("cannot create element without a tagName");
+    }
+    this.tagName = change.tagName;
+    this.ref = runtime.createElement(change.tagName);
+    this.parent = parent;
+    const children = this.calculateChildren(runtime, options, change, list);
+    for (const child of children) {
+      createNewNodeFromChange(runtime, options, normalizeChild(runtime, child), this, list);
+    }
+    return super.create(runtime, options, change, parent, list);
+  }
+  update(runtime, options, change, list, initial) {
+    const attributesSet = [];
+    let setInnerHTMLFlag = true;
+    let setInnerHTML = void 0;
+    const attributesRemove = [];
+    const listenerChanges = [];
+    let refListener = null;
+    const changeProps = change.props ? change.props : {};
+    const changePropNames = new Set(Object.keys(changeProps));
+    const element = this.ref;
+    const currentAttributeNames = new Set(element.getAttributeNames());
+    for (const changePropName of changePropNames) {
+      const changePropValue = changeProps[changePropName];
+      if (typeof changePropValue === "function") {
+        if (changePropName === "ref") {
+          if (!initial) {
+            continue;
+          } else {
+            refListener = changePropValue;
+            continue;
+          }
+        } else if (changePropName.indexOf("on") === 0) {
+          const eventName = changePropName.substring("on".length);
+          listenerChanges.push({
+            eventName,
+            listener: changePropValue
+          });
+          continue;
+        } else if (changePropName.indexOf("data-on") === 0) {
+          const eventName = changePropName.substring("data-on".length);
+          listenerChanges.push({
+            eventName,
+            listener: changePropValue
+          });
+          continue;
+        }
+        continue;
+      }
+      if (!this.component) {
+        if (changePropName === "innerHTML") {
+          if (changePropValue !== this.innerHTML) {
+            setInnerHTMLFlag = true;
+            setInnerHTML = changePropValue;
+          }
+          continue;
+        }
+        const attributeName = changePropName === "className" ? "class" : changePropName;
+        currentAttributeNames.delete(attributeName);
+        const currentAttributeValue = attributeName === "value" ? element.value : attributeName === "checked" ? element.checked : element.getAttribute(attributeName);
+        if (typeof changePropValue === "boolean" && ATTRIBUTES_WITHOUT_VALUE.has(attributeName)) {
+          if (attributeName === "checked") {
+            if (changePropValue) {
+              attributesSet.push({
+                name: attributeName,
+                value: ""
+              });
+            } else {
+              attributesRemove.push(attributeName);
+            }
+          } else if (!changePropValue && currentAttributeValue !== null) {
+            attributesRemove.push(attributeName);
+          } else if (changePropValue && currentAttributeValue === null) {
+            attributesSet.push({
+              name: attributeName,
+              value: ""
+            });
+          }
+        } else {
+          const sValue = String(changePropValue);
+          if (sValue !== currentAttributeValue) {
+            attributesSet.push({
+              name: attributeName,
+              value: String(changePropValue)
+            });
+          }
+        }
+      }
+    }
+    if (!this.component) {
+      if (currentAttributeNames.size > 0) {
+        for (const name of currentAttributeNames) {
+          attributesRemove.push(name);
+        }
+      }
+    }
+    if (this.currentEventListeners.length > 0) {
+      list.push(createRemoveListeners(this, runtime));
+    }
+    if (attributesRemove.length > 0) {
+      list.push(createRemoveAttributesAction(this, attributesRemove, runtime));
+    }
+    if (attributesSet.length > 0) {
+      list.push(createSetAttributesAction(this, attributesSet, runtime));
+    }
+    if (listenerChanges.length > 0) {
+      list.push(createUpdateListeners(this, listenerChanges, runtime));
+    }
+    if (refListener !== null) {
+      list.push(createNotifyRef(this, refListener, runtime));
+    }
+    if (setInnerHTMLFlag) {
+      list.push(createSetInnerHTMLAction(this, setInnerHTML, runtime));
+    }
+    return super.update(runtime, options, change, list);
+  }
+};
+
+// node_modules/@miqro/jsx/build/esm/vdom/nodes/component.js
+var Component = class extends Element {
+  constructor(parent) {
+    super(parent);
+    this.type = "Component";
+  }
+  create(runtime, options, change, parent, list) {
+    if (change.func === void 0) {
+      throw new Error("cannot create Function without func");
+    }
+    if (change.tagName === void 0) {
+      throw new Error("cannot create element without a tagName");
+    }
+    this.component = change.func;
+    this.tagName = change.tagName;
+    this.ref = runtime.createElement(change.tagName);
+    if (this.component) {
+      const o = {};
+      if (this.component.asFragment !== void 0) {
+        o.asFragment = this.component.asFragment;
+      }
+      if (this.component.shadowInit !== void 0) {
+        o.shadowInit = this.component.shadowInit;
+      }
+      this.initComponentState(runtime, o);
+    }
+    this.parent = parent;
+    const children = this.calculateChildren(runtime, options, change, list);
+    for (const child of children) {
+      createNewNodeFromChange(runtime, options, normalizeChild(runtime, child), this, list);
+    }
+    this.parent = parent;
+    this.update(runtime, options, change, list, true);
+    list.push(createAppendAction(this, runtime));
+    this.lastRenderArgs = {
+      props: change.props,
+      children: change.children
+    };
+    return this;
+  }
+  calculateChildren(runtime, options, change, list) {
+    if (this.component && this.state) {
+      list.push(createFlushEffects(this, options, runtime));
+      const out = renderComponent(runtime, this, options, list, change.props, change.children);
+      return out ? out : [];
+    } else {
+      return super.calculateChildren(runtime, options, change, list);
+    }
+  }
+};
+
+// node_modules/@miqro/jsx/build/esm/vdom/nodes/ref.js
+var Ref = class extends BaseNode {
+  constructor(parent) {
+    super("Ref", parent);
+  }
+  create(runtime, options, change, parent, list) {
+    if (!change.ref) {
+      throw new Error("cannot create ref without ref");
+    }
+    this.ref = change.ref;
+    this.parent = parent;
+    list.push(createAppendAction(this, runtime));
+    return this;
+  }
+  compare(change) {
+    return this.type === change.type && this.ref === change.ref && this.component === change.func && this.tagName === change.tagName && this.ref === change.ref;
+  }
+};
+
+// node_modules/@miqro/jsx/build/esm/vdom/nodes/text.js
+var Text = class extends BaseNode {
+  constructor(parent) {
+    super("Text", parent);
+  }
+  create(runtime, options, change, parent, list) {
+    if (change.textContent === void 0) {
+      throw new Error("cannot create text without a textContent");
+    }
+    this.ref = runtime.createTextNode(change.textContent);
+    this.textContent = change.textContent;
+    this.parent = parent;
+    list.push(createAppendAction(this, runtime));
+    return this;
+  }
+  update(runtime, options, change, list, initial) {
+    if (this.textContent !== change.textContent) {
+      list.push(createSetTextAction(this, change.textContent, runtime));
+    }
+    return this;
+  }
+};
+
+// node_modules/@miqro/jsx/build/esm/vdom/tree.js
+var Tree = class extends BaseNode {
+  name;
+  constructor(name, ref, runtime, shadowInit) {
+    super("Fragment", null);
+    this.isRoot = true;
+    this.parent = null;
+    this.ref = ref;
+    this.initComponentState(runtime, {
+      asFragment: false,
+      shadowInit
+    });
+    this.name = name;
+  }
+  getName() {
+    return this.name;
+  }
+};
+function createNewNodeFromChange(runtime, options, change, parent, list) {
+  switch (change.type) {
+    case "ContextProvider":
+      return new ContextProvider(parent).create(runtime, options, change, parent, list);
+    case "Element":
+      return new Element(parent).create(runtime, options, change, parent, list);
+    case "Component":
+      return new Component(parent).create(runtime, options, change, parent, list);
+    case "Ref":
+      return new Ref(parent).create(runtime, options, change, parent, list);
+    case "Text":
+      return new Text(parent).create(runtime, options, change, parent, list);
+    case "Fragment":
+      return new Fragment2(parent).create(runtime, options, change, parent, list);
+    case "FragmentComponent":
+      return new FragmentComponent(parent).create(runtime, options, change, parent, list);
+    default:
+      throw new Error(`unsopported change.type = %${change.type}`);
+  }
+}
+function normalizeChild(runtime, c) {
+  if (typeof c === "object") {
+    if (c instanceof Array) {
+      return {
+        type: "Fragment",
+        children: c
+      };
+    } else if (runtime.isInstanceofNode(c)) {
+      return {
+        type: "Ref",
+        ref: c
+      };
+    } else if (c && CHANGE_TYPES_SET.has(c.type)) {
+      return c;
+    }
+  }
+  return {
+    type: "Text",
+    textContent: String(c)
+  };
+}
+
+// node_modules/@miqro/jsx/build/esm/vdom/diff.js
+function diff(abortSignal, tree, changes, actions, options, runtime, lo = false) {
+  if (changes === void 0 || changes === null || abortSignal.aborted) {
+    return actions;
+  }
+  const currentChildren = tree.children.values();
+  let currentChildrenRet = currentChildren.next();
+  for (const change of changes) {
+    const normalizedChange = normalizeChild(runtime, change);
+    const actualChild = currentChildrenRet.value;
+    if (actualChild === void 0) {
+      createNewNodeFromChange(runtime, options, normalizedChange, tree, actions);
+    } else if (!actualChild.compare(normalizedChange)) {
+      currentChildrenRet = removeFrom(runtime, currentChildren, currentChildrenRet, actions, options);
+      createNewNodeFromChange(runtime, options, normalizedChange, tree, actions);
+    } else {
+      actualChild.update(runtime, options, normalizedChange, actions);
+      if (actualChild.type === "Fragment" || actualChild.type === "FragmentComponent" || actualChild.type === "ContextProvider") {
+        const fragmentActions = [];
+        diff(abortSignal, actualChild, actualChild.calculateChildren(runtime, options, normalizedChange, fragmentActions), fragmentActions, options, runtime, true);
+        if (areActionDestructive(fragmentActions)) {
+          currentChildrenRet = currentChildren.next();
+          currentChildrenRet = removeFrom(runtime, currentChildren, currentChildrenRet, actions, options);
+        }
+        actions.push(...fragmentActions);
+      } else {
+        diff(abortSignal, actualChild, actualChild.calculateChildren(runtime, options, normalizedChange, actions), actions, options, runtime);
+      }
+    }
+    currentChildrenRet = currentChildren.next();
+  }
+  currentChildrenRet = removeFrom(runtime, currentChildren, currentChildrenRet, actions, options);
+  return actions;
+}
+function removeFrom(runtime, nodeIterator, nodeIteratorRet, currentActions, options) {
+  while (nodeIteratorRet.value !== void 0) {
+    nodeIteratorRet.value.remove(runtime, options, currentActions);
+    nodeIteratorRet = nodeIterator.next();
+  }
+  return nodeIteratorRet;
+}
+function areActionDestructive(actions) {
+  for (const fragmentAction of actions) {
+    if (fragmentAction.isDestructive) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// node_modules/@miqro/jsx/build/esm/vdom/execute.js
+function execute(abortSignal, runtime, actions) {
+  if (abortSignal.aborted) {
+    return 0;
+  }
+  let changes = 0;
+  const postExecute = [];
+  for (const action of actions) {
+    try {
+      if (action.execute) {
+        const actionChanges = action.execute();
+        changes += actionChanges;
+      }
+      if (action.postExecute) {
+        postExecute.push(action);
+      }
+    } catch (e) {
+      error(runtime, e);
+      throw e;
+    }
+  }
+  for (const action of postExecute) {
+    try {
+      const actionChanges = action.postExecute();
+      changes += actionChanges;
+    } catch (e) {
+      error(runtime, e);
+      throw e;
+    }
+  }
+  return changes;
+}
+
+// node_modules/@miqro/jsx/build/esm/vdom/render.js
+function render(runtime, tree, treeOptions, change, preActions = [], props, children) {
+  const meta = tree.state;
+  if (!meta) {
+    throw new Error("cannot find meta");
+  }
+  const abortSignal = tree.abortApply(runtime).signal;
+  debug(runtime, "render for [%s]", tree.getName());
+  if (tree.isRoot || tree.parent !== null) {
+    const applyStart = Date.now();
+    const out = change instanceof Array ? change : change === true ? renderComponent(runtime, tree, treeOptions, preActions, props, children) : void 0;
+    const changes = execute(abortSignal, runtime, diff(abortSignal, tree, out, preActions, treeOptions, runtime));
+    const took = Date.now() - applyStart;
+    if (took > 5e3) {
+      error(runtime, "render for [%s] with [%s] changes took [%s]ms", tree.getName(), changes, took);
+    } else {
+      debug(runtime, "render for [%s] with [%s] changes took [%s]ms", tree.getName(), changes, took);
+    }
+    return changes;
+  } else {
+    debug(runtime, "render skipped for [%s]", tree.getName());
+    return 0;
+  }
+}
+
+// node_modules/@miqro/jsx/build/esm/component/container.js
+var objectDefineProperty2 = Object.defineProperty;
+function createContainer(element, runtime, args) {
+  const name = `DOMContainer [${String(element)}]`;
+  const tree = new Tree(name, element, runtime, args?.shadowInit);
+  const treeOptions = args && args.runtimeOptions ? {
+    disableEffects: false,
+    disableRefListener: false,
+    disableRefresh: false,
+    disableEvents: false,
+    ...args.runtimeOptions
+  } : {
+    disableEffects: false,
+    disableRefListener: false,
+    disableRefresh: false,
+    disableEvents: false
+  };
+  const container = /* @__PURE__ */ Object.create(null);
+  objectDefineProperty2(container, "name", {
+    configurable: false,
+    enumerable: true,
+    writable: false,
+    value: name
+  });
+  objectDefineProperty2(container, "render", {
+    configurable: false,
+    enumerable: true,
+    writable: false,
+    value: function render3(out) {
+      return render(runtime, tree, treeOptions, [out]);
+    }
+  });
+  objectDefineProperty2(container, "disconnect", {
+    configurable: false,
+    enumerable: true,
+    writable: false,
+    value: function disconnect() {
+      return render(runtime, tree, treeOptions, []);
+    }
+  });
+  Object.freeze(container);
+  return container;
+}
+
+// node_modules/@miqro/jsx/build/esm/hooks/runtime.js
+function useRuntime() {
+  useConditional("useRuntime");
+  const currentContext3 = useRenderContext();
+  if (!currentContext3) {
+    throw new Error("useRuntime not in render");
+  }
+  return currentContext3.runtime;
+}
+
+// node_modules/@miqro/jsx/build/esm/hooks/refresh.js
+var REFRESH_TIMEOUT_MS = 0;
+function useRefresh() {
+  useConditional("useRefresh");
+  const currentContext3 = useRenderContext();
+  if (!currentContext3) {
+    throw new Error("useRefresh not in render");
+  }
+  const meta = currentContext3.node.state;
+  if (!meta) {
+    throw new Error("useRefresh without meta");
+  }
+  const runtime = useRuntime();
+  const options = currentContext3.options;
+  const node = currentContext3.node;
+  const component = node.component;
+  if (!component) {
+    throw new Error("useRefresh without func");
+  }
+  return (cb) => {
+    runtime.clearTimeout(meta.refreshTimeout);
+    if (options.disableRefresh) {
+      debug(runtime, "useRefresh.refresh() disabled for [%s]", component.name);
+    } else {
+      meta.refreshTimeout = runtime.setTimeout(() => {
+        debug(runtime, "useRefresh.refresh() for [%s]", component.name);
+        const props = node.lastRenderArgs.props;
+        const children = node.lastRenderArgs.children;
+        const changes = render(runtime, node, options, true, [createFlushEffects(node, options, runtime)], props, children);
+        if (cb) {
+          runtime.setTimeout(() => cb(changes), 0);
+        }
+      }, REFRESH_TIMEOUT_MS);
+    }
+  };
+}
+
+// node_modules/@miqro/jsx/build/esm/hooks/state.js
+function useState(defaultValue) {
+  const key = useConditional("useState");
+  const currentContext3 = useRenderContext();
+  if (!currentContext3) {
+    throw new Error("useState not in render");
+  }
+  const refresh = useRefresh();
+  const meta = currentContext3.node.state;
+  const runtime = useRuntime();
+  if (!meta) {
+    throw new Error("useState without meta");
+  }
+  if (!meta.state) {
+    meta.state = /* @__PURE__ */ Object.create(null);
+  }
+  if (!meta.state) {
+    throw new Error("useState without meta.state");
+  }
+  const name = currentContext3.node.component?.name;
+  const currentStateItem = meta.state[key];
+  if (currentStateItem === void 0) {
+    const stateItem = {
+      value: defaultValue,
+      set: (newValue, refreshOnSet = true) => {
+        debug(runtime, "setState() for [%s]", name);
+        if (stateItem.value !== newValue) {
+          stateItem.value = newValue;
+          if (refreshOnSet) {
+            refresh(typeof refreshOnSet === "function" ? refreshOnSet : void 0);
+          }
+        }
+      },
+      get: () => {
+        return stateItem.value;
+      }
+    };
+    meta.state[key] = stateItem;
+    return [
+      stateItem.value,
+      stateItem.set,
+      stateItem.get
+    ];
+  } else {
+    return [
+      currentStateItem.value,
+      currentStateItem.set,
+      currentStateItem.get
+    ];
+  }
+}
+
+// node_modules/@miqro/jsx/build/esm/hooks/effect.js
+function useEffect(effect, condition) {
+  const currentContext3 = useRenderContext();
+  if (!currentContext3) {
+    throw new Error("useEffect not in render");
+  }
+  const key = useConditional("useEffect");
+  const meta = currentContext3.node.state;
+  if (!meta) {
+    throw new Error("useEffect without meta");
+  }
+  const c = condition ? condition : false;
+  if (meta.effectConditions[key] === void 0 || condition === void 0 && meta.effectConditions[key] === false || !equalArray(meta.effectConditions[key], c)) {
+    meta.effectConditions[key] = c;
+    const oldCallback = meta.effectQueueCallbacks[key];
+    delete meta.effectQueueCallbacks[key];
+    if (meta.effectCallbacks[key]) {
+      meta.conditionalUseDetected = true;
+      throw new Error("invalid state. component lock.");
+    }
+    if (oldCallback) {
+      meta.effectCallbacks[key] = oldCallback;
+    }
+    meta.effects[key] = effect;
+  }
+}
+function equalArray(a, c) {
+  if (typeof a !== typeof c) {
+    return false;
+  }
+  if (typeof a === "undefined" || typeof a === "boolean") {
+    return a === c;
+  }
+  const l1 = a;
+  const l2 = c;
+  if (l1.length !== l2.length) {
+    return false;
+  }
+  for (let i = 0; i < l1.length; i++) {
+    if (l1[i] !== l2[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// node_modules/@miqro/jsx/build/esm/hooks/pathname.js
+function usePathname() {
+  const runtime = useRuntime();
+  const pathname = runtime.getLocation().pathname;
+  const [currentLocation, setCurrentLocation, getL] = useState(pathname);
+  debug(runtime, "usePathname [%s]", currentLocation);
+  useEffect(function usePathnameEffect() {
+    const listener = () => {
+      const newLocation = runtime.getLocation().pathname;
+      setCurrentLocation(newLocation);
+    };
+    runtime.addPathListener(listener);
+    return function usePathnameEffectUnLoad() {
+      runtime.removePathListener(listener);
+    };
+  }, []);
+  return String(currentLocation);
+}
+
+// node_modules/@miqro/jsx/build/esm/component/router.js
+function useIsLocationPathNameActive(path) {
+  useConditional("useIsLocationPathNameMatch");
+  const runtime = useRuntime();
+  const basePath = runtime.getBasePath();
+  return isPathLocation(basePath, path, usePathname());
+}
+function Router(props) {
+  const defaultElement = props.defaultElement;
+  const locationPathName = usePathname();
+  const runtime = useRuntime();
+  const active = getActiveRoute(locationPathName, props.routes, runtime);
+  return active ? active.element : defaultElement;
+}
+Router.asFragment = true;
+Router.shadowInit = false;
+function Link(props, children) {
+  const path = props.path;
+  const runtime = useRuntime();
+  const basePath = runtime.getBasePath();
+  const className = props.className ? props.className : "";
+  const activeClass = props.classNameActive ? props.classNameActive : "active";
+  const inactiveClass = props.classNameInactive ? props.classNameInactive : "inactive";
+  const isActive = useIsLocationPathNameActive(path);
+  const newClassName = `${className ? `${className} ` : ""}${isActive ? activeClass : inactiveClass}`;
+  const fullPath = getFullPath(basePath, path);
+  const element = {
+    type: "Element",
+    tagName: "a",
+    props: {
+      class: newClassName,
+      href: fullPath
+    },
+    children
+  };
+  return props.disableHandler ? element : {
+    ...element,
+    props: {
+      ...element.props,
+      onclick: (ev) => {
+        ev.preventDefault();
+        runtime.pushPath(fullPath);
+      }
+    }
+  };
+}
+Link.asFragment = true;
+Link.shadowInit = false;
+function getFullPath(basePath, p) {
+  return normalizePath(`${basePath ? basePath : ""}${p}`);
+}
+function isPathLocation(basePath, p, currentLocation) {
+  const path = getFullPath(basePath, p);
+  const pathname = normalizePath(currentLocation);
+  return pathname.toLocaleLowerCase() === path.toLowerCase();
+}
+function getActiveRoute(locationPathName, routes, runtime) {
+  let activeRoute;
+  const basePath = runtime.getBasePath() ? runtime.getBasePath() : "";
+  for (const route of routes) {
+    if (isPathLocation(basePath, route.path, locationPathName)) {
+      activeRoute = route;
+      break;
+    }
+  }
+  return activeRoute;
+}
+function normalizePath(path) {
+  if (path.length > 1 && path.charAt(path.length - 1) === "/") {
+    path = path.substring(0, path.length - 1);
+  }
+  return path;
+}
+
+// node_modules/@miqro/jsx/build/esm/hooks/ref.js
+function useRef() {
+  const [ref, setRef] = useState(null);
+  function useRefFunction(newRef) {
+    setRef(newRef);
+  }
+  ;
+  useRefFunction.current = ref;
+  return useRefFunction;
+}
+
+// node_modules/@miqro/jsx/build/esm/hooks/query.js
+function useAllQuery(watch2 = true) {
+  const key = useConditional(`useAllQuery`);
+  const runtime = useRuntime();
+  const [last, setLast, getLast] = useState(getQueryValue(runtime));
+  useEffect(function useQueryEffect() {
+    if (watch2) {
+      let useQueryEffectPathListener = function() {
+        const current = getQueryValue(runtime);
+        if (getLast() !== current) {
+          debug(runtime, "useQuery listener for %s", key);
+          setLast(current);
+        }
+      };
+      runtime.addPathListener(useQueryEffectPathListener);
+      return function useQueryEffectUnLoad() {
+        runtime.removePathListener(useQueryEffectPathListener);
+      };
+    }
+  }, []);
+  return last;
+}
+function useQuery(name, defaultValue, watch2 = true) {
+  const key = useConditional(`useQuery-${name}-${defaultValue}`);
+  const runtime = useRuntime();
+  const [last, setLast, getLast] = useState(getQueryValue(runtime, name, defaultValue));
+  useEffect(function useQueryEffect() {
+    if (watch2) {
+      let useQueryEffectPathListener = function() {
+        const current = getQueryValue(runtime, name, defaultValue);
+        if (getLast() !== current) {
+          debug(runtime, "useQuery listener for %s", key);
+          setLast(current);
+        }
+      };
+      runtime.addPathListener(useQueryEffectPathListener);
+      return function useQueryEffectUnLoad() {
+        runtime.removePathListener(useQueryEffectPathListener);
+      };
+    }
+  }, []);
+  return [
+    last,
+    function setQuery(newValue) {
+      setQueryValue(runtime, name, newValue, watch2);
+      setLast(newValue);
+    },
+    function getQuery() {
+      return getQueryValue(runtime, name, defaultValue);
+    }
+  ];
+}
+function getQueryValue(runtime, name, defaultValue) {
+  if (!name) {
+    return runtime.getLocation().searchParams.toString();
+  } else {
+    const ret = runtime.getLocation().searchParams.getAll(name);
+    if (ret.length === 0) {
+      return defaultValue !== void 0 ? defaultValue : null;
+    }
+    return ret && ret.length === 1 && !(defaultValue instanceof Array) ? ret[0] : ret;
+  }
 }
-var init_html_encode = __esm({
-  "editor/common/html-encode.ts"() {
+function setQueryValue(runtime, name, value, watch2 = true) {
+  const url = runtime.getLocation();
+  if (value instanceof Array) {
+    url.searchParams.delete(name);
+    for (const v of value) {
+      url.searchParams.append(name, v);
+    }
+  } else if (value !== null) {
+    url.searchParams.set(name, value);
+  } else {
+    url.searchParams.delete(name);
   }
-});
+  if (watch2) {
+    runtime.pushPath(String(url));
+  }
+}
 
-// editor/common/editor-index.tsx
-var editor_index_exports = {};
-__export(editor_index_exports, {
-  EditorIndex: () => EditorIndex
-});
-function EditorIndex(editorCSS, editorJS, enableHotReload) {
-  return async function editorIndex(req, res) {
-    const admin = req.editor;
-    const errors = parseInflateErrors(admin ? admin.getInflateErrors() : []);
-    const files = scanDir(req);
-    const migrations = admin ? admin.getMigrations().map((m) => m.name) : [];
-    const services = admin ? admin.getServices() : ["."];
-    const hotReload = enableHotReload ? admin ? admin.getHotReloadHTML() : "" : "";
-    res.html(`<!DOCTYPE html><html><body><style>${editorCSS}</style><script type="module">${editorJS}</script><editor-component class="main-container" reloadstring="${req.uuid}" migrations="${HTMLEncode2(JSON.stringify(migrations))}" services="${HTMLEncode2(JSON.stringify(services))}" errors="${HTMLEncode2(JSON.stringify(errors))}" files="${HTMLEncode2(JSON.stringify(files))}"><noscript>Enable JavaScript</noscript></editor-component>${hotReload}</body></html>`);
+// node_modules/@miqro/jsx/build/esm/hooks/useelement.js
+function useElement() {
+  useConditional("useElement");
+  const currentContext3 = useRenderContext();
+  if (!currentContext3) {
+    throw new Error("useElement not in render");
+  }
+  return currentContext3.node.ref ? currentContext3.node.ref : null;
+}
+
+// node_modules/@miqro/jsx/build/esm/hooks/context.js
+function createContext(defaultValue) {
+  const symbol = /* @__PURE__ */ Symbol();
+  return {
+    provider: createContextProvider(symbol, defaultValue),
+    symbol
   };
 }
-var init_editor_index = __esm({
-  "editor/common/editor-index.tsx"() {
-    init_scan_api();
-    init_restart_api();
-    init_html_encode();
+function useContext(context) {
+  useConditional("useContext");
+  const currentContext3 = useRenderContext();
+  if (!currentContext3) {
+    throw new Error("useContext not in render");
   }
-});
-
-// src/lib.ts
-var lib_exports3 = {};
-__export(lib_exports3, {
-  App: () => App,
-  ClusterCache: () => ClusterCache,
-  ClusterWebSocketServer2: () => ClusterWebSocketServer2,
-  DBManager: () => DBManager,
-  JSX: () => JSX2,
-  LocalCache: () => LocalCache,
-  LogProvider: () => LogProvider,
-  LoggerHandler: () => LoggerHandler,
-  Miqro: () => Miqro,
-  Router: () => Router2,
-  ServerRequestHandler: () => ServerRequestHandler,
-  WebSocketManager: () => WebSocketManager,
-  appendAPIModule: () => appendAPIModule,
-  createLogProviderOptions: () => createLogProviderOptions,
-  createServerInterface: () => createServerInterface,
-  defineRoute: () => defineRoute2,
-  jsx: () => lib_exports,
-  jsx2HTML: () => jsx2HTML,
-  jwt: () => jwt,
-  middleware: () => middleware,
-  migration: () => lib_exports2
-});
-module.exports = __toCommonJS(lib_exports3);
+  let currentNode = currentContext3.node;
+  while (currentNode) {
+    if (currentNode.type === "ContextProvider" && currentNode.contextKey === context.symbol) {
+      return currentNode.contextValue;
+    }
+    currentNode = currentNode.parent;
+  }
+  throw new Error("cannot find provider!");
+}
+function createContextProvider(symbol, defaultValue) {
+  function ContextProvider3({ value }, ...children) {
+    useConditional("ContextProvider");
+    const currentContext3 = useRenderContext();
+    if (!currentContext3) {
+      throw new Error("ContextProvider not in render");
+    }
+    return {
+      type: "ContextProvider",
+      contextKey: symbol,
+      contextValue: value === void 0 ? defaultValue : value,
+      children
+    };
+  }
+  ContextProvider3.asFragment = true;
+  ContextProvider3.shadowInit = false;
+  return ContextProvider3;
+}
 
 // node_modules/@miqro/jsx/build/esm/lib.js
-var lib_exports = {};
-__export(lib_exports, {
-  Fragment: () => Fragment,
-  JSX: () => JSX,
-  Link: () => Link,
-  Router: () => Router,
-  createContainer: () => createContainer,
-  createContext: () => createContext,
-  createElement: () => createElement,
-  default: () => lib_default,
-  enableDebugLog: () => enableDebugLog,
-  isPathLocation: () => isPathLocation,
-  setDefaultOptions: () => setDefaultOptions,
-  useAllQuery: () => useAllQuery,
-  useConditional: () => useConditional,
-  useContext: () => useContext,
-  useEffect: () => useEffect,
-  useElement: () => useElement,
-  useIsLocationPathNameActive: () => useIsLocationPathNameActive,
-  usePathname: () => usePathname,
-  useQuery: () => useQuery,
-  useRef: () => useRef,
-  useRefresh: () => useRefresh,
-  useRuntime: () => useRuntime,
-  useState: () => useState
-});
+var lib_default = JSX;
 
-// node_modules/@miqro/jsx/build/esm/vdom/log.js
-var debugLogEnabled = false;
-function debug(runtime, message2, ...args) {
-  if (debugLogEnabled) {
+// ../jsx-node/node_modules/@miqro/jsx/build/esm/vdom/log.js
+var debugLogEnabled2 = false;
+function debug2(runtime, message2, ...args) {
+  if (debugLogEnabled2) {
     runtime.consoleLog(message2, ...args);
   }
 }
-function error(runtime, message2, ...args) {
+function error2(runtime, message2, ...args) {
   runtime.consoleError(message2, ...args);
 }
-function enableDebugLog() {
-  debugLogEnabled = true;
-}
 
-// node_modules/@miqro/jsx/build/esm/vdom/actions.js
-function createAppendAction(node, runtime) {
+// ../jsx-node/node_modules/@miqro/jsx/build/esm/vdom/actions.js
+function createAppendAction2(node, runtime) {
   return {
     isDestructive: true,
     execute: () => {
@@ -7256,12 +8692,12 @@ function createAppendAction(node, runtime) {
       const nodeRef = node.ref;
       let changes = 0;
       if (parent) {
-        debug(runtime, "%s.children.add(%s)", parent.getName(), node.getName());
+        debug2(runtime, "%s.children.add(%s)", parent.getName(), node.getName());
         parent.children.add(node);
         if (nodeRef) {
           let currentParent = parent;
           if (currentParent.ref) {
-            debug(runtime, "%s.appendChild(%s)", currentParent.getName(), node.getName());
+            debug2(runtime, "%s.appendChild(%s)", currentParent.getName(), node.getName());
             if (currentParent.state?.shadowRoot) {
               currentParent.state.shadowRoot.appendChild(nodeRef);
             } else {
@@ -7273,7 +8709,7 @@ function createAppendAction(node, runtime) {
             while (currentParent !== null) {
               currentParent = currentParent.parent;
               if (currentParent && currentParent.ref) {
-                debug(runtime, "%s.appendChild(%s)", currentParent.getName(), node.getName());
+                debug2(runtime, "%s.appendChild(%s)", currentParent.getName(), node.getName());
                 if (currentParent.state?.shadowRoot) {
                   currentParent.state.shadowRoot.appendChild(nodeRef);
                 } else {
@@ -7292,7 +8728,7 @@ function createAppendAction(node, runtime) {
     }
   };
 }
-function createRemoveAttributesAction(node, toRemove, runtime) {
+function createRemoveAttributesAction2(node, toRemove, runtime) {
   return {
     execute: () => {
       const ref = node.ref;
@@ -7300,11 +8736,11 @@ function createRemoveAttributesAction(node, toRemove, runtime) {
       if (ref) {
         const element = ref;
         for (const name of toRemove) {
-          debug(runtime, "%s.removeAttribute(%s)", node.getName(), name);
+          debug2(runtime, "%s.removeAttribute(%s)", node.getName(), name);
           element.removeAttribute(name);
           changes++;
           if (name === "checked") {
-            debug(runtime, "%s.%s=...", node.getName(), "checked");
+            debug2(runtime, "%s.%s=...", node.getName(), "checked");
             element.checked = false;
             changes++;
           }
@@ -7314,7 +8750,7 @@ function createRemoveAttributesAction(node, toRemove, runtime) {
     }
   };
 }
-function createSetAttributesAction(node, toSet, runtime) {
+function createSetAttributesAction2(node, toSet, runtime) {
   return {
     execute: () => {
       const ref = node.ref;
@@ -7325,15 +8761,15 @@ function createSetAttributesAction(node, toSet, runtime) {
           if (s.name === "className") {
             s.name = "class";
           }
-          debug(runtime, "%s.setAttribute(%s, ...)", node.getName(), s.name);
+          debug2(runtime, "%s.setAttribute(%s, ...)", node.getName(), s.name);
           element.setAttribute(s.name, s.value);
           changes++;
           if (s.name === "value") {
-            debug(runtime, "%s.%s=...", node.getName(), s.name);
+            debug2(runtime, "%s.%s=...", node.getName(), s.name);
             element.value = s.value;
             changes++;
           } else if (s.name === "checked") {
-            debug(runtime, "%s.%s=...", node.getName(), s.name);
+            debug2(runtime, "%s.%s=...", node.getName(), s.name);
             element.checked = true;
             changes++;
           }
@@ -7343,51 +8779,51 @@ function createSetAttributesAction(node, toSet, runtime) {
     }
   };
 }
-function createFlushEffects(node, options, runtime) {
+function createFlushEffects2(node, options, runtime) {
   return {
     postExecute: () => {
       const meta = node.state;
       const func = node.component;
       const changes = 0;
       if (func && meta) {
-        debug(runtime, "flush effects callbacks for [%s]", node.getName());
-        flushEffectCallbacks(meta.effectCallbacks, options.disableEffects, runtime);
-        debug(runtime, "flush effects for [%s]", node.getName());
-        flushEffects(meta.effects, meta.effectQueueCallbacks, options.disableEffects, runtime);
+        debug2(runtime, "flush effects callbacks for [%s]", node.getName());
+        flushEffectCallbacks2(meta.effectCallbacks, options.disableEffects, runtime);
+        debug2(runtime, "flush effects for [%s]", node.getName());
+        flushEffects2(meta.effects, meta.effectQueueCallbacks, options.disableEffects, runtime);
       }
       return changes;
     }
   };
 }
-function createFlushEffectsRemove(node, options, runtime) {
+function createFlushEffectsRemove2(node, options, runtime) {
   return {
     execute: () => {
       const meta = node.state;
       const changes = 0;
       if (node.component && meta) {
-        debug(runtime, "flush effects callbacks for [%s]", node.getName());
-        flushEffectCallbacks(meta.effectCallbacks, options.disableEffects, runtime);
-        debug(runtime, "flush effects for [%s]", node.getName());
-        flushEffectCallbacks(meta.effectQueueCallbacks, options.disableEffects, runtime);
+        debug2(runtime, "flush effects callbacks for [%s]", node.getName());
+        flushEffectCallbacks2(meta.effectCallbacks, options.disableEffects, runtime);
+        debug2(runtime, "flush effects for [%s]", node.getName());
+        flushEffectCallbacks2(meta.effectQueueCallbacks, options.disableEffects, runtime);
       }
       return changes;
     }
   };
 }
-function flushEffectCallbacks(callbacks, disableEffects, runtime) {
+function flushEffectCallbacks2(callbacks, disableEffects, runtime) {
   const keys = Object.keys(callbacks);
   for (const key of keys) {
     if (!disableEffects) {
       try {
         callbacks[key]();
       } catch (e) {
-        error(runtime, e);
+        error2(runtime, e);
       }
     }
     delete callbacks[key];
   }
 }
-function flushEffects(effects, callbacks, disableEffects, runtime) {
+function flushEffects2(effects, callbacks, disableEffects, runtime) {
   const keys = Object.keys(effects);
   for (const key of keys) {
     if (!disableEffects) {
@@ -7397,13 +8833,13 @@ function flushEffects(effects, callbacks, disableEffects, runtime) {
           callbacks[key] = callback;
         }
       } catch (e) {
-        error(runtime, e);
+        error2(runtime, e);
       }
     }
     delete effects[key];
   }
 }
-function createRemoveListeners(node, runtime) {
+function createRemoveListeners2(node, runtime) {
   return {
     execute: () => {
       const ref = node.ref;
@@ -7413,7 +8849,7 @@ function createRemoveListeners(node, runtime) {
       }
       const element = ref;
       for (const listener of node.currentEventListeners) {
-        debug(runtime, "%s.removeEventListener(%s, ...)", node.getName(), listener.eventName);
+        debug2(runtime, "%s.removeEventListener(%s, ...)", node.getName(), listener.eventName);
         element.removeEventListener(listener.eventName, listener.listener);
         changes++;
       }
@@ -7422,7 +8858,7 @@ function createRemoveListeners(node, runtime) {
     }
   };
 }
-function createUpdateListeners(node, listeners, runtime) {
+function createUpdateListeners2(node, listeners, runtime) {
   return {
     execute: () => {
       const ref = node.ref;
@@ -7432,13 +8868,13 @@ function createUpdateListeners(node, listeners, runtime) {
       }
       const element = ref;
       for (const listener of node.currentEventListeners) {
-        debug(runtime, "%s.removeEventListener(%s, ...)", node.getName(), listener.eventName);
+        debug2(runtime, "%s.removeEventListener(%s, ...)", node.getName(), listener.eventName);
         element.removeEventListener(listener.eventName, listener.listener);
         changes++;
       }
       node.currentEventListeners = [];
       for (const listener of listeners) {
-        debug(runtime, "%s.addEventListener(%s, ...)", node.getName(), listener.eventName);
+        debug2(runtime, "%s.addEventListener(%s, ...)", node.getName(), listener.eventName);
         element.addEventListener(listener.eventName, listener.listener);
         changes++;
       }
@@ -7447,7 +8883,7 @@ function createUpdateListeners(node, listeners, runtime) {
     }
   };
 }
-function createNotifyRef(node, refListener, runtime) {
+function createNotifyRef2(node, refListener, runtime) {
   return {
     postExecute: () => {
       const ref = node.ref;
@@ -7455,20 +8891,20 @@ function createNotifyRef(node, refListener, runtime) {
       if (!ref) {
         throw new Error("cannot notify ref without a ref");
       }
-      debug(runtime, "calling ref [%s]", node.getName());
+      debug2(runtime, "calling ref [%s]", node.getName());
       refListener(ref);
       return changes;
     }
   };
 }
-function createRemoveNode(node, options, runtime) {
+function createRemoveNode2(node, options, runtime) {
   return {
     isDestructive: true,
     execute: () => {
       const meta = node.state;
       let changes = 0;
       if (node.component && meta) {
-        debug(runtime, "[%s].remove()", node.getName());
+        debug2(runtime, "[%s].remove()", node.getName());
       }
       const parent = node.parent;
       if (!parent) {
@@ -7478,7 +8914,7 @@ function createRemoveNode(node, options, runtime) {
       const nodeRef = node.ref;
       if (nodeRef) {
         changes++;
-        debug(runtime, "%s.remove()", node.getName());
+        debug2(runtime, "%s.remove()", node.getName());
         nodeRef.remove();
       }
       node.parent = null;
@@ -7486,13 +8922,13 @@ function createRemoveNode(node, options, runtime) {
     }
   };
 }
-function createSetTextAction(node, textContent, runtime) {
+function createSetTextAction2(node, textContent, runtime) {
   return {
     execute: () => {
       const ref = node.ref;
       let changes = 0;
       if (ref) {
-        debug(runtime, "%s.textContent = ...", node.getName());
+        debug2(runtime, "%s.textContent = ...", node.getName());
         ref.textContent = textContent ? textContent : "";
         node.textContent = textContent;
         changes++;
@@ -7501,7 +8937,7 @@ function createSetTextAction(node, textContent, runtime) {
     }
   };
 }
-function createUpdateLastRenderArgs(node, options, runtime, props, children) {
+function createUpdateLastRenderArgs2(node, options, runtime, props, children) {
   return {
     postExecute: () => {
       node.lastRenderArgs = {
@@ -7512,13 +8948,13 @@ function createUpdateLastRenderArgs(node, options, runtime, props, children) {
     }
   };
 }
-function createSetInnerHTMLAction(node, innerHTML, runtime) {
+function createSetInnerHTMLAction2(node, innerHTML, runtime) {
   return {
     execute: () => {
       const ref = node.ref;
       let changes = 0;
       if (ref) {
-        debug(runtime, "%s.innerHTML = ...", node.getName());
+        debug2(runtime, "%s.innerHTML = ...", node.getName());
         if (innerHTML !== null && innerHTML !== void 0) {
           ref.innerHTML = String(innerHTML);
           changes++;
@@ -7530,16 +8966,8 @@ function createSetInnerHTMLAction(node, innerHTML, runtime) {
   };
 }
 
-// node_modules/@miqro/jsx/build/esm/vdom/nodes/base-node.js
-function setDefaultOptions(options) {
-  if (defaultOptionsFuse) {
-    throw new Error("cannot override default options once and before an element has been created!");
-  }
-  defaultOptionsFuse = true;
-  DEFAULT_OPTIONS = options;
-  Object.freeze(DEFAULT_OPTIONS);
-}
-var BaseNode = class {
+// ../jsx-node/node_modules/@miqro/jsx/build/esm/vdom/nodes/base-node.js
+var BaseNode2 = class {
   type;
   parent;
   children = /* @__PURE__ */ new Set();
@@ -7561,7 +8989,7 @@ var BaseNode = class {
   create(runtime, options, change, parent, list) {
     this.parent = parent;
     this.update(runtime, options, change, list, true);
-    list.push(createAppendAction(this, runtime));
+    list.push(createAppendAction2(this, runtime));
     this.lastRenderArgs = {
       props: change.props,
       children: change.children
@@ -7581,9 +9009,9 @@ var BaseNode = class {
       }
     }
     if (this.state && this.component) {
-      list.push(createFlushEffectsRemove(this, options, runtime));
+      list.push(createFlushEffectsRemove2(this, options, runtime));
     }
-    list.push(createRemoveNode(this, options, runtime));
+    list.push(createRemoveNode2(this, options, runtime));
     return this;
   }
   calculateChildren(runtime, options, change, list) {
@@ -7598,10 +9026,10 @@ var BaseNode = class {
     }
     const ref = this.ref;
     const o = options ? {
-      ...getDefaultOptions(),
+      ...getDefaultOptions2(),
       ...options ? options : {}
     } : {
-      ...getDefaultOptions()
+      ...getDefaultOptions2()
     };
     const shadowInit = o.shadowInit;
     const renderAsFragment = o.asFragment;
@@ -7631,7 +9059,7 @@ var BaseNode = class {
     return this.state.abort;
   }
 };
-var DEFAULT_OPTIONS = {
+var DEFAULT_OPTIONS2 = {
   /*shadowInit: {
     mode: "closed"
   },
@@ -7640,20 +9068,20 @@ var DEFAULT_OPTIONS = {
   shadowInit: false,
   asFragment: true
 };
-var defaultOptionsFuse = false;
-function getDefaultOptions() {
-  defaultOptionsFuse = true;
-  return DEFAULT_OPTIONS;
+var defaultOptionsFuse2 = false;
+function getDefaultOptions2() {
+  defaultOptionsFuse2 = true;
+  return DEFAULT_OPTIONS2;
 }
 
-// node_modules/@miqro/jsx/build/esm/jsx.js
-var Fragment = /* @__PURE__ */ Symbol("Fragment");
-function createElement(tag2, attributes, ...children) {
+// ../jsx-node/node_modules/@miqro/jsx/build/esm/jsx.js
+var Fragment3 = /* @__PURE__ */ Symbol("Fragment");
+function createElement2(tag2, attributes, ...children) {
   if (!tag2) {
     throw new Error(`cannot call createElement with [${String(tag2)}] `);
   }
-  const isFragment = tag2 === Fragment;
-  const fAsFragment = typeof tag2 === "string" || isFragment ? getDefaultOptions().asFragment : tag2.asFragment !== void 0 ? tag2.asFragment : getDefaultOptions().asFragment;
+  const isFragment = tag2 === Fragment3;
+  const fAsFragment = typeof tag2 === "string" || isFragment ? getDefaultOptions2().asFragment : tag2.asFragment !== void 0 ? tag2.asFragment : getDefaultOptions2().asFragment;
   const tagName = typeof tag2 === "string" ? tag2 : isFragment ? "Fragment" : `${!tag2.name ? "no-name" : tag2.name}-component`.toLowerCase();
   return isFragment ? {
     type: "Fragment",
@@ -7671,39 +9099,39 @@ function createElement(tag2, attributes, ...children) {
     children
   };
 }
-var JSX = /* @__PURE__ */ Object.create(null);
-var objectDefineProperty = Object.defineProperty;
-objectDefineProperty(JSX, "createElement", {
+var JSX2 = /* @__PURE__ */ Object.create(null);
+var objectDefineProperty3 = Object.defineProperty;
+objectDefineProperty3(JSX2, "createElement", {
   configurable: false,
   enumerable: true,
   writable: false,
-  value: createElement
+  value: createElement2
 });
-objectDefineProperty(JSX, "jsxFactory", {
+objectDefineProperty3(JSX2, "jsxFactory", {
   configurable: false,
   enumerable: true,
   writable: false,
-  value: createElement
+  value: createElement2
 });
-objectDefineProperty(JSX, "Fragment", {
+objectDefineProperty3(JSX2, "Fragment", {
   configurable: false,
   enumerable: true,
   writable: false,
-  value: Fragment
+  value: Fragment3
 });
-objectDefineProperty(JSX, "jsxFragmentFactory", {
+objectDefineProperty3(JSX2, "jsxFragmentFactory", {
   configurable: false,
   enumerable: true,
   writable: false,
-  value: Fragment
+  value: Fragment3
 });
-Object.freeze(JSX);
+Object.freeze(JSX2);
 
-// node_modules/@miqro/jsx/build/esm/vdom/types.js
-var CHANGE_TYPES_SET = /* @__PURE__ */ new Set(["FragmentComponent", "Component", "Element", "Ref", "Fragment", "ContextProvider"]);
+// ../jsx-node/node_modules/@miqro/jsx/build/esm/vdom/types.js
+var CHANGE_TYPES_SET2 = /* @__PURE__ */ new Set(["FragmentComponent", "Component", "Element", "Ref", "Fragment", "ContextProvider"]);
 
-// node_modules/@miqro/jsx/build/esm/vdom/nodes/context-provider.js
-var ContextProvider = class extends BaseNode {
+// ../jsx-node/node_modules/@miqro/jsx/build/esm/vdom/nodes/context-provider.js
+var ContextProvider2 = class extends BaseNode2 {
   constructor(parent) {
     super("ContextProvider", parent);
   }
@@ -7716,7 +9144,7 @@ var ContextProvider = class extends BaseNode {
     this.parent = parent;
     const children = this.calculateChildren(runtime, options, change, list);
     for (const child of children) {
-      createNewNodeFromChange(runtime, options, normalizeChild(runtime, child), this, list);
+      createNewNodeFromChange2(runtime, options, normalizeChild2(runtime, child), this, list);
     }
     return super.create(runtime, options, change, parent, list);
   }
@@ -7726,8 +9154,8 @@ var ContextProvider = class extends BaseNode {
   }
 };
 
-// node_modules/@miqro/jsx/build/esm/vdom/nodes/fragment.js
-var Fragment2 = class extends BaseNode {
+// ../jsx-node/node_modules/@miqro/jsx/build/esm/vdom/nodes/fragment.js
+var Fragment4 = class extends BaseNode2 {
   constructor(parent) {
     super("Fragment", parent);
   }
@@ -7735,25 +9163,25 @@ var Fragment2 = class extends BaseNode {
     this.parent = parent;
     const children = this.calculateChildren(runtime, options, change, list);
     for (const child of children) {
-      createNewNodeFromChange(runtime, options, normalizeChild(runtime, child), this, list);
+      createNewNodeFromChange2(runtime, options, normalizeChild2(runtime, child), this, list);
     }
     super.create(runtime, options, change, parent, list);
     return this;
   }
 };
 
-// node_modules/@miqro/jsx/build/esm/component/render.js
-var currentContext = null;
-function useConditional(name) {
-  return pushContextCall(currentContext, name);
+// ../jsx-node/node_modules/@miqro/jsx/build/esm/component/render.js
+var currentContext2 = null;
+function useConditional2(name) {
+  return pushContextCall2(currentContext2, name);
 }
-function useRenderContext() {
-  if (!currentContext) {
+function useRenderContext2() {
+  if (!currentContext2) {
     throw new Error("useContext not in render");
   }
-  return currentContext;
+  return currentContext2;
 }
-function renderComponent(runtime, component, options, list, props, children) {
+function renderComponent2(runtime, component, options, list, props, children) {
   try {
     const meta = component.state;
     const func = component.component;
@@ -7769,11 +9197,11 @@ function renderComponent(runtime, component, options, list, props, children) {
       options,
       runtime
     };
-    list.push(createUpdateLastRenderArgs(component, options, runtime, props, children));
-    currentContext = null;
-    currentContext = context;
+    list.push(createUpdateLastRenderArgs2(component, options, runtime, props, children));
+    currentContext2 = null;
+    currentContext2 = context;
     const output = func(props, children);
-    currentContext = null;
+    currentContext2 = null;
     if (meta.lastContextCalls && meta.lastContextCalls.length !== context.calls.length) {
       meta.conditionalUseDetected = true;
       throw new Error("conditional this.use calls detected(3)!");
@@ -7781,11 +9209,11 @@ function renderComponent(runtime, component, options, list, props, children) {
     meta.lastContextCalls = context.calls;
     return [output];
   } catch (e) {
-    currentContext = null;
+    currentContext2 = null;
     throw e;
   }
 }
-function pushContextCall(context, name) {
+function pushContextCall2(context, name) {
   if (!context) {
     throw new Error("not in render(7)");
   }
@@ -7813,8 +9241,8 @@ function pushContextCall(context, name) {
   return key;
 }
 
-// node_modules/@miqro/jsx/build/esm/vdom/nodes/component-fragment.js
-var FragmentComponent = class extends Fragment2 {
+// ../jsx-node/node_modules/@miqro/jsx/build/esm/vdom/nodes/component-fragment.js
+var FragmentComponent2 = class extends Fragment4 {
   constructor(parent) {
     super(parent);
     this.type = "FragmentComponent";
@@ -7840,8 +9268,8 @@ var FragmentComponent = class extends Fragment2 {
   }
   calculateChildren(runtime, options, change, list) {
     if (this.component && this.state) {
-      list.push(createFlushEffects(this, options, runtime));
-      const out = renderComponent(runtime, this, options, list, change.props, change.children);
+      list.push(createFlushEffects2(this, options, runtime));
+      const out = renderComponent2(runtime, this, options, list, change.props, change.children);
       return out ? out : [];
     } else {
       return change.children ? change.children : [];
@@ -7849,14 +9277,14 @@ var FragmentComponent = class extends Fragment2 {
   }
 };
 
-// node_modules/@miqro/jsx/build/esm/vdom/nodes/element.js
-var ATTRIBUTES_WITHOUT_VALUE = /* @__PURE__ */ new Set([
+// ../jsx-node/node_modules/@miqro/jsx/build/esm/vdom/nodes/element.js
+var ATTRIBUTES_WITHOUT_VALUE2 = /* @__PURE__ */ new Set([
   "disabled",
   "checked",
   "selected",
   "hidden"
 ]);
-var Element = class extends BaseNode {
+var Element2 = class extends BaseNode2 {
   constructor(parent) {
     super("Element", parent);
   }
@@ -7869,7 +9297,7 @@ var Element = class extends BaseNode {
     this.parent = parent;
     const children = this.calculateChildren(runtime, options, change, list);
     for (const child of children) {
-      createNewNodeFromChange(runtime, options, normalizeChild(runtime, child), this, list);
+      createNewNodeFromChange2(runtime, options, normalizeChild2(runtime, child), this, list);
     }
     return super.create(runtime, options, change, parent, list);
   }
@@ -7922,7 +9350,7 @@ var Element = class extends BaseNode {
         const attributeName = changePropName === "className" ? "class" : changePropName;
         currentAttributeNames.delete(attributeName);
         const currentAttributeValue = attributeName === "value" ? element.value : attributeName === "checked" ? element.checked : element.getAttribute(attributeName);
-        if (typeof changePropValue === "boolean" && ATTRIBUTES_WITHOUT_VALUE.has(attributeName)) {
+        if (typeof changePropValue === "boolean" && ATTRIBUTES_WITHOUT_VALUE2.has(attributeName)) {
           if (attributeName === "checked") {
             if (changePropValue) {
               attributesSet.push({
@@ -7959,29 +9387,29 @@ var Element = class extends BaseNode {
       }
     }
     if (this.currentEventListeners.length > 0) {
-      list.push(createRemoveListeners(this, runtime));
+      list.push(createRemoveListeners2(this, runtime));
     }
     if (attributesRemove.length > 0) {
-      list.push(createRemoveAttributesAction(this, attributesRemove, runtime));
+      list.push(createRemoveAttributesAction2(this, attributesRemove, runtime));
     }
     if (attributesSet.length > 0) {
-      list.push(createSetAttributesAction(this, attributesSet, runtime));
+      list.push(createSetAttributesAction2(this, attributesSet, runtime));
     }
     if (listenerChanges.length > 0) {
-      list.push(createUpdateListeners(this, listenerChanges, runtime));
+      list.push(createUpdateListeners2(this, listenerChanges, runtime));
     }
     if (refListener !== null) {
-      list.push(createNotifyRef(this, refListener, runtime));
+      list.push(createNotifyRef2(this, refListener, runtime));
     }
     if (setInnerHTMLFlag) {
-      list.push(createSetInnerHTMLAction(this, setInnerHTML, runtime));
+      list.push(createSetInnerHTMLAction2(this, setInnerHTML, runtime));
     }
     return super.update(runtime, options, change, list);
   }
 };
-
-// node_modules/@miqro/jsx/build/esm/vdom/nodes/component.js
-var Component = class extends Element {
+
+// ../jsx-node/node_modules/@miqro/jsx/build/esm/vdom/nodes/component.js
+var Component2 = class extends Element2 {
   constructor(parent) {
     super(parent);
     this.type = "Component";
@@ -8009,11 +9437,11 @@ var Component = class extends Element {
     this.parent = parent;
     const children = this.calculateChildren(runtime, options, change, list);
     for (const child of children) {
-      createNewNodeFromChange(runtime, options, normalizeChild(runtime, child), this, list);
+      createNewNodeFromChange2(runtime, options, normalizeChild2(runtime, child), this, list);
     }
     this.parent = parent;
     this.update(runtime, options, change, list, true);
-    list.push(createAppendAction(this, runtime));
+    list.push(createAppendAction2(this, runtime));
     this.lastRenderArgs = {
       props: change.props,
       children: change.children
@@ -8022,8 +9450,8 @@ var Component = class extends Element {
   }
   calculateChildren(runtime, options, change, list) {
     if (this.component && this.state) {
-      list.push(createFlushEffects(this, options, runtime));
-      const out = renderComponent(runtime, this, options, list, change.props, change.children);
+      list.push(createFlushEffects2(this, options, runtime));
+      const out = renderComponent2(runtime, this, options, list, change.props, change.children);
       return out ? out : [];
     } else {
       return super.calculateChildren(runtime, options, change, list);
@@ -8031,8 +9459,8 @@ var Component = class extends Element {
   }
 };
 
-// node_modules/@miqro/jsx/build/esm/vdom/nodes/ref.js
-var Ref = class extends BaseNode {
+// ../jsx-node/node_modules/@miqro/jsx/build/esm/vdom/nodes/ref.js
+var Ref2 = class extends BaseNode2 {
   constructor(parent) {
     super("Ref", parent);
   }
@@ -8042,7 +9470,7 @@ var Ref = class extends BaseNode {
     }
     this.ref = change.ref;
     this.parent = parent;
-    list.push(createAppendAction(this, runtime));
+    list.push(createAppendAction2(this, runtime));
     return this;
   }
   compare(change) {
@@ -8050,8 +9478,8 @@ var Ref = class extends BaseNode {
   }
 };
 
-// node_modules/@miqro/jsx/build/esm/vdom/nodes/text.js
-var Text = class extends BaseNode {
+// ../jsx-node/node_modules/@miqro/jsx/build/esm/vdom/nodes/text.js
+var Text2 = class extends BaseNode2 {
   constructor(parent) {
     super("Text", parent);
   }
@@ -8062,19 +9490,19 @@ var Text = class extends BaseNode {
     this.ref = runtime.createTextNode(change.textContent);
     this.textContent = change.textContent;
     this.parent = parent;
-    list.push(createAppendAction(this, runtime));
+    list.push(createAppendAction2(this, runtime));
     return this;
   }
   update(runtime, options, change, list, initial) {
     if (this.textContent !== change.textContent) {
-      list.push(createSetTextAction(this, change.textContent, runtime));
+      list.push(createSetTextAction2(this, change.textContent, runtime));
     }
     return this;
   }
 };
 
-// node_modules/@miqro/jsx/build/esm/vdom/tree.js
-var Tree = class extends BaseNode {
+// ../jsx-node/node_modules/@miqro/jsx/build/esm/vdom/tree.js
+var Tree2 = class extends BaseNode2 {
   name;
   constructor(name, ref, runtime, shadowInit) {
     super("Fragment", null);
@@ -8091,27 +9519,27 @@ var Tree = class extends BaseNode {
     return this.name;
   }
 };
-function createNewNodeFromChange(runtime, options, change, parent, list) {
+function createNewNodeFromChange2(runtime, options, change, parent, list) {
   switch (change.type) {
     case "ContextProvider":
-      return new ContextProvider(parent).create(runtime, options, change, parent, list);
+      return new ContextProvider2(parent).create(runtime, options, change, parent, list);
     case "Element":
-      return new Element(parent).create(runtime, options, change, parent, list);
+      return new Element2(parent).create(runtime, options, change, parent, list);
     case "Component":
-      return new Component(parent).create(runtime, options, change, parent, list);
+      return new Component2(parent).create(runtime, options, change, parent, list);
     case "Ref":
-      return new Ref(parent).create(runtime, options, change, parent, list);
+      return new Ref2(parent).create(runtime, options, change, parent, list);
     case "Text":
-      return new Text(parent).create(runtime, options, change, parent, list);
+      return new Text2(parent).create(runtime, options, change, parent, list);
     case "Fragment":
-      return new Fragment2(parent).create(runtime, options, change, parent, list);
+      return new Fragment4(parent).create(runtime, options, change, parent, list);
     case "FragmentComponent":
-      return new FragmentComponent(parent).create(runtime, options, change, parent, list);
+      return new FragmentComponent2(parent).create(runtime, options, change, parent, list);
     default:
       throw new Error(`unsopported change.type = %${change.type}`);
   }
 }
-function normalizeChild(runtime, c) {
+function normalizeChild2(runtime, c) {
   if (typeof c === "object") {
     if (c instanceof Array) {
       return {
@@ -8123,7 +9551,7 @@ function normalizeChild(runtime, c) {
         type: "Ref",
         ref: c
       };
-    } else if (c && CHANGE_TYPES_SET.has(c.type)) {
+    } else if (c && CHANGE_TYPES_SET2.has(c.type)) {
       return c;
     }
   }
@@ -8133,48 +9561,48 @@ function normalizeChild(runtime, c) {
   };
 }
 
-// node_modules/@miqro/jsx/build/esm/vdom/diff.js
-function diff(abortSignal, tree, changes, actions, options, runtime, lo = false) {
+// ../jsx-node/node_modules/@miqro/jsx/build/esm/vdom/diff.js
+function diff2(abortSignal, tree, changes, actions, options, runtime, lo = false) {
   if (changes === void 0 || changes === null || abortSignal.aborted) {
     return actions;
   }
   const currentChildren = tree.children.values();
   let currentChildrenRet = currentChildren.next();
   for (const change of changes) {
-    const normalizedChange = normalizeChild(runtime, change);
+    const normalizedChange = normalizeChild2(runtime, change);
     const actualChild = currentChildrenRet.value;
     if (actualChild === void 0) {
-      createNewNodeFromChange(runtime, options, normalizedChange, tree, actions);
+      createNewNodeFromChange2(runtime, options, normalizedChange, tree, actions);
     } else if (!actualChild.compare(normalizedChange)) {
-      currentChildrenRet = removeFrom(runtime, currentChildren, currentChildrenRet, actions, options);
-      createNewNodeFromChange(runtime, options, normalizedChange, tree, actions);
+      currentChildrenRet = removeFrom2(runtime, currentChildren, currentChildrenRet, actions, options);
+      createNewNodeFromChange2(runtime, options, normalizedChange, tree, actions);
     } else {
       actualChild.update(runtime, options, normalizedChange, actions);
       if (actualChild.type === "Fragment" || actualChild.type === "FragmentComponent" || actualChild.type === "ContextProvider") {
         const fragmentActions = [];
-        diff(abortSignal, actualChild, actualChild.calculateChildren(runtime, options, normalizedChange, fragmentActions), fragmentActions, options, runtime, true);
-        if (areActionDestructive(fragmentActions)) {
+        diff2(abortSignal, actualChild, actualChild.calculateChildren(runtime, options, normalizedChange, fragmentActions), fragmentActions, options, runtime, true);
+        if (areActionDestructive2(fragmentActions)) {
           currentChildrenRet = currentChildren.next();
-          currentChildrenRet = removeFrom(runtime, currentChildren, currentChildrenRet, actions, options);
+          currentChildrenRet = removeFrom2(runtime, currentChildren, currentChildrenRet, actions, options);
         }
         actions.push(...fragmentActions);
       } else {
-        diff(abortSignal, actualChild, actualChild.calculateChildren(runtime, options, normalizedChange, actions), actions, options, runtime);
+        diff2(abortSignal, actualChild, actualChild.calculateChildren(runtime, options, normalizedChange, actions), actions, options, runtime);
       }
     }
     currentChildrenRet = currentChildren.next();
   }
-  currentChildrenRet = removeFrom(runtime, currentChildren, currentChildrenRet, actions, options);
+  currentChildrenRet = removeFrom2(runtime, currentChildren, currentChildrenRet, actions, options);
   return actions;
 }
-function removeFrom(runtime, nodeIterator, nodeIteratorRet, currentActions, options) {
+function removeFrom2(runtime, nodeIterator, nodeIteratorRet, currentActions, options) {
   while (nodeIteratorRet.value !== void 0) {
     nodeIteratorRet.value.remove(runtime, options, currentActions);
     nodeIteratorRet = nodeIterator.next();
   }
   return nodeIteratorRet;
 }
-function areActionDestructive(actions) {
+function areActionDestructive2(actions) {
   for (const fragmentAction of actions) {
     if (fragmentAction.isDestructive) {
       return true;
@@ -8183,8 +9611,8 @@ function areActionDestructive(actions) {
   return false;
 }
 
-// node_modules/@miqro/jsx/build/esm/vdom/execute.js
-function execute(abortSignal, runtime, actions) {
+// ../jsx-node/node_modules/@miqro/jsx/build/esm/vdom/execute.js
+function execute2(abortSignal, runtime, actions) {
   if (abortSignal.aborted) {
     return 0;
   }
@@ -8200,7 +9628,7 @@ function execute(abortSignal, runtime, actions) {
         postExecute.push(action);
       }
     } catch (e) {
-      error(runtime, e);
+      error2(runtime, e);
       throw e;
     }
   }
@@ -8209,43 +9637,43 @@ function execute(abortSignal, runtime, actions) {
       const actionChanges = action.postExecute();
       changes += actionChanges;
     } catch (e) {
-      error(runtime, e);
+      error2(runtime, e);
       throw e;
     }
   }
   return changes;
 }
 
-// node_modules/@miqro/jsx/build/esm/vdom/render.js
-function render(runtime, tree, treeOptions, change, preActions = [], props, children) {
+// ../jsx-node/node_modules/@miqro/jsx/build/esm/vdom/render.js
+function render2(runtime, tree, treeOptions, change, preActions = [], props, children) {
   const meta = tree.state;
   if (!meta) {
     throw new Error("cannot find meta");
   }
   const abortSignal = tree.abortApply(runtime).signal;
-  debug(runtime, "render for [%s]", tree.getName());
+  debug2(runtime, "render for [%s]", tree.getName());
   if (tree.isRoot || tree.parent !== null) {
     const applyStart = Date.now();
-    const out = change instanceof Array ? change : change === true ? renderComponent(runtime, tree, treeOptions, preActions, props, children) : void 0;
-    const changes = execute(abortSignal, runtime, diff(abortSignal, tree, out, preActions, treeOptions, runtime));
+    const out = change instanceof Array ? change : change === true ? renderComponent2(runtime, tree, treeOptions, preActions, props, children) : void 0;
+    const changes = execute2(abortSignal, runtime, diff2(abortSignal, tree, out, preActions, treeOptions, runtime));
     const took = Date.now() - applyStart;
     if (took > 5e3) {
-      error(runtime, "render for [%s] with [%s] changes took [%s]ms", tree.getName(), changes, took);
+      error2(runtime, "render for [%s] with [%s] changes took [%s]ms", tree.getName(), changes, took);
     } else {
-      debug(runtime, "render for [%s] with [%s] changes took [%s]ms", tree.getName(), changes, took);
+      debug2(runtime, "render for [%s] with [%s] changes took [%s]ms", tree.getName(), changes, took);
     }
     return changes;
   } else {
-    debug(runtime, "render skipped for [%s]", tree.getName());
+    debug2(runtime, "render skipped for [%s]", tree.getName());
     return 0;
   }
 }
 
-// node_modules/@miqro/jsx/build/esm/component/container.js
-var objectDefineProperty2 = Object.defineProperty;
-function createContainer(element, runtime, args) {
+// ../jsx-node/node_modules/@miqro/jsx/build/esm/component/container.js
+var objectDefineProperty4 = Object.defineProperty;
+function createContainer2(element, runtime, args) {
   const name = `DOMContainer [${String(element)}]`;
-  const tree = new Tree(name, element, runtime, args?.shadowInit);
+  const tree = new Tree2(name, element, runtime, args?.shadowInit);
   const treeOptions = args && args.runtimeOptions ? {
     disableEffects: false,
     disableRefListener: false,
@@ -8259,57 +9687,57 @@ function createContainer(element, runtime, args) {
     disableEvents: false
   };
   const container = /* @__PURE__ */ Object.create(null);
-  objectDefineProperty2(container, "name", {
+  objectDefineProperty4(container, "name", {
     configurable: false,
     enumerable: true,
     writable: false,
     value: name
   });
-  objectDefineProperty2(container, "render", {
+  objectDefineProperty4(container, "render", {
     configurable: false,
     enumerable: true,
     writable: false,
-    value: function render2(out) {
-      return render(runtime, tree, treeOptions, [out]);
+    value: function render3(out) {
+      return render2(runtime, tree, treeOptions, [out]);
     }
   });
-  objectDefineProperty2(container, "disconnect", {
+  objectDefineProperty4(container, "disconnect", {
     configurable: false,
     enumerable: true,
     writable: false,
     value: function disconnect() {
-      return render(runtime, tree, treeOptions, []);
+      return render2(runtime, tree, treeOptions, []);
     }
   });
   Object.freeze(container);
   return container;
 }
 
-// node_modules/@miqro/jsx/build/esm/hooks/runtime.js
-function useRuntime() {
-  useConditional("useRuntime");
-  const currentContext2 = useRenderContext();
-  if (!currentContext2) {
+// ../jsx-node/node_modules/@miqro/jsx/build/esm/hooks/runtime.js
+function useRuntime2() {
+  useConditional2("useRuntime");
+  const currentContext3 = useRenderContext2();
+  if (!currentContext3) {
     throw new Error("useRuntime not in render");
   }
-  return currentContext2.runtime;
+  return currentContext3.runtime;
 }
 
-// node_modules/@miqro/jsx/build/esm/hooks/refresh.js
-var REFRESH_TIMEOUT_MS = 0;
-function useRefresh() {
-  useConditional("useRefresh");
-  const currentContext2 = useRenderContext();
-  if (!currentContext2) {
+// ../jsx-node/node_modules/@miqro/jsx/build/esm/hooks/refresh.js
+var REFRESH_TIMEOUT_MS2 = 0;
+function useRefresh2() {
+  useConditional2("useRefresh");
+  const currentContext3 = useRenderContext2();
+  if (!currentContext3) {
     throw new Error("useRefresh not in render");
   }
-  const meta = currentContext2.node.state;
+  const meta = currentContext3.node.state;
   if (!meta) {
     throw new Error("useRefresh without meta");
   }
-  const runtime = useRuntime();
-  const options = currentContext2.options;
-  const node = currentContext2.node;
+  const runtime = useRuntime2();
+  const options = currentContext3.options;
+  const node = currentContext3.node;
   const component = node.component;
   if (!component) {
     throw new Error("useRefresh without func");
@@ -8317,31 +9745,31 @@ function useRefresh() {
   return (cb) => {
     runtime.clearTimeout(meta.refreshTimeout);
     if (options.disableRefresh) {
-      debug(runtime, "useRefresh.refresh() disabled for [%s]", component.name);
+      debug2(runtime, "useRefresh.refresh() disabled for [%s]", component.name);
     } else {
       meta.refreshTimeout = runtime.setTimeout(() => {
-        debug(runtime, "useRefresh.refresh() for [%s]", component.name);
+        debug2(runtime, "useRefresh.refresh() for [%s]", component.name);
         const props = node.lastRenderArgs.props;
         const children = node.lastRenderArgs.children;
-        const changes = render(runtime, node, options, true, [createFlushEffects(node, options, runtime)], props, children);
+        const changes = render2(runtime, node, options, true, [createFlushEffects2(node, options, runtime)], props, children);
         if (cb) {
           runtime.setTimeout(() => cb(changes), 0);
         }
-      }, REFRESH_TIMEOUT_MS);
+      }, REFRESH_TIMEOUT_MS2);
     }
   };
 }
 
-// node_modules/@miqro/jsx/build/esm/hooks/state.js
-function useState(defaultValue) {
-  const key = useConditional("useState");
-  const currentContext2 = useRenderContext();
-  if (!currentContext2) {
+// ../jsx-node/node_modules/@miqro/jsx/build/esm/hooks/state.js
+function useState2(defaultValue) {
+  const key = useConditional2("useState");
+  const currentContext3 = useRenderContext2();
+  if (!currentContext3) {
     throw new Error("useState not in render");
   }
-  const refresh = useRefresh();
-  const meta = currentContext2.node.state;
-  const runtime = useRuntime();
+  const refresh = useRefresh2();
+  const meta = currentContext3.node.state;
+  const runtime = useRuntime2();
   if (!meta) {
     throw new Error("useState without meta");
   }
@@ -8351,13 +9779,13 @@ function useState(defaultValue) {
   if (!meta.state) {
     throw new Error("useState without meta.state");
   }
-  const name = currentContext2.node.component?.name;
+  const name = currentContext3.node.component?.name;
   const currentStateItem = meta.state[key];
   if (currentStateItem === void 0) {
     const stateItem = {
       value: defaultValue,
       set: (newValue, refreshOnSet = true) => {
-        debug(runtime, "setState() for [%s]", name);
+        debug2(runtime, "setState() for [%s]", name);
         if (stateItem.value !== newValue) {
           stateItem.value = newValue;
           if (refreshOnSet) {
@@ -8384,19 +9812,19 @@ function useState(defaultValue) {
   }
 }
 
-// node_modules/@miqro/jsx/build/esm/hooks/effect.js
-function useEffect(effect, condition) {
-  const currentContext2 = useRenderContext();
-  if (!currentContext2) {
+// ../jsx-node/node_modules/@miqro/jsx/build/esm/hooks/effect.js
+function useEffect2(effect, condition) {
+  const currentContext3 = useRenderContext2();
+  if (!currentContext3) {
     throw new Error("useEffect not in render");
   }
-  const key = useConditional("useEffect");
-  const meta = currentContext2.node.state;
+  const key = useConditional2("useEffect");
+  const meta = currentContext3.node.state;
   if (!meta) {
     throw new Error("useEffect without meta");
   }
   const c = condition ? condition : false;
-  if (meta.effectConditions[key] === void 0 || condition === void 0 && meta.effectConditions[key] === false || !equalArray(meta.effectConditions[key], c)) {
+  if (meta.effectConditions[key] === void 0 || condition === void 0 && meta.effectConditions[key] === false || !equalArray2(meta.effectConditions[key], c)) {
     meta.effectConditions[key] = c;
     const oldCallback = meta.effectQueueCallbacks[key];
     delete meta.effectQueueCallbacks[key];
@@ -8410,7 +9838,7 @@ function useEffect(effect, condition) {
     meta.effects[key] = effect;
   }
 }
-function equalArray(a, c) {
+function equalArray2(a, c) {
   if (typeof a !== typeof c) {
     return false;
   }
@@ -8430,13 +9858,13 @@ function equalArray(a, c) {
   return true;
 }
 
-// node_modules/@miqro/jsx/build/esm/hooks/pathname.js
-function usePathname() {
-  const runtime = useRuntime();
+// ../jsx-node/node_modules/@miqro/jsx/build/esm/hooks/pathname.js
+function usePathname2() {
+  const runtime = useRuntime2();
   const pathname = runtime.getLocation().pathname;
-  const [currentLocation, setCurrentLocation, getL] = useState(pathname);
-  debug(runtime, "usePathname [%s]", currentLocation);
-  useEffect(function usePathnameEffect() {
+  const [currentLocation, setCurrentLocation, getL] = useState2(pathname);
+  debug2(runtime, "usePathname [%s]", currentLocation);
+  useEffect2(function usePathnameEffect() {
     const listener = () => {
       const newLocation = runtime.getLocation().pathname;
       setCurrentLocation(newLocation);
@@ -8449,32 +9877,32 @@ function usePathname() {
   return String(currentLocation);
 }
 
-// node_modules/@miqro/jsx/build/esm/component/router.js
-function useIsLocationPathNameActive(path) {
-  useConditional("useIsLocationPathNameMatch");
-  const runtime = useRuntime();
+// ../jsx-node/node_modules/@miqro/jsx/build/esm/component/router.js
+function useIsLocationPathNameActive2(path) {
+  useConditional2("useIsLocationPathNameMatch");
+  const runtime = useRuntime2();
   const basePath = runtime.getBasePath();
-  return isPathLocation(basePath, path, usePathname());
+  return isPathLocation2(basePath, path, usePathname2());
 }
-function Router(props) {
+function Router2(props) {
   const defaultElement = props.defaultElement;
-  const locationPathName = usePathname();
-  const runtime = useRuntime();
-  const active = getActiveRoute(locationPathName, props.routes, runtime);
+  const locationPathName = usePathname2();
+  const runtime = useRuntime2();
+  const active = getActiveRoute2(locationPathName, props.routes, runtime);
   return active ? active.element : defaultElement;
 }
-Router.asFragment = true;
-Router.shadowInit = false;
-function Link(props, children) {
+Router2.asFragment = true;
+Router2.shadowInit = false;
+function Link2(props, children) {
   const path = props.path;
-  const runtime = useRuntime();
+  const runtime = useRuntime2();
   const basePath = runtime.getBasePath();
   const className = props.className ? props.className : "";
   const activeClass = props.classNameActive ? props.classNameActive : "active";
   const inactiveClass = props.classNameInactive ? props.classNameInactive : "inactive";
-  const isActive = useIsLocationPathNameActive(path);
+  const isActive = useIsLocationPathNameActive2(path);
   const newClassName = `${className ? `${className} ` : ""}${isActive ? activeClass : inactiveClass}`;
-  const fullPath = getFullPath(basePath, path);
+  const fullPath = getFullPath2(basePath, path);
   const element = {
     type: "Element",
     tagName: "a",
@@ -8495,181 +9923,35 @@ function Link(props, children) {
     }
   };
 }
-Link.asFragment = true;
-Link.shadowInit = false;
-function getFullPath(basePath, p) {
-  return normalizePath(`${basePath ? basePath : ""}${p}`);
+Link2.asFragment = true;
+Link2.shadowInit = false;
+function getFullPath2(basePath, p) {
+  return normalizePath2(`${basePath ? basePath : ""}${p}`);
 }
-function isPathLocation(basePath, p, currentLocation) {
-  const path = getFullPath(basePath, p);
-  const pathname = normalizePath(currentLocation);
+function isPathLocation2(basePath, p, currentLocation) {
+  const path = getFullPath2(basePath, p);
+  const pathname = normalizePath2(currentLocation);
   return pathname.toLocaleLowerCase() === path.toLowerCase();
 }
-function getActiveRoute(locationPathName, routes, runtime) {
+function getActiveRoute2(locationPathName, routes, runtime) {
   let activeRoute;
   const basePath = runtime.getBasePath() ? runtime.getBasePath() : "";
   for (const route of routes) {
-    if (isPathLocation(basePath, route.path, locationPathName)) {
+    if (isPathLocation2(basePath, route.path, locationPathName)) {
       activeRoute = route;
       break;
     }
   }
   return activeRoute;
 }
-function normalizePath(path) {
+function normalizePath2(path) {
   if (path.length > 1 && path.charAt(path.length - 1) === "/") {
     path = path.substring(0, path.length - 1);
   }
   return path;
 }
 
-// node_modules/@miqro/jsx/build/esm/hooks/ref.js
-function useRef() {
-  const [ref, setRef] = useState(null);
-  function useRefFunction(newRef) {
-    setRef(newRef);
-  }
-  ;
-  useRefFunction.current = ref;
-  return useRefFunction;
-}
-
-// node_modules/@miqro/jsx/build/esm/hooks/query.js
-function useAllQuery(watch2 = true) {
-  const key = useConditional(`useAllQuery`);
-  const runtime = useRuntime();
-  const [last, setLast, getLast] = useState(getQueryValue(runtime));
-  useEffect(function useQueryEffect() {
-    if (watch2) {
-      let useQueryEffectPathListener = function() {
-        const current = getQueryValue(runtime);
-        if (getLast() !== current) {
-          debug(runtime, "useQuery listener for %s", key);
-          setLast(current);
-        }
-      };
-      runtime.addPathListener(useQueryEffectPathListener);
-      return function useQueryEffectUnLoad() {
-        runtime.removePathListener(useQueryEffectPathListener);
-      };
-    }
-  }, []);
-  return last;
-}
-function useQuery(name, defaultValue, watch2 = true) {
-  const key = useConditional(`useQuery-${name}-${defaultValue}`);
-  const runtime = useRuntime();
-  const [last, setLast, getLast] = useState(getQueryValue(runtime, name, defaultValue));
-  useEffect(function useQueryEffect() {
-    if (watch2) {
-      let useQueryEffectPathListener = function() {
-        const current = getQueryValue(runtime, name, defaultValue);
-        if (getLast() !== current) {
-          debug(runtime, "useQuery listener for %s", key);
-          setLast(current);
-        }
-      };
-      runtime.addPathListener(useQueryEffectPathListener);
-      return function useQueryEffectUnLoad() {
-        runtime.removePathListener(useQueryEffectPathListener);
-      };
-    }
-  }, []);
-  return [
-    last,
-    function setQuery(newValue) {
-      setQueryValue(runtime, name, newValue, watch2);
-      setLast(newValue);
-    },
-    function getQuery() {
-      return getQueryValue(runtime, name, defaultValue);
-    }
-  ];
-}
-function getQueryValue(runtime, name, defaultValue) {
-  if (!name) {
-    return runtime.getLocation().searchParams.toString();
-  } else {
-    const ret = runtime.getLocation().searchParams.getAll(name);
-    if (ret.length === 0) {
-      return defaultValue !== void 0 ? defaultValue : null;
-    }
-    return ret && ret.length === 1 && !(defaultValue instanceof Array) ? ret[0] : ret;
-  }
-}
-function setQueryValue(runtime, name, value, watch2 = true) {
-  const url = runtime.getLocation();
-  if (value instanceof Array) {
-    url.searchParams.delete(name);
-    for (const v of value) {
-      url.searchParams.append(name, v);
-    }
-  } else if (value !== null) {
-    url.searchParams.set(name, value);
-  } else {
-    url.searchParams.delete(name);
-  }
-  if (watch2) {
-    runtime.pushPath(String(url));
-  }
-}
-
-// node_modules/@miqro/jsx/build/esm/hooks/useelement.js
-function useElement() {
-  useConditional("useElement");
-  const currentContext2 = useRenderContext();
-  if (!currentContext2) {
-    throw new Error("useElement not in render");
-  }
-  return currentContext2.node.ref ? currentContext2.node.ref : null;
-}
-
-// node_modules/@miqro/jsx/build/esm/hooks/context.js
-function createContext(defaultValue) {
-  const symbol = /* @__PURE__ */ Symbol();
-  return {
-    provider: createContextProvider(symbol, defaultValue),
-    symbol
-  };
-}
-function useContext(context) {
-  useConditional("useContext");
-  const currentContext2 = useRenderContext();
-  if (!currentContext2) {
-    throw new Error("useContext not in render");
-  }
-  let currentNode = currentContext2.node;
-  while (currentNode) {
-    if (currentNode.type === "ContextProvider" && currentNode.contextKey === context.symbol) {
-      return currentNode.contextValue;
-    }
-    currentNode = currentNode.parent;
-  }
-  throw new Error("cannot find provider!");
-}
-function createContextProvider(symbol, defaultValue) {
-  function ContextProvider2({ value }, ...children) {
-    useConditional("ContextProvider");
-    const currentContext2 = useRenderContext();
-    if (!currentContext2) {
-      throw new Error("ContextProvider not in render");
-    }
-    return {
-      type: "ContextProvider",
-      contextKey: symbol,
-      contextValue: value === void 0 ? defaultValue : value,
-      children
-    };
-  }
-  ContextProvider2.asFragment = true;
-  ContextProvider2.shadowInit = false;
-  return ContextProvider2;
-}
-
-// node_modules/@miqro/jsx/build/esm/lib.js
-var lib_default = JSX;
-
-// node_modules/@miqro/jsx-node/build/esm/runtime.js
+// ../jsx-node/build/esm/runtime.js
 var import_events = require("events");
 var SELF_CLOSING_TAGS = /* @__PURE__ */ new Set([
   "area",
@@ -8782,7 +10064,7 @@ var SSRAttributeMap = class extends Map {
       kIterator = keys.next();
     }
     if (this.node.value) {
-      ret = `${ret} ${AttributeEncode("value")}="${this.node.value}"`;
+      ret = `${ret} ${AttributeEncode("value")}="${AttributeEncode(String(this.node.value))}"`;
     }
     return ret;
   }
@@ -8931,7 +10213,7 @@ function HTMLEncode(str) {
   return aRet.join("");
 }
 function AttributeEncode(str) {
-  return str.replaceAll('"', "&quot;");
+  return str.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
 }
 var containerMap = /* @__PURE__ */ new WeakMap();
 var originalChildNodesMap = /* @__PURE__ */ new WeakMap();
@@ -8958,7 +10240,7 @@ function runtimeDefine(runtime, tagName, component, options) {
         props[name] = self.getAttribute(name);
       }
       props["$element$"] = self;
-      container.render(createElement(component, props, originalChildNodes));
+      container.render(createElement2(component, props, originalChildNodes));
     }
     disconnectedCallback() {
       const container = containerMap.get(this);
@@ -8982,7 +10264,7 @@ function runtimeDefine(runtime, tagName, component, options) {
         props[name] = self.getAttribute(name);
       }
       props["$element$"] = self;
-      container.render(createElement(component, props, originalChildNodes));
+      container.render(createElement2(component, props, originalChildNodes));
     }
     reCalculateOriginalChildren() {
       if (originalChildNodesMap.has(this)) {
@@ -9022,7 +10304,7 @@ function createNodeRuntime(options) {
     basePath: options?.basePath
   };
   const customElementMap = {};
-  const elementByIdMap = {};
+  const elementByIdMap = /* @__PURE__ */ Object.create(null);
   const runtime = {
     name: "node",
     customElementMap,
@@ -9043,7 +10325,7 @@ function createNodeRuntime(options) {
       return runtime._activeElement;
     },
     createContainer: (element, options2) => {
-      return createContainer(element, runtime, options2);
+      return createContainer2(element, runtime, options2);
     },
     getElementById: (id) => {
       return elementByIdMap[id] ? elementByIdMap[id] : null;
@@ -9083,13 +10365,6 @@ function createNodeRuntime(options) {
   return runtime;
 }
 
-// node_modules/@miqro/jsx-node/build/esm/handler.js
-init_lib3();
-
-// node_modules/@miqro/jsx-node/build/esm/constants.js
-var import_os = require("os");
-var DEFAULT_BUILD_DIR = (0, import_os.tmpdir)();
-
 // src/common/jsx.ts
 var import_node_path6 = require("node:path");
 var import_node_crypto4 = require("node:crypto");
@@ -10374,17 +11649,17 @@ async function sqlite3Executor(config) {
     transformOutput: sqliteTransformOutput,
     query: async function sqlite3Executor2(sql, values) {
       return new Promise((resolve24, reject) => {
-        const st = driver.prepare(sql, values, function(error2) {
-          if (error2) {
-            reject(error2);
+        const st = driver.prepare(sql, values, function(error3) {
+          if (error3) {
+            reject(error3);
           } else {
-            st.all(function(error3, rows) {
-              if (error3) {
-                reject(error3);
+            st.all(function(error4, rows) {
+              if (error4) {
+                reject(error4);
               } else {
-                st.finalize((error4) => {
-                  if (error4) {
-                    reject(error4);
+                st.finalize((error5) => {
+                  if (error5) {
+                    reject(error5);
                   } else {
                     resolve24(rows);
                   }
@@ -11679,7 +12954,7 @@ var ClusterWebSocketServer2 = class extends WebSocketServer {
           return options.validate ? options.validate(req) : true;
         }
       },
-      onError: (req, error2) => {
+      onError: (req, error3) => {
         if (process.send) {
           process.send({
             type: ClusterWebSocketServer2MessageType,
@@ -11687,13 +12962,13 @@ var ClusterWebSocketServer2 = class extends WebSocketServer {
             target: this.name,
             clientUUID: req.uuid,
             fromPID: String(process.pid),
-            errorMessage: error2.message
+            errorMessage: error3.message
           });
         }
-        this.logger?.error("[%s] error from (%s) error [%s]", req.uuid, req.req.socket.remoteAddress, error2);
-        this.logger?.error(error2);
+        this.logger?.error("[%s] error from (%s) error [%s]", req.uuid, req.req.socket.remoteAddress, error3);
+        this.logger?.error(error3);
         if (options.onError) {
-          options.onError(req, error2);
+          options.onError(req, error3);
         }
       },
       onConnection: (req) => {
@@ -12383,7 +13658,7 @@ var LogProvider = class {
     try {
       const url = newURL2(req.url ? req.url : "/");
       query = url.searchParams.toString();
-      path = normalizePath2(url.pathname);
+      path = normalizePath3(url.pathname);
       method = req.method ? req.method.toUpperCase() : "GET";
       remoteAddress = req.socket.remoteAddress;
     } catch (e) {
@@ -12704,7 +13979,7 @@ function getRoutes(prePath, defaultPath, apiOptions) {
           inflatePath: p !== "/" ? (0, import_node_path9.join)(prePath, p) : defaultInflatePath,
           defaultInflatePath,
           method: m.toLocaleLowerCase() !== "use" ? m.toUpperCase() : void 0,
-          path: normalizePath2((0, import_node_path9.join)(prePath, p))
+          path: normalizePath3((0, import_node_path9.join)(prePath, p))
         });
       }
     }
@@ -12817,7 +14092,7 @@ async function setupError(logger, servicePath, service, mainRouter, inflateDir,
 
 // src/inflate/setup-http.ts
 async function setupHTTPRouter(importOptions, inflateOptions, server, logger, hotreload, servicePath, service, routeFileMap, staticFileMap, inflateDir, inflateSea, errors, inflateParallel) {
-  const mainRouter = new Router2();
+  const mainRouter = new Router3();
   const apiRouterPath = getHTTPRouterPath(servicePath);
   let middlewareConfig = null;
   await setupError(logger, servicePath, service, mainRouter, inflateDir, inflateSea, importOptions, errors);
@@ -12855,7 +14130,7 @@ async function createStaticRoute(inflateJSXOptions, service, logger, router, dir
       routeFileMap[file.filePath] = {
         routes: [{
           method: "GET",
-          path: normalizePath2(path)
+          path: normalizePath3(path)
         }],
         service,
         filePath: file.filePath,
@@ -12879,7 +14154,7 @@ async function createStaticRoute(inflateJSXOptions, service, logger, router, dir
             filePath: file.filePath,
             previewMethod: "html",
             method: "GET",
-            path: normalizePath2(path),
+            path: normalizePath3(path),
             body: Buffer.from(body),
             inflatePath: inflateDir ? (0, import_node_path12.join)(inflateDir, !inflateJSXOptions.inflateFlat ? service : "", "static", path) : void 0
           };
@@ -12921,7 +14196,7 @@ async function createStaticRoute(inflateJSXOptions, service, logger, router, dir
   });
 }
 async function createStaticRouterFromDirectory(inflateOptions, service, logger, dir, inflateDir, routeFileMap, staticFileMap, inflateParallel) {
-  const router = new Router2();
+  const router = new Router3();
   const maxParallel = inflateParallel ? inflateParallel : 1;
   logger.debug("loading static directory with parallel [%s]", maxParallel);
   let tR = [];
@@ -12940,7 +14215,7 @@ async function createStaticRouterFromDirectory(inflateOptions, service, logger,
   return router;
 }
 async function createRouterFromDirectory(importOptions, inflateJSXOptions, server, hotreload, service, logger, dir, errors = [], routeFileMap = {}, staticFileMap = null, inflateDir, inflateSea, inflateParallel) {
-  const router = new Router2();
+  const router = new Router3();
   const maxParallel = inflateParallel ? inflateParallel : 1;
   server.logger.debug("loading http directory with parallel [%s]", maxParallel);
   let tR = [];
@@ -14052,7 +15327,7 @@ async function inflateApp({ inflateParallel, serverInterface, logger, hotreload,
   const errors = [];
   let routeFileMap = {};
   const wsConfigList = [];
-  const router = new Router2();
+  const router = new Router3();
   const logConfigMap = {};
   for (const service of services) {
     const serviceRouteFileMap = {};
@@ -14216,8 +15491,8 @@ var server_default = {
 init_lib3();
 init_constants();
 async function createEditorRouter(adminInterface) {
-  const router = new Router2();
-  const innerRouter = new Router2();
+  const router = new Router3();
+  const innerRouter = new Router3();
   innerRouter.use(async (req, res) => {
     res.setHeader("x-uuid", req.uuid);
     req.editor = adminInterface;
@@ -14391,13 +15666,13 @@ function setupExitHandlers(app) {
     }
     process.exit(EXIT_CODES.ABNORMAL_UNCONTROLLED);
   });
-  process.on("exit", function(code) {
+  process.on("exit", async function(code) {
     if (exceptionOccured) {
       app.logger?.error("Exception occured");
     } else {
       cleanJSX(app);
       if (app.server) {
-        app.stop();
+        await app.stop();
       }
     }
   });
@@ -17514,7 +18789,7 @@ var Miqro = class _Miqro {
     }
     this.inflated = void 0;
     this.inflated = {
-      router: inflated && inflated.router ? inflated.router : new Router2(),
+      router: inflated && inflated.router ? inflated.router : new Router3(),
       errors: inflated && inflated.errors ? inflated.errors : [],
       fileMap: inflated && inflated.fileMap ? inflated.fileMap : {},
       logConfigMap: inflated && inflated.logConfigMap ? inflated.logConfigMap : {},
@@ -17601,7 +18876,7 @@ var Miqro = class _Miqro {
         _Miqro.initAssetsPromise = initAssets(this.logger);
       }
       await _Miqro.initAssetsPromise;
-      const router = new Router2();
+      const router = new Router3();
       const wsConfigList = [];
       const { dbList, errors: dbConfigErrors } = await this.loadDBConfig(options);
       await Promise.all(dbList.map((db) => this.dbManager.setupDB(db.dbConfig)));
@@ -17620,7 +18895,7 @@ var Miqro = class _Miqro {
           path: HOT_RELOAD_PATH
         });
         this.logger?.debug("setting up hot-reload script on [%s]", HOT_RELOAD_SCRIPT_PATH);
-        const hotReloadScriptRouter = new Router2();
+        const hotReloadScriptRouter = new Router3();
         hotReloadScriptRouter.get(HOT_RELOAD_SCRIPT_PATH, async (req, res) => res.js(HOT_RELOAD_JS_SCRIPT));
         router.use(hotReloadScriptRouter);
       }
@@ -17694,10 +18969,10 @@ var Miqro = class _Miqro {
     this.connect();
     await this.dbManager.connectAll();
     this.server = new App({
-      onUpgrade: (req, socket, head) => {
+      onUpgrade: async (req, socket, head) => {
         try {
           req.server = this.serverInterface;
-          return this.webSocketManager.onUpgrade(req, socket, head);
+          return await this.webSocketManager.onUpgrade(req, socket, head);
         } catch (e) {
           this.logger?.error(e);
         }
@@ -17939,7 +19214,7 @@ async function appendAPIModule(router, dir, filePath, module2) {
 
 // src/lib.ts
 init_lib3();
-var JSX2 = {
+var JSX3 = {
   createElement: (...args) => {
     const ret = createElement(...args);
     ret.toString = () => jsx2HTML(ret);