@depup/typebox 1.1.6-depup.0

package/build/type/engine/evaluate/distribute.mjs

@@ -0,0 +1,55 @@
+// deno-fmt-ignore-file
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { IsSchema } from '../../types/schema.mjs';
+import { IsUnion } from '../../types/union.mjs';
+import { IsObject } from '../../types/object.mjs';
+import { IsTuple } from '../../types/tuple.mjs';
+import { Composite } from './composite.mjs';
+import { Narrow } from './narrow.mjs';
+import { EvaluateType } from './evaluate.mjs';
+import { EvaluateIntersect } from './evaluate.mjs';
+function IsObjectLike(type) {
+    return IsObject(type) || IsTuple(type);
+}
+function IsUnionOperand(left, right) {
+    const isUnionLeft = IsUnion(left);
+    const isUnionRight = IsUnion(right);
+    const result = isUnionLeft || isUnionRight;
+    return result;
+}
+function DistributeOperation(left, right) {
+    const evaluatedLeft = EvaluateType(left);
+    const evaluatedRight = EvaluateType(right);
+    const isUnionOperand = IsUnionOperand(evaluatedLeft, evaluatedRight);
+    const isObjectLeft = IsObjectLike(evaluatedLeft);
+    const IsObjectRight = IsObjectLike(evaluatedRight);
+    const result = (isUnionOperand ? EvaluateIntersect([evaluatedLeft, evaluatedRight]) :
+        isObjectLeft && IsObjectRight ? Composite(evaluatedLeft, evaluatedRight) :
+            isObjectLeft && !IsObjectRight ? evaluatedLeft :
+                !isObjectLeft && IsObjectRight ? evaluatedRight :
+                    Narrow(evaluatedLeft, evaluatedRight));
+    return result;
+}
+function DistributeType(type, types, result = []) {
+    const [left, ...right] = types;
+    return (!Guard.IsUndefined(left) // TSchema[]
+        ? DistributeType(type, right, [...result, DistributeOperation(type, left)])
+        : result.length === 0
+            ? [type]
+            : result);
+}
+function DistributeUnion(types, distribution, result = []) {
+    const [left, ...right] = types;
+    return (IsSchema(left)
+        ? DistributeUnion(right, distribution, [...result, ...Distribute([left], distribution)])
+        : result);
+}
+export function Distribute(types, result = []) {
+    const [left, ...right] = types;
+    return (IsSchema(left)
+        ? IsUnion(left)
+            ? Distribute(right, DistributeUnion(left.anyOf, result))
+            : Distribute(right, DistributeType(left, result))
+        : result);
+}

package/build/type/engine/evaluate/evaluate.d.mts

@@ -0,0 +1,14 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TIntersect } from '../../types/intersect.mjs';
+import { type TDistribute } from './distribute.mjs';
+import { type TBroaden } from './broaden.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TNever } from '../../types/never.mjs';
+export type TEvaluateIntersect<Types extends TSchema[], Distribution extends TSchema[] = TDistribute<Types>, Result extends TSchema = TBroaden<Distribution>> = Result;
+export declare function EvaluateIntersect<Types extends TSchema[]>(types: [...Types]): TEvaluateIntersect<Types>;
+export type TEvaluateUnion<Types extends TSchema[], Result extends TSchema = TBroaden<Types>> = Result;
+export declare function EvaluateUnion<Types extends TSchema[]>(types: [...Types]): TEvaluateUnion<Types>;
+export type TEvaluateType<Type extends TSchema, Result extends TSchema = (Type extends TIntersect<infer Types extends TSchema[]> ? TEvaluateIntersect<Types> : Type extends TUnion<infer Types extends TSchema[]> ? TEvaluateUnion<Types> : Type)> = Result;
+export declare function EvaluateType<Type extends TSchema>(type: Type): TEvaluateType<Type>;
+export type TEvaluateUnionFast<Types extends TSchema[], Result extends TSchema = (Types extends [infer Type extends TSchema] ? Type : Types extends [] ? TNever : TUnion<Types>)> = Result;
+export declare function EvaluateUnionFast<Types extends TSchema[]>(types: [...Types]): TEvaluateUnionFast<Types>;

package/build/type/engine/evaluate/evaluate.mjs

@@ -0,0 +1,27 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { IsIntersect } from '../../types/intersect.mjs';
+import { Distribute } from './distribute.mjs';
+import { Broaden } from './broaden.mjs';
+import { Union, IsUnion } from '../../types/union.mjs';
+import { Never } from '../../types/never.mjs';
+export function EvaluateIntersect(types) {
+    const distribution = Distribute(types);
+    const result = Broaden(distribution);
+    return result;
+}
+export function EvaluateUnion(types) {
+    const result = Broaden(types);
+    return result;
+}
+export function EvaluateType(type) {
+    return (IsIntersect(type) ? EvaluateIntersect(type.allOf) :
+        IsUnion(type) ? EvaluateUnion(type.anyOf) :
+            type);
+}
+export function EvaluateUnionFast(types) {
+    const result = (Guard.IsEqual(types.length, 1) ? types[0] :
+        Guard.IsEqual(types.length, 0) ? Never() :
+            Union(types));
+    return result;
+}

package/build/type/engine/evaluate/flatten.d.mts

@@ -0,0 +1,6 @@
+import { TSchema } from '../../types/schema.mjs';
+import { type TUnion } from '../../types/union.mjs';
+type TFlattenType<Type extends TSchema, Result extends TSchema[] = Type extends TUnion<infer Types extends TSchema[]> ? TFlatten<Types> : [Type]> = Result;
+export type TFlatten<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFlatten<Right, [...Result, ...TFlattenType<Left>]> : Result);
+export declare function Flatten<Types extends TSchema[]>(types: [...Types]): TFlatten<Types>;
+export {};

package/build/type/engine/evaluate/flatten.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { IsUnion } from '../../types/union.mjs';
+function FlattenType(type) {
+    const result = IsUnion(type) ? Flatten(type.anyOf) : [type];
+    return result;
+}
+export function Flatten(types) {
+    return types.reduce((result, type) => {
+        return [...result, ...FlattenType(type)];
+    }, []);
+}

package/build/type/engine/evaluate/index.d.mts

@@ -0,0 +1,8 @@
+export * from './broaden.mjs';
+export * from './compare.mjs';
+export * from './composite.mjs';
+export * from './distribute.mjs';
+export * from './evaluate.mjs';
+export * from './flatten.mjs';
+export * from './instantiate.mjs';
+export * from './narrow.mjs';

package/build/type/engine/evaluate/index.mjs

@@ -0,0 +1,8 @@
+export * from './broaden.mjs';
+export * from './compare.mjs';
+export * from './composite.mjs';
+export * from './distribute.mjs';
+export * from './evaluate.mjs';
+export * from './flatten.mjs';
+export * from './instantiate.mjs';
+export * from './narrow.mjs';

package/build/type/engine/evaluate/instantiate.d.mts

@@ -0,0 +1,8 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TState, type TInstantiateType } from '../instantiate.mjs';
+import { type TEvaluateType } from './evaluate.mjs';
+type TEvaluateImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TEvaluateType<InstantiatedType>;
+export type TEvaluateInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TEvaluateImmediate<Context, State, Type>;
+export declare function EvaluateInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TEvaluateInstantiate<Context, State, Type>;
+export {};

package/build/type/engine/evaluate/instantiate.mjs

@@ -0,0 +1,17 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { InstantiateType } from '../instantiate.mjs';
+import { EvaluateType } from './evaluate.mjs';
+function EvaluateImmediate(context, state, type, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    return Memory.Update(EvaluateType(instantiatedType), {}, options);
+}
+export function EvaluateInstantiate(context, state, type, options) {
+    return (
+    // [instantiation-rule]
+    //
+    // Evaluate instantiation should never defer on instantiate as the caller is specifically 
+    // requesting that the type be evaluated in whatever context is available. However, actions 
+    // embedded in the Evaluate call may defer local to themselves.
+    EvaluateImmediate(context, state, type, options));
+}

package/build/type/engine/evaluate/narrow.d.mts

@@ -0,0 +1,5 @@
+import { TSchema } from '../../types/schema.mjs';
+import { TNever } from '../../types/never.mjs';
+import { TCompare, TCompareResult, ResultLeftInside, ResultRightInside, ResultEqual } from './compare.mjs';
+export type TNarrow<Left extends TSchema, Right extends TSchema, Result extends TCompareResult = TCompare<Left, Right>> = (Result extends typeof ResultLeftInside ? Left : Result extends typeof ResultRightInside ? Right : Result extends typeof ResultEqual ? Right : TNever);
+export declare function Narrow<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TNarrow<Left, Right>;

package/build/type/engine/evaluate/narrow.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { Never } from '../../types/never.mjs';
+import { Compare, ResultLeftInside, ResultRightInside, ResultEqual } from './compare.mjs';
+export function Narrow(left, right) {
+    const result = Compare(left, right);
+    return (Guard.IsEqual(result, ResultLeftInside) ? left :
+        Guard.IsEqual(result, ResultRightInside) ? right :
+            Guard.IsEqual(result, ResultEqual) ? right :
+                Never());
+}

package/build/type/engine/exclude/index.d.mts

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

package/build/type/engine/exclude/index.mjs

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

package/build/type/engine/exclude/instantiate.d.mts

@@ -0,0 +1,16 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TExtends, ExtendsResult } from '../../extends/index.mjs';
+import { type TEnumValuesToVariants } from '../enum/index.mjs';
+import { type TEvaluateUnion, type TFlatten } from '../evaluate/index.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+import { type TExcludeDeferred } from '../../action/exclude.mjs';
+type TExcludeUnion<Types extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Types extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExcludeUnion<Tail, Right, [...Result, ...TExcludeType<Head, Right>]> : Result);
+type TExcludeType<Left extends TSchema, Right extends TSchema, Check extends ExtendsResult.TResult = TExtends<{}, Left, Right>, Result extends TSchema[] = Check extends ExtendsResult.TExtendsTrueLike<infer _> ? [] : [Left]> = Result;
+type TExcludeAction<Left extends TSchema, Right extends TSchema, Remaining extends TSchema[] = (Left extends TEnum<infer Values extends TEnumValue[]> ? TExcludeUnion<TEnumValuesToVariants<Values>, Right> : Left extends TUnion<infer Types extends TSchema[]> ? TExcludeUnion<TFlatten<Types>, Right> : TExcludeType<Left, Right>), Result extends TSchema = TEvaluateUnion<Remaining>> = Result;
+type TExcludeImmediate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, InstantiatedLeft extends TSchema = TInstantiateType<Context, State, Left>, InstantiatedRight extends TSchema = TInstantiateType<Context, State, Right>> = TExcludeAction<InstantiatedLeft, InstantiatedRight>;
+export type TExcludeInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema> = TCanInstantiate<Context, [Left, Right]> extends true ? TExcludeImmediate<Context, State, Left, Right> : TExcludeDeferred<Left, Right>;
+export declare function ExcludeInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema>(context: Context, state: State, left: Left, right: Right, options: TSchemaOptions): TExcludeInstantiate<Context, State, Left, Right>;
+export {};

package/build/type/engine/exclude/instantiate.mjs

@@ -0,0 +1,36 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { IsEnum } from '../../types/enum.mjs';
+import { IsUnion } from '../../types/union.mjs';
+import { Extends, ExtendsResult } from '../../extends/index.mjs';
+import { EnumValuesToVariants } from '../enum/index.mjs';
+import { EvaluateUnion, Flatten } from '../evaluate/index.mjs';
+import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
+import { ExcludeDeferred } from '../../action/exclude.mjs';
+function ExcludeUnion(types, right) {
+    return types.reduce((result, head) => {
+        return [...result, ...ExcludeType(head, right)];
+    }, []);
+}
+function ExcludeType(left, right) {
+    const check = Extends({}, left, right);
+    const result = ExtendsResult.IsExtendsTrueLike(check) ? [] : [left];
+    return result;
+}
+function ExcludeAction(left, right) {
+    const remaining = (IsEnum(left) ? ExcludeUnion(EnumValuesToVariants(left.enum), right) :
+        IsUnion(left) ? ExcludeUnion(Flatten(left.anyOf), right) :
+            ExcludeType(left, right));
+    const result = EvaluateUnion(remaining);
+    return result;
+}
+function ExcludeImmediate(context, state, left, right, options) {
+    const instantiatedLeft = InstantiateType(context, state, left);
+    const instantiatedRight = InstantiateType(context, state, right);
+    return Memory.Update(ExcludeAction(instantiatedLeft, instantiatedRight), {}, options);
+}
+export function ExcludeInstantiate(context, state, left, right, options) {
+    return (CanInstantiate(context, [left, right])
+        ? ExcludeImmediate(context, state, left, right, options)
+        : ExcludeDeferred(left, right, options));
+}

package/build/type/engine/extract/index.d.mts

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

package/build/type/engine/extract/index.mjs

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

package/build/type/engine/extract/instantiate.d.mts

@@ -0,0 +1,16 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TExtends, ExtendsResult } from '../../extends/index.mjs';
+import { type TEnumValuesToVariants } from '../enum/index.mjs';
+import { type TEvaluateUnion, type TFlatten } from '../evaluate/index.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+import { type TExtractDeferred } from '../../action/extract.mjs';
+type TExtractUnion<Types extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Types extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtractUnion<Tail, Right, [...Result, ...TExtractType<Head, Right>]> : Result);
+type TExtractType<Left extends TSchema, Right extends TSchema, Check extends ExtendsResult.TResult = TExtends<{}, Left, Right>, Result extends TSchema[] = Check extends ExtendsResult.TExtendsTrueLike<infer _> ? [Left] : []> = Result;
+type TExtractAction<Left extends TSchema, Right extends TSchema, Remaining extends TSchema[] = (Left extends TEnum<infer Values extends TEnumValue[]> ? TExtractUnion<TEnumValuesToVariants<Values>, Right> : Left extends TUnion<infer Types extends TSchema[]> ? TExtractUnion<TFlatten<Types>, Right> : TExtractType<Left, Right>), Result extends TSchema = TEvaluateUnion<Remaining>> = Result;
+type TExtractImmediate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, InstantiatedLeft extends TSchema = TInstantiateType<Context, State, Left>, InstantiatedRight extends TSchema = TInstantiateType<Context, State, Right>> = TExtractAction<InstantiatedLeft, InstantiatedRight>;
+export type TExtractInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema> = TCanInstantiate<Context, [Left, Right]> extends true ? TExtractImmediate<Context, State, Left, Right> : TExtractDeferred<Left, Right>;
+export declare function ExtractInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema>(context: Context, state: State, left: Left, right: Right, options: TSchemaOptions): TExtractInstantiate<Context, State, Left, Right>;
+export {};

package/build/type/engine/extract/instantiate.mjs

@@ -0,0 +1,36 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { IsEnum } from '../../types/enum.mjs';
+import { IsUnion } from '../../types/union.mjs';
+import { Extends, ExtendsResult } from '../../extends/index.mjs';
+import { EnumValuesToVariants } from '../enum/index.mjs';
+import { EvaluateUnion, Flatten } from '../evaluate/index.mjs';
+import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
+import { ExtractDeferred } from '../../action/extract.mjs';
+function ExtractUnion(types, right) {
+    return types.reduce((result, head) => {
+        return [...result, ...ExtractType(head, right)];
+    }, []);
+}
+function ExtractType(left, right) {
+    const check = Extends({}, left, right);
+    const result = ExtendsResult.IsExtendsTrueLike(check) ? [left] : [];
+    return result;
+}
+function ExtractAction(left, right) {
+    const remaining = (IsEnum(left) ? ExtractUnion(EnumValuesToVariants(left.enum), right) :
+        IsUnion(left) ? ExtractUnion(Flatten(left.anyOf), right) :
+            ExtractType(left, right));
+    const result = EvaluateUnion(remaining);
+    return result;
+}
+function ExtractImmediate(context, state, left, right, options) {
+    const instantiatedLeft = InstantiateType(context, state, left);
+    const instantiatedRight = InstantiateType(context, state, right);
+    return Memory.Update(ExtractAction(instantiatedLeft, instantiatedRight), {}, options);
+}
+export function ExtractInstantiate(context, state, left, right, options) {
+    return (CanInstantiate(context, [left, right])
+        ? ExtractImmediate(context, state, left, right, options)
+        : ExtractDeferred(left, right, options));
+}

package/build/type/engine/helpers/index.d.mts

@@ -0,0 +1,3 @@
+export * from './keys-to-indexer.mjs';
+export * from './keys.mjs';
+export * from './union.mjs';

package/build/type/engine/helpers/index.mjs

@@ -0,0 +1,3 @@
+export * from './keys-to-indexer.mjs';
+export * from './keys.mjs';
+export * from './union.mjs';

package/build/type/engine/helpers/keys-to-indexer.d.mts

@@ -0,0 +1,7 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
+import { type TUnion } from '../../types/union.mjs';
+type TKeysToLiterals<Keys extends PropertyKey[], Result extends TLiteral[] = []> = (Keys extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]] ? (Left extends TLiteralValue ? TKeysToLiterals<Right, [...Result, TLiteral<Left>]> : TKeysToLiterals<Right, Result>) : Result);
+export type TKeysToIndexer<Keys extends PropertyKey[], Literals extends TLiteral[] = TKeysToLiterals<Keys>, Result extends TSchema = TUnion<Literals>> = Result;
+export declare function KeysToIndexer<Keys extends PropertyKey[]>(keys: [...Keys]): TKeysToIndexer<Keys>;
+export {};

package/build/type/engine/helpers/keys-to-indexer.mjs

@@ -0,0 +1,15 @@
+// deno-fmt-ignore-file
+import { Literal, IsLiteralValue } from '../../types/literal.mjs';
+import { Union } from '../../types/union.mjs';
+function KeysToLiterals(keys) {
+    return keys.reduce((result, left) => {
+        return IsLiteralValue(left)
+            ? [...result, Literal(left)]
+            : result;
+    }, []);
+}
+export function KeysToIndexer(keys) {
+    const literals = KeysToLiterals(keys);
+    const result = Union(literals);
+    return result;
+}

package/build/type/engine/helpers/keys.d.mts

@@ -0,0 +1,3 @@
+import { type TLiteralValue } from '../../types/literal.mjs';
+export type TConvertToIntegerKey<Value extends TLiteralValue, Normal extends string = `${Value}`, Result extends TLiteralValue = (Normal extends ` ${infer _ extends number}` ? Normal : Normal extends `${infer _ extends number} ` ? Normal : Normal extends `0${infer _ extends number}` ? Normal : Normal extends `-${infer _ extends number}` ? Normal : Normal extends `${infer Value extends number}` ? Value : Value)> = Result;
+export declare function ConvertToIntegerKey<Value extends TLiteralValue>(value: Value): TConvertToIntegerKey<Value>;

package/build/type/engine/helpers/keys.mjs

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+const integerKeyPattern = new RegExp('^(?:0|[1-9][0-9]*)$');
+export function ConvertToIntegerKey(value) {
+    const normal = `${value}`;
+    return (integerKeyPattern.test(normal)
+        ? parseInt(normal)
+        : value);
+}

package/build/type/engine/helpers/union.d.mts

@@ -0,0 +1,7 @@
+export type TTupleToIntersect<T extends any[]> = T extends [infer I] ? I : T extends [infer I, ...infer R] ? I & TTupleToIntersect<R> : never;
+export type TTupleToUnion<T extends any[]> = {
+    [K in keyof T]: T[K];
+}[number];
+export type TUnionToIntersect<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never;
+export type TUnionLast<U> = TUnionToIntersect<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never;
+export type TUnionToTuple<U, Result extends unknown[] = [], R = TUnionLast<U>> = [U] extends [never] ? Result : TUnionToTuple<Exclude<U, R>, [Extract<U, R>, ...Result]>;

package/build/type/engine/helpers/union.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/type/engine/index.d.mts

@@ -0,0 +1,31 @@
+export { Instantiate, type TInstantiate } from './instantiate.mjs';
+export * from './awaited/index.mjs';
+export * from './conditional/index.mjs';
+export * from './constructor-parameters/index.mjs';
+export * from './cyclic/index.mjs';
+export * from './enum/index.mjs';
+export * from './evaluate/index.mjs';
+export * from './exclude/index.mjs';
+export * from './extract/index.mjs';
+export * from './helpers/index.mjs';
+export * from './indexed/index.mjs';
+export * from './instance-type/index.mjs';
+export * from './interface/index.mjs';
+export * from './intrinsics/index.mjs';
+export * from './keyof/index.mjs';
+export * from './mapped/index.mjs';
+export * from './module/index.mjs';
+export * from './non-nullable/index.mjs';
+export * from './object/index.mjs';
+export * from './omit/index.mjs';
+export * from './options/index.mjs';
+export * from './parameters/index.mjs';
+export * from './patterns/index.mjs';
+export * from './partial/index.mjs';
+export * from './pick/index.mjs';
+export * from './readonly-type/index.mjs';
+export * from './record/index.mjs';
+export * from './ref/index.mjs';
+export * from './required/index.mjs';
+export * from './return-type/index.mjs';
+export * from './template-literal/index.mjs';

package/build/type/engine/index.mjs

@@ -0,0 +1,37 @@
+// ------------------------------------------------------------------
+// Engine: Public
+// ------------------------------------------------------------------
+export { Instantiate } from './instantiate.mjs';
+// ------------------------------------------------------------------
+// Engine: Internals
+// ------------------------------------------------------------------
+export * from './awaited/index.mjs';
+export * from './conditional/index.mjs';
+export * from './constructor-parameters/index.mjs';
+export * from './cyclic/index.mjs';
+export * from './enum/index.mjs';
+export * from './evaluate/index.mjs';
+export * from './exclude/index.mjs';
+export * from './extract/index.mjs';
+export * from './helpers/index.mjs';
+export * from './indexed/index.mjs';
+export * from './instance-type/index.mjs';
+export * from './interface/index.mjs';
+export * from './intrinsics/index.mjs';
+export * from './keyof/index.mjs';
+export * from './mapped/index.mjs';
+export * from './module/index.mjs';
+export * from './non-nullable/index.mjs';
+export * from './object/index.mjs';
+export * from './omit/index.mjs';
+export * from './options/index.mjs';
+export * from './parameters/index.mjs';
+export * from './patterns/index.mjs';
+export * from './partial/index.mjs';
+export * from './pick/index.mjs';
+export * from './readonly-type/index.mjs';
+export * from './record/index.mjs';
+export * from './ref/index.mjs';
+export * from './required/index.mjs';
+export * from './return-type/index.mjs';
+export * from './template-literal/index.mjs';

package/build/type/engine/indexable/from-cyclic.d.mts

@@ -0,0 +1,6 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TFromType } from './from-type.mjs';
+import { type TCyclicTarget } from '../cyclic/target.mjs';
+export type TFromCyclic<Defs extends TProperties, Ref extends string, Target extends TSchema = TCyclicTarget<Defs, Ref>, Result extends string[] = TFromType<Target>> = Result;
+export declare function FromCyclic<Defs extends TProperties, Ref extends string>(defs: Defs, ref: Ref): TFromCyclic<Defs, Ref>;

package/build/type/engine/indexable/from-cyclic.mjs

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+import { FromType } from './from-type.mjs';
+import { CyclicTarget } from '../cyclic/target.mjs';
+export function FromCyclic(defs, ref) {
+    const target = CyclicTarget(defs, ref);
+    const result = FromType(target);
+    return result;
+}

package/build/type/engine/indexable/from-enum.d.mts

@@ -0,0 +1,6 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TEnumValue } from '../../types/enum.mjs';
+import { type TEnumValuesToVariants } from '../enum/enum-to-union.mjs';
+import { type TFromUnion } from './from-union.mjs';
+export type TFromEnum<Values extends TEnumValue[], Variants extends TSchema[] = TEnumValuesToVariants<Values>, Result extends string[] = TFromUnion<Variants>> = Result;
+export declare function FromEnum<Values extends TEnumValue[]>(values: [...Values]): TFromEnum<Values>;

package/build/type/engine/indexable/from-enum.mjs

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+import { EnumValuesToVariants } from '../enum/enum-to-union.mjs';
+import { FromUnion } from './from-union.mjs';
+export function FromEnum(values) {
+    const variants = EnumValuesToVariants(values);
+    const result = FromUnion(variants);
+    return result;
+}

package/build/type/engine/indexable/from-intersect.d.mts

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TEvaluateIntersect } from '../evaluate/evaluate.mjs';
+import { type TFromType } from './from-type.mjs';
+export type TFromIntersect<Types extends TSchema[], Evaluated extends TSchema = TEvaluateIntersect<Types>, Result extends string[] = TFromType<Evaluated>> = Result;
+export declare function FromIntersect<Types extends TSchema[]>(types: [...Types]): TFromIntersect<Types>;

package/build/type/engine/indexable/from-intersect.mjs

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+import { EvaluateIntersect } from '../evaluate/evaluate.mjs';
+import { FromType } from './from-type.mjs';
+export function FromIntersect(types) {
+    const evaluated = EvaluateIntersect(types);
+    const result = FromType(evaluated);
+    return result;
+}

package/build/type/engine/indexable/from-literal.d.mts

@@ -0,0 +1,3 @@
+import { TLiteralValue } from '../../types/literal.mjs';
+export type TFromLiteral<Value extends TLiteralValue, Result extends string[] = [`${Value}`]> = Result;
+export declare function FromLiteral<Value extends TLiteralValue>(value: Value): TFromLiteral<Value>;

package/build/type/engine/indexable/from-literal.mjs

@@ -0,0 +1,5 @@
+// deno-fmt-ignore-file
+export function FromLiteral(value) {
+    const result = [`${value}`];
+    return result;
+}

package/build/type/engine/indexable/from-template-literal.d.mts

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TTemplateLiteralDecode } from '../template-literal/decode.mjs';
+import { type TFromType } from './from-type.mjs';
+export type TFromTemplateLiteral<Pattern extends string, Decoded extends TSchema = TTemplateLiteralDecode<Pattern>, Result extends string[] = TFromType<Decoded>> = Result;
+export declare function FromTemplateLiteral<Pattern extends string>(pattern: Pattern): TFromTemplateLiteral<Pattern>;

package/build/type/engine/indexable/from-template-literal.mjs

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+import { TemplateLiteralDecode } from '../template-literal/decode.mjs';
+import { FromType } from './from-type.mjs';
+export function FromTemplateLiteral(pattern) {
+    const decoded = TemplateLiteralDecode(pattern);
+    const result = FromType(decoded);
+    return result;
+}

package/build/type/engine/indexable/from-type.d.mts

@@ -0,0 +1,17 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
+import { type TIntersect } from '../../types/intersect.mjs';
+import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TTemplateLiteral } from '../../types/template-literal.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { TFromCyclic } from './from-cyclic.mjs';
+import { TFromEnum } from './from-enum.mjs';
+import { TFromIntersect } from './from-intersect.mjs';
+import { TFromLiteral } from './from-literal.mjs';
+import { TFromTemplateLiteral } from './from-template-literal.mjs';
+import { TFromUnion } from './from-union.mjs';
+export type TFromType<Indexer extends TSchema, Result extends string[] = (Indexer extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? TFromCyclic<Defs, Ref> : Indexer extends TEnum<infer Values extends TEnumValue[]> ? TFromEnum<Values> : Indexer extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types> : Indexer extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteral<Value> : Indexer extends TTemplateLiteral<infer Pattern extends string> ? TFromTemplateLiteral<Pattern> : Indexer extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : [
+])> = Result;
+export declare function FromType<Indexer extends TSchema>(type: Indexer): TFromType<Indexer>;

package/build/type/engine/indexable/from-type.mjs

@@ -0,0 +1,22 @@
+// deno-fmt-ignore-file
+import { IsCyclic } from '../../types/cyclic.mjs';
+import { IsEnum } from '../../types/enum.mjs';
+import { IsIntersect } from '../../types/intersect.mjs';
+import { IsLiteral } from '../../types/literal.mjs';
+import { IsTemplateLiteral } from '../../types/template-literal.mjs';
+import { IsUnion } from '../../types/union.mjs';
+import { FromCyclic } from './from-cyclic.mjs';
+import { FromEnum } from './from-enum.mjs';
+import { FromIntersect } from './from-intersect.mjs';
+import { FromLiteral } from './from-literal.mjs';
+import { FromTemplateLiteral } from './from-template-literal.mjs';
+import { FromUnion } from './from-union.mjs';
+export function FromType(type) {
+    return (IsCyclic(type) ? FromCyclic(type.$defs, type.$ref) :
+        IsEnum(type) ? FromEnum(type.enum) :
+            IsIntersect(type) ? FromIntersect(type.allOf) :
+                IsLiteral(type) ? FromLiteral(type.const) :
+                    IsTemplateLiteral(type) ? FromTemplateLiteral(type.pattern) :
+                        IsUnion(type) ? FromUnion(type.anyOf) :
+                            []);
+}

package/build/type/engine/indexable/from-union.d.mts

@@ -0,0 +1,4 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TFromType } from './from-type.mjs';
+export type TFromUnion<Types extends TSchema[], Result extends string[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromUnion<Right, [...Result, ...TFromType<Left>]> : Result);
+export declare function FromUnion<Types extends TSchema[]>(types: [...Types]): TFromUnion<Types>;

package/build/type/engine/indexable/from-union.mjs

@@ -0,0 +1,7 @@
+// deno-fmt-ignore-file
+import { FromType } from './from-type.mjs';
+export function FromUnion(types) {
+    return types.reduce((result, left) => {
+        return [...result, ...FromType(left)];
+    }, []);
+}

package/build/type/engine/indexable/to-indexable-keys.d.mts

@@ -0,0 +1,10 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TFromType } from './from-type.mjs';
+export type TToIndexableKeys<Indexer extends TSchema, Result extends string[] = TFromType<Indexer>> = Result;
+/**
+ * Transforms a type meant as an Indexer into string[] array which is used by Indexable types
+ * like Index, Pick and Omit to select from property keys. This function should only be used
+ * for Object key selection, and not for Array / Tuple key selection as Array-Like structures
+ * require TNumber indexing support.
+ */
+export declare function ToIndexableKeys<Indexer extends TSchema>(type: Indexer): TToIndexableKeys<Indexer>;

package/build/type/engine/indexable/to-indexable-keys.mjs

@@ -0,0 +1,12 @@
+// deno-fmt-ignore-file
+import { FromType } from './from-type.mjs';
+/**
+ * Transforms a type meant as an Indexer into string[] array which is used by Indexable types
+ * like Index, Pick and Omit to select from property keys. This function should only be used
+ * for Object key selection, and not for Array / Tuple key selection as Array-Like structures
+ * require TNumber indexing support.
+ */
+export function ToIndexableKeys(type) {
+    const result = FromType(type);
+    return result;
+}