@zuplo/cli 6.69.11 → 6.70.0

package/node_modules/hono/dist/types/utils/mime.d.ts

@@ -0,0 +1,70 @@
+/**
+ * @module
+ * MIME utility.
+ */
+export declare const getMimeType: (filename: string, mimes?: Record<string, string>) => string | undefined;
+export declare const getExtension: (mimeType: string) => string | undefined;
+export { baseMimes as mimes };
+/**
+ * Union types for BaseMime
+ */
+export type BaseMime = (typeof _baseMimes)[keyof typeof _baseMimes];
+declare const _baseMimes: {
+    readonly aac: "audio/aac";
+    readonly avi: "video/x-msvideo";
+    readonly avif: "image/avif";
+    readonly av1: "video/av1";
+    readonly bin: "application/octet-stream";
+    readonly bmp: "image/bmp";
+    readonly css: "text/css";
+    readonly csv: "text/csv";
+    readonly eot: "application/vnd.ms-fontobject";
+    readonly epub: "application/epub+zip";
+    readonly gif: "image/gif";
+    readonly gz: "application/gzip";
+    readonly htm: "text/html";
+    readonly html: "text/html";
+    readonly ico: "image/x-icon";
+    readonly ics: "text/calendar";
+    readonly jpeg: "image/jpeg";
+    readonly jpg: "image/jpeg";
+    readonly js: "text/javascript";
+    readonly json: "application/json";
+    readonly jsonld: "application/ld+json";
+    readonly map: "application/json";
+    readonly mid: "audio/x-midi";
+    readonly midi: "audio/x-midi";
+    readonly mjs: "text/javascript";
+    readonly mp3: "audio/mpeg";
+    readonly mp4: "video/mp4";
+    readonly mpeg: "video/mpeg";
+    readonly oga: "audio/ogg";
+    readonly ogv: "video/ogg";
+    readonly ogx: "application/ogg";
+    readonly opus: "audio/opus";
+    readonly otf: "font/otf";
+    readonly pdf: "application/pdf";
+    readonly png: "image/png";
+    readonly rtf: "application/rtf";
+    readonly svg: "image/svg+xml";
+    readonly tif: "image/tiff";
+    readonly tiff: "image/tiff";
+    readonly ts: "video/mp2t";
+    readonly ttf: "font/ttf";
+    readonly txt: "text/plain";
+    readonly wasm: "application/wasm";
+    readonly webm: "video/webm";
+    readonly weba: "audio/webm";
+    readonly webmanifest: "application/manifest+json";
+    readonly webp: "image/webp";
+    readonly woff: "font/woff";
+    readonly woff2: "font/woff2";
+    readonly xhtml: "application/xhtml+xml";
+    readonly xml: "application/xml";
+    readonly zip: "application/zip";
+    readonly '3gp': "video/3gpp";
+    readonly '3g2': "video/3gpp2";
+    readonly gltf: "model/gltf+json";
+    readonly glb: "model/gltf-binary";
+};
+declare const baseMimes: Record<string, BaseMime>;

package/node_modules/hono/dist/types/utils/stream.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @module
+ * Stream utility.
+ */
+export declare class StreamingApi {
+    private writer;
+    private encoder;
+    private writable;
+    private abortSubscribers;
+    responseReadable: ReadableStream;
+    /**
+     * Whether the stream has been aborted.
+     */
+    aborted: boolean;
+    /**
+     * Whether the stream has been closed normally.
+     */
+    closed: boolean;
+    constructor(writable: WritableStream, _readable: ReadableStream);
+    write(input: Uint8Array | string): Promise<StreamingApi>;
+    writeln(input: string): Promise<StreamingApi>;
+    sleep(ms: number): Promise<unknown>;
+    close(): Promise<void>;
+    pipe(body: ReadableStream): Promise<void>;
+    onAbort(listener: () => void | Promise<void>): void;
+    /**
+     * Abort the stream.
+     * You can call this method when stream is aborted by external event.
+     */
+    abort(): void;
+}

package/node_modules/hono/dist/types/utils/types.d.ts

@@ -0,0 +1,74 @@
+/**
+ * @module
+ * Types utility.
+ */
+export type Expect<T extends true> = T;
+export type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
+export type NotEqual<X, Y> = true extends Equal<X, Y> ? false : true;
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export type RemoveBlankRecord<T> = T extends Record<infer K, unknown> ? (K extends string ? T : never) : never;
+export type IfAnyThenEmptyObject<T> = 0 extends 1 & T ? {} : T;
+export type JSONPrimitive = string | boolean | number | null;
+export type JSONArray = (JSONPrimitive | JSONObject | JSONArray)[];
+export type JSONObject = {
+    [key: string]: JSONPrimitive | JSONArray | JSONObject | object | InvalidJSONValue;
+};
+export type InvalidJSONValue = undefined | symbol | ((...args: unknown[]) => unknown);
+type InvalidToNull<T> = T extends InvalidJSONValue ? null : T;
+type IsInvalid<T> = T extends InvalidJSONValue ? true : false;
+/**
+ * symbol keys are omitted through `JSON.stringify`
+ */
+type OmitSymbolKeys<T> = {
+    [K in keyof T as K extends symbol ? never : K]: T[K];
+};
+export type JSONValue = JSONObject | JSONArray | JSONPrimitive;
+/**
+ * Convert a type to a JSON-compatible type.
+ *
+ * Non-JSON values such as `Date` implement `.toJSON()`,
+ * so they can be transformed to a value assignable to `JSONObject`
+ *
+ * `JSON.stringify()` throws a `TypeError` when it encounters a `bigint` value,
+ * unless a custom `replacer` function or `.toJSON()` method is provided.
+ *
+ * This behaviour can be controlled by the `TError` generic type parameter,
+ * which defaults to `bigint | ReadonlyArray<bigint>`.
+ * You can set it to `never` to disable this check.
+ */
+export type JSONParsed<T, TError = bigint | ReadonlyArray<bigint>> = T extends {
+    toJSON(): infer J;
+} ? (() => J) extends () => JSONPrimitive ? J : (() => J) extends () => {
+    toJSON(): unknown;
+} ? {} : JSONParsed<J, TError> : T extends JSONPrimitive ? T : T extends InvalidJSONValue ? never : T extends ReadonlyArray<unknown> ? {
+    [K in keyof T]: JSONParsed<InvalidToNull<T[K]>, TError>;
+} : T extends Set<unknown> | Map<unknown, unknown> | Record<string, never> ? {} : T extends object ? T[keyof T] extends TError ? never : {
+    [K in keyof OmitSymbolKeys<T> as IsInvalid<T[K]> extends true ? never : K]: boolean extends IsInvalid<T[K]> ? JSONParsed<T[K], TError> | undefined : JSONParsed<T[K], TError>;
+} : T extends unknown ? T extends TError ? never : JSONValue : never;
+/**
+ * Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
+ * @copyright from sindresorhus/type-fest
+ */
+export type Simplify<T> = {
+    [KeyType in keyof T]: T[KeyType];
+} & {};
+/**
+ * A simple extension of Simplify that will deeply traverse array elements.
+ */
+export type SimplifyDeepArray<T> = T extends any[] ? {
+    [E in keyof T]: SimplifyDeepArray<T[E]>;
+} : Simplify<T>;
+export type InterfaceToType<T> = T extends Function ? T : {
+    [K in keyof T]: InterfaceToType<T[K]>;
+};
+export type RequiredKeysOf<BaseType extends object> = Exclude<{
+    [Key in keyof BaseType]: BaseType extends Record<Key, BaseType[Key]> ? Key : never;
+}[keyof BaseType], undefined>;
+export type HasRequiredKeys<BaseType extends object> = RequiredKeysOf<BaseType> extends never ? false : true;
+export type IsAny<T> = boolean extends (T extends never ? true : false) ? true : false;
+/**
+ * String literal types with auto-completion
+ * @see https://github.com/Microsoft/TypeScript/issues/29729
+ */
+export type StringLiteralUnion<T> = T | (string & Record<never, never>);
+export {};

package/node_modules/hono/dist/types/utils/url.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @module
+ * URL utility.
+ */
+export type Pattern = readonly [string, string, RegExp | true] | '*';
+export declare const splitPath: (path: string) => string[];
+export declare const splitRoutingPath: (routePath: string) => string[];
+export declare const getPattern: (label: string, next?: string) => Pattern | null;
+type Decoder = (str: string) => string;
+export declare const tryDecode: (str: string, decoder: Decoder) => string;
+/**
+ * Try to apply decodeURI() to given string.
+ * If it fails, skip invalid percent encoding or invalid UTF-8 sequences, and apply decodeURI() to the rest as much as possible.
+ * @param str The string to decode.
+ * @returns The decoded string that sometimes contains undecodable percent encoding.
+ * @example
+ * tryDecodeURI('Hello%20World') // 'Hello World'
+ * tryDecodeURI('Hello%20World/%A4%A2') // 'Hello World/%A4%A2'
+ */
+export declare const tryDecodeURI: (str: string) => string;
+export declare const getPath: (request: Request) => string;
+export declare const getQueryStrings: (url: string) => string;
+export declare const getPathNoStrict: (request: Request) => string;
+/**
+ * Merge paths.
+ * @param {string[]} ...paths - The paths to merge.
+ * @returns {string} The merged path.
+ * @example
+ * mergePath('/api', '/users') // '/api/users'
+ * mergePath('/api/', '/users') // '/api/users'
+ * mergePath('/api', '/') // '/api'
+ * mergePath('/api/', '/') // '/api/'
+ */
+export declare const mergePath: (...paths: string[]) => string;
+export declare const checkOptionalParameter: (path: string) => string[] | null;
+export declare const getQueryParam: (url: string, key?: string) => string | undefined | Record<string, string>;
+export declare const getQueryParams: (url: string, key?: string) => string[] | undefined | Record<string, string[]>;
+export declare const decodeURIComponent_: typeof decodeURIComponent;
+export {};

package/node_modules/hono/dist/types/validator/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @module
+ * Validator for Hono.
+ */
+export { validator } from './validator';
+export type { ValidationFunction } from './validator';
+export type { InferInput } from './utils';

package/node_modules/hono/dist/types/validator/utils.d.ts

@@ -0,0 +1,29 @@
+import type { FormValue, ParsedFormValue, ValidationTargets } from '../types';
+import type { UnionToIntersection } from '../utils/types';
+/**
+ * Checks if T is a literal union type (e.g., 'asc' | 'desc')
+ * that should be preserved in input types.
+ * Returns true for union literals, false for single literals or wide types.
+ */
+export type IsLiteralUnion<T, Base> = [Exclude<T, undefined>] extends [Base] ? [Exclude<T, undefined>] extends [UnionToIntersection<Exclude<T, undefined>>] ? false : true : false;
+type IsOptionalUnion<T> = [unknown] extends [T] ? false : undefined extends T ? true : false;
+type SimplifyDeep<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type InferInputInner<Output, Target extends keyof ValidationTargets, T extends FormValue> = SimplifyDeep<{
+    [K in keyof Output]: IsLiteralUnion<Output[K], string> extends true ? Output[K] : IsOptionalUnion<Output[K]> extends true ? Output[K] : Target extends 'form' ? T | T[] : Target extends 'query' ? string | string[] : Target extends 'param' ? string : Target extends 'header' ? string : Target extends 'cookie' ? string : unknown;
+}>;
+/**
+ * Utility type to infer input types for validation targets.
+ * Preserves literal union types (e.g., 'asc' | 'desc') while using
+ * the default ValidationTargets type for other values.
+ *
+ * @example
+ * ```ts
+ * // In @hono/zod-validator or similar:
+ * type Input = InferInput<z.input<Schema>, 'query'>
+ * // { orderBy: 'asc' | 'desc', page: string | string[] }
+ * ```
+ */
+export type InferInput<Output, Target extends keyof ValidationTargets, T extends FormValue = ParsedFormValue> = [Exclude<Output, undefined>] extends [never] ? {} : [Exclude<Output, undefined>] extends [object] ? undefined extends Output ? SimplifyDeep<InferInputInner<Exclude<Output, undefined>, Target, T>> | undefined : SimplifyDeep<InferInputInner<Output, Target, T>> : {};
+export {};

package/node_modules/hono/dist/types/validator/validator.d.ts

@@ -0,0 +1,16 @@
+import type { Context } from '../context';
+import type { Env, MiddlewareHandler, TypedResponse, ValidationTargets, FormValue } from '../types';
+import type { InferInput } from './utils';
+type ValidationTargetKeysWithBody = 'form' | 'json';
+type ValidationTargetByMethod<M> = M extends 'get' | 'head' ? Exclude<keyof ValidationTargets, ValidationTargetKeysWithBody> : keyof ValidationTargets;
+export type ValidationFunction<InputType, OutputType, E extends Env = {}, P extends string = string> = (value: InputType, c: Context<E, P>) => OutputType | TypedResponse | Promise<OutputType> | Promise<TypedResponse>;
+export type ExtractValidationResponse<VF> = VF extends (value: any, c: any) => infer R ? R extends Promise<infer PR> ? PR extends TypedResponse<infer T, infer S, infer F> ? TypedResponse<T, S, F> : PR extends Response ? PR : PR extends undefined ? never : never : R extends TypedResponse<infer T, infer S, infer F> ? TypedResponse<T, S, F> : R extends Response ? R : R extends undefined ? never : never : never;
+export declare const validator: <InputType, P extends string, M extends string, U extends ValidationTargetByMethod<M>, P2 extends string = P, VF extends (value: unknown extends InputType ? ValidationTargets[U] : InputType, c: Context<any, P2>) => any = (value: unknown extends InputType ? ValidationTargets[U] : InputType, c: Context<any, P2>) => any, V extends {
+    in: { [K in U]: K extends "json" ? unknown extends InputType ? ExtractValidatorOutput<VF> : InputType : InferInput<ExtractValidatorOutput<VF>, K, FormValue>; };
+    out: { [K in U]: ExtractValidatorOutput<VF>; };
+} = {
+    in: { [K in U]: K extends "json" ? unknown extends InputType ? ExtractValidatorOutput<VF> : InputType : InferInput<ExtractValidatorOutput<VF>, K, FormValue>; };
+    out: { [K in U]: ExtractValidatorOutput<VF>; };
+}, E extends Env = any>(target: U, validationFunc: VF) => MiddlewareHandler<E, P, V, ExtractValidationResponse<VF>>;
+export type ExtractValidatorOutput<VF> = VF extends (value: any, c: any) => infer R ? R extends Promise<infer PR> ? PR extends Response | TypedResponse<any, any, any> ? never : PR : R extends Response | TypedResponse<any, any, any> ? never : R : never;
+export {};

package/node_modules/hono/dist/types.js

@@ -0,0 +1,6 @@
+// src/types.ts
+var FetchEventLike = class {
+};
+export {
+  FetchEventLike
+};

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

@@ -0,0 +1,223 @@
+// src/utils/accept.ts
+var isWhitespace = (char) => char === 32 || char === 9 || char === 10 || char === 13;
+var consumeWhitespace = (acceptHeader, startIndex) => {
+  while (startIndex < acceptHeader.length) {
+    if (!isWhitespace(acceptHeader.charCodeAt(startIndex))) {
+      break;
+    }
+    startIndex++;
+  }
+  return startIndex;
+};
+var ignoreTrailingWhitespace = (acceptHeader, startIndex) => {
+  while (startIndex > 0) {
+    if (!isWhitespace(acceptHeader.charCodeAt(startIndex - 1))) {
+      break;
+    }
+    startIndex--;
+  }
+  return startIndex;
+};
+var skipInvalidParam = (acceptHeader, startIndex) => {
+  while (startIndex < acceptHeader.length) {
+    const char = acceptHeader.charCodeAt(startIndex);
+    if (char === 59) {
+      return [startIndex + 1, true];
+    }
+    if (char === 44) {
+      return [startIndex + 1, false];
+    }
+    startIndex++;
+  }
+  return [startIndex, false];
+};
+var skipInvalidAcceptValue = (acceptHeader, startIndex) => {
+  let i = startIndex;
+  let inQuotes = false;
+  while (i < acceptHeader.length) {
+    const char = acceptHeader.charCodeAt(i);
+    if (inQuotes && char === 92) {
+      i++;
+    } else if (char === 34) {
+      inQuotes = !inQuotes;
+    } else if (!inQuotes && char === 44) {
+      return i + 1;
+    }
+    i++;
+  }
+  return i;
+};
+var getNextParam = (acceptHeader, startIndex) => {
+  startIndex = consumeWhitespace(acceptHeader, startIndex);
+  let i = startIndex;
+  let key;
+  let value;
+  let hasNext = false;
+  while (i < acceptHeader.length) {
+    const char = acceptHeader.charCodeAt(i);
+    if (char === 61) {
+      key = acceptHeader.slice(startIndex, ignoreTrailingWhitespace(acceptHeader, i));
+      i++;
+      break;
+    }
+    if (char === 59) {
+      return [i + 1, void 0, void 0, true];
+    }
+    if (char === 44) {
+      return [i + 1, void 0, void 0, false];
+    }
+    i++;
+  }
+  if (key === void 0) {
+    return [i, void 0, void 0, false];
+  }
+  i = consumeWhitespace(acceptHeader, i);
+  if (acceptHeader.charCodeAt(i) === 61) {
+    const skipResult = skipInvalidParam(acceptHeader, i + 1);
+    return [skipResult[0], key, void 0, skipResult[1]];
+  }
+  let inQuotes = false;
+  const paramStartIndex = i;
+  while (i < acceptHeader.length) {
+    const char = acceptHeader.charCodeAt(i);
+    if (inQuotes && char === 92) {
+      i++;
+    } else if (char === 34) {
+      if (inQuotes) {
+        let nextIndex = consumeWhitespace(acceptHeader, i + 1);
+        const nextChar = acceptHeader.charCodeAt(nextIndex);
+        if (nextIndex < acceptHeader.length && !(nextChar === 59 || nextChar === 44)) {
+          const skipResult = skipInvalidParam(acceptHeader, nextIndex);
+          return [skipResult[0], key, void 0, skipResult[1]];
+        }
+        value = acceptHeader.slice(paramStartIndex + 1, i);
+        if (value.includes("\\")) {
+          value = value.replace(/\\(.)/g, "$1");
+        }
+        if (nextChar === 44) {
+          return [nextIndex + 1, key, value, false];
+        }
+        if (nextChar === 59) {
+          hasNext = true;
+          nextIndex++;
+        }
+        i = nextIndex;
+        break;
+      }
+      inQuotes = true;
+    } else if (!inQuotes && (char === 59 || char === 44)) {
+      value = acceptHeader.slice(paramStartIndex, ignoreTrailingWhitespace(acceptHeader, i));
+      if (char === 59) {
+        hasNext = true;
+      }
+      i++;
+      break;
+    }
+    i++;
+  }
+  return [
+    i,
+    key,
+    value ?? acceptHeader.slice(paramStartIndex, ignoreTrailingWhitespace(acceptHeader, i)),
+    hasNext
+  ];
+};
+var getNextAcceptValue = (acceptHeader, startIndex) => {
+  const accept = {
+    type: "",
+    params: {},
+    q: 1
+  };
+  startIndex = consumeWhitespace(acceptHeader, startIndex);
+  let i = startIndex;
+  while (i < acceptHeader.length) {
+    const char = acceptHeader.charCodeAt(i);
+    if (char === 59 || char === 44) {
+      accept.type = acceptHeader.slice(startIndex, ignoreTrailingWhitespace(acceptHeader, i));
+      i++;
+      if (char === 44) {
+        return [i, accept.type ? accept : void 0];
+      }
+      if (!accept.type) {
+        return [skipInvalidAcceptValue(acceptHeader, i), void 0];
+      }
+      break;
+    }
+    i++;
+  }
+  if (!accept.type) {
+    accept.type = acceptHeader.slice(
+      startIndex,
+      ignoreTrailingWhitespace(acceptHeader, acceptHeader.length)
+    );
+    return [acceptHeader.length, accept.type ? accept : void 0];
+  }
+  let param;
+  let value;
+  let hasNext;
+  while (i < acceptHeader.length) {
+    ;
+    [i, param, value, hasNext] = getNextParam(acceptHeader, i);
+    if (param && value) {
+      accept.params[param] = value;
+    }
+    if (!hasNext) {
+      break;
+    }
+  }
+  return [i, accept];
+};
+var parseAccept = (acceptHeader) => {
+  if (!acceptHeader) {
+    return [];
+  }
+  const values = [];
+  let i = 0;
+  let accept;
+  let requiresSort = false;
+  let lastAccept;
+  while (i < acceptHeader.length) {
+    ;
+    [i, accept] = getNextAcceptValue(acceptHeader, i);
+    if (accept) {
+      accept.q = parseQuality(accept.params.q);
+      values.push(accept);
+      if (lastAccept && lastAccept.q < accept.q) {
+        requiresSort = true;
+      }
+      lastAccept = accept;
+    }
+  }
+  if (requiresSort) {
+    values.sort((a, b) => b.q - a.q);
+  }
+  return values;
+};
+var parseQuality = (qVal) => {
+  if (qVal === void 0) {
+    return 1;
+  }
+  if (qVal === "") {
+    return 1;
+  }
+  if (qVal === "NaN") {
+    return 0;
+  }
+  const num = Number(qVal);
+  if (num === Infinity) {
+    return 1;
+  }
+  if (num === -Infinity) {
+    return 0;
+  }
+  if (Number.isNaN(num)) {
+    return 1;
+  }
+  if (num < 0 || num > 1) {
+    return 1;
+  }
+  return num;
+};
+export {
+  parseAccept
+};

package/node_modules/hono/dist/utils/basic-auth.js

@@ -0,0 +1,23 @@
+// src/utils/basic-auth.ts
+import { decodeBase64 } from "./encode.js";
+var CREDENTIALS_REGEXP = /^ *(?:[Bb][Aa][Ss][Ii][Cc]) +([A-Za-z0-9._~+/-]+=*) *$/;
+var USER_PASS_REGEXP = /^([^:]*):(.*)$/;
+var utf8Decoder = new TextDecoder();
+var auth = (req) => {
+  const match = CREDENTIALS_REGEXP.exec(req.headers.get("Authorization") || "");
+  if (!match) {
+    return void 0;
+  }
+  let userPass = void 0;
+  try {
+    userPass = USER_PASS_REGEXP.exec(utf8Decoder.decode(decodeBase64(match[1])));
+  } catch {
+  }
+  if (!userPass) {
+    return void 0;
+  }
+  return { username: userPass[1], password: userPass[2] };
+};
+export {
+  auth
+};

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

@@ -0,0 +1,75 @@
+// src/utils/body.ts
+import { HonoRequest } from "../request.js";
+var parseBody = async (request, options = /* @__PURE__ */ Object.create(null)) => {
+  const { all = false, dot = false } = options;
+  const headers = request instanceof HonoRequest ? request.raw.headers : request.headers;
+  const contentType = headers.get("Content-Type");
+  if (contentType?.startsWith("multipart/form-data") || contentType?.startsWith("application/x-www-form-urlencoded")) {
+    return parseFormData(request, { all, dot });
+  }
+  return {};
+};
+async function parseFormData(request, options) {
+  const formData = await request.formData();
+  if (formData) {
+    return convertFormDataToBodyData(formData, options);
+  }
+  return {};
+}
+function convertFormDataToBodyData(formData, options) {
+  const form = /* @__PURE__ */ Object.create(null);
+  formData.forEach((value, key) => {
+    const shouldParseAllValues = options.all || key.endsWith("[]");
+    if (!shouldParseAllValues) {
+      form[key] = value;
+    } else {
+      handleParsingAllValues(form, key, value);
+    }
+  });
+  if (options.dot) {
+    Object.entries(form).forEach(([key, value]) => {
+      const shouldParseDotValues = key.includes(".");
+      if (shouldParseDotValues) {
+        handleParsingNestedValues(form, key, value);
+        delete form[key];
+      }
+    });
+  }
+  return form;
+}
+var handleParsingAllValues = (form, key, value) => {
+  if (form[key] !== void 0) {
+    if (Array.isArray(form[key])) {
+      ;
+      form[key].push(value);
+    } else {
+      form[key] = [form[key], value];
+    }
+  } else {
+    if (!key.endsWith("[]")) {
+      form[key] = value;
+    } else {
+      form[key] = [value];
+    }
+  }
+};
+var handleParsingNestedValues = (form, key, value) => {
+  if (/(?:^|\.)__proto__\./.test(key)) {
+    return;
+  }
+  let nestedForm = form;
+  const keys = key.split(".");
+  keys.forEach((key2, index) => {
+    if (index === keys.length - 1) {
+      nestedForm[key2] = value;
+    } else {
+      if (!nestedForm[key2] || typeof nestedForm[key2] !== "object" || Array.isArray(nestedForm[key2]) || nestedForm[key2] instanceof File) {
+        nestedForm[key2] = /* @__PURE__ */ Object.create(null);
+      }
+      nestedForm = nestedForm[key2];
+    }
+  });
+};
+export {
+  parseBody
+};

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

@@ -0,0 +1,77 @@
+// src/utils/buffer.ts
+import { sha256 } from "./crypto.js";
+var equal = (a, b) => {
+  if (a === b) {
+    return true;
+  }
+  if (a.byteLength !== b.byteLength) {
+    return false;
+  }
+  const va = new DataView(a);
+  const vb = new DataView(b);
+  let i = va.byteLength;
+  while (i--) {
+    if (va.getUint8(i) !== vb.getUint8(i)) {
+      return false;
+    }
+  }
+  return true;
+};
+var constantTimeEqualString = (a, b) => {
+  const aLen = a.length;
+  const bLen = b.length;
+  const maxLen = Math.max(aLen, bLen);
+  let out = aLen ^ bLen;
+  for (let i = 0; i < maxLen; i++) {
+    const aChar = i < aLen ? a.charCodeAt(i) : 0;
+    const bChar = i < bLen ? b.charCodeAt(i) : 0;
+    out |= aChar ^ bChar;
+  }
+  return out === 0;
+};
+var timingSafeEqualString = async (a, b, hashFunction) => {
+  if (!hashFunction) {
+    hashFunction = sha256;
+  }
+  const [sa, sb] = await Promise.all([hashFunction(a), hashFunction(b)]);
+  if (sa == null || sb == null || typeof sa !== "string" || typeof sb !== "string") {
+    return false;
+  }
+  const hashEqual = constantTimeEqualString(sa, sb);
+  const originalEqual = constantTimeEqualString(a, b);
+  return hashEqual && originalEqual;
+};
+var timingSafeEqual = async (a, b, hashFunction) => {
+  if (typeof a === "string" && typeof b === "string") {
+    return timingSafeEqualString(a, b, hashFunction);
+  }
+  if (!hashFunction) {
+    hashFunction = sha256;
+  }
+  const [sa, sb] = await Promise.all([hashFunction(a), hashFunction(b)]);
+  if (!sa || !sb || typeof sa !== "string" || typeof sb !== "string") {
+    return false;
+  }
+  return timingSafeEqualString(sa, sb);
+};
+var bufferToString = (buffer) => {
+  if (buffer instanceof ArrayBuffer) {
+    const enc = new TextDecoder("utf-8");
+    return enc.decode(buffer);
+  }
+  return buffer;
+};
+var bufferToFormData = (arrayBuffer, contentType) => {
+  const response = new Response(arrayBuffer, {
+    headers: {
+      "Content-Type": contentType
+    }
+  });
+  return response.formData();
+};
+export {
+  bufferToFormData,
+  bufferToString,
+  equal,
+  timingSafeEqual
+};