elysia 1.4.30 → 1.4.31

package/dist/index.js

@@ -65,6 +65,9 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 var import_memoirist = require("memoirist"), import_typebox = require("@sinclair/typebox"), import_fast_decode_uri_component = __toESM(require("fast-decode-uri-component")), import_type_system = require('./type-system/index.js'), import_sucrose = require('./sucrose.js'), import_bun = require('./adapter/bun/index.js'), import_web_standard = require('./adapter/web-standard/index.js'), import_env = require('./universal/env.js'), import_utils = require('./utils.js'), import_schema = require('./schema.js'), import_compose = require('./compose.js'), import_trace = require('./trace.js'), import_utils2 = require('./utils.js'), import_dynamic_handle = require('./dynamic-handle.js'), import_error = require('./error.js'), import_replace_schema = require('./replace-schema.js'), import_type_system2 = require('./type-system/index.js'), import_utils3 = require('./type-system/utils.js'), import_cookies = require('./cookies.js'), import_trace2 = require('./trace.js'), import_schema2 = require('./schema.js'), import_replace_schema2 = require('./replace-schema.js'), import_utils4 = require('./utils.js'), import_error2 = require('./error.js'), import_env2 = require('./universal/env.js'), import_file = require('./universal/file.js'), import_system = require("@sinclair/typebox/system"), _a;
+const decodePathParameter = (value) => (0, import_fast_decode_uri_component.default)(
+  value.replace(/%2f/gi, (separator) => `%25${separator.slice(1)}`)
+);
 _a = Symbol.dispose;
 const _Elysia = class _Elysia {
   constructor(config = {}) {
@@ -121,14 +124,14 @@ const _Elysia = class _Elysia {
       get http() {
         return this["~http"] || (this["~http"] = new import_memoirist.Memoirist({
           lazy: !0,
-          onParam: import_fast_decode_uri_component.default
+          onParam: decodePathParameter
         })), this["~http"];
       },
       "~dynamic": void 0,
       // Use in non-AOT mode
       get dynamic() {
         return this["~dynamic"] || (this["~dynamic"] = new import_memoirist.Memoirist({
-          onParam: import_fast_decode_uri_component.default
+          onParam: decodePathParameter
         })), this["~dynamic"];
       },
       // Static Router
@@ -208,7 +211,7 @@ const _Elysia = class _Elysia {
       },
       experimental: config?.experimental ?? {},
       seed: config?.seed === void 0 ? "" : config?.seed
-    }, this["~adapter"] = config.adapter ?? (typeof Bun < "u" ? import_bun.BunAdapter : import_web_standard.WebStandardAdapter), config?.analytic && (config?.name || config?.seed !== void 0) && (this.telemetry = {
+    }, this["~cookieConfig"] = config.cookie, this["~adapter"] = config.adapter ?? (typeof Bun < "u" ? import_bun.BunAdapter : import_web_standard.WebStandardAdapter), config?.analytic && (config?.name || config?.seed !== void 0) && (this.telemetry = {
       stack: new Error().stack
     });
   }
@@ -283,7 +286,9 @@ const _Elysia = class _Elysia {
   }
   add(method, path, handle, localHook, options) {
     const skipPrefix = options?.skipPrefix ?? !1, allowMeta = options?.allowMeta ?? !1;
-    localHook ??= {}, this.applyMacro(localHook);
+    localHook ??= {};
+    const cookieConfig = localHook.config?.cookie ? (0, import_utils.mergeCookie)(this.config.cookie ?? {}, localHook.config.cookie) : this.config.cookie;
+    this.applyMacro(localHook);
     let standaloneValidators = [];
     if (localHook.standaloneValidator && (standaloneValidators = standaloneValidators.concat(
       localHook.standaloneValidator
@@ -326,7 +331,7 @@ const _Elysia = class _Elysia {
           return (0, import_schema.getCookieValidator)({
             modules,
             validator: cloned.cookie,
-            defaultConfig: this.config.cookie,
+            defaultConfig: cookieConfig,
             normalize,
             config: cloned.cookie?.config ?? {},
             dynamic,
@@ -1253,7 +1258,16 @@ const _Elysia = class _Elysia {
                 method,
                 path,
                 handler,
-                hooks,
+                plugin2["~cookieConfig"] ? {
+                  ...hooks,
+                  config: {
+                    ...hooks.config,
+                    cookie: (0, import_utils.mergeCookie)(
+                      plugin2["~cookieConfig"],
+                      hooks.config?.cookie ?? {}
+                    )
+                  }
+                } : hooks,
                 void 0
               );
             return plugin2 === this ? void 0 : (this.propagatePromiseModules(plugin2), plugin2);
@@ -1309,7 +1323,21 @@ const _Elysia = class _Elysia {
     for (const { method, path, handler, hooks } of Object.values(
       plugin.router.history
     ))
-      this.add(method, path, handler, hooks);
+      this.add(
+        method,
+        path,
+        handler,
+        plugin["~cookieConfig"] ? {
+          ...hooks,
+          config: {
+            ...hooks.config,
+            cookie: (0, import_utils.mergeCookie)(
+              plugin["~cookieConfig"],
+              hooks.config?.cookie ?? {}
+            )
+          }
+        } : hooks
+      );
     if (name) {
       name in this.dependencies || (this.dependencies[name] = []);
       const current = seed !== void 0 ? (0, import_utils2.checksum)(name + JSON.stringify(seed)) : 0;

package/dist/index.mjs

@@ -24,7 +24,8 @@ import {
   lifeCycleToArray,
   supportPerMethodInlineHandler,
   emptySchema,
-  insertStandaloneValidator
+  insertStandaloneValidator,
+  mergeCookie
 } from "./utils.mjs";
 import {
   getSchemaValidator,
@@ -61,6 +62,9 @@ import {
   queryCoercions,
   stringToStructureCoercions
 } from "./replace-schema.mjs";
+const decodePathParameter = (value) => fastDecodeURIComponent(
+  value.replace(/%2f/gi, (separator) => `%25${separator.slice(1)}`)
+);
 _a = Symbol.dispose;
 const _Elysia = class _Elysia {
   constructor(config = {}) {
@@ -117,14 +121,14 @@ const _Elysia = class _Elysia {
       get http() {
         return this["~http"] || (this["~http"] = new Memoirist({
           lazy: !0,
-          onParam: fastDecodeURIComponent
+          onParam: decodePathParameter
         })), this["~http"];
       },
       "~dynamic": void 0,
       // Use in non-AOT mode
       get dynamic() {
         return this["~dynamic"] || (this["~dynamic"] = new Memoirist({
-          onParam: fastDecodeURIComponent
+          onParam: decodePathParameter
         })), this["~dynamic"];
       },
       // Static Router
@@ -204,7 +208,7 @@ const _Elysia = class _Elysia {
       },
       experimental: config?.experimental ?? {},
       seed: config?.seed === void 0 ? "" : config?.seed
-    }, this["~adapter"] = config.adapter ?? (typeof Bun < "u" ? BunAdapter : WebStandardAdapter), config?.analytic && (config?.name || config?.seed !== void 0) && (this.telemetry = {
+    }, this["~cookieConfig"] = config.cookie, this["~adapter"] = config.adapter ?? (typeof Bun < "u" ? BunAdapter : WebStandardAdapter), config?.analytic && (config?.name || config?.seed !== void 0) && (this.telemetry = {
       stack: new Error().stack
     });
   }
@@ -279,7 +283,9 @@ const _Elysia = class _Elysia {
   }
   add(method, path, handle, localHook, options) {
     const skipPrefix = options?.skipPrefix ?? !1, allowMeta = options?.allowMeta ?? !1;
-    localHook ??= {}, this.applyMacro(localHook);
+    localHook ??= {};
+    const cookieConfig = localHook.config?.cookie ? mergeCookie(this.config.cookie ?? {}, localHook.config.cookie) : this.config.cookie;
+    this.applyMacro(localHook);
     let standaloneValidators = [];
     if (localHook.standaloneValidator && (standaloneValidators = standaloneValidators.concat(
       localHook.standaloneValidator
@@ -322,7 +328,7 @@ const _Elysia = class _Elysia {
           return getCookieValidator({
             modules,
             validator: cloned.cookie,
-            defaultConfig: this.config.cookie,
+            defaultConfig: cookieConfig,
             normalize,
             config: cloned.cookie?.config ?? {},
             dynamic,
@@ -1249,7 +1255,16 @@ const _Elysia = class _Elysia {
                 method,
                 path,
                 handler,
-                hooks,
+                plugin2["~cookieConfig"] ? {
+                  ...hooks,
+                  config: {
+                    ...hooks.config,
+                    cookie: mergeCookie(
+                      plugin2["~cookieConfig"],
+                      hooks.config?.cookie ?? {}
+                    )
+                  }
+                } : hooks,
                 void 0
               );
             return plugin2 === this ? void 0 : (this.propagatePromiseModules(plugin2), plugin2);
@@ -1305,7 +1320,21 @@ const _Elysia = class _Elysia {
     for (const { method, path, handler, hooks } of Object.values(
       plugin.router.history
     ))
-      this.add(method, path, handler, hooks);
+      this.add(
+        method,
+        path,
+        handler,
+        plugin["~cookieConfig"] ? {
+          ...hooks,
+          config: {
+            ...hooks.config,
+            cookie: mergeCookie(
+              plugin["~cookieConfig"],
+              hooks.config?.cookie ?? {}
+            )
+          }
+        } : hooks
+      );
     if (name) {
       name in this.dependencies || (this.dependencies[name] = []);
       const current = seed !== void 0 ? checksum(name + JSON.stringify(seed)) : 0;

package/dist/replace-schema.js

@@ -59,9 +59,14 @@ const replaceSchemaTypeFromManyOptions = (schema, options) => {
     )), s.not && (withTransformedChildren.not = walk({ ...newWalkInput, s: s.not })), s.properties) {
       withTransformedChildren.properties = {};
       for (const [k, v] of Object.entries(s.properties))
-        withTransformedChildren.properties[k] = walk({
-          ...newWalkInput,
-          s: v
+        Object.defineProperty(withTransformedChildren.properties, k, {
+          value: walk({
+            ...newWalkInput,
+            s: v
+          }),
+          enumerable: !0,
+          configurable: !0,
+          writable: !0
         });
     }
     if (s.items) {

package/dist/replace-schema.mjs

@@ -35,9 +35,14 @@ const replaceSchemaTypeFromManyOptions = (schema, options) => {
     )), s.not && (withTransformedChildren.not = walk({ ...newWalkInput, s: s.not })), s.properties) {
       withTransformedChildren.properties = {};
       for (const [k, v] of Object.entries(s.properties))
-        withTransformedChildren.properties[k] = walk({
-          ...newWalkInput,
-          s: v
+        Object.defineProperty(withTransformedChildren.properties, k, {
+          value: walk({
+            ...newWalkInput,
+            s: v
+          }),
+          enumerable: !0,
+          configurable: !0,
+          writable: !0
         });
     }
     if (s.items) {

package/dist/schema.d.ts

@@ -67,6 +67,8 @@ export declare const getSchemaValidator: <T extends AnySchema | string | undefin
 }) => IsAny<T> extends true ? ElysiaTypeCheck<TAnySchema> : undefined extends T ? undefined : ElysiaTypeCheck<NonNullable<Exclude<T, string>>>;
 export declare const isUnion: (schema: TSchema) => boolean;
 export declare const getSchemaProperties: (schema: TAnySchema | undefined) => Record<string, TAnySchema> | undefined;
+export declare const cloneSchemaInput: (value: any) => any;
+export declare const applySchemaDefaults: (checker: TypeCheck<any> | ElysiaTypeCheck<any>, value: unknown, nullish?: boolean) => any;
 export declare const mergeObjectSchemas: (schemas: TSchema[]) => {
     schema: TObject | undefined;
     notObjects: TSchema[];

package/dist/schema.js

@@ -15,6 +15,8 @@ var __export = (target, all) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
 var schema_exports = {};
 __export(schema_exports, {
+  applySchemaDefaults: () => applySchemaDefaults,
+  cloneSchemaInput: () => cloneSchemaInput,
   getCookieValidator: () => getCookieValidator,
   getResponseSchemaValidator: () => getResponseSchemaValidator,
   getSchemaProperties: () => getSchemaProperties,
@@ -671,6 +673,356 @@ const isOptional = (schema) => schema ? schema?.[import_typebox.Kind] === "Impor
     }
     return Object.keys(result).length > 0 ? result : void 0;
   }
+}, hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key), cloneDefaultValue = (value) => {
+  if (Array.isArray(value)) return value.map(cloneDefaultValue);
+  if (value instanceof Date) return new Date(value);
+  if (value instanceof Map)
+    return new Map(
+      [...value].map(([key, entry]) => [
+        cloneDefaultValue(key),
+        cloneDefaultValue(entry)
+      ])
+    );
+  if (value instanceof Set)
+    return new Set([...value].map(cloneDefaultValue));
+  if (ArrayBuffer.isView(value) && "slice" in value)
+    return value.slice();
+  if (value === null || typeof value != "object") return value;
+  const cloned = /* @__PURE__ */ Object.create(null);
+  for (const key of Reflect.ownKeys(value))
+    Object.defineProperty(cloned, key, {
+      value: cloneDefaultValue(value[key]),
+      enumerable: Object.prototype.propertyIsEnumerable.call(value, key),
+      configurable: !0,
+      writable: !0
+    });
+  return cloned;
+}, cloneDefault = (value) => typeof value == "function" ? value() : cloneDefaultValue(value), resolveDefaultSchema = (schema, references) => {
+  if (schema[import_typebox.Kind] === "Import") {
+    const definitions = Object.values(schema.$defs ?? {}), target = schema.$defs?.[schema.$ref];
+    return target ? resolveDefaultSchema(
+      target,
+      [...references, ...definitions]
+    ) : schema;
+  }
+  if (schema[import_typebox.Kind] === "Ref" || schema[import_typebox.Kind] === "This") {
+    const reference = references.find(
+      (reference2) => reference2.$id === schema.$ref
+    );
+    if (reference) return resolveDefaultSchema(reference, references);
+  }
+  return schema;
+}, cloneSchemaInput = (value) => {
+  if (Array.isArray(value)) return value.map(cloneForDefaults);
+  if (value === null || typeof value != "object" || value instanceof Date || value instanceof Map || value instanceof Set || value instanceof ArrayBuffer || ArrayBuffer.isView(value) || Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)
+    return value;
+  const cloned = /* @__PURE__ */ Object.create(null);
+  for (const key of Object.getOwnPropertyNames(value))
+    Object.defineProperty(cloned, key, {
+      value: cloneSchemaInput(value[key]),
+      enumerable: Object.prototype.propertyIsEnumerable.call(value, key),
+      configurable: !0,
+      writable: !0
+    });
+  for (const key of Object.getOwnPropertySymbols(value))
+    Object.defineProperty(cloned, key, {
+      value: cloneSchemaInput(value[key]),
+      enumerable: Object.prototype.propertyIsEnumerable.call(value, key),
+      configurable: !0,
+      writable: !0
+    });
+  return cloned;
+}, cloneForDefaults = cloneSchemaInput, skipFunctionDefaults = (inputSchema, references, functionDefaults, seen = /* @__PURE__ */ new Set()) => {
+  const schema = resolveDefaultSchema(inputSchema, references);
+  if (!seen.has(schema)) {
+    seen.add(schema), typeof schema.default == "function" && !functionDefaults.has(schema) && functionDefaults.set(schema, { skip: !0 });
+    for (const child of [
+      ...Object.values(schema.properties ?? {}),
+      ...Object.values(schema.patternProperties ?? {}),
+      ...schema.allOf ?? [],
+      ...schema.anyOf ?? [],
+      ...schema.oneOf ?? [],
+      ...Array.isArray(schema.items) ? schema.items : schema.items ? [schema.items] : [],
+      ...schema.not ? [schema.not] : [],
+      ...schema.additionalProperties && typeof schema.additionalProperties == "object" ? [schema.additionalProperties] : []
+    ])
+      skipFunctionDefaults(child, references, functionDefaults, seen);
+  }
+}, matchesExistingProperties = (inputSchema, input, references) => {
+  const schema = resolveDefaultSchema(inputSchema, references), properties = getSchemaProperties(schema);
+  if (!properties || input === null || typeof input != "object")
+    return input === void 0 || import_value.Value.Check(schema, references, input);
+  for (const [key, propertySchema] of Object.entries(properties))
+    if (hasOwn(input, key) && input[key] !== void 0 && !import_value.Value.Check(propertySchema, references, input[key]))
+      return !1;
+  return !0;
+}, prepareDefaultInput = (inputSchema, input, references, nullish, isRoot, functionDefaults) => {
+  const schema = resolveDefaultSchema(inputSchema, references);
+  let value = input;
+  const missing = value === void 0 || nullish && value === null;
+  typeof schema.default == "function" ? missing ? (value = cloneDefault(schema.default), functionDefaults.set(schema, { skip: !1, value })) : functionDefaults.has(schema) || functionDefaults.set(schema, { skip: !0 }) : missing && hasOwn(schema, "default") && (value = cloneDefault(schema.default));
+  const properties = getSchemaProperties(schema);
+  if (isRoot && value === void 0 && (schema[import_typebox.Kind] === "Object" || schema.type === "object") ? value = /* @__PURE__ */ Object.create(null) : value = cloneForDefaults(value), schema[import_typebox.Kind] === "Object" && properties && value !== null && typeof value == "object")
+    for (const [key, propertySchema] of Object.entries(properties)) {
+      const rawPropertyValue = hasOwn(value, key) ? value[key] : void 0, propertyValue = prepareDefaultInput(
+        propertySchema,
+        rawPropertyValue,
+        references,
+        nullish,
+        !1,
+        functionDefaults
+      );
+      propertyValue !== void 0 && Object.defineProperty(value, key, {
+        value: propertyValue,
+        enumerable: !0,
+        configurable: !0,
+        writable: !0
+      });
+    }
+  else if (Array.isArray(value) && schema.items)
+    if (Array.isArray(schema.items))
+      for (let i = 0; i < schema.items.length; i++)
+        value[i] = prepareDefaultInput(
+          schema.items[i],
+          value[i],
+          references,
+          nullish,
+          !1,
+          functionDefaults
+        );
+    else
+      for (let i = 0; i < value.length; i++)
+        value[i] = prepareDefaultInput(
+          schema.items,
+          value[i],
+          references,
+          nullish,
+          !1,
+          functionDefaults
+        );
+  if (schema.allOf)
+    for (const member of schema.allOf)
+      prepareDefaultInput(
+        member,
+        input,
+        references,
+        nullish,
+        !1,
+        functionDefaults
+      );
+  for (const members of [schema.anyOf, schema.oneOf])
+    if (members) {
+      let selected = !1;
+      for (const member of members) {
+        if (selected || !matchesExistingProperties(member, input, references)) {
+          skipFunctionDefaults(
+            member,
+            references,
+            functionDefaults
+          );
+          continue;
+        }
+        const candidate = prepareDefaultInput(
+          member,
+          input,
+          references,
+          nullish,
+          !1,
+          functionDefaults
+        );
+        import_value.Value.Check(member, references, candidate) && (selected = !0, value = candidate);
+      }
+    }
+  if (schema.patternProperties && value !== null && typeof value == "object")
+    for (const [pattern, propertySchema] of Object.entries(
+      schema.patternProperties
+    ))
+      for (const key of Object.keys(value))
+        new RegExp(pattern).test(key) && (value[key] = prepareDefaultInput(
+          propertySchema,
+          value[key],
+          references,
+          nullish,
+          !1,
+          functionDefaults
+        ));
+  return value;
+}, withResolvedFunctionDefaults = (functionDefaults, run) => {
+  const originals = [];
+  try {
+    for (const [schema, resolved] of functionDefaults) {
+      const descriptor = Object.getOwnPropertyDescriptor(schema, "default");
+      descriptor && (originals.push([schema, descriptor]), resolved.skip ? delete schema.default : Object.defineProperty(schema, "default", {
+        ...descriptor,
+        value: resolved.value
+      }));
+    }
+    return run();
+  } finally {
+    for (const [schema, descriptor] of originals)
+      Object.defineProperty(schema, "default", descriptor);
+  }
+}, restoreArrayBuffers = (inputSchema, input, defaulted, references) => {
+  const schema = resolveDefaultSchema(inputSchema, references);
+  if (schema[import_typebox.Kind] === "ArrayBuffer" && input instanceof ArrayBuffer)
+    return input;
+  const properties = getSchemaProperties(schema);
+  if (properties && input !== null && typeof input == "object" && defaulted !== null && typeof defaulted == "object")
+    for (const [key, propertySchema] of Object.entries(properties))
+      !hasOwn(input, key) || !hasOwn(defaulted, key) || Object.defineProperty(defaulted, key, {
+        value: restoreArrayBuffers(
+          propertySchema,
+          input[key],
+          defaulted[key],
+          references
+        ),
+        enumerable: !0,
+        configurable: !0,
+        writable: !0
+      });
+  else if (Array.isArray(input) && Array.isArray(defaulted) && schema.items)
+    if (Array.isArray(schema.items))
+      for (let i = 0; i < schema.items.length; i++)
+        defaulted[i] = restoreArrayBuffers(
+          schema.items[i],
+          input[i],
+          defaulted[i],
+          references
+        );
+    else
+      for (let i = 0; i < input.length; i++)
+        defaulted[i] = restoreArrayBuffers(
+          schema.items,
+          input[i],
+          defaulted[i],
+          references
+        );
+  return defaulted;
+}, repairPrototypeDefaults = (inputSchema, input, references, nullish) => {
+  const schema = resolveDefaultSchema(inputSchema, references);
+  if (schema.anyOf || schema.oneOf) {
+    const members = schema.anyOf ?? schema.oneOf;
+    for (const member of members) {
+      const candidate = repairPrototypeDefaults(
+        member,
+        cloneForDefaults(input),
+        references,
+        nullish
+      );
+      if (import_value.Value.Check(member, references, candidate)) return candidate;
+    }
+    return input;
+  }
+  if (schema.allOf) {
+    let value = input;
+    for (const member of schema.allOf)
+      value = repairPrototypeDefaults(
+        member,
+        value,
+        references,
+        nullish
+      );
+    return value;
+  }
+  const properties = getSchemaProperties(schema);
+  if (properties && input !== null && typeof input == "object")
+    for (const [key, propertySchema] of Object.entries(properties))
+      (!hasOwn(input, key) || nullish && input[key] === null) && hasOwn(propertySchema, "default") && Object.defineProperty(input, key, {
+        value: cloneDefault(propertySchema.default),
+        enumerable: !0,
+        configurable: !0,
+        writable: !0
+      }), hasOwn(input, key) && Object.defineProperty(input, key, {
+        value: repairPrototypeDefaults(
+          propertySchema,
+          input[key],
+          references,
+          nullish
+        ),
+        enumerable: !0,
+        configurable: !0,
+        writable: !0
+      });
+  else if (Array.isArray(input) && schema.items && !Array.isArray(schema.items))
+    for (let i = 0; i < input.length; i++)
+      input[i] = repairPrototypeDefaults(
+        schema.items,
+        input[i],
+        references,
+        nullish
+      );
+  return input;
+}, removeFileDefaults = (inputSchema, value, references) => {
+  const schema = resolveDefaultSchema(inputSchema, references), properties = getSchemaProperties(schema);
+  if (properties && value !== null && typeof value == "object")
+    for (const [key, propertySchema] of Object.entries(properties))
+      hasOwn(value, key) && (propertySchema[import_typebox.Kind] === "File" && value[key] === "File" || propertySchema[import_typebox.Kind] === "Files" && value[key] === "Files" ? delete value[key] : removeFileDefaults(propertySchema, value[key], references));
+  else if (Array.isArray(value) && schema.items && !Array.isArray(schema.items))
+    for (const item of value) removeFileDefaults(schema.items, item, references);
+}, mergeDefaultResult = (original, defaulted) => {
+  if (Array.isArray(defaulted)) {
+    const target2 = Array.isArray(original) ? original : [];
+    target2.length = defaulted.length;
+    for (let i = 0; i < defaulted.length; i++)
+      target2[i] = mergeDefaultResult(
+        Array.isArray(original) ? original[i] : void 0,
+        defaulted[i]
+      );
+    return target2;
+  }
+  if (defaulted === null || typeof defaulted != "object" || defaulted instanceof Date || defaulted instanceof Map || defaulted instanceof Set || defaulted instanceof ArrayBuffer || ArrayBuffer.isView(defaulted))
+    return defaulted;
+  const target = original !== null && typeof original == "object" && !Array.isArray(original) ? original : {};
+  for (const key of Object.getOwnPropertyNames(defaulted))
+    Object.defineProperty(target, key, {
+      value: mergeDefaultResult(
+        hasOwn(target, key) ? target[key] : void 0,
+        defaulted[key]
+      ),
+      enumerable: Object.prototype.propertyIsEnumerable.call(defaulted, key),
+      configurable: !0,
+      writable: !0
+    });
+  for (const key of Object.getOwnPropertySymbols(defaulted))
+    Object.defineProperty(target, key, {
+      value: mergeDefaultResult(
+        hasOwn(target, key) ? target[key] : void 0,
+        defaulted[key]
+      ),
+      enumerable: Object.prototype.propertyIsEnumerable.call(defaulted, key),
+      configurable: !0,
+      writable: !0
+    });
+  return target;
+}, applySchemaDefaults = (checker, value, nullish = !1) => {
+  const schema = checker.schema;
+  if (!schema) return value;
+  const references = typeof checker.References == "function" ? checker.References() : Object.values(schema.$defs ?? {}), functionDefaults = /* @__PURE__ */ new Map(), prepared = prepareDefaultInput(
+    schema,
+    value,
+    references,
+    nullish,
+    !0,
+    functionDefaults
+  );
+  return withResolvedFunctionDefaults(functionDefaults, () => {
+    const defaulted = repairPrototypeDefaults(
+      schema,
+      restoreArrayBuffers(
+        schema,
+        prepared,
+        import_value.Value.Default(
+          schema,
+          references,
+          cloneForDefaults(prepared)
+        ),
+        references
+      ),
+      references,
+      nullish
+    );
+    return removeFileDefaults(schema, defaulted, references), mergeDefaultResult(value, defaulted);
+  });
 }, mergeObjectSchemas = (schemas) => {
   if (schemas.length === 0)
     return {
@@ -822,6 +1174,8 @@ const isOptional = (schema) => schema ? schema?.[import_typebox.Kind] === "Impor
 }, unwrapImportSchema = (schema) => schema && schema[import_typebox.Kind] === "Import" && schema.$defs[schema.$ref][import_typebox.Kind] === "Object" ? schema.$defs[schema.$ref] : schema;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  applySchemaDefaults,
+  cloneSchemaInput,
   getCookieValidator,
   getResponseSchemaValidator,
   getSchemaProperties,