@pome-sh/cli 0.20.0 → 0.21.0

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

@@ -1,70 +0,0 @@
-/**
- * @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; charset=utf-8";
-    readonly csv: "text/csv; charset=utf-8";
-    readonly eot: "application/vnd.ms-fontobject";
-    readonly epub: "application/epub+zip";
-    readonly gif: "image/gif";
-    readonly gz: "application/gzip";
-    readonly htm: "text/html; charset=utf-8";
-    readonly html: "text/html; charset=utf-8";
-    readonly ico: "image/x-icon";
-    readonly ics: "text/calendar; charset=utf-8";
-    readonly jpeg: "image/jpeg";
-    readonly jpg: "image/jpeg";
-    readonly js: "text/javascript; charset=utf-8";
-    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; charset=utf-8";
-    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; charset=utf-8";
-    readonly tif: "image/tiff";
-    readonly tiff: "image/tiff";
-    readonly ts: "video/mp2t";
-    readonly ttf: "font/ttf";
-    readonly txt: "text/plain; charset=utf-8";
-    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; charset=utf-8";
-    readonly xml: "application/xml; charset=utf-8";
-    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

@@ -1,31 +0,0 @@
-/**
- * @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

@@ -1,74 +0,0 @@
-/**
- * @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>;
-} extends infer A ? A extends ReadonlyArray<unknown> ? A : JSONParsed<InvalidToNull<T[number]>, TError>[] : never : 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

@@ -1,40 +0,0 @@
-/**
- * @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 tryDecodeURIComponent: (str: string) => string;
-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

@@ -1,7 +0,0 @@
-/**
- * @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

@@ -1,29 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

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

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

@@ -1,223 +0,0 @@
-// 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: /* @__PURE__ */ Object.create(null),
-    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

@@ -1,23 +0,0 @@
-// 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

@@ -1,89 +0,0 @@
-// src/utils/body.ts
-import { bufferToFormData } from "./buffer.js";
-var isRawRequest = (request) => "headers" in request;
-var parseBody = async (request, options = /* @__PURE__ */ Object.create(null)) => {
-  const { all = false, dot = false } = options;
-  const headers = isRawRequest(request) ? request.headers : request.raw.headers;
-  const contentType = headers.get("Content-Type");
-  const mediaType = contentType?.split(";")[0].trim().toLowerCase();
-  if (mediaType === "multipart/form-data" || mediaType === "application/x-www-form-urlencoded") {
-    return parseFormData(request, { all, dot });
-  }
-  return {};
-};
-async function parseFormData(request, options) {
-  if (!isRawRequest(request) && request.bodyCache.formData) {
-    return convertFormDataToBodyData(
-      await request.bodyCache.formData,
-      options
-    );
-  }
-  const headers = isRawRequest(request) ? request.headers : request.raw.headers;
-  const arrayBuffer = await request.arrayBuffer();
-  const formDataPromise = bufferToFormData(arrayBuffer, headers.get("Content-Type") || "");
-  if (!isRawRequest(request)) {
-    request.bodyCache.formData = formDataPromise;
-  }
-  const formData = await formDataPromise;
-  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
-};