typebox 0.0.1 → 1.0.0-rc

package/build/value/convert/try/try-number.mjs

@@ -0,0 +1,76 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { Ok, Fail, IsOk } from './try-result.mjs';
+// ------------------------------------------------------------------
+// Two-Phase
+// ------------------------------------------------------------------
+import { TryBigInt } from './try-bigint.mjs';
+// ------------------------------------------------------------------
+// BigInt
+// ------------------------------------------------------------------
+const maxBigInt = BigInt(Number.MAX_SAFE_INTEGER);
+const minBigInt = BigInt(Number.MIN_SAFE_INTEGER);
+function CanBigIntDowncast(value) {
+    return (value <= maxBigInt && value >= minBigInt);
+}
+function FromBigInt(value) {
+    return CanBigIntDowncast(value) ? Ok(Number(value)) : Fail();
+}
+// ------------------------------------------------------------------
+// Boolean
+// ------------------------------------------------------------------
+function FromBoolean(value) {
+    return value ? Ok(1) : Ok(0);
+}
+// ------------------------------------------------------------------
+// Number
+// ------------------------------------------------------------------
+// deno-coverage-ignore-start - unreachable | guarded
+function FromNumber(value) {
+    return Ok(value);
+}
+// deno-coverage-ignore-stop
+// ------------------------------------------------------------------
+// Null
+// ------------------------------------------------------------------
+function FromNull(value) {
+    return Ok(0);
+}
+// ------------------------------------------------------------------
+// String
+// ------------------------------------------------------------------
+function FromString(value) {
+    const coerced = +value;
+    if (Guard.IsNumber(coerced))
+        return Ok(coerced);
+    const lowercase = value.toLowerCase();
+    if (Guard.IsEqual(lowercase, 'false'))
+        return Ok(0);
+    if (Guard.IsEqual(lowercase, 'true'))
+        return Ok(1);
+    const result = TryBigInt(value);
+    if (IsOk(result))
+        return FromBigInt(result.value);
+    return Fail();
+}
+// ------------------------------------------------------------------
+// Undefined
+// ------------------------------------------------------------------
+function FromUndefined(value) {
+    return Ok(0);
+}
+// ------------------------------------------------------------------
+// Try
+// ------------------------------------------------------------------
+// deno-coverage-ignore-start - unreachable | guarded
+export function TryNumber(value) {
+    return (Guard.IsBigInt(value) ? FromBigInt(value) :
+        Guard.IsBoolean(value) ? FromBoolean(value) :
+            Guard.IsNumber(value) ? FromNumber(value) :
+                Guard.IsNull(value) ? FromNull(value) :
+                    Guard.IsString(value) ? FromString(value) :
+                        Guard.IsUndefined(value) ? FromUndefined(value) :
+                            Fail());
+}
+// deno-coverage-ignore-stop

package/build/value/convert/try/try-result.d.mts

@@ -0,0 +1,8 @@
+export type TResult<Value extends unknown = unknown> = TOk<Value> | TFail;
+export type TFail = undefined;
+export type TOk<Value extends unknown = unknown> = {
+    value: Value;
+};
+export declare function IsOk<Result extends TResult>(value: Result): value is Exclude<Result, TFail>;
+export declare function Ok<Value extends unknown>(value: Value): TOk<Value>;
+export declare function Fail(): undefined;

package/build/value/convert/try/try-result.mjs

@@ -0,0 +1,18 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+export function IsOk(value) {
+    return Guard.IsObject(value) && Guard.HasPropertyKey(value, 'value');
+}
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+export function Ok(value) {
+    return { value };
+}
+export function Fail() {
+    return undefined;
+}

package/build/value/convert/try/try-string.d.mts

@@ -0,0 +1,2 @@
+import { TResult } from './try-result.mjs';
+export declare function TryString(value: unknown): TResult;

package/build/value/convert/try/try-string.mjs

@@ -0,0 +1,56 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { Ok, Fail } from './try-result.mjs';
+// ------------------------------------------------------------------
+// BigInt
+// ------------------------------------------------------------------
+function FromBigInt(value) {
+    return Ok(value.toString());
+}
+// ------------------------------------------------------------------
+// Boolean
+// ------------------------------------------------------------------
+function FromBoolean(value) {
+    return Ok(value.toString());
+}
+// ------------------------------------------------------------------
+// Number
+// ------------------------------------------------------------------
+function FromNumber(value) {
+    return Ok(value.toString());
+}
+// ------------------------------------------------------------------
+// Null
+// ------------------------------------------------------------------
+function FromNull(value) {
+    return Ok('null');
+}
+// ------------------------------------------------------------------
+// String
+// ------------------------------------------------------------------
+// deno-coverage-ignore-start - unreachable | guarded
+function FromString(value) {
+    return Ok(value);
+}
+// deno-coverage-ignore-stop
+// ------------------------------------------------------------------
+// Undefined
+// ------------------------------------------------------------------
+function FromUndefined(value) {
+    return Ok('');
+}
+// ------------------------------------------------------------------
+// Try
+// ------------------------------------------------------------------
+// deno-coverage-ignore-start - unreachable | guarded
+export function TryString(value) {
+    return (Guard.IsBigInt(value) ? FromBigInt(value) :
+        Guard.IsBoolean(value) ? FromBoolean(value) :
+            Guard.IsNumber(value) ? FromNumber(value) :
+                Guard.IsNull(value) ? FromNull(value) :
+                    Guard.IsString(value) ? FromString(value) :
+                        Guard.IsUndefined(value) ? FromUndefined(value) :
+                            Fail());
+}
+// deno-coverage-ignore-stop

package/build/value/convert/try/try-undefined.d.mts

@@ -0,0 +1,2 @@
+import { TResult } from './try-result.mjs';
+export declare function TryUndefined(value: unknown): TResult<undefined>;

package/build/value/convert/try/try-undefined.mjs

@@ -0,0 +1,61 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { Ok, Fail } from './try-result.mjs';
+// ------------------------------------------------------------------
+// BigInt
+// ------------------------------------------------------------------
+function FromBigInt(value) {
+    return Guard.IsEqual(value, BigInt(0)) ? Ok(undefined) : Fail();
+}
+// ------------------------------------------------------------------
+// Boolean
+// ------------------------------------------------------------------
+function FromBoolean(value) {
+    return Guard.IsEqual(value, false) ? Ok(undefined) : Fail();
+}
+// ------------------------------------------------------------------
+// Number
+// ------------------------------------------------------------------
+function FromNumber(value) {
+    return Guard.IsEqual(value, 0) ? Ok(undefined) : Fail();
+}
+// ------------------------------------------------------------------
+// Null
+// ------------------------------------------------------------------
+function FromNull(value) {
+    return Ok(undefined);
+}
+// ------------------------------------------------------------------
+// String
+// ------------------------------------------------------------------
+function FromString(value) {
+    const lowercase = value.toLowerCase();
+    const predicate = Guard.IsEqual(lowercase, 'undefined')
+        || Guard.IsEqual(lowercase, 'null')
+        || Guard.IsEqual(value, '')
+        || Guard.IsEqual(value, '0');
+    return predicate ? Ok(undefined) : Fail();
+}
+// ------------------------------------------------------------------
+// Undefined
+// ------------------------------------------------------------------
+// deno-coverage-ignore-start - unreachable | guarded
+function FromUndefined(value) {
+    return Ok(undefined);
+}
+// deno-coverage-ignore-stop
+// ------------------------------------------------------------------
+// Try
+// ------------------------------------------------------------------
+// deno-coverage-ignore-start - unreachable | guarded
+export function TryUndefined(value) {
+    return (Guard.IsBigInt(value) ? FromBigInt(value) :
+        Guard.IsBoolean(value) ? FromBoolean(value) :
+            Guard.IsNumber(value) ? FromNumber(value) :
+                Guard.IsNull(value) ? FromNull(value) :
+                    Guard.IsString(value) ? FromString(value) :
+                        Guard.IsUndefined(value) ? FromUndefined(value) :
+                            Fail());
+}
+// deno-coverage-ignore-stop

package/build/value/convert/try/try.d.mts

@@ -0,0 +1,7 @@
+export * from './try-bigint.mjs';
+export * from './try-boolean.mjs';
+export * from './try-null.mjs';
+export * from './try-number.mjs';
+export * from './try-result.mjs';
+export * from './try-string.mjs';
+export * from './try-undefined.mjs';

package/build/value/convert/try/try.mjs

@@ -0,0 +1,7 @@
+export * from './try-bigint.mjs';
+export * from './try-boolean.mjs';
+export * from './try-null.mjs';
+export * from './try-number.mjs';
+export * from './try-result.mjs';
+export * from './try-string.mjs';
+export * from './try-undefined.mjs';

package/build/value/create/create.d.mts

@@ -0,0 +1,5 @@
+import type { TProperties, TSchema, Static } from '../../type/index.mjs';
+/** Creates a value from the provided type. This function will use `default` annotations if present. */
+export declare function Create<const Type extends TSchema, Result extends unknown = Static<Type>>(type: Type): Result;
+/** Creates a value from the provided type. This function will use `default` annotations if present. */
+export declare function Create<const Context extends TProperties, Type extends TSchema, Result extends unknown = Static<Type, Context>>(context: Context, type: Type): Result;

package/build/value/create/create.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Arguments } from '../../system/arguments/index.mjs';
+import { FromType } from './from-type.mjs';
+/** Creates a value from the provided type. This function will use `default` annotations if present. */
+export function Create(...args) {
+    const [context, type] = Arguments.Match(args, {
+        2: (context, type) => [context, type],
+        1: (type) => [{}, type],
+    });
+    return FromType(context, type);
+}

package/build/value/create/error.d.mts

@@ -0,0 +1,5 @@
+import type { TSchema } from '../../type/index.mjs';
+export declare class CreateError extends Error {
+    readonly type: TSchema;
+    constructor(type: TSchema, message: string);
+}

package/build/value/create/error.mjs

@@ -0,0 +1,7 @@
+// deno-fmt-ignore-file
+export class CreateError extends Error {
+    constructor(type, message) {
+        super(message);
+        this.type = type;
+    }
+}

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

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

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

@@ -0,0 +1,10 @@
+// deno-fmt-ignore-file
+import { IsUniqueItems, IsDefault, IsMinItems } from '../../schema/types/index.mjs';
+import { FromType } from './from-type.mjs';
+import { CreateError } from './error.mjs';
+export function FromArray(context, type) {
+    if (IsUniqueItems(type) && !IsDefault(type))
+        throw new CreateError(type, 'Arrays with uniqueItems constraints must specify a default annotation');
+    const length = IsMinItems(type) ? type.minItems : 0;
+    return Array.from({ length }, () => FromType(context, type.items));
+}

package/build/value/create/from-async-iterator.d.mts

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

package/build/value/create/from-async-iterator.mjs

@@ -0,0 +1,5 @@
+// deno-fmt-ignore-file
+async function* CreateAsyncIterator() { }
+export function FromAsyncIterator(context, type) {
+    return CreateAsyncIterator();
+}

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

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

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

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

package/build/value/create/from-bigint.d.mts

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

package/build/value/create/from-bigint.mjs

@@ -0,0 +1,7 @@
+// deno-fmt-ignore-file
+import { IsExclusiveMinimum, IsMinimum } from '../../schema/types/index.mjs';
+export function FromBigInt(context, type) {
+    return (IsExclusiveMinimum(type) ? BigInt(type.exclusiveMinimum) + BigInt(1) :
+        IsMinimum(type) ? BigInt(type.minimum) :
+            BigInt(0));
+}

package/build/value/create/from-boolean.d.mts

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

package/build/value/create/from-boolean.mjs

@@ -0,0 +1,4 @@
+// deno-fmt-ignore-file
+export function FromBoolean(context, type) {
+    return false;
+}

package/build/value/create/from-constructor.d.mts

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

package/build/value/create/from-constructor.mjs

@@ -0,0 +1,10 @@
+// deno-fmt-ignore-file
+import { FromType } from './from-type.mjs';
+export function FromConstructor(context, type) {
+    const instanceType = FromType(context, type.instanceType);
+    return class {
+        constructor() {
+            Object.assign(this, instanceType);
+        }
+    };
+}

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

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

package/build/value/create/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) {
+    return FromType({ ...context, ...type.$defs }, Ref(type.$ref));
+}

package/build/value/create/from-default.d.mts

@@ -0,0 +1,3 @@
+import { type TProperties } from '../../type/index.mjs';
+import { type XDefault } from '../../schema/types/index.mjs';
+export declare function FromDefault(context: TProperties, schema: XDefault): unknown;

package/build/value/create/from-default.mjs

@@ -0,0 +1,10 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { Clone } from '../clone/index.mjs';
+export function FromDefault(context, schema) {
+    return Guard.IsFunction(schema.default)
+        ? schema.default(schema)
+        : Guard.IsObject(schema.default)
+            ? Clone(schema.default)
+            : schema.default;
+}

package/build/value/create/from-enum.d.mts

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

package/build/value/create/from-enum.mjs

@@ -0,0 +1,6 @@
+// deno-fmt-ignore-file
+import { EnumToUnion } from '../../type/engine/enum/index.mjs';
+import { FromType } from './from-type.mjs';
+export function FromEnum(context, type) {
+    return FromType(context, EnumToUnion(type));
+}

package/build/value/create/from-function.d.mts

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

package/build/value/create/from-function.mjs

@@ -0,0 +1,6 @@
+// deno-fmt-ignore-file
+import { FromType } from './from-type.mjs';
+export function FromFunction(context, type) {
+    const returnType = FromType(context, type.returnType);
+    return () => returnType;
+}

package/build/value/create/from-integer.d.mts

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

package/build/value/create/from-integer.mjs

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsExclusiveMinimum, IsMinimum } from '../../schema/types/index.mjs';
+export function FromInteger(context, type) {
+    return ((IsExclusiveMinimum(type) && Guard.IsNumber(type.exclusiveMinimum)) ? type.exclusiveMinimum + 1 :
+        IsMinimum(type) ? type.minimum :
+            0);
+}

package/build/value/create/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): unknown;

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

@@ -0,0 +1,6 @@
+// deno-fmt-ignore-file
+import { Evaluate } from '../../type/index.mjs';
+import { FromType } from './from-type.mjs';
+export function FromIntersect(context, type) {
+    return FromType(context, Evaluate(type));
+}

package/build/value/create/from-iterator.d.mts

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

package/build/value/create/from-iterator.mjs

@@ -0,0 +1,5 @@
+// deno-fmt-ignore-file
+function* CreateIterator() { }
+export function FromIterator(context, type) {
+    return CreateIterator();
+}

package/build/value/create/from-literal.d.mts

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

package/build/value/create/from-literal.mjs

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

package/build/value/create/from-never.d.mts

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

package/build/value/create/from-never.mjs

@@ -0,0 +1,5 @@
+// deno-fmt-ignore-file
+import { CreateError } from './error.mjs';
+export function FromNever(context, type) {
+    throw new CreateError(type, 'Cannot create TNever types');
+}

package/build/value/create/from-null.d.mts

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

package/build/value/create/from-null.mjs

@@ -0,0 +1,4 @@
+// deno-fmt-ignore-file
+export function FromNull(context, type) {
+    return null;
+}

package/build/value/create/from-number.d.mts

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

package/build/value/create/from-number.mjs

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsExclusiveMinimum, IsMinimum } from '../../schema/types/index.mjs';
+export function FromNumber(context, type) {
+    return (IsExclusiveMinimum(type) && Guard.IsNumber(type.exclusiveMinimum) ? type.exclusiveMinimum + 1 :
+        IsMinimum(type) ? type.minimum :
+            0);
+}

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

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

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

@@ -0,0 +1,9 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { FromType } from './from-type.mjs';
+export function FromObject(context, type) {
+    const required = Guard.IsUndefined(type.required) ? [] : type.required;
+    return required.reduce((result, key) => {
+        return { ...result, [key]: FromType(context, type.properties[key]) };
+    }, {});
+}

package/build/value/create/from-promise.d.mts

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

package/build/value/create/from-promise.mjs

@@ -0,0 +1,5 @@
+// deno-fmt-ignore-file
+import { FromType } from './from-type.mjs';
+export function FromPromise(context, type) {
+    return Promise.resolve(FromType(context, type.item));
+}

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

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

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

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+import { IsMinProperties, IsDefault } from '../../schema/types/index.mjs';
+import { CreateError } from './error.mjs';
+export function FromRecord(context, type) {
+    if (IsMinProperties(type) && !IsDefault(type))
+        throw new CreateError(type, 'Record with the minProperties constraint must have a default annotation');
+    return {};
+}

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

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

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

@@ -0,0 +1,9 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { FromType } from './from-type.mjs';
+import { CreateError } from './error.mjs';
+export function FromRef(context, type) {
+    return Guard.HasPropertyKey(context, type.$ref)
+        ? FromType(context, context[type.$ref])
+        : (() => { throw new CreateError(type, 'Unable to deref Ref'); })();
+}

package/build/value/create/from-string.d.mts

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

package/build/value/create/from-string.mjs

@@ -0,0 +1,9 @@
+// deno-fmt-ignore-file
+import { IsPattern, IsFormat, IsDefault, IsMinLength } from '../../schema/types/index.mjs';
+export function FromString(context, type) {
+    const needsDefault = (IsPattern(type) || IsFormat(type)) && !IsDefault(type);
+    if (needsDefault)
+        throw Error('Strings with format or pattern constraints must specify default');
+    const minLength = IsMinLength(type) ? type.minLength : 0;
+    return ''.padEnd(minLength);
+}

package/build/value/create/from-symbol.d.mts

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

package/build/value/create/from-symbol.mjs

@@ -0,0 +1,4 @@
+// deno-fmt-ignore-file
+export function FromSymbol(context, type) {
+    return Symbol();
+}

package/build/value/create/from-template-literal.d.mts

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

package/build/value/create/from-template-literal.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { IsString } from '../../type/index.mjs';
+import { TemplateLiteralDecode } from '../../type/engine/template-literal/index.mjs';
+import { FromType } from './from-type.mjs';
+import { CreateError } from './error.mjs';
+export function FromTemplateLiteral(context, type) {
+    const decoded = TemplateLiteralDecode(type.pattern);
+    if (IsString(decoded))
+        throw new CreateError(type, 'Unable to create TemplateLiteral due to infinite type expansion');
+    return FromType(context, decoded);
+}

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

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

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

@@ -0,0 +1,5 @@
+// deno-fmt-ignore-file
+import { FromType } from './from-type.mjs';
+export function FromTuple(context, type) {
+    return Array.from({ length: type.minItems }, (_, i) => FromType(context, type.items[i]));
+}

package/build/value/create/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): unknown;