@zuplo/cli 6.73.30 → 6.73.31

package/node_modules/@zuplo/editor/node_modules/hono/dist/cjs/helper/html/index.js

@@ -0,0 +1,64 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var html_exports = {};
+__export(html_exports, {
+  html: () => html,
+  raw: () => import_html.raw
+});
+module.exports = __toCommonJS(html_exports);
+var import_html = require("../../utils/html");
+const html = (strings, ...values) => {
+  const buffer = [""];
+  for (let i = 0, len = strings.length - 1; i < len; i++) {
+    buffer[0] += strings[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") {
+        (0, import_html.escapeToBuffer)(child, buffer);
+      } else if (typeof child === "number") {
+        ;
+        buffer[0] += child;
+      } else if (typeof child === "boolean" || child === null || child === void 0) {
+        continue;
+      } else if (typeof child === "object" && child.isEscaped) {
+        if (child.callbacks) {
+          buffer.unshift("", child);
+        } else {
+          const tmp = child.toString();
+          if (tmp instanceof Promise) {
+            buffer.unshift("", tmp);
+          } else {
+            buffer[0] += tmp;
+          }
+        }
+      } else if (child instanceof Promise) {
+        buffer.unshift("", child);
+      } else {
+        (0, import_html.escapeToBuffer)(child.toString(), buffer);
+      }
+    }
+  }
+  buffer[0] += strings.at(-1);
+  return buffer.length === 1 ? "callbacks" in buffer ? (0, import_html.raw)((0, import_html.resolveCallbackSync)((0, import_html.raw)(buffer[0], buffer.callbacks))) : (0, import_html.raw)(buffer[0]) : (0, import_html.stringBufferToString)(buffer, buffer.callbacks);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  html,
+  raw
+});

package/node_modules/@zuplo/editor/node_modules/hono/dist/cjs/helper/proxy/index.js

@@ -0,0 +1,111 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var proxy_exports = {};
+__export(proxy_exports, {
+  proxy: () => proxy
+});
+module.exports = __toCommonJS(proxy_exports);
+var import_http_exception = require("../../http-exception");
+const hopByHopHeaders = [
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+];
+const ALLOWED_TOKEN_PATTERN = /^[!#$%&'*+\-.0-9A-Z^_`a-z|~]+$/;
+const buildRequestInitFromRequest = (request, strictConnectionProcessing) => {
+  if (!request) {
+    return {};
+  }
+  const headers = new Headers(request.headers);
+  if (strictConnectionProcessing) {
+    const connectionValue = headers.get("connection");
+    if (connectionValue) {
+      const headerNames = connectionValue.split(",").map((h) => h.trim());
+      const invalidHeaders = headerNames.filter((h) => !ALLOWED_TOKEN_PATTERN.test(h));
+      if (invalidHeaders.length > 0) {
+        throw new import_http_exception.HTTPException(400, {
+          message: `Invalid Connection header value: ${invalidHeaders.join(", ")}`
+        });
+      }
+      headerNames.forEach((headerName) => {
+        headers.delete(headerName);
+      });
+    }
+  }
+  hopByHopHeaders.forEach((header) => {
+    headers.delete(header);
+  });
+  return {
+    method: request.method,
+    body: request.body,
+    duplex: request.body ? "half" : void 0,
+    headers,
+    signal: request.signal
+  };
+};
+const preprocessRequestInit = (requestInit) => {
+  if (!requestInit.headers || Array.isArray(requestInit.headers) || requestInit.headers instanceof Headers) {
+    return requestInit;
+  }
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(requestInit.headers)) {
+    if (value == null) {
+      headers.delete(key);
+    } else {
+      headers.set(key, value);
+    }
+  }
+  requestInit.headers = headers;
+  return requestInit;
+};
+const proxy = async (input, proxyInit) => {
+  const {
+    raw,
+    customFetch,
+    strictConnectionProcessing = false,
+    ...requestInit
+  } = proxyInit instanceof Request ? { raw: proxyInit } : proxyInit ?? {};
+  const req = new Request(input, {
+    ...buildRequestInitFromRequest(raw, strictConnectionProcessing),
+    ...preprocessRequestInit(requestInit)
+  });
+  req.headers.delete("accept-encoding");
+  const res = await (customFetch || fetch)(req);
+  const resHeaders = new Headers(res.headers);
+  hopByHopHeaders.forEach((header) => {
+    resHeaders.delete(header);
+  });
+  if (resHeaders.has("content-encoding")) {
+    resHeaders.delete("content-encoding");
+    resHeaders.delete("content-length");
+  }
+  return new Response(res.body, {
+    status: res.status,
+    statusText: res.statusText,
+    headers: resHeaders
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  proxy
+});

package/node_modules/@zuplo/editor/node_modules/hono/dist/cjs/helper/route/index.js

@@ -0,0 +1,71 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var route_exports = {};
+__export(route_exports, {
+  basePath: () => basePath,
+  baseRoutePath: () => baseRoutePath,
+  matchedRoutes: () => matchedRoutes,
+  routePath: () => routePath
+});
+module.exports = __toCommonJS(route_exports);
+var import_constants = require("../../request/constants");
+var import_url = require("../../utils/url");
+const matchedRoutes = (c) => (
+  // @ts-expect-error c.req[GET_MATCH_RESULT] is not typed
+  c.req[import_constants.GET_MATCH_RESULT][0].map(([[, route]]) => route)
+);
+const routePath = (c, index) => matchedRoutes(c).at(index ?? c.req.routeIndex)?.path ?? "";
+const baseRoutePath = (c, index) => matchedRoutes(c).at(index ?? c.req.routeIndex)?.basePath ?? "";
+const basePathCacheMap = /* @__PURE__ */ new WeakMap();
+const basePath = (c, index) => {
+  index ??= c.req.routeIndex;
+  const cache = basePathCacheMap.get(c) || [];
+  if (typeof cache[index] === "string") {
+    return cache[index];
+  }
+  let result;
+  const rp = baseRoutePath(c, index);
+  if (!/[:*]/.test(rp)) {
+    result = rp;
+  } else {
+    const paths = (0, import_url.splitRoutingPath)(rp);
+    const reqPath = c.req.path;
+    let basePathLength = 0;
+    for (let i = 0, len = paths.length; i < len; i++) {
+      const pattern = (0, import_url.getPattern)(paths[i], paths[i + 1]);
+      if (pattern) {
+        const re = pattern[2] === true || pattern === "*" ? /[^\/]+/ : pattern[2];
+        basePathLength += reqPath.substring(basePathLength + 1).match(re)?.[0].length || 0;
+      } else {
+        basePathLength += paths[i].length;
+      }
+      basePathLength += 1;
+    }
+    result = reqPath.substring(0, basePathLength);
+  }
+  cache[index] = result;
+  basePathCacheMap.set(c, cache);
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  basePath,
+  baseRoutePath,
+  matchedRoutes,
+  routePath
+});

package/node_modules/@zuplo/editor/node_modules/hono/dist/cjs/helper/ssg/index.js

@@ -0,0 +1,43 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ssg_exports = {};
+__export(ssg_exports, {
+  X_HONO_DISABLE_SSG_HEADER_KEY: () => import_middleware.X_HONO_DISABLE_SSG_HEADER_KEY,
+  defaultPlugin: () => import_plugins.defaultPlugin,
+  disableSSG: () => import_middleware.disableSSG,
+  isSSGContext: () => import_middleware.isSSGContext,
+  onlySSG: () => import_middleware.onlySSG,
+  redirectPlugin: () => import_plugins.redirectPlugin,
+  ssgParams: () => import_middleware.ssgParams
+});
+module.exports = __toCommonJS(ssg_exports);
+__reExport(ssg_exports, require("./ssg"), module.exports);
+var import_middleware = require("./middleware");
+var import_plugins = require("./plugins");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  X_HONO_DISABLE_SSG_HEADER_KEY,
+  defaultPlugin,
+  disableSSG,
+  isSSGContext,
+  onlySSG,
+  redirectPlugin,
+  ssgParams,
+  ...require("./ssg")
+});

package/node_modules/@zuplo/editor/node_modules/hono/dist/cjs/helper/ssg/middleware.js

@@ -0,0 +1,73 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var middleware_exports = {};
+__export(middleware_exports, {
+  SSG_CONTEXT: () => SSG_CONTEXT,
+  SSG_DISABLED_RESPONSE: () => SSG_DISABLED_RESPONSE,
+  X_HONO_DISABLE_SSG_HEADER_KEY: () => X_HONO_DISABLE_SSG_HEADER_KEY,
+  disableSSG: () => disableSSG,
+  isSSGContext: () => isSSGContext,
+  onlySSG: () => onlySSG,
+  ssgParams: () => ssgParams
+});
+module.exports = __toCommonJS(middleware_exports);
+var import_utils = require("./utils");
+const SSG_CONTEXT = "HONO_SSG_CONTEXT";
+const X_HONO_DISABLE_SSG_HEADER_KEY = "x-hono-disable-ssg";
+const SSG_DISABLED_RESPONSE = (() => {
+  try {
+    return new Response("SSG is disabled", {
+      status: 404,
+      headers: { [X_HONO_DISABLE_SSG_HEADER_KEY]: "true" }
+    });
+  } catch {
+    return null;
+  }
+})();
+const ssgParams = (params) => async (c, next) => {
+  if ((0, import_utils.isDynamicRoute)(c.req.path)) {
+    ;
+    c.req.raw.ssgParams = Array.isArray(params) ? params : await params(c);
+    return c.notFound();
+  }
+  await next();
+};
+const isSSGContext = (c) => !!c.env?.[SSG_CONTEXT];
+const disableSSG = () => async function disableSSG2(c, next) {
+  if (isSSGContext(c)) {
+    c.header(X_HONO_DISABLE_SSG_HEADER_KEY, "true");
+    return c.notFound();
+  }
+  await next();
+};
+const onlySSG = () => async function onlySSG2(c, next) {
+  if (!isSSGContext(c)) {
+    return c.notFound();
+  }
+  await next();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SSG_CONTEXT,
+  SSG_DISABLED_RESPONSE,
+  X_HONO_DISABLE_SSG_HEADER_KEY,
+  disableSSG,
+  isSSGContext,
+  onlySSG,
+  ssgParams
+});

package/node_modules/@zuplo/editor/node_modules/hono/dist/cjs/helper/ssg/plugins.js

@@ -0,0 +1,70 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plugins_exports = {};
+__export(plugins_exports, {
+  defaultPlugin: () => defaultPlugin,
+  redirectPlugin: () => redirectPlugin
+});
+module.exports = __toCommonJS(plugins_exports);
+var import_html = require("../html");
+const defaultPlugin = () => {
+  return {
+    afterResponseHook: (res) => {
+      if (res.status !== 200) {
+        return false;
+      }
+      return res;
+    }
+  };
+};
+const REDIRECT_STATUS_CODES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+const generateRedirectHtml = (location) => {
+  const content = import_html.html`<!DOCTYPE html>
+<title>Redirecting to: ${location}</title>
+<meta http-equiv="refresh" content="0;url=${location}" />
+<meta name="robots" content="noindex" />
+<link rel="canonical" href="${location}" />
+<body>
+<a href="${location}">Redirecting to <code>${location}</code></a>
+</body>
+`;
+  return content.toString().replace(/\n/g, "");
+};
+const redirectPlugin = () => {
+  return {
+    afterResponseHook: (res) => {
+      if (REDIRECT_STATUS_CODES.has(res.status)) {
+        const location = res.headers.get("Location");
+        if (!location) {
+          return false;
+        }
+        const htmlBody = generateRedirectHtml(location);
+        return new Response(htmlBody, {
+          status: 200,
+          headers: { "Content-Type": "text/html; charset=utf-8" }
+        });
+      }
+      return res;
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defaultPlugin,
+  redirectPlugin
+});