@sinclair/typebox 0.32.0-dev-26 → 0.32.0-dev-28

package/build/require/type/constructor/constructor.js

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Constructor = void 0;
-const index_1 = require("../symbols/index");
 const type_1 = require("../clone/type");
+const index_1 = require("../symbols/index");
 /** `[JavaScript]` Creates a Constructor type */
 function Constructor(parameters, returns, options) {
     return {

package/build/require/type/deref/deref.js

@@ -8,7 +8,6 @@ const value_1 = require("../guard/value");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 const type_2 = require("../guard/type");
 function FromRest(schema, references) {
     return schema.map((schema) => Deref(schema, references));

package/build/require/type/discard/discard.js

@@ -2,11 +2,11 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Discard = void 0;
-function Key(value, key) {
+function DiscardKey(value, key) {
     const { [key]: _, ...rest } = value;
     return rest;
 }
 function Discard(value, keys) {
-    return keys.reduce((acc, key) => Key(acc, key), value);
+    return keys.reduce((acc, key) => DiscardKey(acc, key), value);
 }
 exports.Discard = Discard;

package/build/require/type/enum/enum.js

@@ -5,6 +5,9 @@ exports.Enum = void 0;
 const index_1 = require("../literal/index");
 const index_2 = require("../symbols/index");
 const index_3 = require("../union/index");
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
 const value_1 = require("../guard/value");
 /** `[Json]` Creates a Enum type */
 function Enum(item, options = {}) {

package/build/require/type/exclude/exclude-from-mapped-result.d.ts

@@ -2,10 +2,10 @@ import type { TSchema, SchemaOptions } from '../schema/index';
 import type { TProperties } from '../object/index';
 import { type TMappedResult } from '../mapped/index';
 import { type TExclude } from './exclude';
-type TFromProperties<K extends TProperties, U extends TSchema> = ({
-    [K2 in keyof K]: TExclude<K[K2], U>;
+type TFromProperties<K extends TProperties, T extends TSchema> = ({
+    [K2 in keyof K]: TExclude<K[K2], T>;
 });
-type TFromMappedResult<K extends TMappedResult, U extends TSchema> = (TFromProperties<K['properties'], U>);
-export type TExcludeFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = TFromMappedResult<T, U>> = (TMappedResult<P>);
-export declare function ExcludeFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = TFromMappedResult<T, U>>(T: T, U: U, options: SchemaOptions): TMappedResult<P>;
+type TFromMappedResult<R extends TMappedResult, T extends TSchema> = (TFromProperties<R['properties'], T>);
+export type TExcludeFromMappedResult<R extends TMappedResult, T extends TSchema, P extends TProperties = TFromMappedResult<R, T>> = (TMappedResult<P>);
+export declare function ExcludeFromMappedResult<R extends TMappedResult, T extends TSchema, P extends TProperties = TFromMappedResult<R, T>>(R: R, T: T, options: SchemaOptions): TMappedResult<P>;
 export {};

package/build/require/type/exclude/exclude-from-mapped-result.js

@@ -5,18 +5,18 @@ exports.ExcludeFromMappedResult = void 0;
 const index_1 = require("../mapped/index");
 const exclude_1 = require("./exclude");
 // prettier-ignore
-function FromProperties(K, U, options) {
-    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: (0, exclude_1.Exclude)(K[K2], U, options) };
+function FromProperties(P, U, options) {
+    return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: (0, exclude_1.Exclude)(P[K2], U, options) };
     }, {});
 }
 // prettier-ignore
-function FromMappedResult(K, U, options) {
-    return FromProperties(K.properties, U, options);
+function FromMappedResult(R, T, options) {
+    return FromProperties(R.properties, T, options);
 }
 // prettier-ignore
-function ExcludeFromMappedResult(T, U, options) {
-    const P = FromMappedResult(T, U, options);
+function ExcludeFromMappedResult(R, T, options) {
+    const P = FromMappedResult(R, T, options);
     return (0, index_1.MappedResult)(P);
 }
 exports.ExcludeFromMappedResult = ExcludeFromMappedResult;

package/build/require/type/exclude/exclude.js

@@ -11,7 +11,6 @@ const exclude_from_mapped_result_1 = require("./exclude-from-mapped-result");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 const type_2 = require("../guard/type");
 // prettier-ignore
 function ExcludeResolve(L, R) {