@sinclair/typebox 0.34.22 → 0.34.24

package/build/esm/syntax/runtime.mjs

@@ -36,13 +36,58 @@ const Dereference = (context, key) => {
     return key in context ? context[key] : t.Ref(key);
 };
 // ------------------------------------------------------------------
+// GenericArgumentList
+// ------------------------------------------------------------------
+// prettier-ignore
+const GenericArgumentListMapping = (results) => {
+    return (results.length === 3 ? [results[0], ...results[2]] :
+        results.length === 2 ? [results[0]] :
+            results.length === 1 ? [results[0]] :
+                []);
+};
+// prettier-ignore
+const GenericArgumentList = Runtime.Union([
+    Runtime.Tuple([Runtime.Ident(), Runtime.Const(Comma), Runtime.Ref('GenericArgumentList')]),
+    Runtime.Tuple([Runtime.Ident(), Runtime.Const(Comma)]),
+    Runtime.Tuple([Runtime.Ident()]),
+    Runtime.Tuple([]),
+], (results) => GenericArgumentListMapping(results));
+// ------------------------------------------------------------------
+// GenericArguments
+// ------------------------------------------------------------------
+// prettier-ignore
+const GenericArgumentsContext = (args) => {
+    return args.reduce((result, arg, index) => {
+        return { ...result, [arg]: t.Argument(index) };
+    }, {});
+};
+// prettier-ignore
+const GenericArgumentsMapping = (results) => {
+    return results.length === 3
+        ? GenericArgumentsContext(results[1])
+        : {};
+};
+// prettier-ignore
+const GenericArguments = Runtime.Tuple([
+    Runtime.Const(LAngle),
+    Runtime.Ref('GenericArgumentList'),
+    Runtime.Const(RAngle),
+], results => GenericArgumentsMapping(results));
+// ------------------------------------------------------------------
 // GenericReference
 // ------------------------------------------------------------------
 function GenericReferenceMapping(results, context) {
-    const target = Dereference(context, results[0]);
-    return t.Instantiate(target, results[2]);
+    const type = Dereference(context, results[0]);
+    const args = results[2];
+    return t.Instantiate(type, args);
 }
-const GenericReference = Runtime.Tuple([Runtime.Ident(), Runtime.Const(LAngle), Runtime.Ref('Elements'), Runtime.Const(RAngle)], (results, context) => GenericReferenceMapping(results, context));
+// prettier-ignore
+const GenericReference = Runtime.Tuple([
+    Runtime.Ident(),
+    Runtime.Const(LAngle),
+    Runtime.Ref('Elements'),
+    Runtime.Const(RAngle)
+], (results, context) => GenericReferenceMapping(results, context));
 // ------------------------------------------------------------------
 // Reference
 // ------------------------------------------------------------------
@@ -603,6 +648,11 @@ const Uint8Array = Runtime.Const('Uint8Array', Runtime.As(t.Uint8Array()));
 // ------------------------------------------------------------------
 // prettier-ignore
 export const Module = new Runtime.Module({
+    // ----------------------------------------------------------------
+    // Generic Arguments
+    // ----------------------------------------------------------------
+    GenericArgumentList,
+    GenericArguments,
     // ----------------------------------------------------------------
     // Type Expressions
     // ----------------------------------------------------------------

package/build/esm/syntax/static.d.mts

@@ -42,8 +42,29 @@ type Delimit<Parser extends Static.IParser, Delimiter extends Static.IParser> =
     Static.Tuple<[]>
 ], DelimitMapping>);
 type Dereference<Context extends t.TProperties, Ref extends string> = (Ref extends keyof Context ? Context[Ref] : t.TRef<Ref>);
+interface GenericArgumentListMapping extends Static.IMapping {
+    output: (this['input'] extends [infer Ident extends string, Comma, infer Rest extends unknown[]] ? [Ident, ...Rest] : this['input'] extends [infer Ident extends string, Comma] ? [Ident] : this['input'] extends [infer Ident extends string] ? [Ident] : [
+    ]);
+}
+type GenericArgumentList = Static.Union<[
+    Static.Tuple<[Static.Ident, Static.Const<Comma>, GenericArgumentList]>,
+    Static.Tuple<[Static.Ident, Static.Const<Comma>]>,
+    Static.Tuple<[Static.Ident]>,
+    Static.Tuple<[]>
+], GenericArgumentListMapping>;
+type GenericArgumentsContext<Args extends string[], Result extends t.TProperties = {}> = (Args extends [...infer Left extends string[], infer Right extends string] ? GenericArgumentsContext<Left, Result & {
+    [_ in Right]: t.TArgument<Left['length']>;
+}> : t.Evaluate<Result>);
+interface GenericArgumentsMapping extends Static.IMapping {
+    output: this['input'] extends [LAngle, infer Args extends string[], RAngle] ? GenericArgumentsContext<Args> : never;
+}
+export type GenericArguments = Static.Tuple<[
+    Static.Const<LAngle>,
+    GenericArgumentList,
+    Static.Const<RAngle>
+], GenericArgumentsMapping>;
 interface GenericReferenceMapping extends Static.IMapping {
-    output: this['context'] extends t.TProperties ? this['input'] extends [infer Reference extends string, LAngle, infer Parameters extends t.TSchema[], RAngle] ? t.TInstantiate<Dereference<this['context'], Reference>, [...Parameters]> : never : never;
+    output: this['context'] extends t.TProperties ? this['input'] extends [infer Reference extends string, LAngle, infer Args extends t.TSchema[], RAngle] ? t.TInstantiate<Dereference<this['context'], Reference>, Args> : never : never;
 }
 type GenericReference = Static.Tuple<[
     Static.Ident,

package/build/esm/syntax/syntax.d.mts

@@ -1,33 +1,31 @@
-import * as Types from '../type/index.mjs';
+import * as t from '../type/index.mjs';
 import { Static } from '../parser/index.mjs';
-import { Type } from './static.mjs';
-/** Parses a TSchema type from TypeScript syntax but does not infer schematics */
-export declare function NoInfer<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined;
-/** Parses a TSchema type from TypeScript syntax but does not infer schematics */
-export declare function NoInfer<Code extends string>(code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined;
-/** Infers a TSchema type from TypeScript syntax. */
-export type TSyntax<Context extends Record<PropertyKey, Types.TSchema>, Code extends string> = (Static.Parse<Type, Code, Context> extends [infer Type extends Types.TSchema, string] ? Type : Types.TNever);
-/** Parses a TSchema type from TypeScript syntax */
-export declare function Syntax<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): TSyntax<Context, Code>;
-/** Parses a TSchema type from TypeScript syntax */
-export declare function Syntax<Code extends string>(code: Code, options?: Types.SchemaOptions): TSyntax<{}, Code>;
+import { Type, GenericArguments } from './static.mjs';
+type TParseSyntax<Context extends Record<PropertyKey, t.TSchema>, Code extends string> = (Static.Parse<GenericArguments, Code, {}> extends [infer Args extends t.TProperties, infer Rest extends string] ? Static.Parse<Type, Rest, Context & Args> : Static.Parse<Type, Code, Context>);
+/** Parses a TypeScript annotation into a TypeBox type but does not infer schematics */
+export declare function NoInfer<Context extends Record<PropertyKey, t.TSchema>, Code extends string>(context: Context, code: Code, options?: t.SchemaOptions): t.TSchema;
+/** Parses a TypeScript annotation into a TypeBox type but does not infer schematics */
+export declare function NoInfer<Code extends string>(code: Code, options?: t.SchemaOptions): t.TSchema;
+/** Parses a TypeScript annotation into a TypeBox type */
+export type TSyntax<Context extends Record<PropertyKey, t.TSchema>, Code extends string> = (TParseSyntax<Context, Code> extends [infer Type extends t.TSchema, string] ? Type : t.TNever);
+/** Parses a TypeScript annotation into a TypeBox type */
+export declare function Syntax<Context extends Record<PropertyKey, t.TSchema>, Annotation extends string>(context: Context, annotation: Annotation, options?: t.SchemaOptions): TSyntax<Context, Annotation>;
+/** Parses a TypeScript annotation into a TypeBox type */
+export declare function Syntax<Annotation extends string>(annotation: Annotation, options?: t.SchemaOptions): TSyntax<{}, Annotation>;
 /**
- * Parses a TSchema type from Syntax.
  * @deprecated Use Syntax() function
  */
-export declare function Parse<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): TSyntax<Context, Code>;
+export declare function Parse<Context extends Record<PropertyKey, t.TSchema>, Annotation extends string>(context: Context, annotation: Annotation, options?: t.SchemaOptions): TSyntax<Context, Annotation>;
 /**
- * Parses a TSchema type from Syntax.
  * @deprecated Use Syntax() function
  */
-export declare function Parse<Code extends string>(code: Code, options?: Types.SchemaOptions): TSyntax<{}, Code>;
+export declare function Parse<Annotation extends string>(annotation: Annotation, options?: t.SchemaOptions): TSyntax<{}, Annotation>;
 /**
- * Parses a TSchema from TypeScript Syntax
  * @deprecated Use NoInfer() function
  */
-export declare function ParseOnly<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined;
+export declare function ParseOnly<Context extends Record<PropertyKey, t.TSchema>, Code extends string>(context: Context, code: Code, options?: t.SchemaOptions): t.TSchema | undefined;
 /**
- * Parses a TSchema from TypeScript Syntax
  * @deprecated Use NoInfer() function
  */
-export declare function ParseOnly<Code extends string>(code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined;
+export declare function ParseOnly<Code extends string>(code: Code, options?: t.SchemaOptions): t.TSchema | undefined;
+export {};

package/build/esm/syntax/syntax.mjs

@@ -1,28 +1,33 @@
-import * as Types from '../type/index.mjs';
+import * as t from '../type/index.mjs';
 import { Module } from './runtime.mjs';
-/** Parses a TSchema type from TypeScript syntax but does not infer schematics */
+// prettier-ignore
+function ParseSyntax(context, code) {
+    const results = Module.Parse('GenericArguments', code, {}); // [ArgumentContext, Rest]
+    return (results.length === 2
+        ? Module.Parse('Type', results[1], { ...context, ...results[0] })
+        : Module.Parse('Type', code, context));
+}
+/** Parses a TypeScript annotation into a TypeBox type but does not infer schematics */
 // prettier-ignore
 export function NoInfer(...args) {
     const withContext = typeof args[0] === 'string' ? false : true;
     const [context, code, options] = withContext ? [args[0], args[1], args[2] || {}] : [{}, args[0], args[1] || {}];
-    const type = Module.Parse('Type', code, context)[0];
-    return Types.KindGuard.IsSchema(type)
-        ? Types.CloneType(type, options)
-        : Types.Never(options);
+    const result = ParseSyntax(context, code)[0];
+    return t.KindGuard.IsSchema(result)
+        ? t.CloneType(result, options)
+        : t.Never(options);
 }
-/** Parses a TSchema type from TypeScript syntax */
+/** Parses a TypeScript annotation into a TypeBox type */
 export function Syntax(...args) {
     return NoInfer.apply(null, args);
 }
 /**
- * Parses a TSchema type from Syntax.
  * @deprecated Use Syntax() function
  */
 export function Parse(...args) {
     return NoInfer.apply(null, args);
 }
 /**
- * Parses a TSchema from TypeScript Syntax
  * @deprecated Use NoInfer() function
  */
 export function ParseOnly(...args) {

package/build/esm/type/instantiate/instantiate.d.mts

@@ -1,25 +1,50 @@
-import type { TSchema } from '../schema/index.mjs';
-import type { TArgument } from '../argument/index.mjs';
-import { type TNever } from '../never/index.mjs';
+import { type TSchema } from '../schema/index.mjs';
+import { type TArgument } from '../argument/index.mjs';
+import { type TUnknown } from '../unknown/index.mjs';
 import { type TReadonlyOptional } from '../readonly-optional/index.mjs';
 import { type TReadonly } from '../readonly/index.mjs';
 import { type TOptional } from '../optional/index.mjs';
-import { type TRemap, type TMapping as TRemapMapping } from '../remap/index.mjs';
-type TInstantiateArgument<Argument extends TArgument, Type extends TSchema, IsArgumentReadonly extends number = Argument extends TReadonly<TSchema> ? 1 : 0, IsArgumentOptional extends number = Argument extends TOptional<TSchema> ? 1 : 0, Result extends TSchema = ([
-    IsArgumentReadonly,
-    IsArgumentOptional
-] extends [1, 1] ? TReadonlyOptional<Type> : [
-    IsArgumentReadonly,
-    IsArgumentOptional
-] extends [0, 1] ? TOptional<Type> : [
-    IsArgumentReadonly,
-    IsArgumentOptional
-] extends [1, 0] ? TReadonly<Type> : Type)> = Result;
-interface TInstantiateArguments<Arguments extends TSchema[]> extends TRemapMapping {
-    output: (this['input'] extends TArgument<infer Index extends number> ? Index extends keyof Arguments ? Arguments[Index] extends TSchema ? TInstantiateArgument<this['input'], Arguments[Index]> : TNever : TNever : this['input']);
-}
+import { type TConstructor } from '../constructor/index.mjs';
+import { type TFunction } from '../function/index.mjs';
+import { type TIntersect } from '../intersect/index.mjs';
+import { type TUnion } from '../union/index.mjs';
+import { type TTuple } from '../tuple/index.mjs';
+import { type TArray } from '../array/index.mjs';
+import { type TAsyncIterator } from '../async-iterator/index.mjs';
+import { type TIterator } from '../iterator/index.mjs';
+import { type TPromise } from '../promise/index.mjs';
+import { type TObject, type TProperties } from '../object/index.mjs';
+import { type TRecordOrObject, type TRecord } from '../record/index.mjs';
+type TFromConstructor<Args extends TSchema[], Parameters extends TSchema[], InstanceType extends TSchema, Result extends TConstructor = TConstructor<TFromTypes<Args, Parameters>, TFromType<Args, InstanceType>>> = Result;
+type TFromFunction<Args extends TSchema[], Parameters extends TSchema[], ReturnType extends TSchema, Result extends TFunction = TFunction<TFromTypes<Args, Parameters>, TFromType<Args, ReturnType>>> = Result;
+type TFromIntersect<Args extends TSchema[], Types extends TSchema[], Result extends TIntersect = TIntersect<TFromTypes<Args, Types>>> = Result;
+type TFromUnion<Args extends TSchema[], Types extends TSchema[], Result extends TUnion = TUnion<TFromTypes<Args, Types>>> = Result;
+type TFromTuple<Args extends TSchema[], Types extends TSchema[], Result extends TTuple = TTuple<TFromTypes<Args, Types>>> = Result;
+type TFromArray<Args extends TSchema[], Type extends TSchema, Result extends TArray = TArray<TFromType<Args, Type>>> = Result;
+type TFromAsyncIterator<Args extends TSchema[], Type extends TSchema, Result extends TAsyncIterator = TAsyncIterator<TFromType<Args, Type>>> = Result;
+type TFromIterator<Args extends TSchema[], Type extends TSchema, Result extends TIterator = TIterator<TFromType<Args, Type>>> = Result;
+type TFromPromise<Args extends TSchema[], Type extends TSchema, Result extends TPromise = TPromise<TFromType<Args, Type>>> = Result;
+type TFromObject<Args extends TSchema[], Properties extends TProperties, Result extends TProperties = TFromProperties<Args, Properties>> = TObject<Result>;
+type TFromRecord<Args extends TSchema[], Key extends TSchema, Value extends TSchema, MappedKey extends TSchema = TFromType<Args, Key>, MappedValue extends TSchema = TFromType<Args, Value>, Result extends TSchema = TRecordOrObject<MappedKey, MappedValue>> = Result;
+type TFromArgument<Args extends TSchema[], Index extends number, Result extends TSchema = Index extends keyof Args[Index] ? Args[Index] : TUnknown> = Result;
+type TFromProperty<Args extends TSchema[], Type extends TSchema, IsReadonly extends boolean = Type extends TReadonly<Type> ? true : false, IsOptional extends boolean = Type extends TOptional<Type> ? true : false, Mapped extends TSchema = TFromType<Args, Type>, Result extends TSchema = ([
+    IsReadonly,
+    IsOptional
+] extends [true, true] ? TReadonlyOptional<Mapped> : [
+    IsReadonly,
+    IsOptional
+] extends [true, false] ? TReadonly<Mapped> : [
+    IsReadonly,
+    IsOptional
+] extends [false, true] ? TOptional<Mapped> : Mapped)> = Result;
+type TFromProperties<Args extends TSchema[], Properties extends TProperties, Result extends TProperties = {
+    [Key in keyof Properties]: TFromProperty<Args, Properties[Key]>;
+}> = Result;
+export type TFromTypes<Args extends TSchema[], Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromTypes<Args, Right, [...Result, TFromType<Args, Left>]> : Result);
+export declare function FromTypes<Args extends TSchema[], Types extends TSchema[]>(args: [...Args], types: [...Types]): TFromTypes<Args, Types>;
+export type TFromType<Args extends TSchema[], Type extends TSchema> = (Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromConstructor<Args, Parameters, InstanceType> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromFunction<Args, Parameters, ReturnType> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Args, Types> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Args, Types> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Args, Types> : Type extends TArray<infer Type extends TSchema> ? TFromArray<Args, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? TFromAsyncIterator<Args, Type> : Type extends TIterator<infer Type extends TSchema> ? TFromIterator<Args, Type> : Type extends TPromise<infer Type extends TSchema> ? TFromPromise<Args, Type> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Args, Properties> : Type extends TRecord<infer Key extends TSchema, infer Value extends TSchema> ? TFromRecord<Args, Key, Value> : Type extends TArgument<infer Index extends number> ? TFromArgument<Args, Index> : Type);
 /** `[JavaScript]` Instantiates a type with the given parameters */
-export type TInstantiate<Type extends TSchema, Arguments extends TSchema[]> = (TRemap<Type, TInstantiateArguments<Arguments>>);
+export type TInstantiate<Type extends TSchema, Args extends TSchema[], Result extends TSchema = TFromType<Args, Type>> = Result;
 /** `[JavaScript]` Instantiates a type with the given parameters */
-export declare function Instantiate<Type extends TSchema, Arguments extends TSchema[]>(type: Type, args: [...Arguments]): TInstantiate<Type, Arguments>;
+export declare function Instantiate<Type extends TSchema, Args extends TSchema[]>(type: Type, args: [...Args]): TInstantiate<Type, Args>;
 export {};

package/build/esm/type/instantiate/instantiate.mjs

@@ -1,28 +1,115 @@
-import { Never } from '../never/index.mjs';
+import { CloneType } from '../clone/type.mjs';
+import { Unknown } from '../unknown/index.mjs';
 import { ReadonlyOptional } from '../readonly-optional/index.mjs';
 import { Readonly } from '../readonly/index.mjs';
 import { Optional } from '../optional/index.mjs';
-import { Remap } from '../remap/index.mjs';
+import { Object } from '../object/index.mjs';
+import { Record, RecordKey, RecordValue } from '../record/index.mjs';
+import * as ValueGuard from '../guard/value.mjs';
 import * as KindGuard from '../guard/kind.mjs';
 // prettier-ignore
-function InstantiateArgument(argument, type) {
-    const isReadonly = KindGuard.IsReadonly(argument);
-    const isOptional = KindGuard.IsOptional(argument);
-    return (isReadonly && isOptional ? ReadonlyOptional(type) :
-        isReadonly && !isOptional ? Readonly(type) :
-            !isReadonly && isOptional ? Optional(type) :
-                type);
+function FromConstructor(args, type) {
+    type.parameters = FromTypes(args, type.parameters);
+    type.returns = FromType(args, type.returns);
+    return type;
+}
+// prettier-ignore
+function FromFunction(args, type) {
+    type.parameters = FromTypes(args, type.parameters);
+    type.returns = FromType(args, type.returns);
+    return type;
+}
+// prettier-ignore
+function FromIntersect(args, type) {
+    type.allOf = FromTypes(args, type.allOf);
+    return type;
+}
+// prettier-ignore
+function FromUnion(args, type) {
+    type.anyOf = FromTypes(args, type.anyOf);
+    return type;
+}
+// prettier-ignore
+function FromTuple(args, type) {
+    if (ValueGuard.IsUndefined(type.items))
+        return type;
+    type.items = FromTypes(args, type.items);
+    return type;
+}
+// prettier-ignore
+function FromArray(args, type) {
+    type.items = FromType(args, type.items);
+    return type;
+}
+// prettier-ignore
+function FromAsyncIterator(args, type) {
+    type.items = FromType(args, type.items);
+    return type;
+}
+// prettier-ignore
+function FromIterator(args, type) {
+    type.items = FromType(args, type.items);
+    return type;
+}
+// prettier-ignore
+function FromPromise(args, type) {
+    type.item = FromType(args, type.item);
+    return type;
+}
+// prettier-ignore
+function FromObject(args, type) {
+    const properties = FromProperties(args, type.properties);
+    return { ...type, ...Object(properties) }; // retain options
+}
+// prettier-ignore
+function FromRecord(args, type) {
+    const mappedKey = FromType(args, RecordKey(type));
+    const mappedValue = FromType(args, RecordValue(type));
+    const result = Record(mappedKey, mappedValue);
+    return { ...type, ...result }; // retain options
+}
+// prettier-ignore
+function FromArgument(args, argument) {
+    return argument.index in args ? args[argument.index] : Unknown();
+}
+// prettier-ignore
+function FromProperty(args, type) {
+    const isReadonly = KindGuard.IsReadonly(type);
+    const isOptional = KindGuard.IsOptional(type);
+    const mapped = FromType(args, type);
+    return (isReadonly && isOptional ? ReadonlyOptional(mapped) :
+        isReadonly && !isOptional ? Readonly(mapped) :
+            !isReadonly && isOptional ? Optional(mapped) :
+                mapped);
+}
+// prettier-ignore
+function FromProperties(args, properties) {
+    return globalThis.Object.getOwnPropertyNames(properties).reduce((result, key) => {
+        return { ...result, [key]: FromProperty(args, properties[key]) };
+    }, {});
+}
+// prettier-ignore
+export function FromTypes(args, types) {
+    return types.map(type => FromType(args, type));
+}
+// prettier-ignore
+function FromType(args, type) {
+    return (KindGuard.IsConstructor(type) ? FromConstructor(args, type) :
+        KindGuard.IsFunction(type) ? FromFunction(args, type) :
+            KindGuard.IsIntersect(type) ? FromIntersect(args, type) :
+                KindGuard.IsUnion(type) ? FromUnion(args, type) :
+                    KindGuard.IsTuple(type) ? FromTuple(args, type) :
+                        KindGuard.IsArray(type) ? FromArray(args, type) :
+                            KindGuard.IsAsyncIterator(type) ? FromAsyncIterator(args, type) :
+                                KindGuard.IsIterator(type) ? FromIterator(args, type) :
+                                    KindGuard.IsPromise(type) ? FromPromise(args, type) :
+                                        KindGuard.IsObject(type) ? FromObject(args, type) :
+                                            KindGuard.IsRecord(type) ? FromRecord(args, type) :
+                                                KindGuard.IsArgument(type) ? FromArgument(args, type) :
+                                                    type);
 }
 /** `[JavaScript]` Instantiates a type with the given parameters */
 // prettier-ignore
 export function Instantiate(type, args) {
-    return Remap(type, (type) => {
-        return KindGuard.IsArgument(type)
-            ? type.index in args
-                ? KindGuard.IsSchema(args[type.index])
-                    ? InstantiateArgument(type, args[type.index])
-                    : Never()
-                : Never()
-            : type;
-    });
+    return FromType(args, CloneType(type));
 }

package/build/esm/type/type/type.d.mts

@@ -43,7 +43,6 @@ export { Record } from '../record/index.mjs';
 export { Recursive } from '../recursive/index.mjs';
 export { Ref } from '../ref/index.mjs';
 export { RegExp } from '../regexp/index.mjs';
-export { Remap } from '../remap/index.mjs';
 export { Required } from '../required/index.mjs';
 export { Rest } from '../rest/index.mjs';
 export { ReturnType } from '../return-type/index.mjs';

package/build/esm/type/type/type.mjs

@@ -46,7 +46,6 @@ export { Record } from '../record/index.mjs';
 export { Recursive } from '../recursive/index.mjs';
 export { Ref } from '../ref/index.mjs';
 export { RegExp } from '../regexp/index.mjs';
-export { Remap } from '../remap/index.mjs';
 export { Required } from '../required/index.mjs';
 export { Rest } from '../rest/index.mjs';
 export { ReturnType } from '../return-type/index.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.22",
+  "version": "0.34.24",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",