hono 4.6.8 → 4.6.10

package/dist/adapter/cloudflare-workers/websocket.js

@@ -1,45 +1,40 @@
 // src/adapter/cloudflare-workers/websocket.ts
 import { WSContext, defineWebSocketHelper } from "../../helper/websocket/index.js";
-var upgradeWebSocket = defineWebSocketHelper(
-  async (c, events) => {
-    const upgradeHeader = c.req.header("Upgrade");
-    if (upgradeHeader !== "websocket") {
-      return;
-    }
-    const webSocketPair = new WebSocketPair();
-    const client = webSocketPair[0];
-    const server = webSocketPair[1];
-    const wsContext = new WSContext({
-      close: (code, reason) => server.close(code, reason),
-      get protocol() {
-        return server.protocol;
-      },
-      raw: server,
-      get readyState() {
-        return server.readyState;
-      },
-      url: server.url ? new URL(server.url) : null,
-      send: (source) => server.send(source)
-    });
-    if (events.onOpen) {
-      server.addEventListener("open", (evt) => events.onOpen?.(evt, wsContext));
-    }
-    if (events.onClose) {
-      server.addEventListener("close", (evt) => events.onClose?.(evt, wsContext));
-    }
-    if (events.onMessage) {
-      server.addEventListener("message", (evt) => events.onMessage?.(evt, wsContext));
-    }
-    if (events.onError) {
-      server.addEventListener("error", (evt) => events.onError?.(evt, wsContext));
-    }
-    server.accept?.();
-    return new Response(null, {
-      status: 101,
-      webSocket: client
-    });
+var upgradeWebSocket = defineWebSocketHelper(async (c, events) => {
+  const upgradeHeader = c.req.header("Upgrade");
+  if (upgradeHeader !== "websocket") {
+    return;
   }
-);
+  const webSocketPair = new WebSocketPair();
+  const client = webSocketPair[0];
+  const server = webSocketPair[1];
+  const wsContext = new WSContext({
+    close: (code, reason) => server.close(code, reason),
+    get protocol() {
+      return server.protocol;
+    },
+    raw: server,
+    get readyState() {
+      return server.readyState;
+    },
+    url: server.url ? new URL(server.url) : null,
+    send: (source) => server.send(source)
+  });
+  if (events.onClose) {
+    server.addEventListener("close", (evt) => events.onClose?.(evt, wsContext));
+  }
+  if (events.onMessage) {
+    server.addEventListener("message", (evt) => events.onMessage?.(evt, wsContext));
+  }
+  if (events.onError) {
+    server.addEventListener("error", (evt) => events.onError?.(evt, wsContext));
+  }
+  server.accept?.();
+  return new Response(null, {
+    status: 101,
+    webSocket: client
+  });
+});
 export {
   upgradeWebSocket
 };

package/dist/adapter/deno/serve-static.js

@@ -5,12 +5,16 @@ var serveStatic = (options) => {
   return async function serveStatic2(c, next) {
     const getContent = async (path) => {
       try {
+        if (isDir(path)) {
+          return null;
+        }
         const file = await open(path);
-        return file ? file.readable : null;
+        return file.readable;
       } catch (e) {
         if (!(e instanceof errors.NotFound)) {
           console.warn(`${e}`);
         }
+        return null;
       }
     };
     const pathResolve = (path) => {

package/dist/adapter/lambda-edge/handler.js

@@ -31,7 +31,7 @@ var createResult = async (res) => {
     status: res.status.toString(),
     headers: convertHeaders(res.headers),
     body,
-    ...isBase64Encoded ? { bodyEncoding: "base64" } : {}
+    ...isBase64Encoded && { bodyEncoding: "base64" }
   };
 };
 var createRequest = (event) => {

package/dist/cjs/adapter/cloudflare-workers/websocket.js

@@ -22,46 +22,41 @@ __export(websocket_exports, {
 });
 module.exports = __toCommonJS(websocket_exports);
 var import_websocket = require("../../helper/websocket");
-const upgradeWebSocket = (0, import_websocket.defineWebSocketHelper)(
-  async (c, events) => {
-    const upgradeHeader = c.req.header("Upgrade");
-    if (upgradeHeader !== "websocket") {
-      return;
-    }
-    const webSocketPair = new WebSocketPair();
-    const client = webSocketPair[0];
-    const server = webSocketPair[1];
-    const wsContext = new import_websocket.WSContext({
-      close: (code, reason) => server.close(code, reason),
-      get protocol() {
-        return server.protocol;
-      },
-      raw: server,
-      get readyState() {
-        return server.readyState;
-      },
-      url: server.url ? new URL(server.url) : null,
-      send: (source) => server.send(source)
-    });
-    if (events.onOpen) {
-      server.addEventListener("open", (evt) => events.onOpen?.(evt, wsContext));
-    }
-    if (events.onClose) {
-      server.addEventListener("close", (evt) => events.onClose?.(evt, wsContext));
-    }
-    if (events.onMessage) {
-      server.addEventListener("message", (evt) => events.onMessage?.(evt, wsContext));
-    }
-    if (events.onError) {
-      server.addEventListener("error", (evt) => events.onError?.(evt, wsContext));
-    }
-    server.accept?.();
-    return new Response(null, {
-      status: 101,
-      webSocket: client
-    });
+const upgradeWebSocket = (0, import_websocket.defineWebSocketHelper)(async (c, events) => {
+  const upgradeHeader = c.req.header("Upgrade");
+  if (upgradeHeader !== "websocket") {
+    return;
   }
-);
+  const webSocketPair = new WebSocketPair();
+  const client = webSocketPair[0];
+  const server = webSocketPair[1];
+  const wsContext = new import_websocket.WSContext({
+    close: (code, reason) => server.close(code, reason),
+    get protocol() {
+      return server.protocol;
+    },
+    raw: server,
+    get readyState() {
+      return server.readyState;
+    },
+    url: server.url ? new URL(server.url) : null,
+    send: (source) => server.send(source)
+  });
+  if (events.onClose) {
+    server.addEventListener("close", (evt) => events.onClose?.(evt, wsContext));
+  }
+  if (events.onMessage) {
+    server.addEventListener("message", (evt) => events.onMessage?.(evt, wsContext));
+  }
+  if (events.onError) {
+    server.addEventListener("error", (evt) => events.onError?.(evt, wsContext));
+  }
+  server.accept?.();
+  return new Response(null, {
+    status: 101,
+    webSocket: client
+  });
+});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   upgradeWebSocket

package/dist/cjs/adapter/deno/serve-static.js

@@ -27,12 +27,16 @@ const serveStatic = (options) => {
   return async function serveStatic2(c, next) {
     const getContent = async (path) => {
       try {
+        if (isDir(path)) {
+          return null;
+        }
         const file = await open(path);
-        return file ? file.readable : null;
+        return file.readable;
       } catch (e) {
         if (!(e instanceof errors.NotFound)) {
           console.warn(`${e}`);
         }
+        return null;
       }
     };
     const pathResolve = (path) => {

package/dist/cjs/adapter/lambda-edge/handler.js

@@ -61,7 +61,7 @@ const createResult = async (res) => {
     status: res.status.toString(),
     headers: convertHeaders(res.headers),
     body,
-    ...isBase64Encoded ? { bodyEncoding: "base64" } : {}
+    ...isBase64Encoded && { bodyEncoding: "base64" }
   };
 };
 const createRequest = (event) => {

package/dist/cjs/client/client.js

@@ -80,8 +80,8 @@ class ClientRequestImpl {
     }
     let methodUpperCase = this.method.toUpperCase();
     const headerValues = {
-      ...args?.header ?? {},
-      ...typeof opt?.headers === "function" ? await opt.headers() : opt?.headers ? opt.headers : {}
+      ...args?.header,
+      ...typeof opt?.headers === "function" ? await opt.headers() : opt?.headers
     };
     if (args?.cookie) {
       const cookies = [];
@@ -172,7 +172,7 @@ const hc = (baseUrl, options) => createProxy(function proxyCallback(opts) {
   const req = new ClientRequestImpl(url, method);
   if (method) {
     options ??= {};
-    const args = (0, import_utils.deepMerge)(options, { ...opts.args[1] ?? {} });
+    const args = (0, import_utils.deepMerge)(options, { ...opts.args[1] });
     return req.fetch(opts.args[0], args);
   }
   return req;

package/dist/cjs/compose.js

@@ -25,6 +25,7 @@ var import_context = require("./context");
 const compose = (middleware, onError, onNotFound) => {
   return (context, next) => {
     let index = -1;
+    const isContext = context instanceof import_context.Context;
     return dispatch(0);
     async function dispatch(i) {
       if (i <= index) {
@@ -36,14 +37,14 @@ const compose = (middleware, onError, onNotFound) => {
       let handler;
       if (middleware[i]) {
         handler = middleware[i][0][0];
-        if (context instanceof import_context.Context) {
+        if (isContext) {
           context.req.routeIndex = i;
         }
       } else {
         handler = i === middleware.length && next || void 0;
       }
       if (!handler) {
-        if (context instanceof import_context.Context && context.finalized === false && onNotFound) {
+        if (isContext && context.finalized === false && onNotFound) {
           res = await onNotFound(context);
         }
       } else {
@@ -52,7 +53,7 @@ const compose = (middleware, onError, onNotFound) => {
             return dispatch(i + 1);
           });
         } catch (err) {
-          if (err instanceof Error && context instanceof import_context.Context && onError) {
+          if (err instanceof Error && isContext && onError) {
             context.error = err;
             res = await onError(err, context);
             isError = true;

package/dist/cjs/context.js

@@ -26,7 +26,9 @@ var import_request = require("./request");
 var import_html = require("./utils/html");
 const TEXT_PLAIN = "text/plain; charset=UTF-8";
 const setHeaders = (headers, map = {}) => {
-  Object.entries(map).forEach(([key, value]) => headers.set(key, value));
+  for (const key of Object.keys(map)) {
+    headers.set(key, map[key]);
+  }
   return headers;
 };
 class Context {
@@ -173,7 +175,7 @@ class Context {
     }
     return Object.fromEntries(this.#var);
   }
-  newResponse = (data, arg, headers) => {
+  #newResponse(data, arg, headers) {
     if (this.#isFresh && !headers && !arg && this.#status === 200) {
       return new Response(data, {
         headers: this.#preparedHeaders
@@ -225,9 +227,10 @@ class Context {
       status,
       headers: this.#headers
     });
-  };
+  }
+  newResponse = (...args) => this.#newResponse(...args);
   body = (data, arg, headers) => {
-    return typeof arg === "number" ? this.newResponse(data, arg, headers) : this.newResponse(data, arg);
+    return typeof arg === "number" ? this.#newResponse(data, arg, headers) : this.#newResponse(data, arg);
   };
   text = (text, arg, headers) => {
     if (!this.#preparedHeaders) {
@@ -237,27 +240,27 @@ class Context {
       this.#preparedHeaders = {};
     }
     this.#preparedHeaders["content-type"] = TEXT_PLAIN;
-    return typeof arg === "number" ? this.newResponse(text, arg, headers) : this.newResponse(text, arg);
+    return typeof arg === "number" ? this.#newResponse(text, arg, headers) : this.#newResponse(text, arg);
   };
   json = (object, arg, headers) => {
     const body = JSON.stringify(object);
     this.#preparedHeaders ??= {};
     this.#preparedHeaders["content-type"] = "application/json; charset=UTF-8";
-    return typeof arg === "number" ? this.newResponse(body, arg, headers) : this.newResponse(body, arg);
+    return typeof arg === "number" ? this.#newResponse(body, arg, headers) : this.#newResponse(body, arg);
   };
   html = (html, arg, headers) => {
     this.#preparedHeaders ??= {};
     this.#preparedHeaders["content-type"] = "text/html; charset=UTF-8";
     if (typeof html === "object") {
       return (0, import_html.resolveCallback)(html, import_html.HtmlEscapedCallbackPhase.Stringify, false, {}).then((html2) => {
-        return typeof arg === "number" ? this.newResponse(html2, arg, headers) : this.newResponse(html2, arg);
+        return typeof arg === "number" ? this.#newResponse(html2, arg, headers) : this.#newResponse(html2, arg);
       });
     }
-    return typeof arg === "number" ? this.newResponse(html, arg, headers) : this.newResponse(html, arg);
+    return typeof arg === "number" ? this.#newResponse(html, arg, headers) : this.#newResponse(html, arg);
   };
   redirect = (location, status) => {
     this.#headers ??= new Headers();
-    this.#headers.set("Location", location);
+    this.#headers.set("Location", String(location));
     return this.newResponse(null, status ?? 302);
   };
   notFound = () => {

package/dist/cjs/helper/html/index.js

@@ -27,7 +27,7 @@ const html = (strings, ...values) => {
   const buffer = [""];
   for (let i = 0, len = strings.length - 1; i < len; i++) {
     buffer[0] += strings[i];
-    const children = values[i] instanceof Array ? values[i].flat(Infinity) : [values[i]];
+    const children = Array.isArray(values[i]) ? values[i].flat(Infinity) : [values[i]];
     for (let i2 = 0, len2 = children.length; i2 < len2; i2++) {
       const child = children[i2];
       if (typeof child === "string") {

package/dist/cjs/helper/ssg/ssg.js

@@ -261,8 +261,8 @@ const toSSG = async (app, fs, options) => {
     result = { success: false, files: [], error: errorObj };
   }
   if (options?.afterGenerateHook) {
-    const conbinedAfterGenerateHooks = combineAfterGenerateHooks(options?.afterGenerateHook);
-    await conbinedAfterGenerateHooks(result);
+    const combinedAfterGenerateHooks = combineAfterGenerateHooks(options?.afterGenerateHook);
+    await combinedAfterGenerateHooks(result);
   }
   return result;
 };

package/dist/cjs/helper/ssg/utils.js

@@ -26,8 +26,8 @@ module.exports = __toCommonJS(utils_exports);
 var import_router = require("../../router");
 var import_handler = require("../../utils/handler");
 const dirname = (path) => {
-  const splittedPath = path.split(/[\/\\]/);
-  return splittedPath.slice(0, -1).join("/");
+  const separatedPath = path.split(/[\/\\]/);
+  return separatedPath.slice(0, -1).join("/");
 };
 const normalizePath = (path) => {
   return path.replace(/(\\)/g, "/").replace(/\/$/g, "");

package/dist/cjs/hono-base.js

@@ -59,12 +59,10 @@ class Hono {
         if (typeof args1 === "string") {
           this.#path = args1;
         } else {
-          this.addRoute(method, this.#path, args1);
+          this.#addRoute(method, this.#path, args1);
         }
         args.forEach((handler) => {
-          if (typeof handler !== "string") {
-            this.addRoute(method, this.#path, handler);
-          }
+          this.#addRoute(method, this.#path, handler);
         });
         return this;
       };
@@ -74,7 +72,7 @@ class Hono {
         this.#path = p;
         for (const m of [method].flat()) {
           handlers.map((handler) => {
-            this.addRoute(m.toUpperCase(), this.#path, handler);
+            this.#addRoute(m.toUpperCase(), this.#path, handler);
           });
         }
       }
@@ -88,7 +86,7 @@ class Hono {
         handlers.unshift(arg1);
       }
       handlers.forEach((handler) => {
-        this.addRoute(import_router.METHOD_NAME_ALL, this.#path, handler);
+        this.#addRoute(import_router.METHOD_NAME_ALL, this.#path, handler);
       });
       return this;
     };
@@ -97,7 +95,7 @@ class Hono {
     Object.assign(this, options);
     this.getPath = strict ? options.getPath ?? import_url.getPath : import_url.getPathNoStrict;
   }
-  clone() {
+  #clone() {
     const clone = new Hono({
       router: this.router,
       getPath: this.getPath
@@ -105,33 +103,33 @@ class Hono {
     clone.routes = this.routes;
     return clone;
   }
-  notFoundHandler = notFoundHandler;
-  errorHandler = errorHandler;
+  #notFoundHandler = notFoundHandler;
+  #errorHandler = errorHandler;
   route(path, app) {
     const subApp = this.basePath(path);
     app.routes.map((r) => {
       let handler;
-      if (app.errorHandler === errorHandler) {
+      if (app.#errorHandler === errorHandler) {
         handler = r.handler;
       } else {
-        handler = async (c, next) => (await (0, import_compose.compose)([], app.errorHandler)(c, () => r.handler(c, next))).res;
+        handler = async (c, next) => (await (0, import_compose.compose)([], app.#errorHandler)(c, () => r.handler(c, next))).res;
         handler[COMPOSED_HANDLER] = r.handler;
       }
-      subApp.addRoute(r.method, r.path, handler);
+      subApp.#addRoute(r.method, r.path, handler);
     });
     return this;
   }
   basePath(path) {
-    const subApp = this.clone();
+    const subApp = this.#clone();
     subApp._basePath = (0, import_url.mergePath)(this._basePath, path);
     return subApp;
   }
   onError = (handler) => {
-    this.errorHandler = handler;
+    this.#errorHandler = handler;
     return this;
   };
   notFound = (handler) => {
-    this.notFoundHandler = handler;
+    this.#notFoundHandler = handler;
     return this;
   };
   mount(path, applicationHandler, options) {
@@ -172,52 +170,49 @@ class Hono {
       }
       await next();
     };
-    this.addRoute(import_router.METHOD_NAME_ALL, (0, import_url.mergePath)(path, "*"), handler);
+    this.#addRoute(import_router.METHOD_NAME_ALL, (0, import_url.mergePath)(path, "*"), handler);
     return this;
   }
-  addRoute(method, path, handler) {
+  #addRoute(method, path, handler) {
     method = method.toUpperCase();
     path = (0, import_url.mergePath)(this._basePath, path);
     const r = { path, method, handler };
     this.router.add(method, path, [handler, r]);
     this.routes.push(r);
   }
-  matchRoute(method, path) {
-    return this.router.match(method, path);
-  }
-  handleError(err, c) {
+  #handleError(err, c) {
     if (err instanceof Error) {
-      return this.errorHandler(err, c);
+      return this.#errorHandler(err, c);
     }
     throw err;
   }
-  dispatch(request, executionCtx, env, method) {
+  #dispatch(request, executionCtx, env, method) {
     if (method === "HEAD") {
-      return (async () => new Response(null, await this.dispatch(request, executionCtx, env, "GET")))();
+      return (async () => new Response(null, await this.#dispatch(request, executionCtx, env, "GET")))();
     }
     const path = this.getPath(request, { env });
-    const matchResult = this.matchRoute(method, path);
+    const matchResult = this.router.match(method, path);
     const c = new import_context.Context(request, {
       path,
       matchResult,
       env,
       executionCtx,
-      notFoundHandler: this.notFoundHandler
+      notFoundHandler: this.#notFoundHandler
     });
     if (matchResult[0].length === 1) {
       let res;
       try {
         res = matchResult[0][0][0][0](c, async () => {
-          c.res = await this.notFoundHandler(c);
+          c.res = await this.#notFoundHandler(c);
         });
       } catch (err) {
-        return this.handleError(err, c);
+        return this.#handleError(err, c);
       }
       return res instanceof Promise ? res.then(
-        (resolved) => resolved || (c.finalized ? c.res : this.notFoundHandler(c))
-      ).catch((err) => this.handleError(err, c)) : res ?? this.notFoundHandler(c);
+        (resolved) => resolved || (c.finalized ? c.res : this.#notFoundHandler(c))
+      ).catch((err) => this.#handleError(err, c)) : res ?? this.#notFoundHandler(c);
     }
-    const composed = (0, import_compose.compose)(matchResult[0], this.errorHandler, this.notFoundHandler);
+    const composed = (0, import_compose.compose)(matchResult[0], this.#errorHandler, this.#notFoundHandler);
     return (async () => {
       try {
         const context = await composed(c);
@@ -228,28 +223,30 @@ class Hono {
         }
         return context.res;
       } catch (err) {
-        return this.handleError(err, c);
+        return this.#handleError(err, c);
       }
     })();
   }
   fetch = (request, ...rest) => {
-    return this.dispatch(request, rest[1], rest[0], request.method);
+    return this.#dispatch(request, rest[1], rest[0], request.method);
   };
   request = (input, requestInit, Env, executionCtx) => {
     if (input instanceof Request) {
-      if (requestInit !== void 0) {
-        input = new Request(input, requestInit);
-      }
-      return this.fetch(input, Env, executionCtx);
+      return this.fetch(requestInit ? new Request(input, requestInit) : input, Env, executionCtx);
     }
     input = input.toString();
-    const path = /^https?:\/\//.test(input) ? input : `http://localhost${(0, import_url.mergePath)("/", input)}`;
-    const req = new Request(path, requestInit);
-    return this.fetch(req, Env, executionCtx);
+    return this.fetch(
+      new Request(
+        /^https?:\/\//.test(input) ? input : `http://localhost${(0, import_url.mergePath)("/", input)}`,
+        requestInit
+      ),
+      Env,
+      executionCtx
+    );
   };
   fire = () => {
     addEventListener("fetch", (event) => {
-      event.respondWith(this.dispatch(event.request, event, void 0, event.request.method));
+      event.respondWith(this.#dispatch(event.request, event, void 0, event.request.method));
     });
   };
 }

package/dist/cjs/jsx/base.js

@@ -34,7 +34,8 @@ __export(base_exports, {
   jsx: () => jsx,
   jsxFn: () => jsxFn,
   memo: () => memo,
-  reactAPICompatVersion: () => reactAPICompatVersion
+  reactAPICompatVersion: () => reactAPICompatVersion,
+  shallowEqual: () => shallowEqual
 });
 module.exports = __toCommonJS(base_exports);
 var import_html = require("../helper/html");
@@ -308,13 +309,16 @@ const shallowEqual = (a, b) => {
 const memo = (component, propsAreEqual = shallowEqual) => {
   let computed = null;
   let prevProps = void 0;
-  return (props) => {
+  const wrapper = (props) => {
     if (prevProps && !propsAreEqual(prevProps, props)) {
       computed = null;
     }
     prevProps = props;
     return computed ||= component(props);
   };
+  wrapper[import_constants.DOM_MEMO] = propsAreEqual;
+  wrapper[import_constants.DOM_RENDERER] = component;
+  return wrapper;
 };
 const Fragment = ({
   children
@@ -350,5 +354,6 @@ const reactAPICompatVersion = "19.0.0-hono-jsx";
   jsx,
   jsxFn,
   memo,
-  reactAPICompatVersion
+  reactAPICompatVersion,
+  shallowEqual
 });

package/dist/cjs/jsx/constants.js

@@ -20,6 +20,7 @@ var constants_exports = {};
 __export(constants_exports, {
   DOM_ERROR_HANDLER: () => DOM_ERROR_HANDLER,
   DOM_INTERNAL_TAG: () => DOM_INTERNAL_TAG,
+  DOM_MEMO: () => DOM_MEMO,
   DOM_RENDERER: () => DOM_RENDERER,
   DOM_STASH: () => DOM_STASH,
   PERMALINK: () => PERMALINK
@@ -29,11 +30,13 @@ const DOM_RENDERER = Symbol("RENDERER");
 const DOM_ERROR_HANDLER = Symbol("ERROR_HANDLER");
 const DOM_STASH = Symbol("STASH");
 const DOM_INTERNAL_TAG = Symbol("INTERNAL");
+const DOM_MEMO = Symbol("MEMO");
 const PERMALINK = Symbol("PERMALINK");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DOM_ERROR_HANDLER,
   DOM_INTERNAL_TAG,
+  DOM_MEMO,
   DOM_RENDERER,
   DOM_STASH,
   PERMALINK

package/dist/cjs/jsx/dom/index.js

@@ -33,7 +33,7 @@ __export(dom_exports, {
   forwardRef: () => import_hooks.forwardRef,
   isValidElement: () => import_base.isValidElement,
   jsx: () => createElement,
-  memo: () => import_base.memo,
+  memo: () => memo,
   render: () => import_render2.render,
   startTransition: () => import_hooks.startTransition,
   startViewTransition: () => import_hooks.startViewTransition,
@@ -62,6 +62,7 @@ __export(dom_exports, {
 module.exports = __toCommonJS(dom_exports);
 var import_base = require("../base");
 var import_children = require("../children");
+var import_constants = require("../constants");
 var import_context = require("../context");
 var import_hooks = require("../hooks");
 var import_components = require("./components");
@@ -93,6 +94,11 @@ const cloneElement = (element, props, ...children) => {
     element.key
   );
 };
+const memo = (component, propsAreEqual = import_base.shallowEqual) => {
+  const wrapper = (props) => component(props);
+  wrapper[import_constants.DOM_MEMO] = propsAreEqual;
+  return wrapper;
+};
 var dom_default = {
   version: import_base.reactAPICompatVersion,
   useState: import_hooks.useState,
@@ -122,7 +128,7 @@ var dom_default = {
   ErrorBoundary: import_components.ErrorBoundary,
   createContext: import_context2.createContext,
   useContext: import_context.useContext,
-  memo: import_base.memo,
+  memo,
   isValidElement: import_base.isValidElement,
   createElement,
   cloneElement,