elysia 1.4.29 → 1.4.31

package/dist/error.mjs

@@ -75,9 +75,10 @@ const mapValueError = (error) => {
         summary: isRoot ? "Value should be an email" : `Property '${property}' should be ${format}`
       };
     case 54:
+      const found = formatValidationSummaryValue(value);
       return {
         ...error,
-        summary: `${message.slice(0, 9).trim()} property '${property}' to be ${message.slice(8).trim()} but found: ${value}`
+        summary: `${message.slice(0, 9).trim()} property '${property}' to be ${message.slice(8).trim()} but found: ${found}`
       };
     case 62:
       const union = error.schema.anyOf.map((x) => `'${x?.format ?? x.type}'`).join(", ");
@@ -88,6 +89,220 @@ const mapValueError = (error) => {
     default:
       return { summary: message, ...error };
   }
+}, MAX_ERRORS = 64, MAX_VALIDATION_ERROR_DEPTH = 16, MAX_VALIDATION_ERROR_NODES = 8192, MAX_VALIDATION_ERROR_ENTRIES = 4096, MAX_VALIDATION_ERROR_CONTAINER_ENTRIES = 512, MAX_VALIDATION_ERROR_STRING_LENGTH = 4096, MAX_VALIDATION_ERROR_OUTPUT_LENGTH = 65536, VALIDATION_TRUNCATED = "[Truncated]", VALIDATION_UNSERIALIZABLE = "[Unserializable]", OMIT_VALIDATION_VALUE = Symbol("omitValidationValue"), boundValidationString = (value, state) => {
+  const remaining = state ? MAX_VALIDATION_ERROR_OUTPUT_LENGTH - state.strings : MAX_VALIDATION_ERROR_STRING_LENGTH, limit = Math.min(MAX_VALIDATION_ERROR_STRING_LENGTH, remaining);
+  return value.length <= limit ? (state && (state.strings += value.length), value) : (state && (state.strings += Math.max(limit, 0)), limit <= 0 ? "" : limit <= VALIDATION_TRUNCATED.length ? VALIDATION_TRUNCATED.slice(0, limit) : value.slice(0, limit - VALIDATION_TRUNCATED.length) + VALIDATION_TRUNCATED);
+}, formatValidationSummaryValue = (value) => {
+  if (typeof value == "string") return boundValidationString(value);
+  if (value === null || typeof value == "number" || typeof value == "boolean" || typeof value == "bigint" || typeof value > "u")
+    return String(value);
+  try {
+    if (Array.isArray(value)) {
+      const length = Object.getOwnPropertyDescriptor(
+        value,
+        "length"
+      )?.value;
+      if (typeof length != "number" || length > MAX_VALIDATION_ERROR_CONTAINER_ENTRIES)
+        return "[object Object]";
+      const output = [];
+      let size = 0;
+      for (let index = 0; index < length; index++) {
+        const descriptor = Object.getOwnPropertyDescriptor(
+          value,
+          `${index}`
+        );
+        if (!descriptor || !("value" in descriptor)) {
+          output.push("");
+          continue;
+        }
+        const item = descriptor.value;
+        if (item == null) output.push("");
+        else if (typeof item == "string" || typeof item == "number" || typeof item == "boolean" || typeof item == "bigint") {
+          const part = String(item);
+          if (size += part.length + 1, size > MAX_VALIDATION_ERROR_STRING_LENGTH)
+            return boundValidationString(output.join(","));
+          output.push(part);
+        } else return "[object Object]";
+      }
+      return boundValidationString(output.join(","));
+    }
+  } catch {
+  }
+  return "[object Object]";
+}, validationOutputFits = (value) => {
+  let bytes = 0;
+  for (let index = 0; index < value.length; index++) {
+    const code = value.charCodeAt(index);
+    if (code < 128 ? bytes++ : code < 2048 ? bytes += 2 : code >= 55296 && code <= 56319 && value.charCodeAt(index + 1) >= 56320 && value.charCodeAt(index + 1) <= 57343 ? (bytes += 4, index++) : bytes += 3, bytes > MAX_VALIDATION_ERROR_OUTPUT_LENGTH) return !1;
+  }
+  return !0;
+}, projectValidationValue = (value, state, depth = 0) => {
+  if (state.nodes++ >= MAX_VALIDATION_ERROR_NODES) return VALIDATION_TRUNCATED;
+  switch (typeof value) {
+    case "string":
+      return boundValidationString(value, state);
+    case "number":
+      return Number.isFinite(value) ? value : null;
+    case "boolean":
+      return value;
+    case "bigint":
+      return "[BigInt]";
+    case "undefined":
+    case "function":
+    case "symbol":
+      return OMIT_VALIDATION_VALUE;
+  }
+  if (typeof value != "object" || value === null) return null;
+  if (depth >= MAX_VALIDATION_ERROR_DEPTH) return VALIDATION_TRUNCATED;
+  if (state.depth.has(value)) return "[Circular]";
+  try {
+    if (value instanceof Date) {
+      const timestamp = Date.prototype.getTime.call(value);
+      return Number.isFinite(timestamp) ? boundValidationString(
+        Date.prototype.toISOString.call(value),
+        state
+      ) : null;
+    }
+  } catch {
+  }
+  state.depth.add(value);
+  try {
+    if (Array.isArray(value)) {
+      const output2 = [], lengthDescriptor = Object.getOwnPropertyDescriptor(
+        value,
+        "length"
+      ), length = typeof lengthDescriptor?.value == "number" ? lengthDescriptor.value : 0;
+      let index = 0;
+      for (; index < length && index < MAX_VALIDATION_ERROR_CONTAINER_ENTRIES && state.entries < MAX_VALIDATION_ERROR_ENTRIES && state.nodes < MAX_VALIDATION_ERROR_NODES; index++) {
+        state.entries++;
+        const descriptor = Object.getOwnPropertyDescriptor(
+          value,
+          `${index}`
+        ), projected = descriptor ? "value" in descriptor ? projectValidationValue(
+          descriptor.value,
+          state,
+          depth + 1
+        ) : VALIDATION_UNSERIALIZABLE : OMIT_VALIDATION_VALUE;
+        output2.push(
+          projected === OMIT_VALIDATION_VALUE ? null : projected
+        );
+      }
+      return index < length && output2.push(VALIDATION_TRUNCATED), state.preservePrototype || Object.setPrototypeOf(output2, null), output2;
+    }
+    const output = state.preservePrototype ? {} : /* @__PURE__ */ Object.create(null);
+    let truncated = !1, entries = 0, inspected = 0;
+    for (const key in value) {
+      if (inspected++ >= MAX_VALIDATION_ERROR_CONTAINER_ENTRIES) {
+        truncated = !0;
+        break;
+      }
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (!descriptor?.enumerable) continue;
+      if (entries >= MAX_VALIDATION_ERROR_CONTAINER_ENTRIES || state.entries >= MAX_VALIDATION_ERROR_ENTRIES || state.nodes >= MAX_VALIDATION_ERROR_NODES) {
+        truncated = !0;
+        break;
+      }
+      entries++, state.entries++;
+      const projected = "value" in descriptor ? projectValidationValue(descriptor.value, state, depth + 1) : VALIDATION_UNSERIALIZABLE;
+      projected !== OMIT_VALIDATION_VALUE && Object.defineProperty(output, boundValidationString(key, state), {
+        value: projected,
+        enumerable: !0,
+        configurable: !0,
+        writable: !0
+      });
+    }
+    return truncated && Object.defineProperty(output, VALIDATION_TRUNCATED, {
+      value: !0,
+      enumerable: !0
+    }), output;
+  } catch {
+    return VALIDATION_UNSERIALIZABLE;
+  } finally {
+    state.depth.delete(value);
+  }
+}, validationSerializationFallback = () => {
+  const fallback = /* @__PURE__ */ Object.create(null);
+  return fallback.type = "validation", fallback.message = "Validation details exceeded serialization limit", fallback;
+}, projectValidationDetails = (value, preservePrototype = !1) => {
+  const projected = projectValidationValue(value, {
+    depth: /* @__PURE__ */ new WeakSet(),
+    nodes: 0,
+    entries: 0,
+    strings: 0,
+    preservePrototype
+  }), result = projected === OMIT_VALIDATION_VALUE ? null : projected;
+  try {
+    const serialized = JSON.stringify(result);
+    if (typeof serialized == "string" && validationOutputFits(serialized))
+      return result;
+  } catch {
+  }
+  return validationSerializationFallback();
+}, stringifyValidationDetails = (value, space) => {
+  const projected = projectValidationDetails(value);
+  try {
+    const serialized = JSON.stringify(projected, null, space);
+    if (validationOutputFits(serialized)) return serialized;
+  } catch {
+  }
+  return JSON.stringify(validationSerializationFallback(), null, space);
+}, stringifyCustomValidationError = (value) => {
+  if (value !== null && typeof value == "object")
+    return stringifyValidationDetails(value);
+  try {
+    return boundValidationString(String(value));
+  } catch {
+    return VALIDATION_UNSERIALIZABLE;
+  }
+}, tryMapValueError = (error) => {
+  try {
+    return mapValueError(error);
+  } catch {
+    return;
+  }
+}, readValidationDataProperty = (value, key) => {
+  if (!(value === null || typeof value != "object"))
+    try {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (descriptor && "value" in descriptor) return descriptor.value;
+    } catch {
+    }
+}, formatStandardValidationPath = (value) => {
+  try {
+    if (!Array.isArray(value)) return "root";
+    const length = Object.getOwnPropertyDescriptor(value, "length")?.value;
+    if (typeof length != "number") return "root";
+    const output = [];
+    let size = 0;
+    const limit = Math.min(length, MAX_VALIDATION_ERROR_CONTAINER_ENTRIES);
+    for (let index = 0; index < limit; index++) {
+      const descriptor = Object.getOwnPropertyDescriptor(
+        value,
+        `${index}`
+      );
+      if (!descriptor || !("value" in descriptor)) continue;
+      const part = descriptor.value;
+      if (typeof part == "string" || typeof part == "number" || typeof part == "boolean" || typeof part == "bigint") {
+        const formatted = boundValidationString(String(part));
+        if (size += formatted.length + 1, size > MAX_VALIDATION_ERROR_STRING_LENGTH) {
+          output.push(VALIDATION_TRUNCATED);
+          break;
+        }
+        output.push(formatted);
+      } else output.push(VALIDATION_UNSERIALIZABLE);
+    }
+    return limit < length && output.push(VALIDATION_TRUNCATED), boundValidationString(output.join(".")) || "root";
+  } catch {
+    return "root";
+  }
+}, takeErrors = (iterator, limit = MAX_ERRORS) => {
+  const errors = [];
+  for (const error of iterator) {
+    if (!error) continue;
+    const mapped = tryMapValueError(error);
+    if (mapped && errors.push(mapped), errors.length >= limit) break;
+  }
+  return errors;
 };
 class InvalidFileType extends Error {
   constructor(property, expected, message = `"${property}" has invalid file type`) {
@@ -142,27 +357,39 @@ class ValidationError extends Error {
       const standard = (
         // @ts-ignore
         ("~standard" in validator ? validator : validator.schema)["~standard"]
+      ), _errors = errors ?? standard.validate(value).issues;
+      error = readValidationDataProperty(_errors, 0);
+      const standardErrorPath = readValidationDataProperty(error, "path"), standardErrorMessage = readValidationDataProperty(
+        error,
+        "message"
+      ), standardErrorProblem = readValidationDataProperty(
+        error,
+        "problem"
       );
-      error = (errors ?? standard.validate(value).issues)?.[0], isProduction && !allowUnsafeValidationDetails ? message = JSON.stringify({
+      isProduction && !allowUnsafeValidationDetails ? message = stringifyValidationDetails({
         type: "validation",
         on: type,
         found: value
-      }) : message = JSON.stringify(
+      }) : message = stringifyValidationDetails(
         {
           type: "validation",
           on: type,
-          property: error.path?.[0] || "root",
-          message: error?.message,
-          summary: error?.problem,
+          property: readValidationDataProperty(standardErrorPath, 0) || "root",
+          message: standardErrorMessage,
+          summary: standardErrorProblem,
           expected,
           found: value,
           errors
         },
-        null,
         2
-      ), customError = error?.message;
+      ), customError = standardErrorMessage;
     } else {
-      value && typeof value == "object" && value instanceof ElysiaCustomStatusResponse && (value = value.response), error = errors?.First() ?? ("Errors" in validator ? validator.Errors(value).First() : Value.Errors(validator, value).First());
+      if (value && typeof value == "object")
+        try {
+          value instanceof ElysiaCustomStatusResponse && (value = value.response);
+        } catch {
+        }
+      error = errors?.First() ?? ("Errors" in validator ? validator.Errors(value).First() : Value.Errors(validator, value).First());
       const accessor = error?.path || "root", schema = validator?.schema ?? validator;
       if (!isProduction && !allowUnsafeValidationDetails)
         try {
@@ -186,41 +413,36 @@ class ValidationError extends Error {
           value,
           property: accessor,
           message: error?.message,
-          summary: mapValueError(error)?.summary,
+          summary: tryMapValueError(error)?.summary,
           found: value,
           expected,
-          errors: "Errors" in validator ? [
-            ...validator.Errors(
+          errors: "Errors" in validator ? takeErrors(
+            validator.Errors(
               value
             )
-          ].map(mapValueError) : [
-            ...Value.Errors(
+          ) : takeErrors(
+            Value.Errors(
               validator,
               value
             )
-          ].map(mapValueError)
+          )
         },
         validator
-      ) : error.schema.error : void 0, customError !== void 0 ? message = typeof customError == "object" ? JSON.stringify(customError) : customError + "" : isProduction && !allowUnsafeValidationDetails ? message = JSON.stringify({
+      ) : error.schema.error : void 0, customError !== void 0 ? message = stringifyCustomValidationError(customError) : isProduction && !allowUnsafeValidationDetails ? message = stringifyValidationDetails({
         type: "validation",
         on: type,
         found: value
-      }) : message = JSON.stringify(
+      }) : message = stringifyValidationDetails(
         {
           type: "validation",
           on: type,
           property: accessor,
           message: error?.message,
-          summary: mapValueError(error)?.summary,
+          summary: tryMapValueError(error)?.summary,
           expected,
           found: value,
-          errors: "Errors" in validator ? [...validator.Errors(value)].map(
-            mapValueError
-          ) : [...Value.Errors(validator, value)].map(
-            mapValueError
-          )
+          errors: "Errors" in validator ? takeErrors(validator.Errors(value)) : takeErrors(Value.Errors(validator, value))
         },
-        null,
         2
       );
     }
@@ -248,14 +470,19 @@ class ValidationError extends Error {
       "~standard" in this.validator.schema ? /* @ts-ignore */ ("~standard" in this.validator ? this.validator : (
         // @ts-ignore
         this.validator.schema
-      ))["~standard"].validate(this.value).issues?.map((issue) => ({
-        summary: issue.message,
-        path: issue.path?.join(".") || "root",
-        message: issue.message,
-        value: this.value
-      })) || [] : "Errors" in this.validator ? [...this.validator.Errors(this.value)].filter((x) => x).map((x) => mapValueError(x)) : (
+      ))["~standard"].validate(this.value).issues?.slice(0, MAX_ERRORS).map((issue) => {
+        const message = readValidationDataProperty(issue, "message");
+        return {
+          summary: message,
+          path: formatStandardValidationPath(
+            readValidationDataProperty(issue, "path")
+          ),
+          message,
+          value: this.value
+        };
+      }) || [] : "Errors" in this.validator ? takeErrors(this.validator.Errors(this.value)) : (
         // @ts-ignore
-        [...Value.Errors(this.validator, this.value)].map(mapValueError)
+        takeErrors(Value.Errors(this.validator, this.value))
       )
     );
   }
@@ -301,22 +528,30 @@ class ValidationError extends Error {
    */
   detail(message, allowUnsafeValidatorDetails = this.allowUnsafeValidationDetails) {
     if (!this.customError) return this.message;
-    const value = this.value, expected = this.expected, errors = this.all;
-    return isProduction && !allowUnsafeValidatorDetails ? {
-      type: "validation",
-      on: this.type,
-      found: value,
-      message
-    } : {
-      type: "validation",
-      on: this.type,
-      property: this.valueError?.path || "root",
-      message,
-      summary: mapValueError(this.valueError)?.summary,
-      found: value,
-      expected,
-      errors
-    };
+    const value = this.value, expected = this.expected;
+    let errors = [], property = "root", summary;
+    try {
+      errors = this.all, property = this.valueError?.path || "root", summary = tryMapValueError(this.valueError)?.summary;
+    } catch {
+    }
+    return projectValidationDetails(
+      isProduction && !allowUnsafeValidatorDetails ? {
+        type: "validation",
+        on: this.type,
+        found: value,
+        message
+      } : {
+        type: "validation",
+        on: this.type,
+        property,
+        message,
+        summary,
+        found: value,
+        expected,
+        errors
+      },
+      !0
+    );
   }
 }
 export {
@@ -326,6 +561,13 @@ export {
   InternalServerError,
   InvalidCookieSignature,
   InvalidFileType,
+  MAX_ERRORS,
+  MAX_VALIDATION_ERROR_CONTAINER_ENTRIES,
+  MAX_VALIDATION_ERROR_DEPTH,
+  MAX_VALIDATION_ERROR_ENTRIES,
+  MAX_VALIDATION_ERROR_NODES,
+  MAX_VALIDATION_ERROR_OUTPUT_LENGTH,
+  MAX_VALIDATION_ERROR_STRING_LENGTH,
   NotFoundError,
   ParseError,
   ValidationError,

package/dist/form-data.d.ts

@@ -0,0 +1,3 @@
+export declare const parseFormData: (form?: {
+    forEach(callback: (value: unknown, key: string, parent: unknown) => void): void;
+}) => Record<string, unknown>;

package/dist/form-data.js

@@ -0,0 +1,124 @@
+"use strict";
+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: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__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: !0 }), mod);
+var form_data_exports = {};
+__export(form_data_exports, {
+  parseFormData: () => parseFormData
+});
+module.exports = __toCommonJS(form_data_exports);
+const ARRAY_INDEX_REGEX = /^(.+)\[(\d+)\]$/, DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]), MAX_PATH_DEPTH = 32, MAX_ARRAY_INDEX = 1e4, MAX_ASSIGNMENTS = 2e4, spend = (budget, cost = 1) => budget.remaining < cost ? !1 : (budget.remaining -= cost, !0), growArray = (array, index, budget) => index < array.length || spend(budget, index - array.length + 1), isDangerousKey = (key) => {
+  if (DANGEROUS_KEYS.has(key)) return !0;
+  const match = key.match(ARRAY_INDEX_REGEX);
+  return match ? DANGEROUS_KEYS.has(match[1]) : !1;
+}, parseArrayKey = (key) => {
+  const match = key.match(ARRAY_INDEX_REGEX);
+  if (!match) return;
+  const index = Number(match[2]);
+  return !Number.isSafeInteger(index) || index > MAX_ARRAY_INDEX ? null : {
+    name: match[1],
+    index
+  };
+}, parseObjectString = (entry) => {
+  if (!(typeof entry != "string" || entry.charCodeAt(0) !== 123))
+    try {
+      const parsed = JSON.parse(entry);
+      if (parsed && typeof parsed == "object" && !Array.isArray(parsed))
+        return parsed;
+    } catch {
+    }
+}, normalizeFormValue = (value) => {
+  if (value.length === 1) {
+    const stringValue2 = value[0];
+    if (typeof stringValue2 == "string" && (stringValue2.charCodeAt(0) === 123 || stringValue2.charCodeAt(0) === 91))
+      try {
+        const parsed2 = JSON.parse(stringValue2);
+        if (parsed2 && typeof parsed2 == "object") return parsed2;
+      } catch {
+      }
+    return value[0];
+  }
+  const stringValue = value.find(
+    (entry) => typeof entry == "string"
+  );
+  if (!stringValue || typeof File > "u") return value;
+  const files = value.filter((entry) => entry instanceof File);
+  if (!files.length || stringValue.charCodeAt(0) !== 123) return value;
+  const parsed = parseObjectString(stringValue);
+  return parsed ? (!("file" in parsed) && files.length === 1 ? parsed.file = files[0] : !("files" in parsed) && files.length > 1 && (parsed.files = files), parsed) : value;
+}, setNestedValue = (obj, path, value, budget) => {
+  const keys = path.split(".");
+  if (keys.length > MAX_PATH_DEPTH) return;
+  const lastKey = keys.pop();
+  if (isDangerousKey(lastKey) || keys.some(isDangerousKey)) return;
+  let current = obj;
+  for (const key of keys) {
+    const arrayInfo2 = parseArrayKey(key);
+    if (arrayInfo2 === null) return;
+    if (arrayInfo2) {
+      if (!Array.isArray(current[arrayInfo2.name])) {
+        if (!spend(budget)) return;
+        current[arrayInfo2.name] = [];
+      }
+      const array = current[arrayInfo2.name];
+      if (!growArray(array, arrayInfo2.index, budget)) return;
+      const existing = array[arrayInfo2.index], isFile = typeof File < "u" && existing instanceof File;
+      if (!existing || typeof existing != "object" || Array.isArray(existing) || isFile) {
+        if (!spend(budget)) return;
+        array[arrayInfo2.index] = parseObjectString(existing) ?? {};
+      }
+      current = array[arrayInfo2.index];
+      continue;
+    }
+    if (!current[key] || typeof current[key] != "object") {
+      if (!spend(budget)) return;
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  const arrayInfo = parseArrayKey(lastKey);
+  if (arrayInfo !== null) {
+    if (arrayInfo) {
+      if (!Array.isArray(current[arrayInfo.name])) {
+        if (!spend(budget)) return;
+        current[arrayInfo.name] = [];
+      }
+      const array = current[arrayInfo.name];
+      if (!growArray(array, arrayInfo.index, budget) || !spend(budget)) return;
+      array[arrayInfo.index] = value;
+      return;
+    }
+    spend(budget) && (current[lastKey] = value);
+  }
+}, parseFormData = (form) => {
+  const body = {};
+  if (!form) return body;
+  const grouped = /* @__PURE__ */ new Map();
+  form.forEach((value, key) => {
+    const entries = grouped.get(key);
+    entries ? entries.push(value) : grouped.set(key, [value]);
+  });
+  const budget = { remaining: MAX_ASSIGNMENTS };
+  for (const [key, value] of grouped) {
+    if (isDangerousKey(key) || Object.prototype.hasOwnProperty.call(body, key))
+      continue;
+    const finalValue = normalizeFormValue(value);
+    key.includes(".") || key.includes("[") ? setNestedValue(body, key, finalValue, budget) : spend(budget) && (body[key] = finalValue);
+  }
+  return body;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseFormData
+});

package/dist/form-data.mjs

@@ -0,0 +1,103 @@
+const ARRAY_INDEX_REGEX = /^(.+)\[(\d+)\]$/, DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]), MAX_PATH_DEPTH = 32, MAX_ARRAY_INDEX = 1e4, MAX_ASSIGNMENTS = 2e4, spend = (budget, cost = 1) => budget.remaining < cost ? !1 : (budget.remaining -= cost, !0), growArray = (array, index, budget) => index < array.length || spend(budget, index - array.length + 1), isDangerousKey = (key) => {
+  if (DANGEROUS_KEYS.has(key)) return !0;
+  const match = key.match(ARRAY_INDEX_REGEX);
+  return match ? DANGEROUS_KEYS.has(match[1]) : !1;
+}, parseArrayKey = (key) => {
+  const match = key.match(ARRAY_INDEX_REGEX);
+  if (!match) return;
+  const index = Number(match[2]);
+  return !Number.isSafeInteger(index) || index > MAX_ARRAY_INDEX ? null : {
+    name: match[1],
+    index
+  };
+}, parseObjectString = (entry) => {
+  if (!(typeof entry != "string" || entry.charCodeAt(0) !== 123))
+    try {
+      const parsed = JSON.parse(entry);
+      if (parsed && typeof parsed == "object" && !Array.isArray(parsed))
+        return parsed;
+    } catch {
+    }
+}, normalizeFormValue = (value) => {
+  if (value.length === 1) {
+    const stringValue2 = value[0];
+    if (typeof stringValue2 == "string" && (stringValue2.charCodeAt(0) === 123 || stringValue2.charCodeAt(0) === 91))
+      try {
+        const parsed2 = JSON.parse(stringValue2);
+        if (parsed2 && typeof parsed2 == "object") return parsed2;
+      } catch {
+      }
+    return value[0];
+  }
+  const stringValue = value.find(
+    (entry) => typeof entry == "string"
+  );
+  if (!stringValue || typeof File > "u") return value;
+  const files = value.filter((entry) => entry instanceof File);
+  if (!files.length || stringValue.charCodeAt(0) !== 123) return value;
+  const parsed = parseObjectString(stringValue);
+  return parsed ? (!("file" in parsed) && files.length === 1 ? parsed.file = files[0] : !("files" in parsed) && files.length > 1 && (parsed.files = files), parsed) : value;
+}, setNestedValue = (obj, path, value, budget) => {
+  const keys = path.split(".");
+  if (keys.length > MAX_PATH_DEPTH) return;
+  const lastKey = keys.pop();
+  if (isDangerousKey(lastKey) || keys.some(isDangerousKey)) return;
+  let current = obj;
+  for (const key of keys) {
+    const arrayInfo2 = parseArrayKey(key);
+    if (arrayInfo2 === null) return;
+    if (arrayInfo2) {
+      if (!Array.isArray(current[arrayInfo2.name])) {
+        if (!spend(budget)) return;
+        current[arrayInfo2.name] = [];
+      }
+      const array = current[arrayInfo2.name];
+      if (!growArray(array, arrayInfo2.index, budget)) return;
+      const existing = array[arrayInfo2.index], isFile = typeof File < "u" && existing instanceof File;
+      if (!existing || typeof existing != "object" || Array.isArray(existing) || isFile) {
+        if (!spend(budget)) return;
+        array[arrayInfo2.index] = parseObjectString(existing) ?? {};
+      }
+      current = array[arrayInfo2.index];
+      continue;
+    }
+    if (!current[key] || typeof current[key] != "object") {
+      if (!spend(budget)) return;
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  const arrayInfo = parseArrayKey(lastKey);
+  if (arrayInfo !== null) {
+    if (arrayInfo) {
+      if (!Array.isArray(current[arrayInfo.name])) {
+        if (!spend(budget)) return;
+        current[arrayInfo.name] = [];
+      }
+      const array = current[arrayInfo.name];
+      if (!growArray(array, arrayInfo.index, budget) || !spend(budget)) return;
+      array[arrayInfo.index] = value;
+      return;
+    }
+    spend(budget) && (current[lastKey] = value);
+  }
+}, parseFormData = (form) => {
+  const body = {};
+  if (!form) return body;
+  const grouped = /* @__PURE__ */ new Map();
+  form.forEach((value, key) => {
+    const entries = grouped.get(key);
+    entries ? entries.push(value) : grouped.set(key, [value]);
+  });
+  const budget = { remaining: MAX_ASSIGNMENTS };
+  for (const [key, value] of grouped) {
+    if (isDangerousKey(key) || Object.prototype.hasOwnProperty.call(body, key))
+      continue;
+    const finalValue = normalizeFormValue(value);
+    key.includes(".") || key.includes("[") ? setNestedValue(body, key, finalValue, budget) : spend(budget) && (body[key] = finalValue);
+  }
+  return body;
+};
+export {
+  parseFormData
+};

package/dist/index.d.ts

@@ -61,6 +61,7 @@ export default class Elysia<const in out BasePath extends string = '', const in
     '~Ephemeral': Ephemeral;
     '~Volatile': Volatile;
     '~Routes': Routes;
+    '~cookieConfig': ElysiaConfig<any>['cookie'] | undefined;
     protected singleton: SingletonBase;
     get store(): Singleton['store'];
     get decorator(): Singleton['decorator'];
@@ -1736,6 +1737,7 @@ export default class Elysia<const in out BasePath extends string = '', const in
         config?: {
             allowMeta?: boolean;
             mount?: Function;
+            cookie?: ElysiaConfig<any>['cookie'];
         };
     }): Elysia<BasePath, Singleton, Definitions, Metadata, Routes & CreateEden<JoinPath<BasePath, Path>, {
         [method in Method]: CreateEdenResponse<Path, Schema, MacroContext, ComposeElysiaResponse<Schema & MacroContext & Metadata['standaloneSchema'] & Ephemeral['standaloneSchema'] & Volatile['standaloneSchema'], Handle, UnionResponseStatus<Metadata['response'], UnionResponseStatus<Ephemeral['response'], UnionResponseStatus<Volatile['response'], MacroContext['return'] & {}>>>>>;