typebox 0.0.1 → 1.0.0-rc

package/build/type/types/void.mjs

@@ -0,0 +1,17 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { IsKind } from './schema.mjs';
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Void type. */
+export function Void(options) {
+    return Memory.Create({ '~kind': 'Void' }, { type: 'void' }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TVoid. */
+export function IsVoid(value) {
+    return IsKind(value, 'Void');
+}

package/build/typebox.d.mts

@@ -0,0 +1,71 @@
+export { Instantiate, type TInstantiate } from './type/engine/instantiate.mjs';
+export { Extends, ExtendsResult, type TExtends } from './type/extends/index.mjs';
+export { Script, type TScript } from './type/script/index.mjs';
+export { Awaited, type AwaitedDeferred, type TAwaited } from './type/action/awaited.mjs';
+export { Capitalize, type TCapitalize, type TCapitalizeDeferred } from './type/action/capitalize.mjs';
+export { Conditional, type TConditional, type TConditionalDeferred } from './type/action/conditional.mjs';
+export { ConstructorParameters, type TConstructorParameters, type TConstructorParametersDeferred } from './type/action/constructor-parameters.mjs';
+export { Evaluate, type TEvaluate, type TEvaluateDeferred } from './type/action/evaluate.mjs';
+export { Exclude, type TExclude, type TExcludeDeferred } from './type/action/exclude.mjs';
+export { Extract, type TExtract, type TExtractDeferred } from './type/action/extract.mjs';
+export { Index, type TIndex, type TIndexDeferred } from './type/action/index.mjs';
+export { InstanceType, type TInstanceType, type TInstanceTypeDeferred } from './type/action/instance-type.mjs';
+export { Interface, type TInterface, type TInterfaceDeferred } from './type/action/interface.mjs';
+export { KeyOf, type TKeyOf, type TKeyOfDeferred } from './type/action/keyof.mjs';
+export { Lowercase, type TLowercase, type TLowercaseDeferred } from './type/action/lowercase.mjs';
+export { Mapped, type TMapped, type TMappedDeferred } from './type/action/mapped.mjs';
+export { Module, type TModule, type TModuleDeferred } from './type/action/module.mjs';
+export { NonNullable, type TNonNullable, type TNonNullableDeferred } from './type/action/non-nullable.mjs';
+export { Omit, type TOmit, type TOmitDeferred } from './type/action/omit.mjs';
+export { Options, type TOptions } from './type/action/options.mjs';
+export { Parameters, type TParameters, type TParametersDeferred } from './type/action/parameters.mjs';
+export { Partial, type TPartial, type TPartialDeferred } from './type/action/partial.mjs';
+export { Pick, type TPick, type TPickDeferred } from './type/action/pick.mjs';
+export { Required, type TRequired, type TRequiredDeferred } from './type/action/required.mjs';
+export { ReturnType, type TReturnType, type TReturnTypeDeferred } from './type/action/return-type.mjs';
+export { type TUncapitalize, type TUncapitalizeDeferred, Uncapitalize } from './type/action/uncapitalize.mjs';
+export { type TUppercase, type TUppercaseDeferred, Uppercase } from './type/action/uppercase.mjs';
+export { Codec, Decode, DecodeBuilder, Encode, EncodeBuilder, IsCodec, type TCodec } from './type/types/_codec.mjs';
+export { IsOptional, Optional, type TOptional } from './type/types/_optional.mjs';
+export { IsReadonly, Readonly, type TReadonly } from './type/types/_readonly.mjs';
+export { IsRefine, Refine, type TRefine, type TRefineCallback, type TRefinement } from './type/types/_refine.mjs';
+export { Any, IsAny, type TAny } from './type/types/any.mjs';
+export { Array, IsArray, type TArray } from './type/types/array.mjs';
+export { AsyncIterator, IsAsyncIterator, type TAsyncIterator } from './type/types/async-iterator.mjs';
+export { Base, IsBase } from './type/types/base.mjs';
+export { BigInt, IsBigInt, type TBigInt } from './type/types/bigint.mjs';
+export { Boolean, IsBoolean, type TBoolean } from './type/types/boolean.mjs';
+export { Call, IsCall, type TCall } from './type/types/call.mjs';
+export { Constructor, IsConstructor, type TConstructor } from './type/types/constructor.mjs';
+export { Cyclic, IsCyclic, type TCyclic } from './type/types/cyclic.mjs';
+export { Enum, IsEnum, type TEnum, type TEnumValue } from './type/types/enum.mjs';
+export { Function, IsFunction, type TFunction } from './type/types/function.mjs';
+export { Generic, IsGeneric, type TGeneric } from './type/types/generic.mjs';
+export { Identifier, IsIdentifier, type TIdentifier } from './type/types/identifier.mjs';
+export { Infer, IsInfer, type TInfer } from './type/types/infer.mjs';
+export { Integer, IsInteger, type TInteger } from './type/types/integer.mjs';
+export { Intersect, IsIntersect, type TIntersect } from './type/types/intersect.mjs';
+export { IsIterator, Iterator, type TIterator } from './type/types/iterator.mjs';
+export { IsLiteral, Literal, type TLiteral, type TLiteralValue } from './type/types/literal.mjs';
+export { IsNever, Never, type TNever } from './type/types/never.mjs';
+export { IsNull, Null, type TNull } from './type/types/null.mjs';
+export { IsNumber, Number, type TNumber } from './type/types/number.mjs';
+export { IsObject, Object, type TObject } from './type/types/object.mjs';
+export { IsParameter, Parameter, type TParameter } from './type/types/parameter.mjs';
+export { IsPromise, Promise, type TPromise } from './type/types/promise.mjs';
+export { type TProperties, type TRequiredArray } from './type/types/properties.mjs';
+export { IsRecord, Record, RecordKey, RecordPattern as RecordKeyAsPattern, RecordValue, type TRecord, type TRecordKey as TRecordKey, type TRecordPattern as TRecordKeyAsPattern, type TRecordValue } from './type/types/record.mjs';
+export { IsRef, Ref, type TRef } from './type/types/ref.mjs';
+export { IsRest, Rest, type TRest } from './type/types/rest.mjs';
+export { IsKind, IsSchema, type TArrayOptions, type TFormat, type TIntersectOptions, type TNumberOptions, type TObjectOptions, type TSchema, type TSchemaOptions, type TStringOptions, type TTupleOptions } from './type/types/schema.mjs';
+export { type Static } from './type/types/static.mjs';
+export { IsString, String, type TString } from './type/types/string.mjs';
+export { IsSymbol, Symbol, type TSymbol } from './type/types/symbol.mjs';
+export { IsTemplateLiteral, TemplateLiteral, type TTemplateLiteral } from './type/types/template-literal.mjs';
+export { IsThis, This, type TThis } from './type/types/this.mjs';
+export { IsTuple, type TTuple, Tuple } from './type/types/tuple.mjs';
+export { IsUndefined, type TUndefined, Undefined } from './type/types/undefined.mjs';
+export { IsUnion, type TUnion, Union } from './type/types/union.mjs';
+export { IsUnknown, type TUnknown, Unknown } from './type/types/unknown.mjs';
+export { IsUnsafe, type TUnsafe, Unsafe } from './type/types/unsafe.mjs';
+export { IsVoid, type TVoid, Void } from './type/types/void.mjs';

package/build/typebox.mjs

@@ -0,0 +1,87 @@
+// ------------------------------------------------------------------
+// Engine
+// ------------------------------------------------------------------
+export { Instantiate } from './type/engine/instantiate.mjs';
+// ------------------------------------------------------------------
+// Extends
+// ------------------------------------------------------------------
+export { Extends, ExtendsResult } from './type/extends/index.mjs';
+// ------------------------------------------------------------------
+// Script
+// ------------------------------------------------------------------
+export { Script } from './type/script/index.mjs';
+// ------------------------------------------------------------------
+// Actions
+// ------------------------------------------------------------------
+export { Awaited } from './type/action/awaited.mjs';
+export { Capitalize } from './type/action/capitalize.mjs';
+export { Conditional } from './type/action/conditional.mjs';
+export { ConstructorParameters } from './type/action/constructor-parameters.mjs';
+export { Evaluate } from './type/action/evaluate.mjs';
+export { Exclude } from './type/action/exclude.mjs';
+export { Extract } from './type/action/extract.mjs';
+export { Index } from './type/action/index.mjs';
+export { InstanceType } from './type/action/instance-type.mjs';
+export { Interface } from './type/action/interface.mjs';
+export { KeyOf } from './type/action/keyof.mjs';
+export { Lowercase } from './type/action/lowercase.mjs';
+export { Mapped } from './type/action/mapped.mjs';
+export { Module } from './type/action/module.mjs';
+export { NonNullable } from './type/action/non-nullable.mjs';
+export { Omit } from './type/action/omit.mjs';
+export { Options } from './type/action/options.mjs';
+export { Parameters } from './type/action/parameters.mjs';
+export { Partial } from './type/action/partial.mjs';
+export { Pick } from './type/action/pick.mjs';
+export { Required } from './type/action/required.mjs';
+export { ReturnType } from './type/action/return-type.mjs';
+export { Uncapitalize } from './type/action/uncapitalize.mjs';
+export { Uppercase } from './type/action/uppercase.mjs';
+// ------------------------------------------------------------------
+// Extension
+// ------------------------------------------------------------------
+export { Codec, Decode, DecodeBuilder, Encode, EncodeBuilder, IsCodec } from './type/types/_codec.mjs';
+export { IsOptional, Optional } from './type/types/_optional.mjs';
+export { IsReadonly, Readonly } from './type/types/_readonly.mjs';
+export { IsRefine, Refine } from './type/types/_refine.mjs';
+// ------------------------------------------------------------------
+// Standard
+// ------------------------------------------------------------------
+export { Any, IsAny } from './type/types/any.mjs';
+export { Array, IsArray } from './type/types/array.mjs';
+export { AsyncIterator, IsAsyncIterator } from './type/types/async-iterator.mjs';
+export { Base, IsBase } from './type/types/base.mjs';
+export { BigInt, IsBigInt } from './type/types/bigint.mjs';
+export { Boolean, IsBoolean } from './type/types/boolean.mjs';
+export { Call, IsCall } from './type/types/call.mjs';
+export { Constructor, IsConstructor } from './type/types/constructor.mjs';
+export { Cyclic, IsCyclic } from './type/types/cyclic.mjs';
+export { Enum, IsEnum } from './type/types/enum.mjs';
+export { Function, IsFunction } from './type/types/function.mjs';
+export { Generic, IsGeneric } from './type/types/generic.mjs';
+export { Identifier, IsIdentifier } from './type/types/identifier.mjs';
+export { Infer, IsInfer } from './type/types/infer.mjs';
+export { Integer, IsInteger } from './type/types/integer.mjs';
+export { Intersect, IsIntersect } from './type/types/intersect.mjs';
+export { IsIterator, Iterator } from './type/types/iterator.mjs';
+export { IsLiteral, Literal } from './type/types/literal.mjs';
+export { IsNever, Never } from './type/types/never.mjs';
+export { IsNull, Null } from './type/types/null.mjs';
+export { IsNumber, Number } from './type/types/number.mjs';
+export { IsObject, Object } from './type/types/object.mjs';
+export { IsParameter, Parameter } from './type/types/parameter.mjs';
+export { IsPromise, Promise } from './type/types/promise.mjs';
+export { IsRecord, Record, RecordKey, RecordPattern as RecordKeyAsPattern, RecordValue } from './type/types/record.mjs';
+export { IsRef, Ref } from './type/types/ref.mjs';
+export { IsRest, Rest } from './type/types/rest.mjs';
+export { IsKind, IsSchema } from './type/types/schema.mjs';
+export { IsString, String } from './type/types/string.mjs';
+export { IsSymbol, Symbol } from './type/types/symbol.mjs';
+export { IsTemplateLiteral, TemplateLiteral } from './type/types/template-literal.mjs';
+export { IsThis, This } from './type/types/this.mjs';
+export { IsTuple, Tuple } from './type/types/tuple.mjs';
+export { IsUndefined, Undefined } from './type/types/undefined.mjs';
+export { IsUnion, Union } from './type/types/union.mjs';
+export { IsUnknown, Unknown } from './type/types/unknown.mjs';
+export { IsUnsafe, Unsafe } from './type/types/unsafe.mjs';
+export { IsVoid, Void } from './type/types/void.mjs';

package/build/value/assert/assert.d.mts

@@ -0,0 +1,8 @@
+import type { Static, TProperties, TSchema } from '../../type/index.mjs';
+export declare class AssertError extends Error {
+    constructor(source: string, value: unknown, errors: object[]);
+}
+/** Asserts the a value matches the given type. This function returns a TypeScript type asserts predicate and will throw AssertError if value does not match. */
+export declare function Assert<Context extends TProperties, const Type extends TSchema, Result extends unknown = Static<Type, Context>>(context: Context, type: Type, value: unknown): asserts value is Result;
+/** Asserts the a value matches the given type. This function returns a TypeScript type asserts predicate and will throw AssertError if value does not match. */
+export declare function Assert<const Type extends TSchema, Result extends unknown = Static<Type>>(type: TSchema, value: unknown): asserts value is Result;

package/build/value/assert/assert.mjs

@@ -0,0 +1,27 @@
+import { Arguments } from '../../system/arguments/index.mjs';
+import { Check } from '../check/index.mjs';
+import { Errors } from '../errors/index.mjs';
+// ------------------------------------------------------------------
+// AssertError
+// ------------------------------------------------------------------
+export class AssertError extends Error {
+    constructor(source, value, errors) {
+        super(source);
+        Object.defineProperty(this, 'cause', {
+            value: { source, errors, value },
+            writable: false,
+            configurable: false,
+            enumerable: false
+        });
+    }
+}
+/** Asserts the a value matches the given type. This function returns a TypeScript type asserts predicate and will throw AssertError if value does not match. */
+export function Assert(...args) {
+    const [context, type, value] = Arguments.Match(args, {
+        3: (context, type, value) => [context, type, value],
+        2: (type, value) => [{}, type, value]
+    });
+    const check = Check(context, type, value);
+    if (!check)
+        throw new AssertError('Assert', value, Errors(context, type, value));
+}

package/build/value/assert/index.d.mts

@@ -0,0 +1 @@
+export * from './assert.mjs';

package/build/value/assert/index.mjs

@@ -0,0 +1 @@
+export * from './assert.mjs';

package/build/value/check/check.d.mts

@@ -0,0 +1,5 @@
+import type { Static, TProperties, TSchema } from '../../type/index.mjs';
+/** Checks a value matches the provided type. This function returns a TypeScript type predicate and does not throw. */
+export declare function Check<const Type extends TSchema, Result extends unknown = Static<Type>>(type: Type, value: unknown): value is Result;
+/** Checks a value matches the provided type. This function returns a TypeScript type predicate and does not throw. */
+export declare function Check<Context extends TProperties, const Type extends TSchema, Result extends unknown = Static<Type, Context>>(context: Context, type: Type, value: unknown): value is Result;

package/build/value/check/check.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Arguments } from '../../system/arguments/index.mjs';
+import { Check as SchemaCheck } from '../../schema/index.mjs';
+/** Checks a value matches the provided type. This function returns a TypeScript type predicate and does not throw. */
+export function Check(...args) {
+    const [context, type, value] = Arguments.Match(args, {
+        3: (context, type, value) => [context, type, value],
+        2: (type, value) => [{}, type, value]
+    });
+    return SchemaCheck(context, type, value);
+}

package/build/value/check/index.d.mts

@@ -0,0 +1 @@
+export * from './check.mjs';

package/build/value/check/index.mjs

@@ -0,0 +1 @@
+export * from './check.mjs';

package/build/value/clean/additional.d.mts

@@ -0,0 +1,2 @@
+import { type TSchema } from '../../type/index.mjs';
+export declare function GetAdditionalProperties(type: TSchema): TSchema | boolean | undefined;

package/build/value/clean/additional.mjs

@@ -0,0 +1,6 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+export function GetAdditionalProperties(type) {
+    const additionalProperties = Guard.HasPropertyKey(type, 'additionalProperties') ? type.additionalProperties : undefined;
+    return additionalProperties;
+}

package/build/value/clean/clean.d.mts

@@ -0,0 +1,15 @@
+import type { TProperties, TSchema } from '../../type/index.mjs';
+/**
+ * Cleans a value by removing non-evaluated properties and elements as derived from the provided type.
+ * This function returns unknown so callers should Check the return value before use. This function
+ * mutates the provided value. If mutation is not wanted, you should Clone the value before passing
+ * to this function.
+ */
+export declare function Clean(type: TSchema, value: unknown): unknown;
+/**
+ * Cleans a value by removing non-evaluated properties and elements as derived from the provided type.
+ * This function returns unknown so callers should Check the return value before use. This function
+ * mutates the provided value. If mutation is not wanted, you should Clone the value before passing
+ * to this function.
+ */
+export declare function Clean(context: TProperties, type: TSchema, value: unknown): unknown;

package/build/value/clean/clean.mjs

@@ -0,0 +1,15 @@
+import { Arguments } from '../../system/arguments/index.mjs';
+import { FromType } from './from-type.mjs';
+/**
+ * Cleans a value by removing non-evaluated properties and elements as derived from the provided type.
+ * This function returns unknown so callers should Check the return value before use. This function
+ * mutates the provided value. If mutation is not wanted, you should Clone the value before passing
+ * to this function.
+ */
+export function Clean(...args) {
+    const [context, type, value] = Arguments.Match(args, {
+        3: (context, type, value) => [context, type, value],
+        2: (type, value) => [{}, type, value]
+    });
+    return FromType(context, type, value);
+}

package/build/value/clean/from-array.d.mts

@@ -0,0 +1,2 @@
+import type { TProperties, TArray } from '../../type/index.mjs';
+export declare function FromArray(context: TProperties, type: TArray, value: unknown): unknown;

package/build/value/clean/from-array.mjs

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { FromType } from './from-type.mjs';
+export function FromArray(context, type, value) {
+    if (!Guard.IsArray(value))
+        return value;
+    return value.map((value) => FromType(context, type.items, value));
+}

package/build/value/clean/from-base.d.mts

@@ -0,0 +1,2 @@
+import type { TProperties, Base } from '../../type/index.mjs';
+export declare function FromBase(context: TProperties, type: Base, value: unknown): unknown;

package/build/value/clean/from-base.mjs

@@ -0,0 +1,4 @@
+// deno-fmt-ignore-file
+export function FromBase(context, type, value) {
+    return type.Clean(value);
+}

package/build/value/clean/from-cyclic.d.mts

@@ -0,0 +1,2 @@
+import { type TProperties, TCyclic } from '../../type/index.mjs';
+export declare function FromCyclic(context: TProperties, type: TCyclic, value: unknown): unknown;

package/build/value/clean/from-cyclic.mjs

@@ -0,0 +1,6 @@
+// deno-fmt-ignore-file
+import { Ref } from '../../type/index.mjs';
+import { FromType } from './from-type.mjs';
+export function FromCyclic(context, type, value) {
+    return FromType({ ...context, ...type.$defs }, Ref(type.$ref), value);
+}

package/build/value/clean/from-intersect.d.mts

@@ -0,0 +1,2 @@
+import { type TProperties, type TIntersect } from '../../type/index.mjs';
+export declare function FromIntersect(context: TProperties, type: TIntersect, value: unknown): unknown;

package/build/value/clean/from-intersect.mjs

@@ -0,0 +1,25 @@
+// deno-fmt-ignore-file
+import { Evaluate, IsObject, Options } from '../../type/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { FromType } from './from-type.mjs';
+// ------------------------------------------------------------------
+// EvaluateIntersection
+// ------------------------------------------------------------------
+function EvaluateIntersection(type) {
+    // Note: reinterpret unevaluatedProperties as additionalProperties
+    const additionalProperties = Guard.HasPropertyKey(type, 'unevaluatedProperties')
+        ? { additionalProperties: type.unevaluatedProperties }
+        : {};
+    const evaluated = Evaluate(type);
+    return IsObject(evaluated)
+        ? Options(evaluated, additionalProperties)
+        : evaluated;
+}
+// ------------------------------------------------------------------
+// FromIntersection
+// ------------------------------------------------------------------
+export function FromIntersect(context, type, value) {
+    // Note: Evaluate and route back to FromType in evaluated form (likely an Object)
+    const evaluated = EvaluateIntersection(type);
+    return FromType(context, evaluated, value);
+}

package/build/value/clean/from-object.d.mts

@@ -0,0 +1,2 @@
+import { type TProperties, type TObject } from '../../type/index.mjs';
+export declare function FromObject(context: TProperties, type: TObject, value: unknown): unknown;

package/build/value/clean/from-object.mjs

@@ -0,0 +1,31 @@
+// deno-fmt-ignore-file
+import { IsSchema } from '../../type/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { FromType } from './from-type.mjs';
+import { Check } from '../check/index.mjs';
+import { GetAdditionalProperties } from './additional.mjs';
+// ------------------------------------------------------------------
+// FromObject
+// ------------------------------------------------------------------
+export function FromObject(context, type, value) {
+    if (!Guard.IsObject(value) || Guard.IsArray(value))
+        return value;
+    const additionalProperties = GetAdditionalProperties(type);
+    for (const key of Guard.Keys(value)) {
+        if (Guard.HasPropertyKey(type.properties, key)) {
+            value[key] = FromType(context, type.properties[key], value[key]);
+            continue;
+        }
+        const unknownCheck = 
+        // 1. additionalProperties: true
+        (Guard.IsBoolean(additionalProperties) && Guard.IsEqual(additionalProperties, true))
+            // 2. additionalProperties: TSchema
+            || IsSchema(additionalProperties) && Check(context, additionalProperties, value[key]);
+        if (unknownCheck) {
+            value[key] = FromType(context, additionalProperties, value[key]);
+            continue;
+        }
+        delete value[key];
+    }
+    return value;
+}

package/build/value/clean/from-record.d.mts

@@ -0,0 +1,2 @@
+import { type TProperties, type TRecord } from '../../type/index.mjs';
+export declare function FromRecord(context: TProperties, type: TRecord, value: unknown): unknown;

package/build/value/clean/from-record.mjs

@@ -0,0 +1,32 @@
+// deno-fmt-ignore-file
+import { IsSchema, RecordPattern, RecordValue } from '../../type/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { FromType } from './from-type.mjs';
+import { Check } from '../check/index.mjs';
+import { GetAdditionalProperties } from './additional.mjs';
+// ------------------------------------------------------------------
+// FromRecord
+// ------------------------------------------------------------------
+export function FromRecord(context, type, value) {
+    if (!Guard.IsObject(value))
+        return value;
+    const additionalProperties = GetAdditionalProperties(type);
+    const [recordPattern, recordValue] = [new RegExp(RecordPattern(type)), RecordValue(type)];
+    for (const key of Guard.Keys(value)) {
+        if (recordPattern.test(key)) {
+            value[key] = FromType(context, recordValue, value[key]);
+            continue;
+        }
+        const unknownCheck = 
+        // 1. additionalProperties: true
+        (Guard.IsBoolean(additionalProperties) && Guard.IsEqual(additionalProperties, true))
+            // 2. additionalProperties: TSchema
+            || IsSchema(additionalProperties) && Check(context, additionalProperties, value[key]);
+        if (unknownCheck) {
+            value[key] = FromType(context, additionalProperties, value[key]);
+            continue;
+        }
+        delete value[key];
+    }
+    return value;
+}

package/build/value/clean/from-ref.d.mts

@@ -0,0 +1,2 @@
+import type { TProperties, TRef } from '../../type/index.mjs';
+export declare function FromRef(context: TProperties, type: TRef, value: unknown): unknown;

package/build/value/clean/from-ref.mjs

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { FromType } from './from-type.mjs';
+export function FromRef(context, type, value) {
+    return Guard.HasPropertyKey(context, type.$ref)
+        ? FromType(context, context[type.$ref], value)
+        : value;
+}

package/build/value/clean/from-tuple.d.mts

@@ -0,0 +1,2 @@
+import type { TProperties, TTuple } from '../../type/index.mjs';
+export declare function FromTuple(context: TProperties, schema: TTuple, value: unknown): unknown;

package/build/value/clean/from-tuple.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { FromType } from './from-type.mjs';
+export function FromTuple(context, schema, value) {
+    if (!Guard.IsArray(value))
+        return value;
+    const length = Math.min(value.length, schema.items.length);
+    for (let index = 0; index < length; index++) {
+        value[index] = FromType(context, schema.items[index], value[index]);
+    }
+    return Guard.IsGreaterThan(value.length, length)
+        ? value.slice(0, length)
+        : value;
+}

package/build/value/clean/from-type.d.mts

@@ -0,0 +1,2 @@
+import * as T from '../../type/index.mjs';
+export declare function FromType(context: T.TProperties, type: T.TSchema, value: unknown): unknown;

package/build/value/clean/from-type.mjs

@@ -0,0 +1,23 @@
+// deno-fmt-ignore-file
+import * as T from '../../type/index.mjs';
+import { FromArray } from './from-array.mjs';
+import { FromBase } from './from-base.mjs';
+import { FromCyclic } from './from-cyclic.mjs';
+import { FromIntersect } from './from-intersect.mjs';
+import { FromObject } from './from-object.mjs';
+import { FromRecord } from './from-record.mjs';
+import { FromRef } from './from-ref.mjs';
+import { FromTuple } from './from-tuple.mjs';
+import { FromUnion } from './from-union.mjs';
+export function FromType(context, type, value) {
+    return (T.IsArray(type) ? FromArray(context, type, value) :
+        T.IsBase(type) ? FromBase(context, type, value) :
+            T.IsCyclic(type) ? FromCyclic(context, type, value) :
+                T.IsIntersect(type) ? FromIntersect(context, type, value) :
+                    T.IsObject(type) ? FromObject(context, type, value) :
+                        T.IsRecord(type) ? FromRecord(context, type, value) :
+                            T.IsRef(type) ? FromRef(context, type, value) :
+                                T.IsTuple(type) ? FromTuple(context, type, value) :
+                                    T.IsUnion(type) ? FromUnion(context, type, value) :
+                                        value);
+}

package/build/value/clean/from-union.d.mts

@@ -0,0 +1,2 @@
+import type { TProperties, TUnion } from '../../type/index.mjs';
+export declare function FromUnion(context: TProperties, type: TUnion, value: unknown): unknown;

package/build/value/clean/from-union.mjs

@@ -0,0 +1,12 @@
+// deno-fmt-ignore-file
+import { Check } from '../check/index.mjs';
+import { Clone } from '../clone/index.mjs';
+import { FromType } from './from-type.mjs';
+export function FromUnion(context, type, value) {
+    for (const schema of type.anyOf) {
+        const clean = FromType(context, schema, Clone(value));
+        if (Check(context, type, clean))
+            return clean;
+    }
+    return value;
+}

package/build/value/clean/index.d.mts

@@ -0,0 +1 @@
+export * from './clean.mjs';

package/build/value/clean/index.mjs

@@ -0,0 +1 @@
+export * from './clean.mjs';

package/build/value/clone/clone.d.mts

@@ -0,0 +1,5 @@
+/**
+ * Returns a Clone of the given value. This function is similar to structuredClone()
+ * but also supports deep cloning instances of Map, Set and TypeArray.
+ */
+export declare function Clone<Value extends unknown>(value: Value): Value;

package/build/value/clone/clone.mjs

@@ -0,0 +1,60 @@
+// deno-fmt-ignore-file
+import { Guard, GlobalsGuard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Object
+// ------------------------------------------------------------------
+function FromObject(value) {
+    const result = {};
+    for (const key of Object.getOwnPropertyNames(value)) {
+        result[key] = Clone(value[key]);
+    }
+    for (const key of Object.getOwnPropertySymbols(value)) {
+        result[key] = Clone(value[key]);
+    }
+    return result;
+}
+// ------------------------------------------------------------------
+// Array
+// ------------------------------------------------------------------
+function FromArray(value) {
+    return value.map((element) => Clone(element));
+}
+// ------------------------------------------------------------------
+// TypeArray
+// ------------------------------------------------------------------
+function FromTypedArray(value) {
+    return value.slice();
+}
+// ------------------------------------------------------------------
+// Map
+// ------------------------------------------------------------------
+function FromMap(value) {
+    return new Map(Clone([...value.entries()]));
+}
+// ------------------------------------------------------------------
+// Set
+// ------------------------------------------------------------------
+function FromSet(value) {
+    return new Set(Clone([...value.values()]));
+}
+// ------------------------------------------------------------------
+// Value
+// ------------------------------------------------------------------
+function FromValue(value) {
+    return value;
+}
+// ------------------------------------------------------------------
+// Clone
+// ------------------------------------------------------------------
+/**
+ * Returns a Clone of the given value. This function is similar to structuredClone()
+ * but also supports deep cloning instances of Map, Set and TypeArray.
+ */
+export function Clone(value) {
+    return (GlobalsGuard.IsTypeArray(value) ? FromTypedArray(value) :
+        GlobalsGuard.IsMap(value) ? FromMap(value) :
+            GlobalsGuard.IsSet(value) ? FromSet(value) :
+                Guard.IsArray(value) ? FromArray(value) :
+                    Guard.IsObject(value) ? FromObject(value) :
+                        FromValue(value));
+}

package/build/value/clone/index.d.mts

@@ -0,0 +1 @@
+export * from './clone.mjs';

package/build/value/clone/index.mjs

@@ -0,0 +1 @@
+export * from './clone.mjs';

package/build/value/codec/callback.d.mts

@@ -0,0 +1,2 @@
+import { type TProperties, type TSchema } from '../../type/index.mjs';
+export declare function Callback(direction: string, context: TProperties, type: TSchema, value: unknown): unknown;