@zuplo/cli 6.73.30 → 6.73.31

package/node_modules/@zuplo/editor/node_modules/hono/dist/request.js

@@ -0,0 +1,321 @@
+// src/request.ts
+import { HTTPException } from "./http-exception.js";
+import { GET_MATCH_RESULT } from "./request/constants.js";
+import { parseBody } from "./utils/body.js";
+import { decodeURIComponent_, getQueryParam, getQueryParams, tryDecode } from "./utils/url.js";
+var tryDecodeURIComponent = (str) => tryDecode(str, decodeURIComponent_);
+var HonoRequest = class {
+  /**
+   * `.raw` can get the raw Request object.
+   *
+   * @see {@link https://hono.dev/docs/api/request#raw}
+   *
+   * @example
+   * ```ts
+   * // For Cloudflare Workers
+   * app.post('/', async (c) => {
+   *   const metadata = c.req.raw.cf?.hostMetadata?
+   *   ...
+   * })
+   * ```
+   */
+  raw;
+  #validatedData;
+  // Short name of validatedData
+  #matchResult;
+  routeIndex = 0;
+  /**
+   * `.path` can get the pathname of the request.
+   *
+   * @see {@link https://hono.dev/docs/api/request#path}
+   *
+   * @example
+   * ```ts
+   * app.get('/about/me', (c) => {
+   *   const pathname = c.req.path // `/about/me`
+   * })
+   * ```
+   */
+  path;
+  bodyCache = {};
+  constructor(request, path = "/", matchResult = [[]]) {
+    this.raw = request;
+    this.path = path;
+    this.#matchResult = matchResult;
+    this.#validatedData = {};
+  }
+  param(key) {
+    return key ? this.#getDecodedParam(key) : this.#getAllDecodedParams();
+  }
+  #getDecodedParam(key) {
+    const paramKey = this.#matchResult[0][this.routeIndex][1][key];
+    const param = this.#getParamValue(paramKey);
+    return param && /\%/.test(param) ? tryDecodeURIComponent(param) : param;
+  }
+  #getAllDecodedParams() {
+    const decoded = {};
+    const keys = Object.keys(this.#matchResult[0][this.routeIndex][1]);
+    for (const key of keys) {
+      const value = this.#getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
+      if (value !== void 0) {
+        decoded[key] = /\%/.test(value) ? tryDecodeURIComponent(value) : value;
+      }
+    }
+    return decoded;
+  }
+  #getParamValue(paramKey) {
+    return this.#matchResult[1] ? this.#matchResult[1][paramKey] : paramKey;
+  }
+  query(key) {
+    return getQueryParam(this.url, key);
+  }
+  queries(key) {
+    return getQueryParams(this.url, key);
+  }
+  header(name) {
+    if (name) {
+      return this.raw.headers.get(name) ?? void 0;
+    }
+    const headerData = /* @__PURE__ */ Object.create(null);
+    this.raw.headers.forEach((value, key) => {
+      headerData[key] = value;
+    });
+    return headerData;
+  }
+  async parseBody(options) {
+    return parseBody(this, options);
+  }
+  #cachedBody = (key) => {
+    const { bodyCache, raw } = this;
+    const cachedBody = bodyCache[key];
+    if (cachedBody) {
+      return cachedBody;
+    }
+    const anyCachedKey = Object.keys(bodyCache)[0];
+    if (anyCachedKey) {
+      return bodyCache[anyCachedKey].then((body) => {
+        if (anyCachedKey === "json") {
+          body = JSON.stringify(body);
+        }
+        return new Response(body)[key]();
+      });
+    }
+    return bodyCache[key] = raw[key]();
+  };
+  /**
+   * `.json()` can parse Request body of type `application/json`
+   *
+   * @see {@link https://hono.dev/docs/api/request#json}
+   *
+   * @example
+   * ```ts
+   * app.post('/entry', async (c) => {
+   *   const body = await c.req.json()
+   * })
+   * ```
+   */
+  json() {
+    return this.#cachedBody("text").then((text) => JSON.parse(text));
+  }
+  /**
+   * `.text()` can parse Request body of type `text/plain`
+   *
+   * @see {@link https://hono.dev/docs/api/request#text}
+   *
+   * @example
+   * ```ts
+   * app.post('/entry', async (c) => {
+   *   const body = await c.req.text()
+   * })
+   * ```
+   */
+  text() {
+    return this.#cachedBody("text");
+  }
+  /**
+   * `.arrayBuffer()` parse Request body as an `ArrayBuffer`
+   *
+   * @see {@link https://hono.dev/docs/api/request#arraybuffer}
+   *
+   * @example
+   * ```ts
+   * app.post('/entry', async (c) => {
+   *   const body = await c.req.arrayBuffer()
+   * })
+   * ```
+   */
+  arrayBuffer() {
+    return this.#cachedBody("arrayBuffer");
+  }
+  /**
+   * `.bytes()` parses the request body as a `Uint8Array`.
+   *
+   * @see {@link https://hono.dev/docs/api/request#bytes}
+   *
+   * @example
+   * ```ts
+   * app.post('/entry', async (c) => {
+   *   const body = await c.req.bytes()
+   * })
+   * ```
+   */
+  bytes() {
+    return this.#cachedBody("arrayBuffer").then((buffer) => new Uint8Array(buffer));
+  }
+  /**
+   * Parses the request body as a `Blob`.
+   * @example
+   * ```ts
+   * app.post('/entry', async (c) => {
+   *   const body = await c.req.blob();
+   * });
+   * ```
+   * @see https://hono.dev/docs/api/request#blob
+   */
+  blob() {
+    return this.#cachedBody("blob");
+  }
+  /**
+   * Parses the request body as `FormData`.
+   * @example
+   * ```ts
+   * app.post('/entry', async (c) => {
+   *   const body = await c.req.formData();
+   * });
+   * ```
+   * @see https://hono.dev/docs/api/request#formdata
+   */
+  formData() {
+    return this.#cachedBody("formData");
+  }
+  /**
+   * Adds validated data to the request.
+   *
+   * @param target - The target of the validation.
+   * @param data - The validated data to add.
+   */
+  addValidatedData(target, data) {
+    this.#validatedData[target] = data;
+  }
+  valid(target) {
+    return this.#validatedData[target];
+  }
+  /**
+   * `.url()` can get the request url strings.
+   *
+   * @see {@link https://hono.dev/docs/api/request#url}
+   *
+   * @example
+   * ```ts
+   * app.get('/about/me', (c) => {
+   *   const url = c.req.url // `http://localhost:8787/about/me`
+   *   ...
+   * })
+   * ```
+   */
+  get url() {
+    return this.raw.url;
+  }
+  /**
+   * `.method()` can get the method name of the request.
+   *
+   * @see {@link https://hono.dev/docs/api/request#method}
+   *
+   * @example
+   * ```ts
+   * app.get('/about/me', (c) => {
+   *   const method = c.req.method // `GET`
+   * })
+   * ```
+   */
+  get method() {
+    return this.raw.method;
+  }
+  get [GET_MATCH_RESULT]() {
+    return this.#matchResult;
+  }
+  /**
+   * `.matchedRoutes()` can return a matched route in the handler
+   *
+   * @deprecated
+   *
+   * Use matchedRoutes helper defined in "hono/route" instead.
+   *
+   * @see {@link https://hono.dev/docs/api/request#matchedroutes}
+   *
+   * @example
+   * ```ts
+   * app.use('*', async function logger(c, next) {
+   *   await next()
+   *   c.req.matchedRoutes.forEach(({ handler, method, path }, i) => {
+   *     const name = handler.name || (handler.length < 2 ? '[handler]' : '[middleware]')
+   *     console.log(
+   *       method,
+   *       ' ',
+   *       path,
+   *       ' '.repeat(Math.max(10 - path.length, 0)),
+   *       name,
+   *       i === c.req.routeIndex ? '<- respond from here' : ''
+   *     )
+   *   })
+   * })
+   * ```
+   */
+  get matchedRoutes() {
+    return this.#matchResult[0].map(([[, route]]) => route);
+  }
+  /**
+   * `routePath()` can retrieve the path registered within the handler
+   *
+   * @deprecated
+   *
+   * Use routePath helper defined in "hono/route" instead.
+   *
+   * @see {@link https://hono.dev/docs/api/request#routepath}
+   *
+   * @example
+   * ```ts
+   * app.get('/posts/:id', (c) => {
+   *   return c.json({ path: c.req.routePath })
+   * })
+   * ```
+   */
+  get routePath() {
+    return this.#matchResult[0].map(([[, route]]) => route)[this.routeIndex].path;
+  }
+};
+var cloneRawRequest = async (req) => {
+  if (!req.raw.bodyUsed) {
+    return req.raw.clone();
+  }
+  const cacheKey = Object.keys(req.bodyCache)[0];
+  if (!cacheKey) {
+    throw new HTTPException(500, {
+      message: "Cannot clone request: body was already consumed and not cached. Please use HonoRequest methods (e.g., req.json(), req.text()) instead of consuming req.raw directly."
+    });
+  }
+  const body = await req[cacheKey]();
+  const headers = req.header();
+  if (body instanceof FormData) {
+    delete headers["content-type"];
+  }
+  const requestInit = {
+    body,
+    cache: req.raw.cache,
+    credentials: req.raw.credentials,
+    headers,
+    integrity: req.raw.integrity,
+    keepalive: req.raw.keepalive,
+    method: req.method,
+    mode: req.raw.mode,
+    redirect: req.raw.redirect,
+    referrer: req.raw.referrer,
+    referrerPolicy: req.raw.referrerPolicy,
+    signal: req.raw.signal
+  };
+  return new Request(req.url, requestInit);
+};
+export {
+  HonoRequest,
+  cloneRawRequest
+};

package/node_modules/@zuplo/editor/node_modules/hono/dist/router/linear-router/index.js

@@ -0,0 +1,5 @@
+// src/router/linear-router/index.ts
+import { LinearRouter } from "./router.js";
+export {
+  LinearRouter
+};

package/node_modules/@zuplo/editor/node_modules/hono/dist/router/linear-router/router.js

@@ -0,0 +1,118 @@
+// src/router/linear-router/router.ts
+import { METHOD_NAME_ALL, UnsupportedPathError } from "../../router.js";
+import { checkOptionalParameter } from "../../utils/url.js";
+var emptyParams = /* @__PURE__ */ Object.create(null);
+var splitPathRe = /\/(:\w+(?:{(?:(?:{[\d,]+})|[^}])+})?)|\/[^\/\?]+|(\?)/g;
+var splitByStarRe = /\*/;
+var LinearRouter = class {
+  name = "LinearRouter";
+  #routes = [];
+  add(method, path, handler) {
+    for (let i = 0, paths = checkOptionalParameter(path) || [path], len = paths.length; i < len; i++) {
+      this.#routes.push([method, paths[i], handler]);
+    }
+  }
+  match(method, path) {
+    const handlers = [];
+    ROUTES_LOOP: for (let i = 0, len = this.#routes.length; i < len; i++) {
+      const [routeMethod, routePath, handler] = this.#routes[i];
+      if (routeMethod === method || routeMethod === METHOD_NAME_ALL) {
+        if (routePath === "*" || routePath === "/*") {
+          handlers.push([handler, emptyParams]);
+          continue;
+        }
+        const hasStar = routePath.indexOf("*") !== -1;
+        const hasLabel = routePath.indexOf(":") !== -1;
+        if (!hasStar && !hasLabel) {
+          if (routePath === path || routePath + "/" === path) {
+            handlers.push([handler, emptyParams]);
+          }
+        } else if (hasStar && !hasLabel) {
+          const endsWithStar = routePath.charCodeAt(routePath.length - 1) === 42;
+          const parts = (endsWithStar ? routePath.slice(0, -2) : routePath).split(splitByStarRe);
+          const lastIndex = parts.length - 1;
+          for (let j = 0, pos = 0, len2 = parts.length; j < len2; j++) {
+            const part = parts[j];
+            const index = path.indexOf(part, pos);
+            if (index !== pos) {
+              continue ROUTES_LOOP;
+            }
+            pos += part.length;
+            if (j === lastIndex) {
+              if (!endsWithStar && pos !== path.length && !(pos === path.length - 1 && path.charCodeAt(pos) === 47)) {
+                continue ROUTES_LOOP;
+              }
+            } else {
+              const index2 = path.indexOf("/", pos);
+              if (index2 === -1) {
+                continue ROUTES_LOOP;
+              }
+              pos = index2;
+            }
+          }
+          handlers.push([handler, emptyParams]);
+        } else if (hasLabel && !hasStar) {
+          const params = /* @__PURE__ */ Object.create(null);
+          const parts = routePath.match(splitPathRe);
+          const lastIndex = parts.length - 1;
+          for (let j = 0, pos = 0, len2 = parts.length; j < len2; j++) {
+            if (pos === -1 || pos >= path.length) {
+              continue ROUTES_LOOP;
+            }
+            const part = parts[j];
+            if (part.charCodeAt(1) === 58) {
+              if (path.charCodeAt(pos) !== 47) {
+                continue ROUTES_LOOP;
+              }
+              let name = part.slice(2);
+              let value;
+              if (name.charCodeAt(name.length - 1) === 125) {
+                const openBracePos = name.indexOf("{");
+                const next = parts[j + 1];
+                const lookahead = next && next[1] !== ":" && next[1] !== "*" ? `(?=${next})` : "";
+                const pattern = name.slice(openBracePos + 1, -1) + lookahead;
+                const restPath = path.slice(pos + 1);
+                const match = new RegExp(pattern, "d").exec(restPath);
+                if (!match || match.indices[0][0] !== 0 || match.indices[0][1] === 0) {
+                  continue ROUTES_LOOP;
+                }
+                name = name.slice(0, openBracePos);
+                value = restPath.slice(...match.indices[0]);
+                pos += match.indices[0][1] + 1;
+              } else {
+                let endValuePos = path.indexOf("/", pos + 1);
+                if (endValuePos === -1) {
+                  if (pos + 1 === path.length) {
+                    continue ROUTES_LOOP;
+                  }
+                  endValuePos = path.length;
+                }
+                value = path.slice(pos + 1, endValuePos);
+                pos = endValuePos;
+              }
+              params[name] ||= value;
+            } else {
+              const index = path.indexOf(part, pos);
+              if (index !== pos) {
+                continue ROUTES_LOOP;
+              }
+              pos += part.length;
+            }
+            if (j === lastIndex) {
+              if (pos !== path.length && !(pos === path.length - 1 && path.charCodeAt(pos) === 47)) {
+                continue ROUTES_LOOP;
+              }
+            }
+          }
+          handlers.push([handler, params]);
+        } else if (hasLabel && hasStar) {
+          throw new UnsupportedPathError();
+        }
+      }
+    }
+    return [handlers];
+  }
+};
+export {
+  LinearRouter
+};

package/node_modules/@zuplo/editor/node_modules/hono/dist/router/pattern-router/index.js

@@ -0,0 +1,5 @@
+// src/router/pattern-router/index.ts
+import { PatternRouter } from "./router.js";
+export {
+  PatternRouter
+};

package/node_modules/@zuplo/editor/node_modules/hono/dist/router/pattern-router/router.js

@@ -0,0 +1,48 @@
+// src/router/pattern-router/router.ts
+import { METHOD_NAME_ALL, UnsupportedPathError } from "../../router.js";
+var emptyParams = /* @__PURE__ */ Object.create(null);
+var PatternRouter = class {
+  name = "PatternRouter";
+  #routes = [];
+  add(method, path, handler) {
+    const endsWithWildcard = path.at(-1) === "*";
+    if (endsWithWildcard) {
+      path = path.slice(0, -2);
+    }
+    if (path.at(-1) === "?") {
+      path = path.slice(0, -1);
+      this.add(method, path.replace(/\/[^/]+$/, ""), handler);
+    }
+    const parts = (path.match(/\/?(:\w+(?:{(?:(?:{[\d,]+})|[^}])+})?)|\/?[^\/\?]+/g) || []).map(
+      (part) => {
+        const match = part.match(/^\/:([^{]+)(?:{(.*)})?/);
+        return match ? `/(?<${match[1]}>${match[2] || "[^/]+"})` : part === "/*" ? "/[^/]+" : part.replace(/[.\\+*[^\]$()]/g, "\\$&");
+      }
+    );
+    try {
+      this.#routes.push([
+        new RegExp(`^${parts.join("")}${endsWithWildcard ? "" : "/?$"}`),
+        method,
+        handler
+      ]);
+    } catch {
+      throw new UnsupportedPathError();
+    }
+  }
+  match(method, path) {
+    const handlers = [];
+    for (let i = 0, len = this.#routes.length; i < len; i++) {
+      const [pattern, routeMethod, handler] = this.#routes[i];
+      if (routeMethod === method || routeMethod === METHOD_NAME_ALL) {
+        const match = pattern.exec(path);
+        if (match) {
+          handlers.push([handler, match.groups || emptyParams]);
+        }
+      }
+    }
+    return [handlers];
+  }
+};
+export {
+  PatternRouter
+};

package/node_modules/@zuplo/editor/node_modules/hono/dist/router/reg-exp-router/index.js

@@ -0,0 +1,9 @@
+// src/router/reg-exp-router/index.ts
+import { RegExpRouter } from "./router.js";
+import { PreparedRegExpRouter, buildInitParams, serializeInitParams } from "./prepared-router.js";
+export {
+  PreparedRegExpRouter,
+  RegExpRouter,
+  buildInitParams,
+  serializeInitParams
+};

package/node_modules/@zuplo/editor/node_modules/hono/dist/router/reg-exp-router/matcher.js

@@ -0,0 +1,25 @@
+// src/router/reg-exp-router/matcher.ts
+import { METHOD_NAME_ALL } from "../../router.js";
+var emptyParam = [];
+function match(method, path) {
+  const matchers = this.buildAllMatchers();
+  const match2 = ((method2, path2) => {
+    const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
+    const staticMatch = matcher[2][path2];
+    if (staticMatch) {
+      return staticMatch;
+    }
+    const match3 = path2.match(matcher[0]);
+    if (!match3) {
+      return [[], emptyParam];
+    }
+    const index = match3.indexOf("", 1);
+    return [matcher[1][index], match3];
+  });
+  this.match = match2;
+  return match2(method, path);
+}
+export {
+  emptyParam,
+  match
+};

package/node_modules/@zuplo/editor/node_modules/hono/dist/router/reg-exp-router/node.js

@@ -0,0 +1,111 @@
+// src/router/reg-exp-router/node.ts
+var LABEL_REG_EXP_STR = "[^/]+";
+var ONLY_WILDCARD_REG_EXP_STR = ".*";
+var TAIL_WILDCARD_REG_EXP_STR = "(?:|/.*)";
+var PATH_ERROR = /* @__PURE__ */ Symbol();
+var regExpMetaChars = new Set(".\\+*[^]$()");
+function compareKey(a, b) {
+  if (a.length === 1) {
+    return b.length === 1 ? a < b ? -1 : 1 : -1;
+  }
+  if (b.length === 1) {
+    return 1;
+  }
+  if (a === ONLY_WILDCARD_REG_EXP_STR || a === TAIL_WILDCARD_REG_EXP_STR) {
+    return 1;
+  } else if (b === ONLY_WILDCARD_REG_EXP_STR || b === TAIL_WILDCARD_REG_EXP_STR) {
+    return -1;
+  }
+  if (a === LABEL_REG_EXP_STR) {
+    return 1;
+  } else if (b === LABEL_REG_EXP_STR) {
+    return -1;
+  }
+  return a.length === b.length ? a < b ? -1 : 1 : b.length - a.length;
+}
+var Node = class _Node {
+  #index;
+  #varIndex;
+  #children = /* @__PURE__ */ Object.create(null);
+  insert(tokens, index, paramMap, context, pathErrorCheckOnly) {
+    if (tokens.length === 0) {
+      if (this.#index !== void 0) {
+        throw PATH_ERROR;
+      }
+      if (pathErrorCheckOnly) {
+        return;
+      }
+      this.#index = index;
+      return;
+    }
+    const [token, ...restTokens] = tokens;
+    const pattern = token === "*" ? restTokens.length === 0 ? ["", "", ONLY_WILDCARD_REG_EXP_STR] : ["", "", LABEL_REG_EXP_STR] : token === "/*" ? ["", "", TAIL_WILDCARD_REG_EXP_STR] : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+    let node;
+    if (pattern) {
+      const name = pattern[1];
+      let regexpStr = pattern[2] || LABEL_REG_EXP_STR;
+      if (name && pattern[2]) {
+        if (regexpStr === ".*") {
+          throw PATH_ERROR;
+        }
+        regexpStr = regexpStr.replace(/^\((?!\?:)(?=[^)]+\)$)/, "(?:");
+        if (/\((?!\?:)/.test(regexpStr)) {
+          throw PATH_ERROR;
+        }
+      }
+      node = this.#children[regexpStr];
+      if (!node) {
+        if (Object.keys(this.#children).some(
+          (k) => k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
+        )) {
+          throw PATH_ERROR;
+        }
+        if (pathErrorCheckOnly) {
+          return;
+        }
+        node = this.#children[regexpStr] = new _Node();
+        if (name !== "") {
+          node.#varIndex = context.varIndex++;
+        }
+      }
+      if (!pathErrorCheckOnly && name !== "") {
+        paramMap.push([name, node.#varIndex]);
+      }
+    } else {
+      node = this.#children[token];
+      if (!node) {
+        if (Object.keys(this.#children).some(
+          (k) => k.length > 1 && k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
+        )) {
+          throw PATH_ERROR;
+        }
+        if (pathErrorCheckOnly) {
+          return;
+        }
+        node = this.#children[token] = new _Node();
+      }
+    }
+    node.insert(restTokens, index, paramMap, context, pathErrorCheckOnly);
+  }
+  buildRegExpStr() {
+    const childKeys = Object.keys(this.#children).sort(compareKey);
+    const strList = childKeys.map((k) => {
+      const c = this.#children[k];
+      return (typeof c.#varIndex === "number" ? `(${k})@${c.#varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + c.buildRegExpStr();
+    });
+    if (typeof this.#index === "number") {
+      strList.unshift(`#${this.#index}`);
+    }
+    if (strList.length === 0) {
+      return "";
+    }
+    if (strList.length === 1) {
+      return strList[0];
+    }
+    return "(?:" + strList.join("|") + ")";
+  }
+};
+export {
+  Node,
+  PATH_ERROR
+};