@psnext/slingcli 3.0.20260820-2 → 3.1.20260904-1

package/node_modules/hono/dist/helper/accepts/accepts.js

@@ -1,9 +1,43 @@
 // src/helper/accepts/accepts.ts
 import { parseAccept } from "../../utils/accept.js";
+var matchType = (acceptType, supportedType) => {
+  if (acceptType === supportedType) {
+    return true;
+  }
+  if (acceptType === "*/*" || acceptType === "*") {
+    return false;
+  }
+  if (acceptType.endsWith("/*")) {
+    const [acceptMain] = acceptType.split("/");
+    const [supportedMain] = supportedType.split("/");
+    return acceptMain === supportedMain;
+  }
+  return false;
+};
+var getSpecificity = (type) => {
+  if (type === "*/*" || type === "*") {
+    return 1;
+  }
+  if (type.endsWith("/*")) {
+    return 2;
+  }
+  return 3;
+};
 var defaultMatch = (accepts2, config) => {
   const { supports, default: defaultSupport } = config;
-  const accept = accepts2.sort((a, b) => b.q - a.q).find((accept2) => supports.includes(accept2.type));
-  return accept ? accept.type : defaultSupport;
+  const sortedAccepts = accepts2.slice().sort((a, b) => {
+    if (b.q !== a.q) {
+      return b.q - a.q;
+    }
+    return getSpecificity(b.type) - getSpecificity(a.type);
+  });
+  for (const accept of sortedAccepts) {
+    const matched = supports.find((supported) => matchType(accept.type, supported));
+    if (matched) {
+      return matched;
+    }
+  }
+  return defaultSupport;
 };
 var accepts = (c, options) => {
   const acceptHeader = c.req.header(options.header);

package/node_modules/hono/dist/helper/ssg/ssg.js

@@ -184,7 +184,7 @@ var saveContentToFile = async (data, fsModule, outDir, extensionMap) => {
   const { routePath, content, mimeType } = awaitedData;
   const filePath = generateFilePath(routePath, outDir, mimeType, extensionMap);
   const dirPath = dirname(filePath);
-  if (!createdDirs.has(dirPath)) {
+  if (dirPath !== "" && !createdDirs.has(dirPath)) {
     await fsModule.mkdir(dirPath, { recursive: true });
     createdDirs.add(dirPath);
   }

package/node_modules/hono/dist/helper/ssg/utils.js

@@ -8,8 +8,14 @@ var dirname = (path) => {
 var normalizePath = (path) => {
   return path.replace(/(\\)/g, "/").replace(/\/$/g, "");
 };
-var handleParent = (resultPaths, beforeParentFlag) => {
-  if (resultPaths.length === 0 || beforeParentFlag) {
+var getUncRoot = (path) => {
+  const uncRoot = path.replace(/\\/g, "/").match(/^\/\/([^/]+)\/([^/]+)/);
+  if (uncRoot) {
+    return `${uncRoot[1].toLowerCase()}/${uncRoot[2].toLowerCase()}`;
+  }
+};
+var handleParent = (resultPaths) => {
+  if (resultPaths.length === 0 || resultPaths[resultPaths.length - 1] === "..") {
     resultPaths.push("..");
   } else {
     resultPaths.pop();
@@ -22,22 +28,20 @@ var handleNonDot = (path, resultPaths) => {
   }
 };
 var handleSegments = (paths, resultPaths) => {
-  let beforeParentFlag = false;
   for (const path of paths) {
     if (path === "..") {
-      handleParent(resultPaths, beforeParentFlag);
-      beforeParentFlag = true;
+      handleParent(resultPaths);
     } else {
       handleNonDot(path, resultPaths);
-      beforeParentFlag = false;
     }
   }
 };
 var joinPaths = (...paths) => {
+  const hasUncPrefix = getUncRoot(paths[0]) !== void 0;
   paths = paths.map(normalizePath);
   const resultPaths = [];
   handleSegments(paths.join("/").split("/"), resultPaths);
-  return (paths[0][0] === "/" ? "/" : "") + resultPaths.join("/");
+  return (hasUncPrefix ? "//" : paths[0][0] === "/" ? "/" : "") + resultPaths.join("/");
 };
 var filterStaticGenerateRoutes = (hono) => {
   return hono.routes.reduce((acc, { method, handler, path }) => {
@@ -51,10 +55,26 @@ var filterStaticGenerateRoutes = (hono) => {
 var isDynamicRoute = (path) => {
   return path.split("/").some((segment) => segment.startsWith(":") || segment.includes("*"));
 };
+var toSegments = (path) => path === "" ? [] : path.split("/");
+var getPathRoot = (path) => {
+  const normalizedPath = path.replace(/\\/g, "/");
+  const uncRoot = getUncRoot(normalizedPath);
+  if (uncRoot) {
+    return `unc:${uncRoot}`;
+  }
+  const driveRoot = normalizedPath.match(/^([A-Za-z]):/);
+  if (driveRoot) {
+    const kind = normalizedPath[2] === "/" ? "drive-absolute" : "drive-relative";
+    return `${kind}:${driveRoot[1].toLowerCase()}`;
+  }
+  return normalizedPath.startsWith("/") ? "absolute" : "relative";
+};
 var ensureWithinOutDir = (outDir, filePath) => {
-  const normalizedOutDir = joinPaths("/", outDir);
-  const normalizedFilePath = joinPaths("/", filePath);
-  if (normalizedFilePath !== normalizedOutDir && !normalizedFilePath.startsWith(`${normalizedOutDir}/`)) {
+  const outDirSegments = toSegments(joinPaths(outDir));
+  const filePathSegments = toSegments(joinPaths(filePath));
+  const hasMismatchedPathRoot = getPathRoot(outDir) !== getPathRoot(filePath);
+  const climbsAboveOutDir = filePathSegments[outDirSegments.length] === "..";
+  if (hasMismatchedPathRoot || filePathSegments.length <= outDirSegments.length || !outDirSegments.every((segment, i) => segment === filePathSegments[i]) || climbsAboveOutDir) {
     throw new Error(`Path traversal detected: "${filePath}" is outside the output directory`);
   }
 };

package/node_modules/hono/dist/jsx/dom/render.js

@@ -78,6 +78,7 @@ var applyProps = (container, attributes, oldAttributes) => {
       } else if (key === "dangerouslySetInnerHTML" && value) {
         container.innerHTML = value.__html;
       } else if (key === "ref") {
+        refCleanupMap.get(container)?.();
         let cleanup;
         if (typeof value === "function") {
           cleanup = value(container) || (() => value(null));
@@ -142,6 +143,7 @@ var applyProps = (container, attributes, oldAttributes) => {
           container.removeEventListener(eventSpec[0], value, eventSpec[1]);
         } else if (key === "ref") {
           refCleanupMap.get(container)?.();
+          refCleanupMap.delete(container);
         } else {
           try {
             container.removeAttribute(toAttributeName(container, key));

package/node_modules/hono/dist/middleware/cache/index.js

@@ -23,7 +23,7 @@ var parseVaryDirectives = (vary) => {
 };
 var createCacheKey = (key, requestUrl, request, varyHeaders) => {
   const url = new URL(cacheKeyPath, requestUrl);
-  url.searchParams.append(cacheKeyParameter, key.split("#", 1)[0]);
+  url.searchParams.append(cacheKeyParameter, key);
   url.searchParams.append(cacheMethodKeyParameter, request.method);
   if (request.method === "QUERY") {
     url.searchParams.append(queryDigestKeyParameter, request.digest);

package/node_modules/hono/dist/middleware/etag/index.js

@@ -10,7 +10,7 @@ var RETAINED_304_HEADERS = [
 ];
 var stripWeak = (tag) => tag.replace(/^W\//, "");
 function etagMatches(etag2, ifNoneMatch) {
-  return ifNoneMatch != null && ifNoneMatch.split(/,\s*/).some((t) => stripWeak(t) === stripWeak(etag2));
+  return ifNoneMatch != null && ifNoneMatch.split(",").some((t) => stripWeak(t.trim()) === stripWeak(etag2));
 }
 function initializeGenerator(generator) {
   if (!generator) {

package/node_modules/hono/dist/request.js

@@ -46,13 +46,13 @@ var HonoRequest = class {
     return key ? this.#getDecodedParam(key) : this.#getAllDecodedParams();
   }
   #getDecodedParam(key) {
-    const paramKey = this.#matchResult[0][this.routeIndex][1][key];
+    const paramKey = this.#matchResult[0][this.routeIndex]?.[1][key];
     const param = this.#getParamValue(paramKey);
     return param && tryDecodeURIComponent(param);
   }
   #getAllDecodedParams() {
     const decoded = {};
-    const keys = Object.keys(this.#matchResult[0][this.routeIndex][1]);
+    const keys = Object.keys(this.#matchResult[0][this.routeIndex]?.[1] ?? {});
     for (const key of keys) {
       const value = this.#getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
       if (value !== void 0) {
@@ -292,10 +292,14 @@ var cloneRawRequest = async (req) => {
       message: "Cannot clone request: body was already consumed and not cached. Please use HonoRequest methods (e.g., req.json(), req.text()) instead of consuming req.raw directly."
     });
   }
-  const body = await req[cacheKey]();
+  let body = await req[cacheKey]();
   const headers = req.header();
-  if (body instanceof FormData) {
+  if (cacheKey === "json") {
+    body = JSON.stringify(body);
+    delete headers["content-length"];
+  } else if (body instanceof FormData) {
     delete headers["content-type"];
+    delete headers["content-length"];
   }
   const requestInit = {
     body,

package/node_modules/hono/dist/router/reg-exp-router/node.js

@@ -1,4 +1,5 @@
 // src/router/reg-exp-router/node.ts
+import { createNullObject } from "../utils.js";
 var LABEL_REG_EXP_STR = "[^/]+";
 var ONLY_WILDCARD_REG_EXP_STR = ".*";
 var TAIL_WILDCARD_REG_EXP_STR = "(?:|/.*)";
@@ -27,7 +28,7 @@ var Node = class _Node {
   // handler index of a dynamic path, or -1 for a static path terminal
   #index;
   #varIndex;
-  #children = /* @__PURE__ */ Object.create(null);
+  #children = createNullObject();
   insert(tokens, index, paramMap, context, isStatic) {
     let node = this;
     for (let i = 0, len = tokens.length; i < len; i++) {
@@ -105,6 +106,9 @@ var Node = class _Node {
   }
 };
 export {
+  LABEL_REG_EXP_STR,
   Node,
-  PATH_ERROR
+  ONLY_WILDCARD_REG_EXP_STR,
+  PATH_ERROR,
+  TAIL_WILDCARD_REG_EXP_STR
 };

package/node_modules/hono/dist/router/reg-exp-router/router.js

@@ -5,25 +5,25 @@ import {
   UnsupportedPathError
 } from "../../router.js";
 import { checkOptionalParameter } from "../../utils/url.js";
+import { createNullObject } from "../utils.js";
 import { match, emptyParam } from "./matcher.js";
-import { PATH_ERROR } from "./node.js";
+import {
+  LABEL_REG_EXP_STR,
+  ONLY_WILDCARD_REG_EXP_STR,
+  PATH_ERROR,
+  TAIL_WILDCARD_REG_EXP_STR
+} from "./node.js";
 import { Trie } from "./trie.js";
-var wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
+var wildcardRegExpCache = createNullObject();
 function buildWildcardRegExp(path) {
   return wildcardRegExpCache[path] ??= new RegExp(
-    path === "*" ? "" : `^${path.replace(
-      /\/\*$|([.\\+*[^\]$()])/g,
-      (_, metaChar) => metaChar ? `\\${metaChar}` : "(?:|/.*)"
+    `^${path.replace(
+      /\/:[^/{}]+(?:\{\[\^\/]\+})?(?=[/{]|$)|\/?\*$|([.\\+*[^\]$()?{}|])/g,
+      (match2, metaChar) => metaChar ? `\\${metaChar}` : match2 === "/*" ? TAIL_WILDCARD_REG_EXP_STR : match2 === "*" ? ONLY_WILDCARD_REG_EXP_STR : `/:${LABEL_REG_EXP_STR}`
     )}$`
   );
 }
-function clearWildcardRegExpCache() {
-  wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
-}
 function findMiddleware(middleware, path) {
-  if (!middleware) {
-    return void 0;
-  }
   for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
     if (buildWildcardRegExp(k).test(path)) {
       return [...middleware[k]];
@@ -37,8 +37,8 @@ var RegExpRouter = class {
   #routes;
   #tries;
   constructor() {
-    this.#middleware = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
-    this.#routes = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
+    this.#middleware = { [METHOD_NAME_ALL]: createNullObject() };
+    this.#routes = { [METHOD_NAME_ALL]: createNullObject() };
     this.#tries = { [METHOD_NAME_ALL]: new Trie() };
   }
   #insertPath(method, path) {
@@ -51,117 +51,86 @@ var RegExpRouter = class {
   add(method, path, handler) {
     const middleware = this.#middleware;
     const routes = this.#routes;
-    if (!middleware || !routes) {
+    if (!middleware) {
       throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
     }
     if (!middleware[method]) {
       this.#tries[method] = new Trie();
-      [middleware, routes].forEach((handlerMap) => {
-        handlerMap[method] = /* @__PURE__ */ Object.create(null);
-        Object.keys(handlerMap[METHOD_NAME_ALL]).forEach((p) => {
+      for (const handlerMap of [middleware, routes]) {
+        handlerMap[method] = createNullObject();
+        for (const p in handlerMap[METHOD_NAME_ALL]) {
           handlerMap[method][p] = [...handlerMap[METHOD_NAME_ALL][p]];
           this.#insertPath(method, p);
-        });
-      });
+        }
+      }
     }
     if (path === "/*") {
       path = "*";
     }
-    const paramCount = (path.match(/\/:/g) || []).length;
+    const methods = method === METHOD_NAME_ALL ? Object.keys(middleware) : [method];
     if (/\*$/.test(path)) {
       const re = buildWildcardRegExp(path);
-      Object.keys(middleware).forEach((m) => {
-        if ((method === METHOD_NAME_ALL || method === m) && !middleware[m][path]) {
+      for (const m of methods) {
+        if (!middleware[m][path]) {
           this.#insertPath(m, path);
           middleware[m][path] = findMiddleware(middleware[m], path) || findMiddleware(middleware[METHOD_NAME_ALL], path) || [];
         }
-      });
-      Object.keys(middleware).forEach((m) => {
-        if (method === METHOD_NAME_ALL || method === m) {
-          Object.keys(middleware[m]).forEach((p) => {
-            re.test(p) && middleware[m][p].push([handler, paramCount]);
-          });
-        }
-      });
-      Object.keys(routes).forEach((m) => {
-        if (method === METHOD_NAME_ALL || method === m) {
-          Object.keys(routes[m]).forEach(
-            (p) => re.test(p) && routes[m][p].push([handler, paramCount])
-          );
+      }
+      for (const handlerMap of [middleware, routes]) {
+        for (const m of methods) {
+          for (const p in handlerMap[m]) {
+            re.test(p) && handlerMap[m][p].push([handler, path]);
+          }
         }
-      });
+      }
       return;
     }
     const paths = checkOptionalParameter(path) || [path];
-    for (let i = 0, len = paths.length; i < len; i++) {
-      const path2 = paths[i];
-      Object.keys(routes).forEach((m) => {
-        if (method === METHOD_NAME_ALL || method === m) {
-          if (!routes[m][path2]) {
-            this.#insertPath(m, path2);
-            routes[m][path2] = [
-              ...findMiddleware(middleware[m], path2) || findMiddleware(middleware[METHOD_NAME_ALL], path2) || []
-            ];
-          }
-          routes[m][path2].push([handler, paramCount - len + i + 1]);
+    for (const path2 of paths) {
+      for (const m of methods) {
+        if (!routes[m][path2]) {
+          this.#insertPath(m, path2);
+          routes[m][path2] = findMiddleware(middleware[m], path2) || findMiddleware(middleware[METHOD_NAME_ALL], path2) || [];
         }
-      });
+        routes[m][path2].push([handler, path2]);
+      }
     }
   }
   match = match;
   buildAllMatchers() {
-    const matchers = /* @__PURE__ */ Object.create(null);
-    Object.keys(this.#routes).concat(Object.keys(this.#middleware)).forEach((method) => {
-      matchers[method] ||= this.#buildMatcher(method);
-    });
+    const matchers = createNullObject();
+    for (const method of Object.keys(this.#routes)) {
+      matchers[method] = this.#buildMatcher(method);
+    }
     this.#middleware = this.#routes = this.#tries = void 0;
-    clearWildcardRegExpCache();
+    wildcardRegExpCache = createNullObject();
     return matchers;
   }
   #buildMatcher(method) {
     const middleware = this.#middleware[method];
     const routes = this.#routes[method];
     const trie = this.#tries[method];
-    const staticMap = /* @__PURE__ */ Object.create(null);
+    const staticMap = createNullObject();
     const handlerData = [];
-    [middleware, routes].forEach((r) => {
+    const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
+    for (const r of [middleware, routes]) {
       for (const path in r) {
         const handlers = r[path];
         const pathData = trie.paths[path];
         if (!pathData) {
-          staticMap[path] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
-          continue;
-        }
-        const paramAssoc = pathData[1];
-        handlerData[pathData[0]] = handlers.map(([h, paramCount]) => {
-          const paramIndexMap = /* @__PURE__ */ Object.create(null);
-          paramCount -= 1;
-          for (; paramCount >= 0; paramCount--) {
-            const [key, value] = paramAssoc[paramCount];
-            paramIndexMap[key] = value;
-          }
-          return [h, paramIndexMap];
-        });
-      }
-    });
-    const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
-    for (let i = 0, len = handlerData.length; i < len; i++) {
-      for (let j = 0, len2 = handlerData[i].length; j < len2; j++) {
-        const map = handlerData[i][j]?.[1];
-        if (!map) {
+          staticMap[path] = [handlers.map(([h]) => [h, createNullObject()]), emptyParam];
           continue;
         }
-        const keys = Object.keys(map);
-        for (let k = 0, len3 = keys.length; k < len3; k++) {
-          map[keys[k]] = paramReplacementMap[map[keys[k]]];
-        }
+        handlerData[pathData[0]] = handlers.map(([h, handlerPath]) => [
+          h,
+          trie.paths[handlerPath][1].reduceRight((map, [key], i) => {
+            map[key] = paramReplacementMap[pathData[1][i][1]];
+            return map;
+          }, createNullObject())
+        ]);
       }
     }
-    const handlerMap = [];
-    for (const i in indexReplacementMap) {
-      handlerMap[i] = handlerData[indexReplacementMap[i]];
-    }
-    return [regexp, handlerMap, staticMap];
+    return [regexp, indexReplacementMap.map((i) => handlerData[i]), staticMap];
   }
 };
 export {

package/node_modules/hono/dist/router/reg-exp-router/trie.js

@@ -1,11 +1,12 @@
 // src/router/reg-exp-router/trie.ts
+import { createNullObject } from "../utils.js";
 import { Node } from "./node.js";
 var Trie = class {
   #context = { varIndex: 0 };
   #root = new Node();
   #index = 0;
   // dynamic path -> [handler index, param assoc]; static paths are not registered
-  paths = /* @__PURE__ */ Object.create(null);
+  paths = createNullObject();
   insert(path, isStatic) {
     if (isStatic) {
       this.#root.insert(path.split(""), 0, [], this.#context, true);

package/node_modules/hono/dist/router/trie-router/node.js

@@ -1,11 +1,12 @@
 // src/router/trie-router/node.ts
 import { METHOD_NAME_ALL } from "../../router.js";
 import { getPattern, splitPath, splitRoutingPath } from "../../utils/url.js";
-var emptyParams = /* @__PURE__ */ Object.create(null);
+import { createNullObject } from "../utils.js";
+var emptyParams = createNullObject();
 var order = 0;
 var Node = class _Node {
   #methods = [];
-  #children = /* @__PURE__ */ Object.create(null);
+  #children = createNullObject();
   #patterns = [];
   #pattern;
   #params = emptyParams;
@@ -42,7 +43,7 @@ var Node = class _Node {
       const m = node.#methods[i];
       const handlerSet = m[method] || m[METHOD_NAME_ALL];
       if (handlerSet) {
-        handlerSet.params = /* @__PURE__ */ Object.create(null);
+        handlerSet.params = createNullObject();
         handlerSets.push(handlerSet);
         for (let i2 = 0, len2 = handlerSet.possibleKeys.length; i2 < len2; i2++) {
           const key = handlerSet.possibleKeys[i2];

package/node_modules/hono/dist/router/utils.js

@@ -0,0 +1,5 @@
+// src/router/utils.ts
+var createNullObject = () => /* @__PURE__ */ Object.create(null);
+export {
+  createNullObject
+};

package/node_modules/hono/dist/types/router/reg-exp-router/node.d.ts

@@ -1,3 +1,6 @@
+export declare const LABEL_REG_EXP_STR = "[^/]+";
+export declare const ONLY_WILDCARD_REG_EXP_STR = ".*";
+export declare const TAIL_WILDCARD_REG_EXP_STR = "(?:|/.*)";
 export declare const PATH_ERROR: unique symbol;
 export type ParamAssocArray = [string, number][];
 export interface Context {

package/node_modules/hono/dist/types/router/utils.d.ts

@@ -0,0 +1 @@
+export declare const createNullObject: () => any;

package/node_modules/hono/dist/types/utils/url.d.ts

@@ -19,6 +19,10 @@ export declare const tryDecode: (str: string, decoder: Decoder) => string;
  */
 export declare const tryDecodeURI: (str: string) => string;
 export declare const getPath: (request: Request) => string;
+/**
+ * @deprecated
+ * Use the `URL` API instead.
+ */
 export declare const getQueryStrings: (url: string) => string;
 export declare const getPathNoStrict: (request: Request) => string;
 /**

package/node_modules/hono/dist/utils/body.js

@@ -1,5 +1,7 @@
 // src/utils/body.ts
 import { bufferToFormData } from "./buffer.js";
+var MAX_NESTING_DEPTH = 32;
+var MAX_NESTED_OBJECTS = 1e4;
 var isRawRequest = (request) => "headers" in request;
 var parseBody = async (request, options = /* @__PURE__ */ Object.create(null)) => {
   const { all = false, dot = false } = options;
@@ -32,6 +34,7 @@ async function parseFormData(request, options) {
 }
 function convertFormDataToBodyData(formData, options) {
   const form = /* @__PURE__ */ Object.create(null);
+  const nestingState = { count: 0 };
   formData.forEach((value, key) => {
     const shouldParseAllValues = options.all || key.endsWith("[]");
     if (!shouldParseAllValues) {
@@ -44,7 +47,7 @@ function convertFormDataToBodyData(formData, options) {
     Object.entries(form).forEach(([key, value]) => {
       const shouldParseDotValues = key.includes(".");
       if (shouldParseDotValues) {
-        handleParsingNestedValues(form, key, value);
+        handleParsingNestedValues(form, key, value, nestingState);
         delete form[key];
       }
     });
@@ -67,23 +70,32 @@ var handleParsingAllValues = (form, key, value) => {
     }
   }
 };
-var handleParsingNestedValues = (form, key, value) => {
+var handleParsingNestedValues = (form, key, value, state) => {
   if (/(?:^|\.)__proto__\./.test(key)) {
     return;
   }
   let nestedForm = form;
-  const keys = key.split(".");
+  const keys = key.split(".", MAX_NESTING_DEPTH + 2);
+  if (keys.length > MAX_NESTING_DEPTH + 1) {
+    throwNestingLimitExceeded();
+  }
   keys.forEach((key2, index) => {
     if (index === keys.length - 1) {
       nestedForm[key2] = value;
     } else {
       if (!nestedForm[key2] || typeof nestedForm[key2] !== "object" || Array.isArray(nestedForm[key2]) || nestedForm[key2] instanceof File) {
+        if (state.count++ >= MAX_NESTED_OBJECTS) {
+          throwNestingLimitExceeded();
+        }
         nestedForm[key2] = /* @__PURE__ */ Object.create(null);
       }
       nestedForm = nestedForm[key2];
     }
   });
 };
+var throwNestingLimitExceeded = () => {
+  throw new Error("Nesting limit exceeded");
+};
 export {
   parseBody
 };

package/node_modules/hono/dist/utils/cookie.js

@@ -77,7 +77,7 @@ var parseSigned = async (cookie, secret, name) => {
   const secretKey = await getCryptoKey(secret);
   for (const [key, value] of Object.entries(parse(cookie, name))) {
     const signatureStartPos = value.lastIndexOf(".");
-    if (signatureStartPos < 1) {
+    if (signatureStartPos < 0) {
       continue;
     }
     const signedValue = value.substring(0, signatureStartPos);

package/node_modules/hono/dist/utils/stream.js

@@ -75,7 +75,13 @@ var StreamingApi = class {
   abort() {
     if (!this.aborted) {
       this.aborted = true;
-      this.abortSubscribers.forEach((subscriber) => subscriber());
+      this.abortSubscribers.forEach((subscriber) => {
+        try {
+          void Promise.resolve(subscriber()).catch(() => {
+          });
+        } catch {
+        }
+      });
     }
   }
 };

package/node_modules/hono/dist/utils/url.js

@@ -85,7 +85,11 @@ var getPath = (request) => {
 };
 var getQueryStrings = (url) => {
   const queryIndex = url.indexOf("?", 8);
-  return queryIndex === -1 ? "" : "?" + url.slice(queryIndex + 1);
+  if (queryIndex === -1) {
+    return "";
+  }
+  const hashIndex = url.indexOf("#", 8);
+  return hashIndex === -1 ? url.slice(queryIndex) : queryIndex < hashIndex ? url.slice(queryIndex, hashIndex) : "";
 };
 var getPathNoStrict = (request) => {
   const result = getPath(request);
@@ -132,6 +136,10 @@ var _decodeURI = (value) => {
   return tryDecodeURIComponent(value);
 };
 var _getQueryParam = (url, key, multiple) => {
+  const hashIndex = url.indexOf("#", 8);
+  if (hashIndex !== -1) {
+    url = url.slice(0, hashIndex);
+  }
   let encoded;
   if (!multiple && key && key.indexOf("%") === -1 && key.indexOf("+") === -1) {
     let keyIndex2 = url.indexOf("?", 8);

package/node_modules/hono/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "4.13.3",
+  "version": "4.13.5",
   "description": "Web framework built on Web Standards",
   "main": "dist/cjs/index.js",
   "type": "module",