@zuplo/cli 6.69.11 → 6.70.1

package/node_modules/hono/dist/jsx/streaming.js

@@ -0,0 +1,153 @@
+// src/jsx/streaming.ts
+import { raw } from "../helper/html/index.js";
+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 { Suspense as SuspenseDomRenderer } from "./dom/components.js";
+import { buildDataStack } from "./dom/render.js";
+var StreamingContext = createContext(null);
+var suspenseCounter = 0;
+var Suspense = async ({
+  children,
+  fallback
+}) => {
+  if (!Array.isArray(children)) {
+    children = [children];
+  }
+  const nonce = useContext(StreamingContext)?.scriptNonce;
+  let resArray = [];
+  const stackNode = { [DOM_STASH]: [0, []] };
+  const popNodeStack = (value) => {
+    buildDataStack.pop();
+    return value;
+  };
+  try {
+    stackNode[DOM_STASH][0] = 0;
+    buildDataStack.push([[], stackNode]);
+    resArray = children.map(
+      (c) => c == null || typeof c === "boolean" ? "" : c.toString()
+    );
+  } catch (e) {
+    if (e instanceof Promise) {
+      resArray = [
+        e.then(() => {
+          stackNode[DOM_STASH][0] = 0;
+          buildDataStack.push([[], stackNode]);
+          return childrenToString(children).then(popNodeStack);
+        })
+      ];
+    } else {
+      throw e;
+    }
+  } finally {
+    popNodeStack();
+  }
+  if (resArray.some((res) => res instanceof Promise)) {
+    const index = suspenseCounter++;
+    const fallbackStr = await fallback.toString();
+    return raw(`<template id="H:${index}"></template>${fallbackStr}<!--/$-->`, [
+      ...fallbackStr.callbacks || [],
+      ({ phase, buffer, context }) => {
+        if (phase === HtmlEscapedCallbackPhase.BeforeStream) {
+          return;
+        }
+        return Promise.all(resArray).then(async (htmlArray) => {
+          htmlArray = htmlArray.flat();
+          const content = htmlArray.join("");
+          if (buffer) {
+            buffer[0] = buffer[0].replace(
+              new RegExp(`<template id="H:${index}"></template>.*?<!--/\\$-->`),
+              content
+            );
+          }
+          let html = buffer ? "" : `<template data-hono-target="H:${index}">${content}</template><script${nonce ? ` nonce="${nonce}"` : ""}>
+((d,c,n) => {
+c=d.currentScript.previousSibling
+d=d.getElementById('H:${index}')
+if(!d)return
+do{n=d.nextSibling;n.remove()}while(n.nodeType!=8||n.nodeValue!='/$')
+d.replaceWith(c.content)
+})(document)
+</script>`;
+          const callbacks = htmlArray.map((html2) => html2.callbacks || []).flat();
+          if (!callbacks.length) {
+            return html;
+          }
+          if (phase === HtmlEscapedCallbackPhase.Stream) {
+            html = await resolveCallback(html, HtmlEscapedCallbackPhase.BeforeStream, true, context);
+          }
+          return raw(html, callbacks);
+        });
+      }
+    ]);
+  } else {
+    return raw(resArray.join(""));
+  }
+};
+Suspense[DOM_RENDERER] = SuspenseDomRenderer;
+var textEncoder = new TextEncoder();
+var renderToReadableStream = (content, onError = console.trace) => {
+  let cancelled = false;
+  const reader = new ReadableStream({
+    async start(controller) {
+      try {
+        if (content instanceof JSXNode) {
+          content = content.toString();
+        }
+        const context = typeof content === "object" ? content : {};
+        const resolved = await resolveCallback(
+          content,
+          HtmlEscapedCallbackPhase.BeforeStream,
+          true,
+          context
+        );
+        if (!cancelled) {
+          controller.enqueue(textEncoder.encode(resolved));
+        }
+        let resolvedCount = 0;
+        const callbacks = [];
+        const then = (promise) => {
+          callbacks.push(
+            promise.catch((err) => {
+              console.log(err);
+              onError(err);
+              return "";
+            }).then(async (res) => {
+              res = await resolveCallback(
+                res,
+                HtmlEscapedCallbackPhase.BeforeStream,
+                true,
+                context
+              );
+              res.callbacks?.map((c) => c({ phase: HtmlEscapedCallbackPhase.Stream, context })).filter(Boolean).forEach(then);
+              resolvedCount++;
+              if (!cancelled) {
+                controller.enqueue(textEncoder.encode(res));
+              }
+            })
+          );
+        };
+        resolved.callbacks?.map((c) => c({ phase: HtmlEscapedCallbackPhase.Stream, context })).filter(Boolean).forEach(then);
+        while (resolvedCount !== callbacks.length) {
+          await Promise.all(callbacks);
+        }
+      } catch (e) {
+        onError(e);
+      }
+      if (!cancelled) {
+        controller.close();
+      }
+    },
+    cancel() {
+      cancelled = true;
+    }
+  });
+  return reader;
+};
+export {
+  StreamingContext,
+  Suspense,
+  renderToReadableStream
+};

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

@@ -0,0 +1,175 @@
+// src/jsx/utils.ts
+var normalizeElementKeyMap = /* @__PURE__ */ new Map([
+  ["className", "class"],
+  ["htmlFor", "for"],
+  ["crossOrigin", "crossorigin"],
+  ["httpEquiv", "http-equiv"],
+  ["itemProp", "itemprop"],
+  ["fetchPriority", "fetchpriority"],
+  ["noModule", "nomodule"],
+  ["formAction", "formaction"]
+]);
+var normalizeIntrinsicElementKey = (key) => normalizeElementKeyMap.get(key) || key;
+var invalidAttributeNameCharRe = /[\s"'<>/=`\\\x00-\x1f\x7f-\x9f]/;
+var validAttributeNameCache = /* @__PURE__ */ new Set();
+var validAttributeNameCacheMax = 1024;
+var invalidTagNameCharRe = /^[!?]|[\s"'<>/=`\\\x00-\x1f\x7f-\x9f]/;
+var validTagNameCache = /* @__PURE__ */ new Set();
+var validTagNameCacheMax = 256;
+var cacheValidName = (cache, max, name) => {
+  if (cache.size >= max) {
+    cache.clear();
+  }
+  cache.add(name);
+};
+var isValidTagName = (name) => {
+  if (validTagNameCache.has(name)) {
+    return true;
+  }
+  if (typeof name !== "string") {
+    return false;
+  }
+  if (name.length === 0) {
+    return true;
+  }
+  if (invalidTagNameCharRe.test(name)) {
+    return false;
+  }
+  cacheValidName(validTagNameCache, validTagNameCacheMax, name);
+  return true;
+};
+var isValidAttributeName = (name) => {
+  if (validAttributeNameCache.has(name)) {
+    return true;
+  }
+  const len = name.length;
+  if (len === 0) {
+    return false;
+  }
+  for (let i = 0; i < len; i++) {
+    const c = name.charCodeAt(i);
+    if (!(c >= 97 && c <= 122 || // a-z
+    c >= 65 && c <= 90 || // A-Z
+    c >= 48 && c <= 57 || // 0-9
+    c === 45 || // -
+    c === 95 || // _
+    c === 46 || // .
+    c === 58)) {
+      if (!invalidAttributeNameCharRe.test(name)) {
+        cacheValidName(validAttributeNameCache, validAttributeNameCacheMax, name);
+        return true;
+      } else {
+        return false;
+      }
+    }
+  }
+  cacheValidName(validAttributeNameCache, validAttributeNameCacheMax, name);
+  return true;
+};
+var invalidStylePropertyNameCharRe = /[\s"'():;\\/\[\]{}\x00-\x1f\x7f-\x9f]/;
+var validStylePropertyNameCache = /* @__PURE__ */ new Set();
+var validStylePropertyNameCacheMax = 1024;
+var isValidStylePropertyName = (name) => {
+  if (validStylePropertyNameCache.has(name)) {
+    return true;
+  }
+  const len = name.length;
+  if (len === 0) {
+    return false;
+  }
+  for (let i = 0; i < len; i++) {
+    const c = name.charCodeAt(i);
+    if (!(c >= 97 && c <= 122 || // a-z
+    c >= 65 && c <= 90 || // A-Z
+    c >= 48 && c <= 57 || // 0-9
+    c === 45 || // -
+    c === 95)) {
+      if (!invalidStylePropertyNameCharRe.test(name)) {
+        cacheValidName(validStylePropertyNameCache, validStylePropertyNameCacheMax, name);
+        return true;
+      } else {
+        return false;
+      }
+    }
+  }
+  cacheValidName(validStylePropertyNameCache, validStylePropertyNameCacheMax, name);
+  return true;
+};
+var unsafeStyleValueCharRe = /[;"'\\/\[\](){}]/;
+var hasUnsafeStyleValue = (value) => {
+  if (!unsafeStyleValueCharRe.test(value)) {
+    return false;
+  }
+  let quote = 0;
+  const blockStack = [];
+  for (let i = 0, len = value.length; i < len; i++) {
+    const c = value.charCodeAt(i);
+    if (c === 92) {
+      if (i === len - 1) {
+        return true;
+      }
+      i++;
+    } else if (quote !== 0) {
+      if (c === 10 || c === 12 || c === 13) {
+        return true;
+      }
+      if (c === quote) {
+        quote = 0;
+      }
+    } else if (c === 47 && value.charCodeAt(i + 1) === 42) {
+      const end = value.indexOf("*/", i + 2);
+      if (end === -1) {
+        return true;
+      }
+      i = end + 1;
+    } else if (c === 34 || c === 39) {
+      quote = c;
+    } else if (c === 40) {
+      blockStack.push(41);
+    } else if (c === 91) {
+      blockStack.push(93);
+    } else if (c === 123 || c === 125) {
+      return true;
+    } else if (c === 41 || c === 93) {
+      if (blockStack[blockStack.length - 1] !== c) {
+        return true;
+      }
+      blockStack.pop();
+    } else if (c === 59 && blockStack.length === 0) {
+      return true;
+    }
+  }
+  return quote !== 0 || blockStack.length !== 0;
+};
+var styleObjectForEach = (style, fn) => {
+  for (const [k, v] of Object.entries(style)) {
+    const key = k[0] === "-" || !/[A-Z]/.test(k) ? k : k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+    if (!isValidStylePropertyName(key)) {
+      continue;
+    }
+    if (v == null) {
+      fn(key, null);
+      continue;
+    }
+    let value;
+    if (typeof v === "number") {
+      value = !key.match(
+        /^(?:a|border-im|column(?:-c|s)|flex(?:$|-[^b])|grid-(?:ar|[^a])|font-w|li|or|sca|st|ta|wido|z)|ty$/
+      ) ? `${v}px` : `${v}`;
+    } else if (typeof v === "string") {
+      if (hasUnsafeStyleValue(v)) {
+        continue;
+      }
+      value = v;
+    } else {
+      continue;
+    }
+    fn(key, value);
+  }
+};
+export {
+  isValidAttributeName,
+  isValidTagName,
+  normalizeIntrinsicElementKey,
+  styleObjectForEach
+};

package/node_modules/hono/dist/middleware/basic-auth/index.js

@@ -0,0 +1,66 @@
+// src/middleware/basic-auth/index.ts
+import { HTTPException } from "../../http-exception.js";
+import { auth } from "../../utils/basic-auth.js";
+import { timingSafeEqual } from "../../utils/buffer.js";
+var basicAuth = (options, ...users) => {
+  const usernamePasswordInOptions = "username" in options && "password" in options;
+  const verifyUserInOptions = "verifyUser" in options;
+  if (!(usernamePasswordInOptions || verifyUserInOptions)) {
+    throw new Error(
+      'basic auth middleware requires options for "username and password" or "verifyUser"'
+    );
+  }
+  if (!options.realm) {
+    options.realm = "Secure Area";
+  }
+  if (!options.invalidUserMessage) {
+    options.invalidUserMessage = "Unauthorized";
+  }
+  if (usernamePasswordInOptions) {
+    users.unshift({ username: options.username, password: options.password });
+  }
+  return async function basicAuth2(ctx, next) {
+    const requestUser = auth(ctx.req.raw);
+    if (requestUser) {
+      if (verifyUserInOptions) {
+        if (await options.verifyUser(requestUser.username, requestUser.password, ctx)) {
+          if (options.onAuthSuccess) {
+            await options.onAuthSuccess(ctx, requestUser.username);
+          }
+          await next();
+          return;
+        }
+      } else {
+        for (const user of users) {
+          const [usernameEqual, passwordEqual] = await Promise.all([
+            timingSafeEqual(user.username, requestUser.username, options.hashFunction),
+            timingSafeEqual(user.password, requestUser.password, options.hashFunction)
+          ]);
+          if (usernameEqual && passwordEqual) {
+            if (options.onAuthSuccess) {
+              await options.onAuthSuccess(ctx, requestUser.username);
+            }
+            await next();
+            return;
+          }
+        }
+      }
+    }
+    const status = 401;
+    const headers = {
+      "WWW-Authenticate": 'Basic realm="' + options.realm?.replace(/"/g, '\\"') + '"'
+    };
+    const responseMessage = typeof options.invalidUserMessage === "function" ? await options.invalidUserMessage(ctx) : options.invalidUserMessage;
+    const res = typeof responseMessage === "string" ? new Response(responseMessage, { status, headers }) : new Response(JSON.stringify(responseMessage), {
+      status,
+      headers: {
+        ...headers,
+        "content-type": "application/json"
+      }
+    });
+    throw new HTTPException(status, { res });
+  };
+};
+export {
+  basicAuth
+};

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

@@ -0,0 +1,92 @@
+// src/middleware/bearer-auth/index.ts
+import { HTTPException } from "../../http-exception.js";
+import { timingSafeEqual } from "../../utils/buffer.js";
+var TOKEN_STRINGS = "[A-Za-z0-9._~+/-]+=*";
+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"');
+  }
+  if (!options.realm) {
+    options.realm = "";
+  }
+  if (options.prefix === void 0) {
+    options.prefix = PREFIX;
+  }
+  const realm = options.realm?.replace(/"/g, '\\"');
+  const prefix = options.prefix;
+  const tokenRegexp = new RegExp(`^${TOKEN_STRINGS}$`);
+  const wwwAuthenticatePrefix = prefix === "" ? "" : `${prefix} `;
+  const throwHTTPException = async (c, status, wwwAuthenticateHeader, messageOption) => {
+    const wwwAuthenticateHeaderValue = typeof wwwAuthenticateHeader === "function" ? await wwwAuthenticateHeader(c) : wwwAuthenticateHeader;
+    const headers = {
+      "WWW-Authenticate": typeof wwwAuthenticateHeaderValue === "string" ? wwwAuthenticateHeaderValue : `${wwwAuthenticatePrefix}${Object.entries(wwwAuthenticateHeaderValue).map(([key, value]) => `${key}="${value}"`).join(",")}`
+    };
+    const responseMessage = typeof messageOption === "function" ? await messageOption(c) : messageOption;
+    const res = typeof responseMessage === "string" ? new Response(responseMessage, { status, headers }) : new Response(JSON.stringify(responseMessage), {
+      status,
+      headers: {
+        ...headers,
+        "content-type": "application/json"
+      }
+    });
+    throw new HTTPException(status, { res });
+  };
+  return async function bearerAuth2(c, next) {
+    const headerToken = c.req.header(options.headerName || HEADER);
+    if (!headerToken) {
+      await throwHTTPException(
+        c,
+        401,
+        options.noAuthenticationHeader?.wwwAuthenticateHeader || `${wwwAuthenticatePrefix}realm="${realm}"`,
+        options.noAuthenticationHeader?.message || options.noAuthenticationHeaderMessage || "Unauthorized"
+      );
+    } else {
+      let tokenValue;
+      if (prefix === "") {
+        tokenValue = headerToken;
+      } else {
+        const headerLower = headerToken.toLowerCase();
+        const prefixLower = prefix.toLowerCase();
+        if (headerLower.startsWith(prefixLower) && headerToken[prefix.length] === " ") {
+          tokenValue = headerToken.slice(prefix.length).trimStart();
+        }
+      }
+      if (!tokenValue || !tokenRegexp.test(tokenValue)) {
+        await throwHTTPException(
+          c,
+          400,
+          options.invalidAuthenticationHeader?.wwwAuthenticateHeader || `${wwwAuthenticatePrefix}error="invalid_request"`,
+          options.invalidAuthenticationHeader?.message || options.invalidAuthenticationHeaderMessage || "Bad Request"
+        );
+      } else {
+        let equal = false;
+        if ("verifyToken" in options) {
+          equal = await options.verifyToken(tokenValue, c);
+        } else if (typeof options.token === "string") {
+          equal = await timingSafeEqual(options.token, tokenValue, options.hashFunction);
+        } else if (Array.isArray(options.token) && options.token.length > 0) {
+          for (const token of options.token) {
+            if (await timingSafeEqual(token, tokenValue, options.hashFunction)) {
+              equal = true;
+              break;
+            }
+          }
+        }
+        if (!equal) {
+          await throwHTTPException(
+            c,
+            401,
+            options.invalidToken?.wwwAuthenticateHeader || `${wwwAuthenticatePrefix}error="invalid_token"`,
+            options.invalidToken?.message || options.invalidTokenMessage || "Unauthorized"
+          );
+        }
+      }
+    }
+    await next();
+  };
+};
+export {
+  bearerAuth
+};

package/node_modules/hono/dist/middleware/body-limit/index.js

@@ -0,0 +1,53 @@
+// src/middleware/body-limit/index.ts
+import { HTTPException } from "../../http-exception.js";
+var ERROR_MESSAGE = "Payload Too Large";
+var bodyLimit = (options) => {
+  const onError = options.onError || (() => {
+    const res = new Response(ERROR_MESSAGE, {
+      status: 413
+    });
+    throw new HTTPException(413, { res });
+  });
+  const maxSize = options.maxSize;
+  return async function bodyLimit2(c, next) {
+    if (!c.req.raw.body) {
+      return next();
+    }
+    const hasTransferEncoding = c.req.raw.headers.has("transfer-encoding");
+    const hasContentLength = c.req.raw.headers.has("content-length");
+    if (hasContentLength && !hasTransferEncoding) {
+      const contentLength = parseInt(c.req.raw.headers.get("content-length") || "0", 10);
+      return contentLength > maxSize ? onError(c) : next();
+    }
+    let size = 0;
+    const chunks = [];
+    const rawReader = c.req.raw.body.getReader();
+    for (; ; ) {
+      const { done, value } = await rawReader.read();
+      if (done) {
+        break;
+      }
+      size += value.length;
+      if (size > maxSize) {
+        return onError(c);
+      }
+      chunks.push(value);
+    }
+    const requestInit = {
+      body: new ReadableStream({
+        start(controller) {
+          for (const chunk of chunks) {
+            controller.enqueue(chunk);
+          }
+          controller.close();
+        }
+      }),
+      duplex: "half"
+    };
+    c.req.raw = new Request(c.req.raw, requestInit);
+    return next();
+  };
+};
+export {
+  bodyLimit
+};

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

@@ -0,0 +1,97 @@
+// src/middleware/cache/index.ts
+var defaultCacheableStatusCodes = [200];
+var shouldSkipCache = (res) => {
+  if (res.headers.has("Vary")) {
+    return true;
+  }
+  const cacheControl = res.headers.get("Cache-Control");
+  if (cacheControl && /(?:^|,\s*)(?:private|no-(?:store|cache))(?:\s*(?:=|,|$))/i.test(cacheControl)) {
+    return true;
+  }
+  if (res.headers.has("Set-Cookie")) {
+    return true;
+  }
+  return false;
+};
+var cache = (options) => {
+  if (!globalThis.caches) {
+    if (options.onCacheNotAvailable === false) {
+    } else if (options.onCacheNotAvailable) {
+      options.onCacheNotAvailable();
+    } else {
+      console.log("Cache Middleware is not enabled because caches is not defined.");
+    }
+    return async (_c, next) => await next();
+  }
+  if (options.wait === void 0) {
+    options.wait = false;
+  }
+  const cacheControlDirectives = options.cacheControl?.split(",").map((directive) => directive.toLowerCase());
+  const varyDirectives = Array.isArray(options.vary) ? options.vary : options.vary?.split(",").map((directive) => directive.trim());
+  if (options.vary?.includes("*")) {
+    throw new Error(
+      'Middleware vary configuration cannot include "*", as it disallows effective caching.'
+    );
+  }
+  const cacheableStatusCodes = new Set(
+    options.cacheableStatusCodes ?? defaultCacheableStatusCodes
+  );
+  const addHeader = (c) => {
+    if (cacheControlDirectives) {
+      const existingDirectives = c.res.headers.get("Cache-Control")?.split(",").map((d) => d.trim().split("=", 1)[0]) ?? [];
+      for (const directive of cacheControlDirectives) {
+        let [name, value] = directive.trim().split("=", 2);
+        name = name.toLowerCase();
+        if (!existingDirectives.includes(name)) {
+          c.header("Cache-Control", `${name}${value ? `=${value}` : ""}`, { append: true });
+        }
+      }
+    }
+    if (varyDirectives) {
+      const existingDirectives = c.res.headers.get("Vary")?.split(",").map((d) => d.trim()) ?? [];
+      const vary = Array.from(
+        new Set(
+          [...existingDirectives, ...varyDirectives].map((directive) => directive.toLowerCase())
+        )
+      ).sort();
+      if (vary.includes("*")) {
+        c.header("Vary", "*");
+      } else {
+        c.header("Vary", vary.join(", "));
+      }
+    }
+  };
+  return async function cache2(c, next) {
+    if (c.req.method !== "GET" || c.req.raw.headers.has("Authorization")) {
+      await next();
+      return;
+    }
+    let key = c.req.url;
+    if (options.keyGenerator) {
+      key = await options.keyGenerator(c);
+    }
+    const cacheName = typeof options.cacheName === "function" ? await options.cacheName(c) : options.cacheName;
+    const cache3 = await caches.open(cacheName);
+    const response = await cache3.match(key);
+    if (response) {
+      return new Response(response.body, response);
+    }
+    await next();
+    if (!cacheableStatusCodes.has(c.res.status)) {
+      return;
+    }
+    addHeader(c);
+    if (shouldSkipCache(c.res)) {
+      return;
+    }
+    const res = c.res.clone();
+    if (options.wait) {
+      await cache3.put(key, res);
+    } else {
+      c.executionCtx.waitUntil(cache3.put(key, res));
+    }
+  };
+};
+export {
+  cache
+};