@nocobase/plugin-mcp-server 2.3.0-beta.11 → 2.3.0-beta.13

package/dist/node_modules/hono/dist/cjs/client/client.js

@@ -40,6 +40,10 @@ const createProxy = (callback, path) => {
   });
   return proxy;
 };
+const appendQueryParams = (url, searchParams) => {
+  const queryString = searchParams.toString();
+  return queryString ? `${url}?${queryString}` : url;
+};
 class ClientRequestImpl {
   url;
   method;
@@ -66,6 +70,9 @@ class ClientRequestImpl {
           }
           if (Array.isArray(v)) {
             for (const v2 of v) {
+              if (v2 === void 0) {
+                continue;
+              }
               form.append(k, v2);
             }
           } else {
@@ -74,7 +81,7 @@ class ClientRequestImpl {
         }
         this.rBody = form;
       }
-      if (args.json) {
+      if (args.json !== void 0) {
         this.rBody = JSON.stringify(args.json);
         this.cType = "application/json";
       }
@@ -90,19 +97,29 @@ class ClientRequestImpl {
     if (args?.cookie) {
       const cookies = [];
       for (const [key, value] of Object.entries(args.cookie)) {
-        cookies.push((0, import_cookie.serialize)(key, value, { path: "/" }));
+        if (value === void 0) {
+          continue;
+        }
+        cookies.push((0, import_cookie.serialize)(key, value));
+      }
+      if (cookies.length > 0) {
+        headerValues["Cookie"] = cookies.join("; ");
       }
-      headerValues["Cookie"] = cookies.join(",");
     }
     if (this.cType) {
       headerValues["Content-Type"] = this.cType;
     }
-    const headers = new Headers(headerValues ?? void 0);
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(headerValues)) {
+      if (value !== void 0) {
+        headers.set(key, value);
+      }
+    }
     let url = this.url;
     url = (0, import_utils.removeIndexString)(url);
     url = (0, import_utils.replaceUrlParam)(url, this.pathParams);
     if (this.queryParams) {
-      url = url + "?" + this.queryParams.toString();
+      url = appendQueryParams(url, this.queryParams);
     }
     methodUpperCase = this.method.toUpperCase();
     const setBody = !(methodUpperCase === "GET" || methodUpperCase === "HEAD");
@@ -146,7 +163,7 @@ const hc = (baseUrl, options) => createProxy(function proxyCallback(opts) {
         result = (0, import_utils.replaceUrlParam)(url, opts.args[0].param);
       }
       if (opts.args[0].query) {
-        result = result + "?" + buildSearchParamsOption(opts.args[0].query).toString();
+        result = appendQueryParams(result, buildSearchParamsOption(opts.args[0].query));
       }
     }
     result = (0, import_utils.removeIndexString)(result);
@@ -157,18 +174,15 @@ const hc = (baseUrl, options) => createProxy(function proxyCallback(opts) {
   }
   if (method === "ws") {
     const webSocketUrl = (0, import_utils.replaceUrlProtocol)(
-      opts.args[0] && opts.args[0].param ? (0, import_utils.replaceUrlParam)(url, opts.args[0].param) : url,
+      opts.args[0]?.param ? (0, import_utils.replaceUrlParam)(url, opts.args[0].param) : url,
       "ws"
     );
     const targetUrl = new URL(webSocketUrl);
     const queryParams = opts.args[0]?.query;
     if (queryParams) {
-      Object.entries(queryParams).forEach(([key, value]) => {
-        if (Array.isArray(value)) {
-          value.forEach((item) => targetUrl.searchParams.append(key, item));
-        } else {
-          targetUrl.searchParams.set(key, value);
-        }
+      const searchParams = buildSearchParamsOption(queryParams);
+      searchParams.forEach((value, key) => {
+        targetUrl.searchParams.append(key, value);
       });
     }
     const establishWebSocket = (...args) => {
@@ -184,7 +198,16 @@ const hc = (baseUrl, options) => createProxy(function proxyCallback(opts) {
   });
   if (method) {
     options ??= {};
-    const args = (0, import_utils.deepMerge)(options, { ...opts.args[1] });
+    const reqOptions = { ...opts.args[1] };
+    const baseHeaders = options.headers;
+    const reqHeaders = reqOptions.headers;
+    if (baseHeaders && reqHeaders) {
+      reqOptions.headers = async () => ({
+        ...typeof baseHeaders === "function" ? await baseHeaders() : baseHeaders,
+        ...typeof reqHeaders === "function" ? await reqHeaders() : reqHeaders
+      });
+    }
+    const args = (0, import_utils.deepMerge)(options, reqOptions);
     return req.fetch(opts.args[0], args);
   }
   return req;

package/dist/node_modules/hono/dist/cjs/client/utils.js

@@ -36,8 +36,8 @@ const mergePath = (base, path) => {
 };
 const replaceUrlParam = (urlString, params) => {
   for (const [k, v] of Object.entries(params)) {
-    const reg = new RegExp("/:" + k + "(?:{[^/]+})?\\??");
-    urlString = urlString.replace(reg, v ? `/${v}` : "");
+    const reg = new RegExp("/:" + k + "(?:{[^/]+})?\\??(?=/|$)");
+    urlString = urlString.replace(reg, () => v ? `/${v}` : "");
   }
   return urlString;
 };
@@ -49,6 +49,9 @@ const buildSearchParams = (query) => {
     }
     if (Array.isArray(v)) {
       for (const v2 of v) {
+        if (v2 === void 0) {
+          continue;
+        }
         searchParams.append(k, v2);
       }
     } else {

package/dist/node_modules/hono/dist/cjs/context.js

@@ -224,6 +224,10 @@ class Context {
    *   c.header('X-Message', 'Hello!')
    *   c.header('Content-Type', 'text/plain')
    *
+   *   // Append multiple headers using the append option (e.g. Vary)
+   *   c.header('Vary', 'Accept-Encoding', { append: true })
+   *   c.header('Vary', 'User-Agent', { append: true })
+   *
    *   return c.body('Thank you for coming')
    * })
    * ```
@@ -295,11 +299,11 @@ class Context {
     return Object.fromEntries(this.#var);
   }
   #newResponse(data, arg, headers) {
-    const responseHeaders = this.#res ? new Headers(this.#res.headers) : this.#preparedHeaders ?? new Headers();
-    if (typeof arg === "object" && "headers" in arg) {
-      const argHeaders = arg.headers instanceof Headers ? arg.headers : new Headers(arg.headers);
-      for (const [key, value] of argHeaders) {
-        if (key.toLowerCase() === "set-cookie") {
+    let responseHeaders = this.#res ? new Headers(this.#res.headers) : this.#preparedHeaders;
+    if (typeof arg === "object" && arg.headers) {
+      responseHeaders ??= new Headers();
+      for (const [key, value] of new Headers(arg.headers)) {
+        if (key === "set-cookie") {
           responseHeaders.append(key, value);
         } else {
           responseHeaders.set(key, value);
@@ -307,19 +311,34 @@ class Context {
       }
     }
     if (headers) {
-      for (const [k, v] of Object.entries(headers)) {
-        if (typeof v === "string") {
-          responseHeaders.set(k, v);
-        } else {
-          responseHeaders.delete(k);
-          for (const v2 of v) {
-            responseHeaders.append(k, v2);
+      if (!responseHeaders) {
+        let count = 0;
+        for (const k in headers) {
+          if (++count > 1 || typeof headers[k] !== "string") {
+            responseHeaders = new Headers();
+            break;
+          }
+        }
+      }
+      if (responseHeaders) {
+        for (const k in headers) {
+          const v = headers[k];
+          if (typeof v === "string") {
+            responseHeaders.set(k, v);
+          } else {
+            responseHeaders.delete(k);
+            for (const v2 of v) {
+              responseHeaders.append(k, v2);
+            }
           }
         }
       }
     }
     const status = typeof arg === "number" ? arg : arg?.status ?? this.#status;
-    return createResponseInstance(data, { status, headers: responseHeaders });
+    return createResponseInstance(data, {
+      status,
+      headers: responseHeaders ?? headers
+    });
   }
   newResponse = (...args) => this.#newResponse(...args);
   /**

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

@@ -22,10 +22,44 @@ __export(accepts_exports, {
 });
 module.exports = __toCommonJS(accepts_exports);
 var import_accept = require("../../utils/accept");
+const 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;
+};
+const getSpecificity = (type) => {
+  if (type === "*/*" || type === "*") {
+    return 1;
+  }
+  if (type.endsWith("/*")) {
+    return 2;
+  }
+  return 3;
+};
 const 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;
 };
 const accepts = (c, options) => {
   const acceptHeader = c.req.header(options.header);

package/dist/node_modules/hono/dist/cjs/helper/css/common.js

@@ -61,6 +61,7 @@ const normalizeLabel = (label) => {
   return label.trim().replace(/\s+/g, "-");
 };
 const isValidClassName = (name) => /^-?[_a-zA-Z][_a-zA-Z0-9-]*$/.test(name);
+const hasUnsafeSelectorChar = (name) => /[<{}]/.test(name);
 const RESERVED_KEYFRAME_NAMES = /* @__PURE__ */ new Set([
   "default",
   "inherit",
@@ -198,7 +199,8 @@ const 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/dist/node_modules/hono/dist/cjs/helper/css/index.js

@@ -29,6 +29,7 @@ module.exports = __toCommonJS(css_exports);
 var import_html = require("../../helper/html");
 var import_constants = require("../../jsx/constants");
 var import_css = require("../../jsx/dom/css");
+var import_html2 = require("../../utils/html");
 var import_common = require("./common");
 var import_common2 = require("./common");
 const createCssContext = ({
@@ -88,7 +89,14 @@ const createCssContext = ({
       }
       return Promise.resolve((0, import_html.raw)("", [appendStyle]));
     };
-    const className = new String(cssClassName[import_common.CLASS_NAME]);
+    const rawClassName = cssClassName[import_common.CLASS_NAME];
+    let escapedClassName = rawClassName;
+    if (/[&<>'"]/.test(rawClassName)) {
+      const escapedBuffer = [""];
+      (0, import_html2.escapeToBuffer)(rawClassName, escapedBuffer);
+      escapedClassName = escapedBuffer[0];
+    }
+    const className = new String(escapedClassName);
     Object.assign(className, cssClassName);
     className.isEscaped = true;
     className.callbacks = [addClassNameToContext];

package/dist/node_modules/hono/dist/cjs/helper/proxy/index.js

@@ -92,6 +92,10 @@ const proxy = async (input, proxyInit) => {
   req.headers.delete("accept-encoding");
   const res = await (customFetch || fetch)(req);
   const resHeaders = new Headers(res.headers);
+  const connectionValue = resHeaders.get("connection");
+  if (connectionValue) {
+    connectionValue.split(",").map((h) => h.trim()).filter((h) => ALLOWED_TOKEN_PATTERN.test(h)).forEach((h) => resHeaders.delete(h));
+  }
   hopByHopHeaders.forEach((header) => {
     resHeaders.delete(header);
   });

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

@@ -69,6 +69,8 @@ const defaultExtensionMap = {
   "text/html": "html",
   "text/xml": "xml",
   "application/xml": "xml",
+  "application/atom+xml": "xml",
+  "application/rss+xml": "xml",
   "application/yaml": "yaml"
 };
 const determineExtension = (mimeType, userExtensionMap) => {
@@ -204,7 +206,7 @@ const saveContentToFile = async (data, fsModule, outDir, extensionMap) => {
   const { routePath, content, mimeType } = awaitedData;
   const filePath = generateFilePath(routePath, outDir, mimeType, extensionMap);
   const dirPath = (0, import_utils2.dirname)(filePath);
-  if (!createdDirs.has(dirPath)) {
+  if (dirPath !== "" && !createdDirs.has(dirPath)) {
     await fsModule.mkdir(dirPath, { recursive: true });
     createdDirs.add(dirPath);
   }

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

@@ -33,8 +33,14 @@ const dirname = (path) => {
 const normalizePath = (path) => {
   return path.replace(/(\\)/g, "/").replace(/\/$/g, "");
 };
-const handleParent = (resultPaths, beforeParentFlag) => {
-  if (resultPaths.length === 0 || beforeParentFlag) {
+const getUncRoot = (path) => {
+  const uncRoot = path.replace(/\\/g, "/").match(/^\/\/([^/]+)\/([^/]+)/);
+  if (uncRoot) {
+    return `${uncRoot[1].toLowerCase()}/${uncRoot[2].toLowerCase()}`;
+  }
+};
+const handleParent = (resultPaths) => {
+  if (resultPaths.length === 0 || resultPaths[resultPaths.length - 1] === "..") {
     resultPaths.push("..");
   } else {
     resultPaths.pop();
@@ -47,22 +53,20 @@ const handleNonDot = (path, resultPaths) => {
   }
 };
 const 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;
     }
   }
 };
 const 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("/");
 };
 const filterStaticGenerateRoutes = (hono) => {
   return hono.routes.reduce((acc, { method, handler, path }) => {
@@ -76,10 +80,26 @@ const filterStaticGenerateRoutes = (hono) => {
 const isDynamicRoute = (path) => {
   return path.split("/").some((segment) => segment.startsWith(":") || segment.includes("*"));
 };
+const toSegments = (path) => path === "" ? [] : path.split("/");
+const 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";
+};
 const 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/dist/node_modules/hono/dist/cjs/helper/streaming/sse.js

@@ -33,16 +33,17 @@ class SSEStreamingApi extends import_stream.StreamingApi {
     const dataLines = data.split(/\r\n|\r|\n/).map((line) => {
       return `data: ${line}`;
     }).join("\n");
-    for (const key of ["event", "id", "retry"]) {
-      if (message[key] && /[\r\n]/.test(message[key])) {
+    for (const key of ["event", "id"]) {
+      const value = message[key];
+      if (value && /[\r\n]/.test(value)) {
         throw new Error(`${key} must not contain "\\r" or "\\n"`);
       }
     }
     const sseData = [
       message.event && `event: ${message.event}`,
       dataLines,
-      message.id && `id: ${message.id}`,
-      message.retry && `retry: ${message.retry}`
+      message.id !== void 0 && `id: ${message.id}`,
+      message.retry !== void 0 && `retry: ${message.retry}`
     ].filter(Boolean).join("\n") + "\n\n";
     await this.write(sseData);
   }

package/dist/node_modules/hono/dist/cjs/hono-base.js

@@ -43,6 +43,7 @@ class Hono {
   delete;
   options;
   patch;
+  query;
   all;
   on;
   use;
@@ -139,7 +140,7 @@ class Hono {
         handler = async (c, next) => (await (0, import_compose.compose)([], app.errorHandler)(c, () => r.handler(c, next))).res;
         handler[import_constants.COMPOSED_HANDLER] = r.handler;
       }
-      subApp.#addRoute(r.method, r.path, handler);
+      subApp.#addRoute(r.method, r.path, handler, r.basePath);
     });
     return this;
   }
@@ -263,7 +264,7 @@ class Hono {
       const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
       return (request) => {
         const url = new URL(request.url);
-        url.pathname = url.pathname.slice(pathPrefixLength) || "/";
+        url.pathname = this.getPath(request).slice(pathPrefixLength) || "/";
         return new Request(url, request);
       };
     })();
@@ -277,10 +278,15 @@ class Hono {
     this.#addRoute(import_router.METHOD_NAME_ALL, (0, import_url.mergePath)(path, "*"), handler);
     return this;
   }
-  #addRoute(method, path, handler) {
+  #addRoute(method, path, handler, baseRoutePath) {
     method = method.toUpperCase();
     path = (0, import_url.mergePath)(this._basePath, path);
-    const r = { basePath: this._basePath, path, method, handler };
+    const r = {
+      basePath: baseRoutePath !== void 0 ? (0, import_url.mergePath)(this._basePath, baseRoutePath) : this._basePath,
+      path,
+      method,
+      handler
+    };
     this.router.add(method, path, [handler, r]);
     this.routes.push(r);
   }
@@ -337,8 +343,8 @@ class Hono {
    * @see {@link https://hono.dev/docs/api/hono#fetch}
    *
    * @param {Request} request - request Object of request
-   * @param {Env} Env - env Object
-   * @param {ExecutionContext} - context of execution
+   * @param {Env} env - env Object
+   * @param {ExecutionContext} executionCtx - context of execution
    * @returns {Response | Promise<Response>} response of request
    *
    */

package/dist/node_modules/hono/dist/cjs/index.js

@@ -17,11 +17,14 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var index_exports = {};
 __export(index_exports, {
+  Context: () => import_context.Context,
   Hono: () => import_hono.Hono
 });
 module.exports = __toCommonJS(index_exports);
 var import_hono = require("./hono");
+var import_context = require("./context");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  Context,
   Hono
 });

package/dist/node_modules/hono/dist/cjs/jsx/base.js

@@ -100,6 +100,18 @@ const booleanAttributes = [
   "reversed",
   "selected"
 ];
+const resolveFunctionComponentResult = (result, suspendedContext) => result.then((resolved) => {
+  if (!Array.isArray(resolved) && !(resolved instanceof JSXNode)) {
+    return resolved;
+  }
+  const children = Array.isArray(resolved) ? resolved : [resolved];
+  const render = () => {
+    const buffer = [""];
+    childrenToStringToBuffer(children, buffer);
+    return buffer.length === 1 ? (0, import_html.raw)(buffer[0], buffer.callbacks) : (0, import_html2.stringBufferToString)(buffer, buffer.callbacks);
+  };
+  return suspendedContext ? suspendedContext(render) : (0, import_context.runWithRenderContext)(render);
+});
 const childrenToStringToBuffer = (children, buffer) => {
   for (let i = 0, len = children.length; i < len; i++) {
     const child = children[i];
@@ -109,9 +121,17 @@ const childrenToStringToBuffer = (children, buffer) => {
       continue;
     } else if (child instanceof JSXNode) {
       child.toStringToBuffer(buffer);
-    } else if (typeof child === "number" || child.isEscaped) {
+    } else if (typeof child === "number") {
       ;
       buffer[0] += child;
+    } else if (child.isEscaped) {
+      ;
+      buffer[0] += child;
+      const callbacks = child.callbacks;
+      if (callbacks) {
+        buffer.callbacks ||= [];
+        buffer.callbacks.push(...callbacks);
+      }
     } else if (child instanceof Promise) {
       buffer.unshift("", child);
     } else {
@@ -125,8 +145,10 @@ class JSXNode {
   key;
   children;
   isEscaped = true;
-  localContexts;
   constructor(tag, props, children) {
+    if (typeof tag !== "function" && !(0, import_utils.isValidTagName)(tag)) {
+      throw new Error(`Invalid JSX tag name: ${tag}`);
+    }
     this.tag = tag;
     this.props = props;
     this.children = children;
@@ -140,27 +162,24 @@ class JSXNode {
     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 ? (0, import_html2.resolveCallbackSync)((0, import_html.raw)(buffer[0], buffer.callbacks)).toString() : buffer[0] : (0, import_html2.stringBufferToString)(buffer, buffer.callbacks);
+      return buffer.length === 1 ? "callbacks" in buffer ? (0, import_html2.resolveCallbackSync)((0, import_html.raw)(buffer[0], buffer.callbacks)).toString() : buffer[0] : (0, import_html2.stringBufferToString)(buffer, buffer.callbacks);
+    };
+    return (0, import_context.runWithRenderContext)(render);
   }
   toStringToBuffer(buffer) {
     const tag = this.tag;
     const props = this.props;
     let { children } = this;
     buffer[0] += `<${tag}`;
-    const normalizeKey = nameSpaceContext && (0, import_context.useContext)(nameSpaceContext) === "svg" ? (key) => toSVGAttributeName((0, import_utils.normalizeIntrinsicElementKey)(key)) : (key) => (0, import_utils.normalizeIntrinsicElementKey)(key);
+    const normalizeKey = tag === "svg" || nameSpaceContext && (0, import_context.useContext)(nameSpaceContext) === "svg" ? (key) => toSVGAttributeName((0, import_utils.normalizeIntrinsicElementKey)(key)) : (key) => (0, import_utils.normalizeIntrinsicElementKey)(key);
     for (let [key, v] of Object.entries(props)) {
       key = normalizeKey(key);
+      if (!(0, import_utils.isValidAttributeName)(key)) {
+        continue;
+      }
       if (key === "children") {
       } else if (key === "style" && typeof v === "object") {
         let styleStr = "";
@@ -222,21 +241,14 @@ class JSXFunctionNode extends JSXNode {
       return;
     } else if (res instanceof Promise) {
       if (import_context.globalContexts.length === 0) {
-        buffer.unshift("", res);
+        buffer.unshift("", resolveFunctionComponentResult(res));
       } else {
-        const currentContexts = import_context.globalContexts.map((c) => [c, c.values.at(-1)]);
-        buffer.unshift(
-          "",
-          res.then((childRes) => {
-            if (childRes instanceof JSXNode) {
-              childRes.localContexts = currentContexts;
-            }
-            return childRes;
-          })
-        );
+        buffer.unshift("", resolveFunctionComponentResult(res, (0, import_context.captureRenderContext)()));
       }
     } else if (res instanceof JSXNode) {
       res.toStringToBuffer(buffer);
+    } else if (Array.isArray(res)) {
+      childrenToStringToBuffer(res, buffer);
     } else if (typeof res === "number" || res.isEscaped) {
       buffer[0] += res;
       if (res.callbacks) {
@@ -315,15 +327,7 @@ const shallowEqual = (a, b) => {
   return true;
 };
 const memo = (component, propsAreEqual = shallowEqual) => {
-  let computed = null;
-  let prevProps = void 0;
-  const wrapper = ((props) => {
-    if (prevProps && !propsAreEqual(prevProps, props)) {
-      computed = null;
-    }
-    prevProps = props;
-    return computed ||= component(props);
-  });
+  const wrapper = ((props) => component(props));
   wrapper[import_constants.DOM_MEMO] = propsAreEqual;
   wrapper[import_constants.DOM_RENDERER] = component;
   return wrapper;