@sinclair/typebox 0.32.0-dev-21 → 0.32.0-dev-22

package/build/import/type/template-literal/syntax.mjs

@@ -3,7 +3,7 @@ import { Boolean } from '../boolean/index.mjs';
 import { BigInt } from '../bigint/index.mjs';
 import { Number } from '../number/index.mjs';
 import { String } from '../string/index.mjs';
-import { Union } from '../union/index.mjs';
+import { UnionEvaluated } from '../union/index.mjs';
 import { Never } from '../never/index.mjs';
 // ------------------------------------------------------------------
 // SyntaxParsers
@@ -19,7 +19,7 @@ function* FromUnion(syntax) {
                         const literals = trim.split('|').map((literal) => Literal(literal.trim()));
                         return (literals.length === 0 ? Never() :
                             literals.length === 1 ? literals[0] :
-                                Union(literals));
+                                UnionEvaluated(literals));
                     })());
 }
 // prettier-ignore

package/build/import/type/transform/transform.mjs

@@ -3,7 +3,6 @@ import { TransformKind } from '../symbols/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 import { IsTransform } from '../guard/type.mjs';
 // ------------------------------------------------------------------
 // TransformBuilders

package/build/import/type/tuple/tuple.d.mts

@@ -1,8 +1,7 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import type { Static } from '../static/index.mjs';
 import { Kind } from '../symbols/index.mjs';
-type TupleStaticRest<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...TupleStaticRest<R, P>] : [];
-type TupleStatic<T extends TSchema[], P extends unknown[], R extends unknown[] = TupleStaticRest<T, P>> = R;
+type TupleStatic<T extends TSchema[], P extends unknown[], Acc extends unknown[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TupleStatic<R, P, [...Acc, Static<L, P>]> : Acc;
 export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
     [Kind]: 'Tuple';
     static: TupleStatic<T, this['params']>;

package/build/import/type/union/union-evaluated.d.mts

@@ -3,15 +3,11 @@ import { type TNever } from '../never/index.mjs';
 import { type TOptional } from '../optional/index.mjs';
 import type { TReadonly } from '../readonly/index.mjs';
 import type { TUnion } from './union-type.mjs';
-type IsUnionOptional<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<TSchema> ? true : IsUnionOptional<R> : false);
-declare function IsUnionOptional<T extends TSchema[]>(T: T): IsUnionOptional<T>;
-type RemoveOptionalFromRest<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<infer S extends TSchema> ? [RemoveOptionalFromType<S>, ...RemoveOptionalFromRest<R>] : [L, ...RemoveOptionalFromRest<R>] : []);
-declare function RemoveOptionalFromRest<T extends TSchema[]>(T: T): RemoveOptionalFromRest<T>;
-type RemoveOptionalFromType<T extends TSchema> = (T extends TReadonly<infer S extends TSchema> ? TReadonly<RemoveOptionalFromType<S>> : T extends TOptional<infer S extends TSchema> ? RemoveOptionalFromType<S> : T);
-declare function RemoveOptionalFromType<T extends TSchema>(T: T): RemoveOptionalFromType<T>;
-type ResolveUnion<T extends TSchema[], R extends TSchema[] = RemoveOptionalFromRest<T>> = (IsUnionOptional<T> extends true ? TOptional<TUnion<R>> : TUnion<R>);
-declare function ResolveUnion<T extends TSchema[]>(T: T, options: SchemaOptions): ResolveUnion<T>;
-export type UnionEvaluated<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : ResolveUnion<T>);
+type TIsUnionOptional<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<TSchema> ? true : TIsUnionOptional<R> : false);
+type TRemoveOptionalFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<infer S extends TSchema> ? TRemoveOptionalFromRest<R, [...Acc, TRemoveOptionalFromType<S>]> : TRemoveOptionalFromRest<R, [...Acc, L]> : Acc);
+type TRemoveOptionalFromType<T extends TSchema> = (T extends TReadonly<infer S extends TSchema> ? TReadonly<TRemoveOptionalFromType<S>> : T extends TOptional<infer S extends TSchema> ? TRemoveOptionalFromType<S> : T);
+type TResolveUnion<T extends TSchema[], R extends TSchema[] = TRemoveOptionalFromRest<T>> = (TIsUnionOptional<T> extends true ? TOptional<TUnion<R>> : TUnion<R>);
+export type TUnionEvaluated<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : TResolveUnion<T>);
 /** `[Json]` Creates an evaluated Union type */
-export declare function UnionEvaluated<T extends TSchema[], R = UnionEvaluated<T>>(T: [...T], options?: SchemaOptions): R;
+export declare function UnionEvaluated<T extends TSchema[], R = TUnionEvaluated<T>>(T: [...T], options?: SchemaOptions): R;
 export {};

package/build/import/type/union/union-evaluated.mjs

@@ -19,8 +19,13 @@ function IsUnionOptional(T) {
         : false);
 }
 // prettier-ignore
-function RemoveOptionalFromRest(T) {
-    return (T.map(T => RemoveOptionalFromType(T)));
+function RemoveOptionalFromRest(T, Acc = []) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? IsOptional(L)
+            ? RemoveOptionalFromRest(R, [...Acc, RemoveOptionalFromType(L)])
+            : RemoveOptionalFromRest(R, [...Acc, L])
+        : Acc);
 }
 // prettier-ignore
 function RemoveOptionalFromType(T) {

package/build/require/index.d.ts

@@ -24,7 +24,7 @@ export { Increment, type Assert, type AssertType, type AssertRest, type AssertPr
 export { Index, IndexPropertyKeys, IndexFromMappedKey, type TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey } from './type/indexed/index';
 export { InstanceType, type TInstanceType } from './type/instance-type/index';
 export { Integer, type TInteger, type IntegerOptions } from './type/integer/index';
-export { Intersect, IntersectEvaluated, type TIntersect, type IntersectOptions } from './type/intersect/index';
+export { Intersect, IntersectEvaluated, type TIntersect, type TIntersectEvaluated, type IntersectOptions } from './type/intersect/index';
 export { Iterator, type TIterator } from './type/iterator/index';
 export { Intrinsic, IntrinsicFromMappedKey, type TIntrinsic, Capitalize, type TCapitalize, Lowercase, type TLowercase, Uncapitalize, type TUncapitalize, Uppercase, type TUppercase } from './type/intrinsic/index';
 export { KeyOf, type TKeyOf, type KeyOfFromMappedResult, KeyOfPropertyKeys, KeyOfPattern } from './type/keyof/index';
@@ -60,7 +60,7 @@ export { Transform, TransformDecodeBuilder, TransformEncodeBuilder, type TTransf
 export { Tuple, type TTuple } from './type/tuple/index';
 export { Uint8Array, type TUint8Array, type Uint8ArrayOptions } from './type/uint8array/index';
 export { Undefined, type TUndefined } from './type/undefined/index';
-export { Union, UnionEvaluated, type TUnion } from './type/union/index';
+export { Union, UnionEvaluated, type TUnion, type TUnionEvaluated } from './type/union/index';
 export { Unknown, type TUnknown } from './type/unknown/index';
 export { Unsafe, type TUnsafe } from './type/unsafe/index';
 export { Void, type TVoid } from './type/void/index';

package/build/require/type/awaited/awaited.d.ts

@@ -2,11 +2,9 @@ import type { TSchema, SchemaOptions } from '../schema/index';
 import { type TIntersect } from '../intersect/index';
 import { type TUnion } from '../union/index';
 import { type TPromise } from '../promise/index';
-type FromRest<T extends TSchema[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [FromSchema<L>, ...FromRest<R>] : [];
-declare function FromRest<T extends TSchema[]>(T: [...T]): FromRest<T>;
-type FromSchema<T extends TSchema> = T extends TIntersect<infer S> ? TIntersect<FromRest<S>> : T extends TUnion<infer S> ? TUnion<FromRest<S>> : T extends TPromise<infer S> ? FromSchema<S> : T;
-declare function FromSchema<T extends TSchema>(T: T): FromSchema<T>;
-export type TAwaited<T extends TSchema> = (FromSchema<T>);
+type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, TFromSchema<L>]> : Acc;
+type TFromSchema<T extends TSchema> = T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S> ? TUnion<TFromRest<S>> : T extends TPromise<infer S> ? TFromSchema<S> : T;
+export type TAwaited<T extends TSchema> = (TFromSchema<T>);
 /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
-export declare function Awaited<T extends TSchema>(T: T, options?: SchemaOptions): FromSchema<T>;
+export declare function Awaited<T extends TSchema>(T: T, options?: SchemaOptions): TFromSchema<T>;
 export {};

package/build/require/type/awaited/awaited.js

@@ -11,11 +11,11 @@ const type_1 = require("../clone/type");
 // prettier-ignore
 const type_2 = require("../guard/type");
 // prettier-ignore
-function FromRest(T) {
+function FromRest(T, Acc = []) {
     const [L, ...R] = T;
     return (T.length > 0
-        ? [FromSchema(L), ...FromRest(R)]
-        : []);
+        ? FromRest(R, [...Acc, FromSchema(L)])
+        : Acc);
 }
 // prettier-ignore
 function FromIntersect(T) {

package/build/require/type/composite/composite.d.ts

@@ -1,15 +1,15 @@
 import type { UnionToTuple, Assert, Evaluate } from '../helpers/index';
-import { type TObject, type ObjectOptions } from '../object/index';
+import { type TObject, type TProperties, type ObjectOptions } from '../object/index';
 import { type TIntersect } from '../intersect/index';
 import { type TIndex } from '../indexed/index';
-type CompositeKeys<T extends TObject[]> = T extends [infer L extends TObject, ...infer R extends TObject[]] ? keyof L['properties'] | CompositeKeys<R> : never;
-type CompositeIndex<T extends TIntersect<TObject[]>, K extends string[]> = K extends [infer L extends string, ...infer R extends string[]] ? {
+type TCompositeKeys<T extends TObject[], Acc extends PropertyKey = never> = T extends [infer L extends TObject, ...infer R extends TObject[]] ? TCompositeKeys<R, Acc | keyof L['properties']> : Acc;
+type TCompositeIndex<T extends TIntersect<TObject[]>, K extends string[], Acc extends TProperties = {}> = K extends [infer L extends string, ...infer R extends string[]] ? TCompositeIndex<T, R, Acc & {
     [_ in L]: TIndex<T, [L]>;
-} & CompositeIndex<T, R> : {};
-type CompositeReduce<T extends TObject[]> = UnionToTuple<CompositeKeys<T>> extends infer K ? Evaluate<CompositeIndex<TIntersect<T>, Assert<K, string[]>>> : {};
-export type CompositeResolve<T extends TObject[]> = TIntersect<T> extends TIntersect ? TObject<CompositeReduce<T>> : TObject<{}>;
-export declare function CompositeResolve<T extends TObject[]>(T: [...T]): CompositeResolve<T>;
-export type TComposite<T extends TObject[]> = CompositeResolve<T>;
+}> : Acc;
+type TCompositeReduce<T extends TObject[]> = UnionToTuple<TCompositeKeys<T>> extends infer K ? Evaluate<TCompositeIndex<TIntersect<T>, Assert<K, string[]>>> : {};
+export type TCompositeResolve<T extends TObject[]> = TIntersect<T> extends TIntersect ? TObject<TCompositeReduce<T>> : TObject<{}>;
+export declare function CompositeResolve<T extends TObject[]>(T: [...T]): TCompositeResolve<T>;
+export type TComposite<T extends TObject[]> = TCompositeResolve<T>;
 /** `[Json]` Creates a Composite object type */
 export declare function Composite<T extends TObject[]>(T: [...T], options?: ObjectOptions): TComposite<T>;
 export {};

package/build/require/type/const/const.d.ts

@@ -14,15 +14,12 @@ import { type TReadonly } from '../readonly/index';
 import { type TUndefined } from '../undefined/index';
 import { type TUint8Array } from '../uint8array/index';
 import { type TUnknown } from '../unknown/index';
-type FromArray<T extends readonly unknown[]> = T extends readonly [infer L extends unknown, ...infer R extends unknown[]] ? [FromValue<L, false>, ...FromArray<R>] : T;
-declare function FromArray<T extends readonly unknown[]>(T: [...T]): FromArray<T>;
-type FromProperties<T extends Record<PropertyKey, unknown>> = {
+type TFromArray<T extends readonly unknown[]> = T extends readonly [infer L extends unknown, ...infer R extends unknown[]] ? [FromValue<L, false>, ...TFromArray<R>] : T;
+type TFromProperties<T extends Record<PropertyKey, unknown>> = {
     -readonly [K in keyof T]: FromValue<T[K], false> extends infer R extends TSchema ? TReadonly<R> : TReadonly<TNever>;
 };
-declare function FromProperties<T extends Record<PropertyKey, unknown>>(value: T): FromProperties<T>;
-type ConditionalReadonly<T extends TSchema, Root extends boolean> = Root extends true ? T : TReadonly<T>;
-declare function ConditionalReadonly<T extends TSchema, Root extends boolean>(T: T, root: Root): ConditionalReadonly<T, Root>;
-type FromValue<T, Root extends boolean> = T extends AsyncIterableIterator<unknown> ? ConditionalReadonly<TAny, Root> : T extends IterableIterator<unknown> ? ConditionalReadonly<TAny, Root> : T extends readonly unknown[] ? TReadonly<TTuple<AssertRest<FromArray<T>>>> : T extends Uint8Array ? TUint8Array : T extends Date ? TDate : T extends Record<PropertyKey, unknown> ? ConditionalReadonly<TObject<Evaluate<FromProperties<T>>>, Root> : T extends Function ? ConditionalReadonly<TFunction<[], TUnknown>, Root> : T extends undefined ? TUndefined : T extends null ? TNull : T extends symbol ? TSymbol : T extends number ? TLiteral<T> : T extends boolean ? TLiteral<T> : T extends string ? TLiteral<T> : T extends bigint ? TBigInt : TObject<{}>;
+type TConditionalReadonly<T extends TSchema, Root extends boolean> = Root extends true ? T : TReadonly<T>;
+type FromValue<T, Root extends boolean> = T extends AsyncIterableIterator<unknown> ? TConditionalReadonly<TAny, Root> : T extends IterableIterator<unknown> ? TConditionalReadonly<TAny, Root> : T extends readonly unknown[] ? TReadonly<TTuple<AssertRest<TFromArray<T>>>> : T extends Uint8Array ? TUint8Array : T extends Date ? TDate : T extends Record<PropertyKey, unknown> ? TConditionalReadonly<TObject<Evaluate<TFromProperties<T>>>, Root> : T extends Function ? TConditionalReadonly<TFunction<[], TUnknown>, Root> : T extends undefined ? TUndefined : T extends null ? TNull : T extends symbol ? TSymbol : T extends number ? TLiteral<T> : T extends boolean ? TLiteral<T> : T extends string ? TLiteral<T> : T extends bigint ? TBigInt : TObject<{}>;
 declare function FromValue<T, Root extends boolean>(value: T, root: Root): FromValue<T, Root>;
 export type TConst<T> = FromValue<T, true>;
 /** `[JavaScript]` Creates a readonly const type from the given value. */

package/build/require/type/constructor/constructor.d.ts

@@ -2,12 +2,12 @@ import type { TSchema, SchemaOptions } from '../schema/index';
 import type { Static } from '../static/index';
 import type { Ensure } from '../helpers/index';
 import { Kind } from '../symbols/index';
-type TConstructorStaticReturnType<T extends TSchema, P extends unknown[]> = Static<T, P>;
-type TConstructorStaticParameters<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...TConstructorStaticParameters<R, P>] : [];
-export type TConstructorStatic<T extends TSchema[], U extends TSchema, P extends unknown[]> = (Ensure<new (...param: TConstructorStaticParameters<T, P>) => TConstructorStaticReturnType<U, P>>);
+type ConstructorStaticReturnType<T extends TSchema, P extends unknown[]> = Static<T, P>;
+type ConstructorStaticParameters<T extends TSchema[], P extends unknown[], Acc extends unknown[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? ConstructorStaticParameters<R, P, [...Acc, Static<L, P>]> : Acc;
+export type ConstructorStatic<T extends TSchema[], U extends TSchema, P extends unknown[]> = (Ensure<new (...param: ConstructorStaticParameters<T, P>) => ConstructorStaticReturnType<U, P>>);
 export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Constructor';
-    static: TConstructorStatic<T, U, this['params']>;
+    static: ConstructorStatic<T, U, this['params']>;
     type: 'Constructor';
     parameters: T;
     returns: U;

package/build/require/type/deref/deref.d.ts

@@ -11,12 +11,12 @@ import type { TConstructor } from '../constructor/index';
 import type { TFunction } from '../function/index';
 import type { TRef } from '../ref/index';
 import type { TObject, TProperties } from '../object/index';
-export type FromRest<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [DerefResolve<L>, ...FromRest<R>] : []);
+export type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, DerefResolve<L>]> : Acc);
 type FromProperties<T extends TProperties> = Evaluate<{
     [K in keyof T]: DerefResolve<T[K]>;
 }>;
 declare function FromProperties(properties: TProperties, references: TSchema[]): TProperties;
-export type DerefResolve<T extends TSchema> = T extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TConstructor<FromRest<S>, DerefResolve<R>> : T extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFunction<FromRest<S>, DerefResolve<R>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<FromRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<FromRest<S>> : T extends TTuple<infer S extends TSchema[]> ? TTuple<FromRest<S>> : T extends TObject<infer S extends TProperties> ? TObject<FromProperties<S>> : T extends TArray<infer S extends TSchema> ? TArray<DerefResolve<S>> : T extends TPromise<infer S extends TSchema> ? TPromise<DerefResolve<S>> : T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<DerefResolve<S>> : T extends TIterator<infer S extends TSchema> ? TIterator<DerefResolve<S>> : T extends TRef<infer S extends TSchema> ? DerefResolve<S> : T;
+export type DerefResolve<T extends TSchema> = T extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TConstructor<TFromRest<S>, DerefResolve<R>> : T extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFunction<TFromRest<S>, DerefResolve<R>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromRest<S>> : T extends TTuple<infer S extends TSchema[]> ? TTuple<TFromRest<S>> : T extends TObject<infer S extends TProperties> ? TObject<FromProperties<S>> : T extends TArray<infer S extends TSchema> ? TArray<DerefResolve<S>> : T extends TPromise<infer S extends TSchema> ? TPromise<DerefResolve<S>> : T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<DerefResolve<S>> : T extends TIterator<infer S extends TSchema> ? TIterator<DerefResolve<S>> : T extends TRef<infer S extends TSchema> ? DerefResolve<S> : T;
 export declare function DerefResolve<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>;
 export type TDeref<T extends TSchema> = DerefResolve<T>;
 /** `[Json]` Creates a dereferenced type */

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

@@ -21,67 +21,57 @@ function FromProperties(properties, references) {
 }
 // prettier-ignore
 function FromConstructor(schema, references) {
-    const clone = (0, type_1.CloneType)(schema);
-    clone.parameters = FromRest(clone.parameters, references);
-    clone.returns = Deref(clone.returns, references);
-    return clone;
+    schema.parameters = FromRest(schema.parameters, references);
+    schema.returns = Deref(schema.returns, references);
+    return schema;
 }
 // prettier-ignore
 function FromFunction(schema, references) {
-    const clone = (0, type_1.CloneType)(schema);
-    clone.parameters = FromRest(clone.parameters, references);
-    clone.returns = Deref(clone.returns, references);
-    return clone;
+    schema.parameters = FromRest(schema.parameters, references);
+    schema.returns = Deref(schema.returns, references);
+    return schema;
 }
 // prettier-ignore
 function FromIntersect(schema, references) {
-    const clone = (0, type_1.CloneType)(schema);
-    clone.allOf = FromRest(clone.allOf, references);
-    return clone;
+    schema.allOf = FromRest(schema.allOf, references);
+    return schema;
 }
 // prettier-ignore
 function FromUnion(schema, references) {
-    const clone = (0, type_1.CloneType)(schema);
-    clone.anyOf = FromRest(clone.anyOf, references);
-    return clone;
+    schema.anyOf = FromRest(schema.anyOf, references);
+    return schema;
 }
 // prettier-ignore
 function FromTuple(schema, references) {
-    const clone = (0, type_1.CloneType)(schema);
-    if ((0, value_1.IsUndefined)(clone.items))
-        return clone;
-    clone.items = FromRest(clone.items, references);
-    return clone;
+    if ((0, value_1.IsUndefined)(schema.items))
+        return schema;
+    schema.items = FromRest(schema.items, references);
+    return schema;
 }
 // prettier-ignore
 function FromArray(schema, references) {
-    const clone = (0, type_1.CloneType)(schema);
-    clone.items = Deref(clone.items, references);
-    return clone;
+    schema.items = Deref(schema.items, references);
+    return schema;
 }
 // prettier-ignore
 function FromObject(schema, references) {
-    const clone = (0, type_1.CloneType)(schema);
-    clone.properties = FromProperties(clone.properties, references);
-    return clone;
+    schema.properties = FromProperties(schema.properties, references);
+    return schema;
 }
 // prettier-ignore
 function FromPromise(schema, references) {
-    const clone = (0, type_1.CloneType)(schema);
-    clone.item = Deref(clone.item, references);
-    return clone;
+    schema.item = Deref(schema.item, references);
+    return schema;
 }
 // prettier-ignore
 function FromAsyncIterator(schema, references) {
-    const clone = (0, type_1.CloneType)(schema);
-    clone.items = Deref(clone.items, references);
-    return clone;
+    schema.items = Deref(schema.items, references);
+    return schema;
 }
 // prettier-ignore
 function FromIterator(schema, references) {
-    const clone = (0, type_1.CloneType)(schema);
-    clone.items = Deref(clone.items, references);
-    return clone;
+    schema.items = Deref(schema.items, references);
+    return schema;
 }
 // prettier-ignore
 function FromRef(schema, references) {
@@ -109,6 +99,6 @@ function DerefResolve(schema, references) {
 exports.DerefResolve = DerefResolve;
 /** `[Json]` Creates a dereferenced type */
 function Deref(schema, references) {
-    return DerefResolve(schema, references);
+    return DerefResolve((0, type_1.CloneType)(schema), (0, type_1.CloneRest)(references));
 }
 exports.Deref = Deref;

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

@@ -2,12 +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 FromProperties<K extends TProperties, U extends TSchema> = ({
+type TFromProperties<K extends TProperties, U extends TSchema> = ({
     [K2 in keyof K]: TExclude<K[K2], U>;
 });
-declare function FromProperties<K extends TProperties, U extends TSchema>(K: K, U: U, options: SchemaOptions): FromProperties<K, U>;
-type FromMappedResult<K extends TMappedResult, U extends TSchema> = (FromProperties<K['properties'], U>);
-declare function FromMappedResult<K extends TMappedResult, U extends TSchema>(K: K, U: U, options: SchemaOptions): FromMappedResult<K, U>;
-export type TExcludeFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = FromMappedResult<T, U>> = (TMappedResult<P>);
-export declare function ExcludeFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = FromMappedResult<T, U>>(T: T, U: U, options: SchemaOptions): TMappedResult<P>;
+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>;
 export {};

package/build/require/type/exclude/exclude.d.ts

@@ -6,18 +6,17 @@ import { type TUnion } from '../union/index';
 import { type TNever } from '../never/index';
 import { type TLiteral } from '../literal/index';
 import { type Static } from '../static/index';
-import { UnionEvaluated } from '../union/index';
+import { type TUnionEvaluated } from '../union/index';
 import { type TExcludeFromMappedResult } from './exclude-from-mapped-result';
-type ExcludeTemplateLiteralResult<T extends string> = UnionEvaluated<AssertRest<UnionToTuple<{
+type TExcludeTemplateLiteralResult<T extends string> = TUnionEvaluated<AssertRest<UnionToTuple<{
     [K in T]: TLiteral<K>;
 }[T]>>>;
-type ExcludeTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = (Exclude<Static<T>, Static<U>> extends infer S ? ExcludeTemplateLiteralResult<Assert<S, string>> : never);
-type ExcludeArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<{
+type TExcludeTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = (Exclude<Static<T>, Static<U>> extends infer S ? TExcludeTemplateLiteralResult<Assert<S, string>> : never);
+type TExcludeArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<{
     [K in keyof T]: Static<AssertType<T[K]>> extends Static<U> ? never : T[K];
-}[number]>> extends infer R extends TSchema[] ? UnionEvaluated<R> : never;
-type ExcludeResolve<T extends TSchema, U extends TSchema> = T extends TTemplateLiteral ? ExcludeTemplateLiteral<T, U> : T extends TUnion<infer S> ? ExcludeArray<S, U> : T extends U ? TNever : T;
-declare function ExcludeResolve<L extends TSchema, R extends TSchema>(L: L, R: R): ExcludeResolve<L, R>;
-export type TExclude<T extends TSchema, U extends TSchema> = ExcludeResolve<T, U>;
+}[number]>> extends infer R extends TSchema[] ? TUnionEvaluated<R> : never;
+type TExcludeResolve<T extends TSchema, U extends TSchema> = T extends TTemplateLiteral ? TExcludeTemplateLiteral<T, U> : T extends TUnion<infer S> ? TExcludeArray<S, U> : T extends U ? TNever : T;
+export type TExclude<T extends TSchema, U extends TSchema> = TExcludeResolve<T, U>;
 /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
 export declare function Exclude<L extends TMappedResult, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExcludeFromMappedResult<L, R>;
 /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */

package/build/require/type/extends/extends-from-mapped-key.d.ts

@@ -4,14 +4,11 @@ import type { Assert } from '../helpers/index';
 import { type TMappedResult, type TMappedKey } from '../mapped/index';
 import { TLiteral, TLiteralValue } from '../literal/index';
 import { type TExtends } from './extends';
-type FromPropertyKey<K extends PropertyKey, U extends TSchema, L extends TSchema, R extends TSchema> = {
+type TFromPropertyKey<K extends PropertyKey, U extends TSchema, L extends TSchema, R extends TSchema> = {
     [_ in K]: TExtends<TLiteral<Assert<K, TLiteralValue>>, U, L, R>;
 };
-declare function FromPropertyKey<K extends PropertyKey, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R, options: SchemaOptions): FromPropertyKey<K, U, L, R>;
-type FromPropertyKeys<K extends PropertyKey[], U extends TSchema, L extends TSchema, R extends TSchema> = (K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]] ? FromPropertyKey<LK, U, L, R> & FromPropertyKeys<RK, U, L, R> : {});
-declare function FromPropertyKeys<K extends PropertyKey[], U extends TSchema, L extends TSchema, R extends TSchema>(K: [...K], U: U, L: L, R: R, options: SchemaOptions): FromPropertyKeys<K, U, L, R>;
-type FromMappedKey<K extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema> = (FromPropertyKeys<K['keys'], U, L, R>);
-declare function FromMappedKey<K extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R, options: SchemaOptions): FromMappedKey<K, U, L, R>;
-export type TExtendsFromMappedKey<T extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = FromMappedKey<T, U, L, R>> = (TMappedResult<P>);
-export declare function ExtendsFromMappedKey<T extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = FromMappedKey<T, U, L, R>>(T: T, U: U, L: L, R: R, options: SchemaOptions): TMappedResult<P>;
+type TFromPropertyKeys<K extends PropertyKey[], U extends TSchema, L extends TSchema, R extends TSchema, Acc extends TProperties = {}> = (K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]] ? TFromPropertyKeys<RK, U, L, R, Acc & TFromPropertyKey<LK, U, L, R>> : Acc);
+type TFromMappedKey<K extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema> = (TFromPropertyKeys<K['keys'], U, L, R>);
+export type TExtendsFromMappedKey<T extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = TFromMappedKey<T, U, L, R>> = (TMappedResult<P>);
+export declare function ExtendsFromMappedKey<T extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = TFromMappedKey<T, U, L, R>>(T: T, U: U, L: L, R: R, options: SchemaOptions): TMappedResult<P>;
 export {};

package/build/require/type/extends/extends-from-mapped-key.js

@@ -12,11 +12,11 @@ function FromPropertyKey(K, U, L, R, options) {
     };
 }
 // prettier-ignore
-function FromPropertyKeys(K, U, L, R, options) {
+function FromPropertyKeys(K, U, L, R, options, Acc = {}) {
     const [LK, ...RK] = K;
     return (K.length > 0
-        ? { ...FromPropertyKey(LK, U, L, R, options), ...FromPropertyKeys(RK, U, L, R, options) }
-        : {});
+        ? FromPropertyKeys(RK, U, L, R, options, { ...Acc, ...FromPropertyKey(LK, U, L, R, options) })
+        : Acc);
 }
 // prettier-ignore
 function FromMappedKey(K, U, L, R, options) {

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

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

package/build/require/type/extends/extends.d.ts

@@ -5,9 +5,8 @@ import { TMappedKey, TMappedResult } from '../mapped/index';
 import { UnionToTuple } from '../helpers/index';
 import { type TExtendsFromMappedKey } from './extends-from-mapped-key';
 import { type TExtendsFromMappedResult } from './extends-from-mapped-result';
-type ExtendsResolve<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema> = ((Static<L> extends Static<R> ? T : U) extends infer O extends TSchema ? UnionToTuple<O> extends [infer X extends TSchema, infer Y extends TSchema] ? TUnion<[X, Y]> : O : never);
-declare function ExtendsResolve<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema>(left: L, right: R, trueType: T, falseType: U): ExtendsResolve<L, R, T, U>;
-export type TExtends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema> = ExtendsResolve<L, R, T, F>;
+type TExtendsResolve<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema> = ((Static<L> extends Static<R> ? T : U) extends infer O extends TSchema ? UnionToTuple<O> extends [infer X extends TSchema, infer Y extends TSchema] ? TUnion<[X, Y]> : O : never);
+export type TExtends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema> = TExtendsResolve<L, R, T, F>;
 /** `[Json]` Creates a Conditional type */
 export declare function Extends<L extends TMappedResult, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsFromMappedResult<L, R, T, F>;
 /** `[Json]` Creates a Conditional type */

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

@@ -2,12 +2,10 @@ import type { TSchema, SchemaOptions } from '../schema/index';
 import type { TProperties } from '../object/index';
 import { type TMappedResult } from '../mapped/index';
 import { type TExtract } from './extract';
-type FromProperties<K extends TProperties, U extends TSchema> = ({
+type TFromProperties<K extends TProperties, U extends TSchema> = ({
     [K2 in keyof K]: TExtract<K[K2], U>;
 });
-declare function FromProperties<K extends TProperties, U extends TSchema>(K: K, U: U, options: SchemaOptions): FromProperties<K, U>;
-type FromMappedResult<K extends TMappedResult, U extends TSchema> = (FromProperties<K['properties'], U>);
-declare function FromMappedResult<K extends TMappedResult, U extends TSchema>(K: K, U: U, options: SchemaOptions): FromMappedResult<K, U>;
-export type TExtractFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = FromMappedResult<T, U>> = (TMappedResult<P>);
-export declare function ExtractFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = FromMappedResult<T, U>>(T: T, U: U, options: SchemaOptions): TMappedResult<P>;
+type TFromMappedResult<K extends TMappedResult, U extends TSchema> = (TFromProperties<K['properties'], U>);
+export type TExtractFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = TFromMappedResult<T, U>> = (TMappedResult<P>);
+export declare function ExtractFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = TFromMappedResult<T, U>>(T: T, U: U, options: SchemaOptions): TMappedResult<P>;
 export {};

package/build/require/type/extract/extract.d.ts

@@ -5,18 +5,18 @@ import { type TTemplateLiteral } from '../template-literal/index';
 import { type TLiteral } from '../literal/index';
 import { type TUnion } from '../union/index';
 import { type Static } from '../static/index';
-import { UnionEvaluated } from '../union/index';
+import { type TUnionEvaluated } from '../union/index';
 import { type TExtractFromMappedResult } from './extract-from-mapped-result';
-type FromTemplateLiteralResult<T extends string> = UnionEvaluated<AssertRest<UnionToTuple<{
+type TFromTemplateLiteralResult<T extends string> = TUnionEvaluated<AssertRest<UnionToTuple<{
     [K in T]: TLiteral<K>;
 }[T]>>>;
-type FromTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = Extract<Static<T>, Static<U>> extends infer S ? FromTemplateLiteralResult<Assert<S, string>> : never;
-type FromArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<{
+type TFromTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = Extract<Static<T>, Static<U>> extends infer S ? TFromTemplateLiteralResult<Assert<S, string>> : never;
+type TFromArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<{
     [K in keyof T]: Static<AssertType<T[K]>> extends Static<U> ? T[K] : never;
-}[number]>> extends infer R extends TSchema[] ? UnionEvaluated<R> : never;
-export type ExtractResolve<T extends TSchema, U extends TSchema> = (T extends TTemplateLiteral ? FromTemplateLiteral<T, U> : T extends TUnion<infer S> ? FromArray<S, U> : T extends U ? T : T);
-export declare function ExtractResolve<L extends TSchema, R extends TSchema>(L: L, R: R): ExtractResolve<L, R>;
-export type TExtract<T extends TSchema, U extends TSchema> = ExtractResolve<T, U>;
+}[number]>> extends infer R extends TSchema[] ? TUnionEvaluated<R> : never;
+export type TExtractResolve<T extends TSchema, U extends TSchema> = (T extends TTemplateLiteral ? TFromTemplateLiteral<T, U> : T extends TUnion<infer S> ? TFromArray<S, U> : T extends U ? T : T);
+export declare function ExtractResolve<L extends TSchema, R extends TSchema>(L: L, R: R): TExtractResolve<L, R>;
+export type TExtract<T extends TSchema, U extends TSchema> = TExtractResolve<T, U>;
 /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
 export declare function Extract<L extends TMappedResult, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtractFromMappedResult<L, R>;
 /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */

package/build/require/type/function/function.d.ts

@@ -3,7 +3,7 @@ import type { Static } from '../static/index';
 import type { Ensure } from '../helpers/index';
 import { Kind } from '../symbols/index';
 type FunctionStaticReturnType<T extends TSchema, P extends unknown[]> = Static<T, P>;
-type FunctionStaticParameters<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...FunctionStaticParameters<R, P>] : [];
+type FunctionStaticParameters<T extends TSchema[], P extends unknown[], Acc extends unknown[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? FunctionStaticParameters<R, P, [...Acc, Static<L, P>]> : Acc;
 type FunctionStatic<T extends TSchema[], U extends TSchema, P extends unknown[]> = (Ensure<(...param: FunctionStaticParameters<T, P>) => FunctionStaticReturnType<U, P>>);
 export interface TFunction<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Function';

package/build/require/type/helpers/helpers.d.ts

@@ -7,7 +7,7 @@ export type TupleToUnion<T extends any[]> = {
 }[number];
 export type UnionToIntersect<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never;
 export type UnionLast<U> = UnionToIntersect<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never;
-export type UnionToTuple<U, L = UnionLast<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, L>>, L];
+export type UnionToTuple<U, Acc extends unknown[] = [], R = UnionLast<U>> = [U] extends [never] ? Acc : UnionToTuple<Exclude<U, R>, [Extract<U, R>, ...Acc]>;
 export type Trim<T> = T extends `${' '}${infer U}` ? Trim<U> : T extends `${infer U}${' '}` ? Trim<U> : T;
 export type Assert<T, E> = T extends E ? T : never;
 export type Evaluate<T> = T extends infer O ? {

package/build/require/type/index.d.ts

@@ -28,7 +28,6 @@ export * from './iterator/index';
 export * from './keyof/index';
 export * from './literal/index';
 export * from './mapped/index';
-export * from './modifiers/index';
 export * from './never/index';
 export * from './not/index';
 export * from './null/index';

package/build/require/type/index.js

@@ -45,7 +45,6 @@ __exportStar(require("./iterator/index"), exports);
 __exportStar(require("./keyof/index"), exports);
 __exportStar(require("./literal/index"), exports);
 __exportStar(require("./mapped/index"), exports);
-__exportStar(require("./modifiers/index"), exports);
 __exportStar(require("./never/index"), exports);
 __exportStar(require("./not/index"), exports);
 __exportStar(require("./null/index"), exports);

package/build/require/type/indexed/indexed-from-mapped-key.d.ts

@@ -3,14 +3,11 @@ import { type TProperties } from '../object/index';
 import { type TIndex } from './indexed';
 import { type TMappedResult, type TMappedKey } from '../mapped/index';
 import { Evaluate } from '../helpers/index';
-type MappedIndexPropertyKey<T extends TSchema, K extends PropertyKey> = {
+type TMappedIndexPropertyKey<T extends TSchema, K extends PropertyKey> = {
     [_ in K]: TIndex<T, [K]>;
 };
-declare function MappedIndexPropertyKey<T extends TSchema, K extends PropertyKey>(T: T, K: K, options: SchemaOptions): MappedIndexPropertyKey<T, K>;
-type MappedIndexPropertyKeys<T extends TSchema, K extends PropertyKey[]> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? MappedIndexPropertyKey<T, L> & MappedIndexPropertyKeys<T, R> : {});
-declare function MappedIndexPropertyKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K], options: SchemaOptions): MappedIndexPropertyKeys<T, K>;
-type MappedIndexProperties<T extends TSchema, K extends TMappedKey> = Evaluate<MappedIndexPropertyKeys<T, K['keys']>>;
-declare function MappedIndexProperties<T extends TSchema, K extends TMappedKey>(T: T, K: K, options: SchemaOptions): MappedIndexProperties<T, K>;
-export type TIndexFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = MappedIndexProperties<T, K>> = (TMappedResult<P>);
-export declare function IndexFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = MappedIndexProperties<T, K>>(T: T, K: K, options: SchemaOptions): TMappedResult<P>;
+type TMappedIndexPropertyKeys<T extends TSchema, K extends PropertyKey[], Acc extends TProperties = {}> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TMappedIndexPropertyKeys<T, R, Acc & TMappedIndexPropertyKey<T, L>> : Acc);
+type TMappedIndexProperties<T extends TSchema, K extends TMappedKey> = Evaluate<TMappedIndexPropertyKeys<T, K['keys']>>;
+export type TIndexFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TMappedIndexProperties<T, K>> = (TMappedResult<P>);
+export declare function IndexFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TMappedIndexProperties<T, K>>(T: T, K: K, options: SchemaOptions): TMappedResult<P>;
 export {};

package/build/require/type/indexed/indexed-from-mapped-key.js

@@ -6,17 +6,14 @@ const indexed_1 = require("./indexed");
 const index_1 = require("../mapped/index");
 // prettier-ignore
 function MappedIndexPropertyKey(T, K, options) {
-    // todo: propogate options into index result. This type looks like it
-    // could use a clean up, possibly inlining it into indexed.ts to
-    // bring it inline with other mapping types.
     return { [K]: (0, indexed_1.Index)(T, [K], options) };
 }
 // prettier-ignore
-function MappedIndexPropertyKeys(T, K, options) {
+function MappedIndexPropertyKeys(T, K, options, Acc = {}) {
     const [L, ...R] = K;
     return (K.length > 0
-        ? { ...MappedIndexPropertyKey(T, L, options), ...MappedIndexPropertyKeys(T, R, options) } // TS 5.4-dev
-        : {});
+        ? MappedIndexPropertyKeys(T, R, options, { ...Acc, ...MappedIndexPropertyKey(T, L, options) })
+        : Acc);
 }
 // prettier-ignore
 function MappedIndexProperties(T, K, options) {