typebox 1.0.31 → 1.0.33

package/build/cjs/type/engine/return-type/instantiate.js

@@ -0,0 +1,21 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReturnTypeInstantiate = ReturnTypeInstantiate;
+const index_1 = require("../../../system/memory/index");
+const function_1 = require("../../types/function");
+const never_1 = require("../../types/never");
+const return_type_1 = require("../../action/return-type");
+const instantiate_1 = require("../instantiate");
+function ReturnTypeAction(type) {
+    return ((0, function_1.IsFunction)(type) ? type.returnType : (0, never_1.Never)());
+}
+function ReturnTypeImmediate(context, state, type, options) {
+    const instantiatedType = (0, instantiate_1.InstantiateType)(context, state, type);
+    return index_1.Memory.Update(ReturnTypeAction(instantiatedType), {}, options);
+}
+function ReturnTypeInstantiate(context, state, type, options) {
+    return ((0, instantiate_1.CanInstantiate)(context, [type])
+        ? ReturnTypeImmediate(context, state, type, options)
+        : (0, return_type_1.ReturnTypeDeferred)(type, options));
+}

package/build/cjs/type/engine/template-literal/create.js

@@ -0,0 +1,8 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateLiteralCreate = TemplateLiteralCreate;
+const index_1 = require("../../../system/memory/index");
+function TemplateLiteralCreate(pattern) {
+    return index_1.Memory.Create({ ['~kind']: 'TemplateLiteral' }, { type: 'string', pattern }, {});
+}

package/build/cjs/type/engine/template-literal/decode.d.ts

@@ -0,0 +1,20 @@
+import { TUnreachable } from '../../../system/unreachable/index';
+import { type TSchema } from '../../types/schema';
+import { type TUnion } from '../../types/union';
+import { type TString } from '../../types/string';
+import { type TLiteral, type TLiteralValue } from '../../types/literal';
+import { type TParsePatternIntoTypes } from '../patterns/pattern';
+import { type TTemplateLiteralFinite } from './finite';
+type TFromLiteralPush<Variants extends string[], Value extends TLiteralValue, Result extends string[] = []> = Variants extends [infer Left extends string, ...infer Right extends string[]] ? TFromLiteralPush<Right, Value, [...Result, `${Left}${Value}`]> : Result;
+type TFromLiteral<Variants extends string[], Value extends TLiteralValue> = Variants extends [] ? [`${Value}`] : TFromLiteralPush<Variants, Value>;
+type TFromUnion<Variants extends string[], Types extends TSchema[], Result extends string[] = []> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromUnion<Variants, Right, [...Result, ...TFromType<Variants, Left>]> : Result;
+type TFromType<Variants extends string[], Type extends TSchema, Result extends string[] = (Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Variants, Types> : Type extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteral<Variants, Value> : TUnreachable)> = Result;
+type TDecodeFromSpan<Variants extends string[], Types extends TSchema[]> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TDecodeFromSpan<TFromType<Variants, Left>, Right> : Variants;
+type TVariantsToLiterals<Variants extends string[], Result extends TSchema[] = []> = Variants extends [infer Left extends string, ...infer Right extends string[]] ? TVariantsToLiterals<Right, [...Result, TLiteral<Left>]> : Result;
+type TDecodeTypesAsUnion<Types extends TSchema[], Variants extends string[] = TDecodeFromSpan<[], Types>, Literals extends TSchema[] = TVariantsToLiterals<Variants>, Result extends TSchema = TUnion<Literals>> = Result;
+type TDecodeTypes<Types extends TSchema[], Result extends TSchema = (Types extends [] ? TUnreachable : Types extends [infer Type extends TLiteral] ? Type : TDecodeTypesAsUnion<Types>)> = Result;
+/** Decodes a TemplateLiteral into a Type. If the TemplateLiteral yields a non-finite set, the return value is TString */
+export type TTemplateLiteralDecode<Pattern extends string, Types extends TSchema[] = TParsePatternIntoTypes<Pattern>, Finite extends boolean = TTemplateLiteralFinite<Types>, Result extends TSchema = (Finite extends true ? TDecodeTypes<Types> : TString)> = Result;
+/** Decodes a TemplateLiteral into a Type. If the TemplateLiteral yields a non-finite set, the return value is TString */
+export declare function TemplateLiteralDecode<Pattern extends string>(pattern: Pattern): TTemplateLiteralDecode<Pattern>;
+export {};

package/build/cjs/type/engine/template-literal/decode.js

@@ -0,0 +1,76 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateLiteralDecode = TemplateLiteralDecode;
+const index_1 = require("../../../system/unreachable/index");
+const index_2 = require("../../../guard/index");
+const schema_1 = require("../../types/schema");
+const union_1 = require("../../types/union");
+const string_1 = require("../../types/string");
+const literal_1 = require("../../types/literal");
+const pattern_1 = require("../patterns/pattern");
+const finite_1 = require("./finite");
+function FromLiteralPush(variants, value, result = []) {
+    const [left, ...right] = variants;
+    return (index_2.Guard.IsString(left) ? FromLiteralPush(right, value, [...result, `${left}${value}`]) : result);
+}
+function FromLiteral(variants, value) {
+    return (index_2.Guard.IsEqual(variants.length, 0) ? [`${value}`] : FromLiteralPush(variants, value));
+}
+function FromUnion(variants, types, result = []) {
+    const [left, ...right] = types;
+    return ((0, schema_1.IsSchema)(left)
+        ? FromUnion(variants, right, [...result, ...FromType(variants, left)])
+        : result);
+}
+// ------------------------------------------------------------------
+// deno-coverage-ignore-start - symmetric unreachable | internal
+// 
+// Parsed TemplateLiteral patterns only yield Literal or Union but
+// we keep the fall-through to assert that no other types can reach 
+// here without error.
+//
+// ------------------------------------------------------------------
+function FromType(variants, type) {
+    const result = ((0, union_1.IsUnion)(type) ? FromUnion(variants, type.anyOf) :
+        (0, literal_1.IsLiteral)(type) ? FromLiteral(variants, type.const) :
+            (0, index_1.Unreachable)() // []
+    );
+    return result;
+}
+function DecodeFromSpan(variants, types) {
+    const [left, ...right] = types;
+    return ((0, schema_1.IsSchema)(left) ? DecodeFromSpan(FromType(variants, left), right) : variants);
+}
+function VariantsToLiterals(variants) {
+    return variants.map(variant => (0, literal_1.Literal)(variant));
+}
+function DecodeTypesAsUnion(types) {
+    const variants = DecodeFromSpan([], types);
+    const literals = VariantsToLiterals(variants);
+    const result = (0, union_1.Union)(literals);
+    return result;
+}
+// ------------------------------------------------------------------
+// deno-coverage-ignore-start - internal
+// 
+// Cannot invoke the 0-length condition as the TemplateLiteral 
+// parsers always return at least 1 TLiteral or TUnion. We would 
+// return a empty string TLiteral for this case, but will use 
+// Unreachable to catch parse inputs that trigger 0-length.
+//
+// ------------------------------------------------------------------
+function DecodeTypes(types) {
+    return (index_2.Guard.IsEqual(types.length, 0) ? (0, index_1.Unreachable)() : // Literal('') :
+        index_2.Guard.IsEqual(types.length, 1) && (0, literal_1.IsLiteral)(types[0]) ? types[0] :
+            DecodeTypesAsUnion(types));
+}
+/** Decodes a TemplateLiteral into a Type. If the TemplateLiteral yields a non-finite set, the return value is TString */
+function TemplateLiteralDecode(pattern) {
+    const types = (0, pattern_1.ParsePatternIntoTypes)(pattern);
+    const finite = (0, finite_1.TemplateLiteralFinite)(types);
+    const result = finite
+        ? DecodeTypes(types)
+        : (0, string_1.String)();
+    return result;
+}

package/build/cjs/type/engine/template-literal/encode.d.ts

@@ -0,0 +1,31 @@
+import { type TSchema } from '../../types/schema';
+import { type TEnum, type TEnumValue } from '../../types/enum';
+import { type TLiteral, type TLiteralValue } from '../../types/literal';
+import { type TUnion } from '../../types/union';
+import { type TTemplateLiteral } from '../../types/template-literal';
+import { type TBigInt, BigIntPattern } from '../../types/bigint';
+import { type TString, StringPattern } from '../../types/string';
+import { type TNumber, NumberPattern } from '../../types/number';
+import { type TInteger, IntegerPattern } from '../../types/integer';
+import { type TBoolean } from '../../types/boolean';
+import { NeverPattern } from '../../types/never';
+import { type TEnumValuesToVariants } from '../enum/enum-to-union';
+type TJoinString<Input extends string[], Result extends string = ''> = (Input extends [infer Left extends string, ...infer Right extends string[]] ? Result extends '' ? TJoinString<Right, Left> : TJoinString<Right, `${Result}|${Left}`> : Result);
+type TUnwrapTemplateLiteralPattern<Pattern extends string> = (Pattern extends `^${infer Pattern extends string}$` ? Pattern : never);
+type TEncodeLiteral<Value extends TLiteralValue, Right extends TSchema[], Pattern extends string> = (TEncodeTypes<Right, `${Pattern}${Value}`>);
+type TEncodeBigInt<Right extends TSchema[], Pattern extends string> = (TEncodeTypes<Right, `${Pattern}${typeof BigIntPattern}`>);
+type TEncodeInteger<Right extends TSchema[], Pattern extends string> = (TEncodeTypes<Right, `${Pattern}${typeof IntegerPattern}`>);
+type TEncodeNumber<Right extends TSchema[], Pattern extends string> = (TEncodeTypes<Right, `${Pattern}${typeof NumberPattern}`>);
+type TEncodeBoolean<Right extends TSchema[], Pattern extends string> = (TEncodeType<TUnion<[TLiteral<'false'>, TLiteral<'true'>]>, Right, Pattern>);
+type TEncodeString<Right extends TSchema[], Pattern extends string> = (TEncodeTypes<Right, `${Pattern}${typeof StringPattern}`>);
+type TEncodeTemplateLiteral<TemplatePattern extends string, Right extends TSchema[], Pattern extends string> = (TEncodeTypes<Right, `${Pattern}${TUnwrapTemplateLiteralPattern<TemplatePattern>}`>);
+type TEncodeEnum<Types extends TEnumValue[], Right extends TSchema[], Pattern extends string, Variants extends TSchema[] = TEnumValuesToVariants<Types>> = TEncodeUnion<Variants, Right, Pattern>;
+type TEncodeUnion<Types extends TSchema[], Right extends TSchema[], Pattern extends string, Result extends string[] = []> = Types extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TEncodeUnion<Tail, Right, Pattern, [...Result, TEncodeType<Head, [], ''>]> : TEncodeTypes<Right, `${Pattern}(${TJoinString<Result>})`>;
+type TEncodeType<Type extends TSchema, Right extends TSchema[], Pattern extends string> = (Type extends TEnum<infer Values extends TEnumValue[]> ? TEncodeEnum<Values, Right, Pattern> : Type extends TInteger ? TEncodeInteger<Right, Pattern> : Type extends TLiteral<infer Value extends TLiteralValue> ? TEncodeLiteral<Value, Right, Pattern> : Type extends TBigInt ? TEncodeBigInt<Right, Pattern> : Type extends TBoolean ? TEncodeBoolean<Right, Pattern> : Type extends TNumber ? TEncodeNumber<Right, Pattern> : Type extends TString ? TEncodeString<Right, Pattern> : Type extends TTemplateLiteral<infer TemplatePattern extends string> ? TEncodeTemplateLiteral<TemplatePattern, Right, Pattern> : Type extends TUnion<infer Types extends TSchema[]> ? TEncodeUnion<Types, Right, Pattern> : typeof NeverPattern);
+type TEncodeTypes<Types extends TSchema[], Pattern extends string> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TEncodeType<Left, Right, Pattern> : Pattern);
+type TEncodePattern<Types extends TSchema[], Encoded extends string = TEncodeTypes<Types, ''>, Result extends string = `^${Encoded}$`> = Result;
+/** Encodes a TemplateLiteral type sequence into a TemplateLiteral */
+export type TTemplateLiteralEncode<Types extends TSchema[], Pattern extends string = TEncodePattern<Types>, Result extends TSchema = TTemplateLiteral<Pattern>> = Result;
+/** Encodes a TemplateLiteral type sequence into a TemplateLiteral */
+export declare function TemplateLiteralEncode<Types extends TSchema[]>(types: [...Types]): TTemplateLiteralEncode<Types>;
+export {};

package/build/cjs/type/engine/template-literal/encode.js

@@ -0,0 +1,83 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateLiteralEncode = TemplateLiteralEncode;
+const schema_1 = require("../../types/schema");
+const enum_1 = require("../../types/enum");
+const literal_1 = require("../../types/literal");
+const union_1 = require("../../types/union");
+const template_literal_1 = require("../../types/template-literal");
+const bigint_1 = require("../../types/bigint");
+const string_1 = require("../../types/string");
+const number_1 = require("../../types/number");
+const integer_1 = require("../../types/integer");
+const boolean_1 = require("../../types/boolean");
+const never_1 = require("../../types/never");
+const create_1 = require("./create");
+const enum_to_union_1 = require("../enum/enum-to-union");
+function JoinString(input) {
+    return input.join('|');
+}
+function UnwrapTemplateLiteralPattern(pattern) {
+    return pattern.slice(1, pattern.length - 1);
+}
+function EncodeLiteral(value, right, pattern) {
+    return EncodeTypes(right, `${pattern}${value}`);
+}
+function EncodeBigInt(right, pattern) {
+    return EncodeTypes(right, `${pattern}${bigint_1.BigIntPattern}`);
+}
+function EncodeInteger(right, pattern) {
+    return EncodeTypes(right, `${pattern}${integer_1.IntegerPattern}`);
+}
+function EncodeNumber(right, pattern) {
+    return EncodeTypes(right, `${pattern}${number_1.NumberPattern}`);
+}
+function EncodeBoolean(right, pattern) {
+    return EncodeType((0, union_1.Union)([(0, literal_1.Literal)('false'), (0, literal_1.Literal)('true')]), right, pattern);
+}
+function EncodeString(right, pattern) {
+    return EncodeTypes(right, `${pattern}${string_1.StringPattern}`);
+}
+function EncodeTemplateLiteral(templatePattern, right, pattern) {
+    return EncodeTypes(right, `${pattern}${UnwrapTemplateLiteralPattern(templatePattern)}`);
+}
+function EncodeEnum(types, right, pattern, result = []) {
+    const variants = (0, enum_to_union_1.EnumValuesToVariants)(types);
+    return EncodeUnion(variants, right, pattern);
+}
+function EncodeUnion(types, right, pattern, result = []) {
+    const [head, ...tail] = types;
+    return ((0, schema_1.IsSchema)(head)
+        ? EncodeUnion(tail, right, pattern, [...result, EncodeType(head, [], '')])
+        : EncodeTypes(right, `${pattern}(${JoinString(result)})`));
+}
+function EncodeType(type, right, pattern) {
+    return ((0, enum_1.IsEnum)(type) ? EncodeEnum(type.enum, right, pattern) :
+        (0, integer_1.IsInteger)(type) ? EncodeInteger(right, pattern) :
+            (0, literal_1.IsLiteral)(type) ? EncodeLiteral(type.const, right, pattern) :
+                (0, bigint_1.IsBigInt)(type) ? EncodeBigInt(right, pattern) :
+                    (0, boolean_1.IsBoolean)(type) ? EncodeBoolean(right, pattern) :
+                        (0, number_1.IsNumber)(type) ? EncodeNumber(right, pattern) :
+                            (0, string_1.IsString)(type) ? EncodeString(right, pattern) :
+                                (0, template_literal_1.IsTemplateLiteral)(type) ? EncodeTemplateLiteral(type.pattern, right, pattern) :
+                                    (0, union_1.IsUnion)(type) ? EncodeUnion(type.anyOf, right, pattern) :
+                                        never_1.NeverPattern);
+}
+function EncodeTypes(types, pattern) {
+    const [left, ...right] = types;
+    return ((0, schema_1.IsSchema)(left)
+        ? EncodeType(left, right, pattern)
+        : pattern);
+}
+function EncodePattern(types) {
+    const encoded = EncodeTypes(types, '');
+    const result = `^${encoded}$`;
+    return result;
+}
+/** Encodes a TemplateLiteral type sequence into a TemplateLiteral */
+function TemplateLiteralEncode(types) {
+    const pattern = EncodePattern(types);
+    const result = (0, create_1.TemplateLiteralCreate)(pattern);
+    return result;
+}

package/build/cjs/type/engine/template-literal/finite.d.ts

@@ -0,0 +1,12 @@
+import { type TSchema } from '../../types/schema';
+import { type TLiteral, type TLiteralValue } from '../../types/literal';
+import { type TUnion } from '../../types/union';
+type TFromLiteral<_Value extends TLiteralValue> = true;
+type TFromTypesReduce<Types extends TSchema[]> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromType<Left> extends true ? TFromTypesReduce<Right> : false : true);
+type TFromTypes<Types extends TSchema[], Result extends boolean = Types extends [] ? false : TFromTypesReduce<Types>> = Result;
+type TFromType<Type extends TSchema> = Type extends TUnion<infer Types extends TSchema[]> ? TFromTypes<Types> : Type extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteral<Value> : false;
+/** Returns true if the given TemplateLiteral types yields a finite variant set */
+export type TTemplateLiteralFinite<Types extends TSchema[], Result extends boolean = TFromTypes<Types>> = Result;
+/** Returns true if the given TemplateLiteral types yields a finite variant set */
+export declare function TemplateLiteralFinite<Types extends TSchema[]>(types: [...Types]): TTemplateLiteralFinite<Types>;
+export {};

package/build/cjs/type/engine/template-literal/finite.js

@@ -0,0 +1,33 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateLiteralFinite = TemplateLiteralFinite;
+const index_1 = require("../../../guard/index");
+const schema_1 = require("../../types/schema");
+const literal_1 = require("../../types/literal");
+const union_1 = require("../../types/union");
+function FromLiteral(value) {
+    return true;
+}
+function FromTypesReduce(types) {
+    const [left, ...right] = types;
+    return ((0, schema_1.IsSchema)(left)
+        ? FromType(left)
+            ? FromTypesReduce(right)
+            : false
+        : true);
+}
+function FromTypes(types) {
+    const result = index_1.Guard.IsEqual(types.length, 0) ? false : FromTypesReduce(types);
+    return result;
+}
+function FromType(type) {
+    return ((0, union_1.IsUnion)(type) ? FromTypes(type.anyOf) :
+        (0, literal_1.IsLiteral)(type) ? FromLiteral(type.const) :
+            false);
+}
+/** Returns true if the given TemplateLiteral types yields a finite variant set */
+function TemplateLiteralFinite(types) {
+    const result = FromTypes(types);
+    return result;
+}

package/build/cjs/type/engine/template-literal/index.d.ts

@@ -0,0 +1,5 @@
+export * from './create';
+export * from './decode';
+export * from './encode';
+export * from './finite';
+export * from './static';

package/build/cjs/type/engine/template-literal/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./create"), exports);
+__exportStar(require("./decode"), exports);
+__exportStar(require("./encode"), exports);
+__exportStar(require("./finite"), exports);
+__exportStar(require("./static"), exports);

package/build/cjs/type/engine/template-literal/instantiate.d.ts

@@ -0,0 +1,9 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema';
+import { type TProperties } from '../../types/properties';
+import { type TTemplateLiteralDeferred } from '../../types/template-literal';
+import { type TTemplateLiteralEncode } from './encode';
+import { type TState, type TInstantiateTypes, type TCanInstantiate } from '../instantiate';
+type TTemplateLiteralImmediate<Context extends TProperties, State extends TState, Types extends TSchema[], InstantiatedTypes extends TSchema[] = TInstantiateTypes<Context, State, Types>, Result extends TSchema = TTemplateLiteralEncode<InstantiatedTypes>> = Result;
+export type TTemplateLiteralInstantiate<Context extends TProperties, State extends TState, Types extends TSchema[]> = TCanInstantiate<Context, Types> extends true ? TTemplateLiteralImmediate<Context, State, Types> : TTemplateLiteralDeferred<Types>;
+export declare function TemplateLiteralInstantiate<Context extends TProperties, State extends TState, Types extends TSchema[]>(context: Context, state: State, types: [...Types], options: TSchemaOptions): TTemplateLiteralInstantiate<Context, State, Types>;
+export {};

package/build/cjs/type/engine/template-literal/instantiate.js

@@ -0,0 +1,17 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateLiteralInstantiate = TemplateLiteralInstantiate;
+const index_1 = require("../../../system/memory/index");
+const template_literal_1 = require("../../types/template-literal");
+const encode_1 = require("./encode");
+const instantiate_1 = require("../instantiate");
+function TemplateLiteralImmediate(context, state, types, options) {
+    const instaniatedTypes = (0, instantiate_1.InstantiateTypes)(context, state, types);
+    return index_1.Memory.Update((0, encode_1.TemplateLiteralEncode)(instaniatedTypes), {}, options);
+}
+function TemplateLiteralInstantiate(context, state, types, options) {
+    return ((0, instantiate_1.CanInstantiate)(context, types)
+        ? TemplateLiteralImmediate(context, state, types, options)
+        : (0, template_literal_1.TemplateLiteralDeferred)(types, options));
+}

package/build/cjs/type/engine/template-literal/static.d.ts

@@ -0,0 +1,18 @@
+import { type TSchema } from '../../types/schema';
+import { type TUnion } from '../../types/union';
+import { type TBigInt } from '../../types/bigint';
+import { type TString } from '../../types/string';
+import { type TNumber } from '../../types/number';
+import { type TInteger } from '../../types/integer';
+import { type TLiteral, type TLiteralValue } from '../../types/literal';
+import { type TParsePatternIntoTypes } from '../patterns/pattern';
+type TFromLiteral<Template extends string, Value extends TLiteralValue> = `${Template}${Value}`;
+type TFromBigInt<Template extends string> = `${Template}${bigint}`;
+type TFromString<Template extends string> = `${Template}${string}`;
+type TFromNumber<Template extends string> = `${Template}${number}`;
+type TFromInteger<Template extends string> = `${Template}${number}`;
+type TFromUnion<Template extends string, Types extends TSchema[], Result extends string = never> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromUnion<Template, Right, Result | TFromType<'', Left>> : `${Template}${Result}`);
+type TFromType<Template extends string, Type extends TSchema, Result extends string = (Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Template, Types> : Type extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteral<Template, Value> : Type extends TBigInt ? TFromBigInt<Template> : Type extends TString ? TFromString<Template> : Type extends TNumber ? TFromNumber<Template> : Type extends TInteger ? TFromInteger<Template> : never)> = Result;
+type TFromSpan<Template extends string, Types extends TSchema[]> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromSpan<TFromType<Template, Left>, Right> : Template);
+export type TTemplateLiteralStatic<Pattern extends string, Types extends TSchema[] = TParsePatternIntoTypes<Pattern>> = TFromSpan<'', Types>;
+export {};

package/build/cjs/type/engine/template-literal/static.js

@@ -0,0 +1,3 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/cjs/type/engine/tuple/to-object.d.ts

@@ -0,0 +1,12 @@
+import { type TSchema } from '../../types/schema';
+import { type TObject } from '../../types/object';
+import { type TProperties } from '../../types/properties';
+import { type TTuple } from '../../types/tuple';
+export type TTupleElementsToProperties<Types extends TSchema[], Result extends TProperties = {}> = (Types extends [...infer Left extends TSchema[], infer Right extends TSchema] ? TTupleElementsToProperties<Left, {
+    [_ in Left['length']]: Right;
+} & Result> : {
+    [Key in keyof Result]: Result[Key];
+});
+export declare function TupleElementsToProperties<Types extends TSchema[]>(types: [...Types]): TTupleElementsToProperties<Types>;
+export type TTupleToObject<Type extends TTuple, Properties extends TProperties = TTupleElementsToProperties<Type['items']>, Result extends TSchema = TObject<Properties>> = Result;
+export declare function TupleToObject<Type extends TTuple>(type: Type): TTupleToObject<Type>;

package/build/cjs/type/engine/tuple/to-object.js

@@ -0,0 +1,17 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TupleElementsToProperties = TupleElementsToProperties;
+exports.TupleToObject = TupleToObject;
+const object_1 = require("../../types/object");
+function TupleElementsToProperties(types) {
+    const result = types.reduceRight((result, right, index) => {
+        return { [index]: right, ...result };
+    }, {});
+    return result;
+}
+function TupleToObject(type) {
+    const properties = TupleElementsToProperties(type.items);
+    const result = (0, object_1.Object)(properties);
+    return result;
+}

package/build/cjs/type/extends/any.d.ts

@@ -0,0 +1,9 @@
+import { type TSchema } from '../types/schema';
+import { type TProperties } from '../types/properties';
+import { type TInfer } from '../types/infer';
+import { type TAny } from '../types/any';
+import { type TUnknown } from '../types/unknown';
+import { type TExtendsRight } from './extends-right';
+import * as Result from './result';
+export type TExtendsAny<Inferred extends TProperties, Left extends TAny, Right extends TSchema> = (Right extends TInfer ? TExtendsRight<Inferred, Left, Right> : Right extends TAny ? Result.TExtendsTrue<Inferred> : Right extends TUnknown ? Result.TExtendsTrue<Inferred> : Result.TExtendsUnion<Inferred>);
+export declare function ExtendsAny<Inferred extends TProperties, Left extends TAny, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsAny<Inferred, Left, Right>;

package/build/cjs/type/extends/any.js

@@ -0,0 +1,15 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendsAny = ExtendsAny;
+const infer_1 = require("../types/infer");
+const any_1 = require("../types/any");
+const unknown_1 = require("../types/unknown");
+const extends_right_1 = require("./extends-right");
+const Result = require("./result");
+function ExtendsAny(inferred, left, right) {
+    return ((0, infer_1.IsInfer)(right) ? (0, extends_right_1.ExtendsRight)(inferred, left, right) :
+        (0, any_1.IsAny)(right) ? Result.ExtendsTrue(inferred) :
+            (0, unknown_1.IsUnknown)(right) ? Result.ExtendsTrue(inferred) :
+                Result.ExtendsUnion(inferred));
+}

package/build/cjs/type/extends/array.d.ts

@@ -0,0 +1,7 @@
+import { type TSchema } from '../types/schema';
+import { type TProperties } from '../types/properties';
+import { type TArray } from '../types/array';
+import { type TExtendsRight } from './extends-right';
+import { type TExtendsLeft } from './extends-left';
+export type TExtendsArray<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Right extends TArray<infer Type extends TSchema> ? TExtendsLeft<Inferred, Left, Type> : TExtendsRight<Inferred, TArray<Left>, Right>);
+export declare function ExtendsArray<Inferred extends TProperties, Left extends TSchema, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsArray<Inferred, Left, Right>;

package/build/cjs/type/extends/array.js

@@ -0,0 +1,12 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendsArray = ExtendsArray;
+const array_1 = require("../types/array");
+const extends_right_1 = require("./extends-right");
+const extends_left_1 = require("./extends-left");
+function ExtendsArray(inferred, left, right) {
+    return ((0, array_1.IsArray)(right)
+        ? (0, extends_left_1.ExtendsLeft)(inferred, left, right.items)
+        : (0, extends_right_1.ExtendsRight)(inferred, (0, array_1.Array)(left), right));
+}

package/build/cjs/type/extends/async-iterator.d.ts

@@ -0,0 +1,7 @@
+import { type TSchema } from '../types/schema';
+import { type TProperties } from '../types/properties';
+import { type TAsyncIterator } from '../types/async-iterator';
+import { type TExtendsRight } from './extends-right';
+import { type TExtendsLeft } from './extends-left';
+export type TExtendsAsyncIterator<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Right extends TAsyncIterator<infer Type extends TSchema> ? TExtendsLeft<Inferred, Left, Type> : TExtendsRight<Inferred, TAsyncIterator<Left>, Right>);
+export declare function ExtendsAsyncIterator<Inferred extends TProperties, Left extends TSchema, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsAsyncIterator<Inferred, Left, Right>;

package/build/cjs/type/extends/async-iterator.js

@@ -0,0 +1,12 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendsAsyncIterator = ExtendsAsyncIterator;
+const async_iterator_1 = require("../types/async-iterator");
+const extends_right_1 = require("./extends-right");
+const extends_left_1 = require("./extends-left");
+function ExtendsAsyncIterator(inferred, left, right) {
+    return ((0, async_iterator_1.IsAsyncIterator)(right)
+        ? (0, extends_left_1.ExtendsLeft)(inferred, left, right.iteratorItems)
+        : (0, extends_right_1.ExtendsRight)(inferred, (0, async_iterator_1.AsyncIterator)(left), right));
+}

package/build/cjs/type/extends/bigint.d.ts

@@ -0,0 +1,7 @@
+import { type TSchema } from '../types/schema';
+import { type TProperties } from '../types/properties';
+import { type TBigInt } from '../types/bigint';
+import { type TExtendsRight } from './extends-right';
+import * as Result from './result';
+export type TExtendsBigInt<Inferred extends TProperties, Left extends TBigInt, Right extends TSchema> = (Right extends TBigInt ? Result.TExtendsTrue<Inferred> : TExtendsRight<Inferred, Left, Right>);
+export declare function ExtendsBigInt<Inferred extends TProperties, Left extends TBigInt, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsBigInt<Inferred, Left, Right>;

package/build/cjs/type/extends/bigint.js

@@ -0,0 +1,12 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendsBigInt = ExtendsBigInt;
+const bigint_1 = require("../types/bigint");
+const extends_right_1 = require("./extends-right");
+const Result = require("./result");
+function ExtendsBigInt(inferred, left, right) {
+    return ((0, bigint_1.IsBigInt)(right)
+        ? Result.ExtendsTrue(inferred)
+        : (0, extends_right_1.ExtendsRight)(inferred, left, right));
+}

package/build/cjs/type/extends/boolean.d.ts

@@ -0,0 +1,7 @@
+import { type TSchema } from '../types/schema';
+import { type TProperties } from '../types/properties';
+import { type TBoolean } from '../types/boolean';
+import { type TExtendsRight } from './extends-right';
+import * as Result from './result';
+export type TExtendsBoolean<Inferred extends TProperties, Left extends TBoolean, Right extends TSchema> = (Right extends TBoolean ? Result.TExtendsTrue<Inferred> : TExtendsRight<Inferred, Left, Right>);
+export declare function ExtendsBoolean<Inferred extends TProperties, Left extends TBoolean, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsBoolean<Inferred, Left, Right>;

package/build/cjs/type/extends/boolean.js

@@ -0,0 +1,12 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendsBoolean = ExtendsBoolean;
+const boolean_1 = require("../types/boolean");
+const extends_right_1 = require("./extends-right");
+const Result = require("./result");
+function ExtendsBoolean(inferred, left, right) {
+    return ((0, boolean_1.IsBoolean)(right)
+        ? Result.ExtendsTrue(inferred)
+        : (0, extends_right_1.ExtendsRight)(inferred, left, right));
+}

package/build/cjs/type/extends/constructor.d.ts

@@ -0,0 +1,8 @@
+import { type TSchema } from '../types/schema';
+import { type TProperties } from '../types/properties';
+import { type TConstructor } from '../types/constructor';
+import * as Result from './result';
+import { type TExtendsParameters } from './parameters';
+import { type TExtendsReturnType } from './return-type';
+export type TExtendsConstructor<Inferred extends TProperties, Parameters extends TSchema[], InstanceType extends TSchema, Right extends TSchema> = (Right extends TConstructor<infer RightParamters extends TSchema[], infer RightInstanceType extends TSchema> ? TExtendsParameters<Inferred, Parameters, RightParamters> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsReturnType<Inferred, InstanceType, RightInstanceType> : Result.TExtendsFalse : Result.TExtendsFalse);
+export declare function ExtendsConstructor<Inferred extends TProperties, Parameters extends TSchema[], InstanceType extends TSchema, Right extends TSchema>(inferred: Inferred, parameters: [...Parameters], returnType: InstanceType, right: Right): TExtendsConstructor<Inferred, Parameters, InstanceType, Right>;

package/build/cjs/type/extends/constructor.js

@@ -0,0 +1,19 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendsConstructor = ExtendsConstructor;
+const constructor_1 = require("../types/constructor");
+const Result = require("./result");
+// ------------------------------------------------------------------
+// Parameters | ReturnType
+// ------------------------------------------------------------------ 
+const parameters_1 = require("./parameters");
+const return_type_1 = require("./return-type");
+function ExtendsConstructor(inferred, parameters, returnType, right) {
+    return ((0, constructor_1.IsConstructor)(right) ? (() => {
+        const check = (0, parameters_1.ExtendsParameters)(inferred, parameters, right.parameters);
+        return Result.IsExtendsTrueLike(check)
+            ? (0, return_type_1.ExtendsReturnType)(check.inferred, returnType, right.instanceType)
+            : Result.ExtendsFalse();
+    })() : Result.ExtendsFalse());
+}

package/build/cjs/type/extends/enum.d.ts

@@ -0,0 +1,7 @@
+import { type TSchema } from '../types/schema';
+import { type TProperties } from '../types/properties';
+import { type TEnum } from '../types/enum';
+import { type TExtendsLeft } from './extends-left';
+import { type TEnumToUnion } from '../engine/enum/index';
+export type TExtendsEnum<Inferred extends TProperties, Left extends TEnum, Right extends TSchema> = (TExtendsLeft<Inferred, TEnumToUnion<Left>, Right>);
+export declare function ExtendsEnum<Inferred extends TProperties, Left extends TEnum, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsEnum<Inferred, Left, Right>;

package/build/cjs/type/extends/enum.js

@@ -0,0 +1,9 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendsEnum = ExtendsEnum;
+const extends_left_1 = require("./extends-left");
+const index_1 = require("../engine/enum/index");
+function ExtendsEnum(inferred, left, right) {
+    return (0, extends_left_1.ExtendsLeft)(inferred, (0, index_1.EnumToUnion)(left), right);
+}