@venos-inc/venos 0.1.5 → 0.1.6

package/etc/mcp-server/node_modules/hono/dist/cjs/utils/ipaddr.js

@@ -43,7 +43,9 @@ const expandIPv6 = (ipV6) => {
     if (node !== "") {
       sections[i] = node.padStart(4, "0");
     } else {
-      sections[i + 1] === "" && sections.splice(i + 1, 1);
+      while (sections[i + 1] === "") {
+        sections.splice(i + 1, 1);
+      }
       sections[i] = new Array(8 - sections.length + 1).fill("0000").join(":");
     }
   }
@@ -263,6 +265,9 @@ const convertIPv4BinaryToString = (ipV4) => {
 const isIPv4MappedIPv6 = (ipv6binary) => ipv6binary >> 32n === 0xffffn;
 const convertIPv4MappedIPv6ToIPv4 = (ipv6binary) => ipv6binary & 0xffffffffn;
 const convertIPv6BinaryToString = (ipV6) => {
+  if (ipV6 === 0n) {
+    return "::";
+  }
   if (isIPv4MappedIPv6(ipV6)) {
     return `::ffff:${convertIPv4BinaryToString(convertIPv4MappedIPv6ToIPv4(ipV6))}`;
   }
@@ -294,7 +299,7 @@ const convertIPv6BinaryToString = (ipV6) => {
       maxZeroEnd = 8;
     }
   }
-  if (maxZeroStart !== -1) {
+  if (maxZeroStart !== -1 && maxZeroEnd - maxZeroStart > 1) {
     sections.splice(maxZeroStart, maxZeroEnd - maxZeroStart, ":");
   }
   return sections.join(":").replace(/:{2,}/g, "::");

package/etc/mcp-server/node_modules/hono/dist/cjs/utils/mime.js

@@ -28,15 +28,13 @@ const getMimeType = (filename, mimes = baseMimes) => {
   if (!match) {
     return;
   }
-  let mimeType = mimes[match[1].toLowerCase()];
-  if (mimeType && mimeType.startsWith("text")) {
-    mimeType += "; charset=utf-8";
-  }
-  return mimeType;
+  return mimes[match[1].toLowerCase()];
 };
 const getExtension = (mimeType) => {
+  const baseType = mimeType.split(";", 1)[0].trim();
   for (const ext in baseMimes) {
-    if (baseMimes[ext] === mimeType) {
+    const stored = baseMimes[ext];
+    if (stored === mimeType || stored.split(";", 1)[0].trim() === baseType) {
       return ext;
     }
   }
@@ -48,25 +46,25 @@ const _baseMimes = {
   av1: "video/av1",
   bin: "application/octet-stream",
   bmp: "image/bmp",
-  css: "text/css",
-  csv: "text/csv",
+  css: "text/css; charset=utf-8",
+  csv: "text/csv; charset=utf-8",
   eot: "application/vnd.ms-fontobject",
   epub: "application/epub+zip",
   gif: "image/gif",
   gz: "application/gzip",
-  htm: "text/html",
-  html: "text/html",
+  htm: "text/html; charset=utf-8",
+  html: "text/html; charset=utf-8",
   ico: "image/x-icon",
-  ics: "text/calendar",
+  ics: "text/calendar; charset=utf-8",
   jpeg: "image/jpeg",
   jpg: "image/jpeg",
-  js: "text/javascript",
+  js: "text/javascript; charset=utf-8",
   json: "application/json",
   jsonld: "application/ld+json",
   map: "application/json",
   mid: "audio/x-midi",
   midi: "audio/x-midi",
-  mjs: "text/javascript",
+  mjs: "text/javascript; charset=utf-8",
   mp3: "audio/mpeg",
   mp4: "video/mp4",
   mpeg: "video/mpeg",
@@ -78,12 +76,12 @@ const _baseMimes = {
   pdf: "application/pdf",
   png: "image/png",
   rtf: "application/rtf",
-  svg: "image/svg+xml",
+  svg: "image/svg+xml; charset=utf-8",
   tif: "image/tiff",
   tiff: "image/tiff",
   ts: "video/mp2t",
   ttf: "font/ttf",
-  txt: "text/plain",
+  txt: "text/plain; charset=utf-8",
   wasm: "application/wasm",
   webm: "video/webm",
   weba: "audio/webm",
@@ -91,8 +89,8 @@ const _baseMimes = {
   webp: "image/webp",
   woff: "font/woff",
   woff2: "font/woff2",
-  xhtml: "application/xhtml+xml",
-  xml: "application/xml",
+  xhtml: "application/xhtml+xml; charset=utf-8",
+  xml: "application/xml; charset=utf-8",
   zip: "application/zip",
   "3gp": "video/3gpp",
   "3g2": "video/3gpp2",

package/etc/mcp-server/node_modules/hono/dist/helper/css/common.js

@@ -25,6 +25,7 @@ var normalizeLabel = (label) => {
   return label.trim().replace(/\s+/g, "-");
 };
 var isValidClassName = (name) => /^-?[_a-zA-Z][_a-zA-Z0-9-]*$/.test(name);
+var hasUnsafeSelectorChar = (name) => /[<{}]/.test(name);
 var RESERVED_KEYFRAME_NAMES = /* @__PURE__ */ new Set([
   "default",
   "inherit",
@@ -162,7 +163,8 @@ var cxCommon = (args) => {
         [CLASS_NAME]: "",
         [STYLE_STRING]: "",
         [SELECTORS]: [],
-        [EXTERNAL_CLASS_NAMES]: [arg]
+        // drop names that are unsafe to emit as a selector
+        [EXTERNAL_CLASS_NAMES]: hasUnsafeSelectorChar(arg) ? [] : [arg]
       };
     }
   }

package/etc/mcp-server/node_modules/hono/dist/helper/css/index.js

@@ -2,6 +2,7 @@
 import { raw } from "../../helper/html/index.js";
 import { DOM_RENDERER } from "../../jsx/constants.js";
 import { createCssJsxDomObjects } from "../../jsx/dom/css.js";
+import { escapeToBuffer } from "../../utils/html.js";
 import {
   CLASS_NAME,
   DEFAULT_STYLE_ID,
@@ -72,7 +73,14 @@ var createCssContext = ({
       }
       return Promise.resolve(raw("", [appendStyle]));
     };
-    const className = new String(cssClassName[CLASS_NAME]);
+    const rawClassName = cssClassName[CLASS_NAME];
+    let escapedClassName = rawClassName;
+    if (/[&<>'"]/.test(rawClassName)) {
+      const escapedBuffer = [""];
+      escapeToBuffer(rawClassName, escapedBuffer);
+      escapedClassName = escapedBuffer[0];
+    }
+    const className = new String(escapedClassName);
     Object.assign(className, cssClassName);
     className.isEscaped = true;
     className.callbacks = [addClassNameToContext];

package/etc/mcp-server/node_modules/hono/dist/index.js

@@ -1,5 +1,7 @@
 // src/index.ts
 import { Hono } from "./hono.js";
+import { Context } from "./context.js";
 export {
+  Context,
   Hono
 };

package/etc/mcp-server/node_modules/hono/dist/jsx/base.js

@@ -2,7 +2,13 @@
 import { raw } from "../helper/html/index.js";
 import { escapeToBuffer, resolveCallbackSync, stringBufferToString } from "../utils/html.js";
 import { DOM_RENDERER, DOM_MEMO } from "./constants.js";
-import { createContext, globalContexts, useContext } from "./context.js";
+import {
+  captureRenderContext,
+  createContext,
+  globalContexts,
+  runWithRenderContext,
+  useContext
+} from "./context.js";
 import { domRenderers } from "./intrinsic-element/common.js";
 import * as intrinsicElementTags from "./intrinsic-element/components.js";
 import {
@@ -88,7 +94,7 @@ var JSXNode = class {
   key;
   children;
   isEscaped = true;
-  localContexts;
+  suspendedContext;
   constructor(tag, props, children) {
     if (typeof tag !== "function" && !isValidTagName(tag)) {
       throw new Error(`Invalid JSX tag name: ${tag}`);
@@ -106,18 +112,12 @@ var JSXNode = class {
     return this.props.ref || null;
   }
   toString() {
-    const buffer = [""];
-    this.localContexts?.forEach(([context, value]) => {
-      context.values.push(value);
-    });
-    try {
+    const render = () => {
+      const buffer = [""];
       this.toStringToBuffer(buffer);
-    } finally {
-      this.localContexts?.forEach(([context]) => {
-        context.values.pop();
-      });
-    }
-    return buffer.length === 1 ? "callbacks" in buffer ? resolveCallbackSync(raw(buffer[0], buffer.callbacks)).toString() : buffer[0] : stringBufferToString(buffer, buffer.callbacks);
+      return buffer.length === 1 ? "callbacks" in buffer ? resolveCallbackSync(raw(buffer[0], buffer.callbacks)).toString() : buffer[0] : stringBufferToString(buffer, buffer.callbacks);
+    };
+    return this.suspendedContext ? this.suspendedContext(render) : runWithRenderContext(render);
   }
   toStringToBuffer(buffer) {
     const tag = this.tag;
@@ -193,12 +193,12 @@ var JSXFunctionNode = class extends JSXNode {
       if (globalContexts.length === 0) {
         buffer.unshift("", res);
       } else {
-        const currentContexts = globalContexts.map((c) => [c, c.values.at(-1)]);
+        const suspendedContext = captureRenderContext();
         buffer.unshift(
           "",
           res.then((childRes) => {
             if (childRes instanceof JSXNode) {
-              childRes.localContexts = currentContexts;
+              childRes.suspendedContext = suspendedContext;
             }
             return childRes;
           })

package/etc/mcp-server/node_modules/hono/dist/jsx/components.js

@@ -3,7 +3,7 @@ import { raw } from "../helper/html/index.js";
 import { HtmlEscapedCallbackPhase, resolveCallback } from "../utils/html.js";
 import { jsx, Fragment } from "./base.js";
 import { DOM_RENDERER } from "./constants.js";
-import { useContext } from "./context.js";
+import { captureRenderContext, useContext } from "./context.js";
 import { ErrorBoundary as ErrorBoundaryDomRenderer } from "./dom/components.js";
 import { StreamingContext } from "./streaming.js";
 var errorBoundaryCounter = 0;
@@ -12,8 +12,9 @@ var childrenToString = async (children) => {
     return children.flat().map((c) => c == null || typeof c === "boolean" ? "" : c.toString());
   } catch (e) {
     if (e instanceof Promise) {
+      const resume = captureRenderContext();
       await e;
-      return childrenToString(children);
+      return resume(() => childrenToString(children));
     } else {
       throw e;
     }
@@ -41,51 +42,68 @@ var ErrorBoundary = async ({ children, fallback, fallbackRender, onError }) => {
     children = [children];
   }
   const nonce = useContext(StreamingContext)?.scriptNonce;
-  let fallbackStr;
-  const resolveFallbackStr = async () => {
+  let resume;
+  const getResume = () => resume ||= captureRenderContext();
+  let fallbackStrPromise;
+  const resolveFallbackStr = () => fallbackStrPromise ||= (async () => {
     const awaitedFallback = await fallback;
     if (typeof awaitedFallback === "string") {
-      fallbackStr = awaitedFallback;
+      return awaitedFallback;
     } else {
-      fallbackStr = await awaitedFallback?.toString();
-      if (typeof fallbackStr === "string") {
-        fallbackStr = raw(fallbackStr);
+      const fallbackResult = await getResume()(() => awaitedFallback?.toString());
+      if (typeof fallbackResult === "string") {
+        return raw(
+          fallbackResult,
+          fallbackResult.callbacks || awaitedFallback?.callbacks
+        );
       }
     }
-  };
-  const fallbackRes = (error) => {
-    onError?.(error);
-    return fallbackStr || fallbackRender && jsx(Fragment, {}, fallbackRender(error)) || "";
+  })();
+  const renderFallback = async (error) => {
+    const fallbackStr = await resolveFallbackStr();
+    return getResume()(async () => {
+      onError?.(error);
+      const fallbackRes = fallbackStr !== void 0 ? fallbackStr : fallbackRender && jsx(Fragment, {}, fallbackRender(error)) || "";
+      const fallbackResString = await Fragment({
+        children: fallbackRes
+      }).toString();
+      return raw(
+        fallbackResString,
+        fallbackResString.callbacks || fallbackRes.callbacks
+      );
+    });
   };
   let resArray = [];
   try {
     resArray = children.map(resolveChildEarly);
   } catch (e) {
-    await resolveFallbackStr();
+    const resume2 = getResume();
     if (e instanceof Promise) {
       resArray = [
-        e.then(() => childrenToString(children)).catch((e2) => fallbackRes(e2))
+        e.then(() => resume2(() => childrenToString(children))).catch((e2) => renderFallback(e2))
       ];
     } else {
-      resArray = [fallbackRes(e)];
+      resArray = [await renderFallback(e)];
     }
   }
   if (resArray.some((res) => res instanceof Promise)) {
-    await resolveFallbackStr();
+    getResume();
     const index = errorBoundaryCounter++;
     const replaceRe = RegExp(`(<template id="E:${index}"></template>.*?)(.*?)(<!--E:${index}-->)`);
-    const caught = false;
+    let caught = false;
     const catchCallback = async ({ error: error2, buffer }) => {
       if (caught) {
         return "";
       }
-      const fallbackResString = await Fragment({
-        children: fallbackRes(error2)
-      }).toString();
+      caught = true;
+      const fallbackResString = await renderFallback(error2);
+      const fallbackCallbacks = fallbackResString.callbacks;
       if (buffer) {
         buffer[0] = buffer[0].replace(replaceRe, fallbackResString);
+        return fallbackCallbacks?.length ? raw("", fallbackCallbacks) : "";
       }
-      return buffer ? "" : `<template data-hono-target="E:${index}">${fallbackResString}</template><script>
+      return raw(
+        `<template data-hono-target="E:${index}">${fallbackResString}</template><script>
 ((d,c,n) => {
 c=d.currentScript.previousSibling
 d=d.getElementById('E:${index}')
@@ -93,7 +111,9 @@ if(!d)return
 do{n=d.nextSibling;n.remove()}while(n.nodeType!=8||n.nodeValue!='E:${index}')
 d.replaceWith(c.content)
 })(document)
-</script>`;
+</script>`,
+        fallbackCallbacks
+      );
     };
     let error;
     const promiseAll = Promise.all(resArray).catch((e) => error = e);

package/etc/mcp-server/node_modules/hono/dist/jsx/context.js

@@ -4,21 +4,143 @@ import { JSXFragmentNode } from "./base.js";
 import { DOM_RENDERER } from "./constants.js";
 import { createContextProviderFunction } from "./dom/context.js";
 var globalContexts = [];
+var alsProbed = false;
+var asyncLocalStorage;
+var fallbackStore;
+var fallbackRendersInFlight = 0;
+var warnedFallbackDefault = false;
+var loadAsyncLocalStorage = () => {
+  if (alsProbed) {
+    return asyncLocalStorage;
+  }
+  alsProbed = true;
+  const global = globalThis;
+  let AsyncLocalStorage;
+  for (const probe of [
+    // Node.js >= 20.16, Deno, Bun, Cloudflare Workers (nodejs_compat). Property
+    // access only, so bundlers don't statically resolve `node:async_hooks`.
+    () => global.process?.getBuiltinModule?.("node:async_hooks")?.AsyncLocalStorage,
+    // Node.js < 20.16 has no `process.getBuiltinModule`, but a CJS entrypoint
+    // exposes the main module's `require` here.
+    () => global.process?.mainModule?.require?.("node:async_hooks")?.AsyncLocalStorage
+  ]) {
+    try {
+      AsyncLocalStorage = probe();
+    } catch {
+    }
+    if (AsyncLocalStorage) {
+      break;
+    }
+  }
+  if (AsyncLocalStorage) {
+    asyncLocalStorage = new AsyncLocalStorage();
+  }
+  return asyncLocalStorage;
+};
+var getCurrentStore = () => {
+  return loadAsyncLocalStorage()?.getStore() || fallbackStore;
+};
+var warnIfStorelessAccess = () => {
+  if (fallbackRendersInFlight > 0 && !warnedFallbackDefault) {
+    warnedFallbackDefault = true;
+    console.warn(
+      "hono/jsx: AsyncLocalStorage is unavailable in this runtime, so useContext() after an await in an async component falls back to the context default value during server-side rendering. To get provided values across await boundaries, use a runtime with AsyncLocalStorage (Node.js >= 20.16, Deno, Bun, or Cloudflare Workers with the nodejs_compat flag)."
+    );
+  }
+};
+var getContextValuesIn = (store, context) => {
+  if (!store) {
+    warnIfStorelessAccess();
+    return context.values;
+  }
+  let values = store.get(context);
+  if (!values) {
+    values = [context.values[0]];
+    store.set(context, values);
+  }
+  return values;
+};
+var readContextValueIn = (store, context) => {
+  if (!store) {
+    warnIfStorelessAccess();
+    return context.values.at(-1);
+  }
+  const values = store.get(context);
+  return values?.length ? values.at(-1) : context.values[0];
+};
+var captureContextValues = (store) => (store ? globalContexts.filter((c) => store.has(c)) : globalContexts).map((c) => [
+  c,
+  readContextValueIn(store, c)
+]);
+var resumeWithContextValues = (callback, store, contexts) => runWithRenderContext(() => {
+  const currentStore = getCurrentStore();
+  const valuesPerContext = contexts.map(([context, value]) => {
+    const values = getContextValuesIn(currentStore, context);
+    values.push(value);
+    return values;
+  });
+  const popContextValues = () => {
+    valuesPerContext.forEach((values) => {
+      values.pop();
+    });
+  };
+  try {
+    const result = callback();
+    if (result instanceof Promise) {
+      return result.finally(popContextValues);
+    }
+    popContextValues();
+    return result;
+  } catch (e) {
+    popContextValues();
+    throw e;
+  }
+}, store);
+var runWithRenderContext = (callback, resumeStore) => {
+  if (getCurrentStore()) {
+    return callback();
+  }
+  const store = resumeStore ?? /* @__PURE__ */ new WeakMap();
+  const storage = loadAsyncLocalStorage();
+  if (storage) {
+    return storage.run(store, callback);
+  }
+  fallbackStore = store;
+  let result;
+  try {
+    result = callback();
+  } finally {
+    fallbackStore = void 0;
+  }
+  if (!warnedFallbackDefault && result instanceof Promise) {
+    fallbackRendersInFlight++;
+    result = result.finally(() => {
+      fallbackRendersInFlight--;
+    });
+  }
+  return result;
+};
+var captureRenderContext = () => {
+  const store = getCurrentStore();
+  const contexts = captureContextValues(store);
+  return (callback) => resumeWithContextValues(callback, store, contexts);
+};
 var createContext = (defaultValue) => {
   const values = [defaultValue];
   const context = ((props) => {
-    values.push(props.value);
+    const contextValues = getContextValuesIn(getCurrentStore(), context);
+    contextValues.push(props.value);
     let string;
     try {
       string = props.children ? (Array.isArray(props.children) ? new JSXFragmentNode("", {}, props.children) : props.children).toString() : "";
     } catch (e) {
-      values.pop();
+      contextValues.pop();
       throw e;
     }
     if (string instanceof Promise) {
-      return string.finally(() => values.pop()).then((resString) => raw(resString, resString.callbacks));
+      return string.finally(() => contextValues.pop()).then((resString) => raw(resString, resString.callbacks));
     } else {
-      values.pop();
+      contextValues.pop();
       return raw(string);
     }
   });
@@ -29,10 +151,12 @@ var createContext = (defaultValue) => {
   return context;
 };
 var useContext = (context) => {
-  return context.values.at(-1);
+  return readContextValueIn(getCurrentStore(), context);
 };
 export {
+  captureRenderContext,
   createContext,
   globalContexts,
+  runWithRenderContext,
   useContext
 };

package/etc/mcp-server/node_modules/hono/dist/jsx/streaming.js

@@ -4,7 +4,7 @@ import { HtmlEscapedCallbackPhase, resolveCallback } from "../utils/html.js";
 import { JSXNode } from "./base.js";
 import { childrenToString } from "./components.js";
 import { DOM_RENDERER, DOM_STASH } from "./constants.js";
-import { createContext, useContext } from "./context.js";
+import { captureRenderContext, createContext, useContext } from "./context.js";
 import { Suspense as SuspenseDomRenderer } from "./dom/components.js";
 import { buildDataStack } from "./dom/render.js";
 var StreamingContext = createContext(null);
@@ -19,9 +19,8 @@ var Suspense = async ({
   const nonce = useContext(StreamingContext)?.scriptNonce;
   let resArray = [];
   const stackNode = { [DOM_STASH]: [0, []] };
-  const popNodeStack = (value) => {
+  const popNodeStack = () => {
     buildDataStack.pop();
-    return value;
   };
   try {
     stackNode[DOM_STASH][0] = 0;
@@ -31,12 +30,15 @@ var Suspense = async ({
     );
   } catch (e) {
     if (e instanceof Promise) {
+      const resume = captureRenderContext();
       resArray = [
-        e.then(() => {
-          stackNode[DOM_STASH][0] = 0;
-          buildDataStack.push([[], stackNode]);
-          return childrenToString(children).then(popNodeStack);
-        })
+        e.then(
+          () => resume(() => {
+            stackNode[DOM_STASH][0] = 0;
+            buildDataStack.push([[], stackNode]);
+            return childrenToString(children).finally(popNodeStack);
+          })
+        )
       ];
     } else {
       throw e;

package/etc/mcp-server/node_modules/hono/dist/middleware/bearer-auth/index.js

@@ -6,7 +6,7 @@ var PREFIX = "Bearer";
 var HEADER = "Authorization";
 var bearerAuth = (options) => {
   if (!("token" in options || "verifyToken" in options)) {
-    throw new Error('bearer auth middleware requires options for "token"');
+    throw new Error('bearer auth middleware requires options for "token" or "verifyToken"');
   }
   if (!options.realm) {
     options.realm = "";

package/etc/mcp-server/node_modules/hono/dist/middleware/compress/index.js

@@ -1,9 +1,37 @@
 // src/middleware/compress/index.ts
+import { parseAccept } from "../../utils/accept.js";
 import { COMPRESSIBLE_CONTENT_TYPE_REGEX } from "../../utils/compress.js";
 var ENCODING_TYPES = ["gzip", "deflate"];
 var cacheControlNoTransformRegExp = /(?:^|,)\s*?no-transform\s*?(?:,|$)/i;
+var selectEncoding = (header, candidates) => {
+  if (header === void 0) {
+    return void 0;
+  }
+  const accepts = parseAccept(header);
+  const wildcardQ = accepts.find((a) => a.type === "*")?.q;
+  let best;
+  for (const enc of candidates) {
+    const explicit = accepts.find((a) => a.type.toLowerCase() === enc);
+    const q = explicit ? explicit.q : wildcardQ ?? 0;
+    if (q === 1) {
+      return enc;
+    } else if (q > 0 && (!best || q > best.q)) {
+      best = { encoding: enc, q };
+    }
+  }
+  return best?.encoding;
+};
 var compress = (options) => {
   const threshold = options?.threshold ?? 1024;
+  const candidates = options?.encoding ? [options.encoding] : ENCODING_TYPES;
+  const contentTypeFilter = options?.contentTypeFilter ?? COMPRESSIBLE_CONTENT_TYPE_REGEX;
+  const shouldCompress = typeof contentTypeFilter === "function" ? (res) => {
+    const type = res.headers.get("Content-Type");
+    return type && contentTypeFilter(type);
+  } : (res) => {
+    const type = res.headers.get("Content-Type");
+    return type && contentTypeFilter.test(type);
+  };
   return async function compress2(ctx, next) {
     await next();
     const contentLength = ctx.res.headers.get("Content-Length");
@@ -16,7 +44,7 @@ var compress = (options) => {
       return;
     }
     const accepted = ctx.req.header("Accept-Encoding");
-    const encoding = options?.encoding ?? ENCODING_TYPES.find((encoding2) => accepted?.includes(encoding2));
+    const encoding = selectEncoding(accepted, candidates);
     if (!encoding || !ctx.res.body) {
       return;
     }
@@ -30,14 +58,11 @@ var compress = (options) => {
     }
   };
 };
-var shouldCompress = (res) => {
-  const type = res.headers.get("Content-Type");
-  return type && COMPRESSIBLE_CONTENT_TYPE_REGEX.test(type);
-};
 var shouldTransform = (res) => {
   const cacheControl = res.headers.get("Cache-Control");
   return !cacheControl || !cacheControlNoTransformRegExp.test(cacheControl);
 };
 export {
+  COMPRESSIBLE_CONTENT_TYPE_REGEX,
   compress
 };

package/etc/mcp-server/node_modules/hono/dist/middleware/cors/index.js

@@ -10,9 +10,6 @@ var cors = (options) => {
   const findAllowOrigin = ((optsOrigin) => {
     if (typeof optsOrigin === "string") {
       if (optsOrigin === "*") {
-        if (opts.credentials) {
-          return (origin) => origin || null;
-        }
         return () => optsOrigin;
       } else {
         return (origin) => optsOrigin === origin ? origin : null;
@@ -47,7 +44,7 @@ var cors = (options) => {
       set("Access-Control-Expose-Headers", opts.exposeHeaders.join(","));
     }
     if (c.req.method === "OPTIONS") {
-      if (opts.origin !== "*" || opts.credentials) {
+      if (opts.origin !== "*") {
         set("Vary", "Origin");
       }
       if (opts.maxAge != null) {
@@ -77,7 +74,7 @@ var cors = (options) => {
       });
     }
     await next();
-    if (opts.origin !== "*" || opts.credentials) {
+    if (opts.origin !== "*") {
       c.header("Vary", "Origin", { append: true });
     }
   };