@sinclair/typebox 0.32.0-dev-16 → 0.32.0-dev-18

package/build/require/type/helpers/helpers.js

@@ -1,6 +1,8 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Increment = void 0;
+/** Increments the given string value + 1 */
 function Increment(T) {
     return (parseInt(T) + 1).toString();
 }

package/build/require/type/helpers/index.js

@@ -1,4 +1,5 @@
 "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);

package/build/require/type/index.js

@@ -1,4 +1,5 @@
 "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);

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

@@ -1,4 +1,3 @@
 export * from './indexed-from-mapped-key';
 export * from './indexed-property-keys';
-export * from './indexed-result';
 export * from './indexed';

package/build/require/type/indexed/index.js

@@ -1,4 +1,5 @@
 "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);
@@ -16,5 +17,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./indexed-from-mapped-key"), exports);
 __exportStar(require("./indexed-property-keys"), exports);
-__exportStar(require("./indexed-result"), exports);
 __exportStar(require("./indexed"), exports);

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

@@ -1,10 +1,10 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
 import { type TProperties } from '../object/index';
-import { type TIndexResult } from './indexed-result';
+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> = {
-    [_ in K]: TIndexResult<T, [K]>;
+    [_ 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> : {});

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

@@ -1,20 +1,28 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IndexFromMappedKey = void 0;
-const indexed_result_1 = require("./indexed-result");
+const indexed_1 = require("./indexed");
 const index_1 = require("../mapped/index");
+// prettier-ignore
 function MappedIndexPropertyKey(T, K, options) {
-    return { [K]: (0, indexed_result_1.IndexResult)(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) {
     const [L, ...R] = K;
     return (K.length > 0
-        ? { ...MappedIndexPropertyKey(T, L, options), ...MappedIndexPropertyKeys(T, R, options) }
+        ? { ...MappedIndexPropertyKey(T, L, options), ...MappedIndexPropertyKeys(T, R, options) } // TS 5.4-dev
         : {});
 }
+// prettier-ignore
 function MappedIndexProperties(T, K, options) {
     return MappedIndexPropertyKeys(T, K.keys, options);
 }
+// prettier-ignore
 function IndexFromMappedKey(T, K, options) {
     const P = MappedIndexProperties(T, K, options);
     return (0, index_1.MappedResult)(P);

package/build/require/type/indexed/indexed-property-keys.d.ts

@@ -12,5 +12,6 @@ type FromLiteral<T extends TLiteralValue> = (T extends PropertyKey ? [`${T}`] :
 declare function FromLiteral<T extends TLiteralValue>(T: T): FromLiteral<T>;
 export type TIndexPropertyKeys<T extends TSchema> = (T extends TTemplateLiteral ? FromTemplateLiteral<T> : T extends TUnion<infer S> ? FromUnion<S> : T extends TLiteral<infer S> ? FromLiteral<S> : T extends TNumber ? ['[number]'] : T extends TInteger ? ['[number]'] : [
 ]);
+/** Returns a tuple of PropertyKeys derived from the given TSchema */
 export declare function IndexPropertyKeys<T extends TSchema>(T: T): TIndexPropertyKeys<T>;
 export {};

package/build/require/type/indexed/indexed-property-keys.js

@@ -1,8 +1,14 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IndexPropertyKeys = void 0;
 const index_1 = require("../template-literal/index");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 const type_1 = require("../guard/type");
+// prettier-ignore
 function FromTemplateLiteral(T) {
     const E = (0, index_1.TemplateLiteralParseExact)(T.pattern);
     const F = (0, index_1.IsTemplateLiteralFinite)(E);
@@ -13,15 +19,19 @@ function FromTemplateLiteral(T) {
             : []
         : []);
 }
+// prettier-ignore
 function FromUnion(T) {
     const [L, ...R] = T;
     return (T.length > 0
         ? [...IndexPropertyKeys(L), ...FromUnion(R)]
         : []);
 }
+// prettier-ignore
 function FromLiteral(T) {
     return ([T.toString()]);
 }
+/** Returns a tuple of PropertyKeys derived from the given TSchema */
+// prettier-ignore
 function IndexPropertyKeys(T) {
     return [...new Set(((0, type_1.TTemplateLiteral)(T) ? FromTemplateLiteral(T) :
             (0, type_1.TUnion)(T) ? FromUnion(T.anyOf) :

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

@@ -1,9 +1,45 @@
-import type { TSchema, SchemaOptions } from '../schema/index';
-import { type TIndexResult } from './indexed-result';
+import { type TSchema, SchemaOptions } from '../schema/index';
+import { type TObject, type TProperties } from '../object/index';
+import { type Assert } from '../helpers/index';
+import { type TNever } from '../never/index';
+import { type TRecursive } from '../recursive/index';
+import { type TIntersect } from '../intersect/index';
+import { type TMappedKey } from '../mapped/index';
+import { type TUnion } from '../union/index';
+import { type TTuple } from '../tuple/index';
+import { type TArray } from '../array/index';
+import { IntersectEvaluated } from '../intersect/index';
+import { UnionEvaluated } from '../union/index';
 import { type TIndexPropertyKeys } from './indexed-property-keys';
 import { type TIndexFromMappedKey } from './indexed-from-mapped-key';
-import { TMappedKey } from '../mapped/index';
-export type TIndex<T extends TSchema, K extends PropertyKey[]> = TIndexResult<T, K>;
+type FromRest<T extends TSchema[], K extends PropertyKey> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [FromKey<L, K>, ...FromRest<R, K>] : []);
+declare function FromRest<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromRest<T, K>;
+type FromIntersectRest<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? [...FromIntersectRest<R>] : [L, ...FromIntersectRest<R>] : []);
+declare function FromIntersectRest<T extends TSchema[]>(T: [...T]): FromIntersectRest<T>;
+type FromIntersect<T extends TSchema[], K extends PropertyKey> = (IntersectEvaluated<FromIntersectRest<FromRest<T, K>>>);
+declare function FromIntersect<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromIntersect<T, K>;
+type FromUnionRest<T extends TSchema[], S = T> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? [] : FromUnionRest<R, S> : S);
+declare function FromUnionRest<T extends TSchema[]>(T: [...T], S?: [...T]): FromUnionRest<T>;
+type FromUnion<T extends TSchema[], K extends PropertyKey> = (UnionEvaluated<FromUnionRest<FromRest<T, K>>>);
+declare function FromUnion<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromUnion<T, K>;
+type FromTuple<T extends TSchema[], K extends PropertyKey> = (K extends keyof T ? T[K] : K extends '[number]' ? UnionEvaluated<T> : TNever);
+declare function FromTuple<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromTuple<T, K>;
+type FromArray<T extends TSchema, K extends PropertyKey> = (K extends '[number]' ? T : TNever);
+declare function FromArray<T extends TSchema, K extends PropertyKey>(T: T, K: K): FromArray<T, K>;
+type AssertPropertyKey<T> = Assert<T, string | number>;
+type FromProperty<T extends TProperties, K extends PropertyKey> = (K extends keyof T ? T[K] : `${AssertPropertyKey<K>}` extends `${AssertPropertyKey<keyof T>}` ? T[AssertPropertyKey<K>] : TNever);
+declare function FromProperty<T extends TProperties, K extends PropertyKey>(T: T, K: K): FromProperty<T, K>;
+type FromKey<T extends TSchema, K extends PropertyKey> = (T extends TRecursive<infer S> ? FromKey<S, K> : T extends TIntersect<infer S> ? FromIntersect<S, K> : T extends TUnion<infer S> ? FromUnion<S, K> : T extends TTuple<infer S> ? FromTuple<S, K> : T extends TArray<infer S> ? FromArray<S, K> : T extends TObject<infer S> ? FromProperty<S, K> : TNever);
+declare function FromKey<T extends TSchema, K extends PropertyKey>(T: T, K: K): FromKey<T, K>;
+type FromKeys<T extends TSchema, K extends PropertyKey[]> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? [FromKey<T, L>, ...FromKeys<T, R>] : []);
+declare function FromKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): FromKeys<T, K>;
+type FromSchema<T extends TSchema, K extends PropertyKey[]> = (UnionEvaluated<FromKeys<T, K>>);
+declare function FromSchema<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): FromSchema<T, K>;
+export type TIndex<T extends TSchema, K extends PropertyKey[]> = (FromSchema<T, K>);
+/** `[Json]` Returns an Indexed property type for the given keys */
 export declare function Index<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedKey<T, K>;
+/** `[Json]` Returns an Indexed property type for the given keys */
 export declare function Index<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TIndex<T, I>;
+/** `[Json]` Returns an Indexed property type for the given keys */
 export declare function Index<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TIndex<T, K>;
+export {};

package/build/require/type/indexed/indexed.js

@@ -1,14 +1,94 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Index = void 0;
-const indexed_result_1 = require("./indexed-result");
+const index_1 = require("../never/index");
+const index_2 = require("../intersect/index");
+const index_3 = require("../union/index");
+const type_1 = require("../clone/type");
 const indexed_property_keys_1 = require("./indexed-property-keys");
 const indexed_from_mapped_key_1 = require("./indexed-from-mapped-key");
-const type_1 = require("../clone/type");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 const type_2 = require("../guard/type");
+// prettier-ignore
+function FromRest(T, K) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? [FromKey(L, K), ...FromRest(R, K)]
+        : []);
+}
+// prettier-ignore
+function FromIntersectRest(T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? (0, type_2.TNever)(L)
+            ? [...FromIntersectRest(R)]
+            : [L, ...FromIntersectRest(R)]
+        : []);
+}
+// prettier-ignore
+function FromIntersect(T, K) {
+    return ((0, index_2.IntersectEvaluated)(FromIntersectRest(FromRest(T, K))));
+}
+// prettier-ignore
+function FromUnionRest(T, S = T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? (0, type_2.TNever)(L)
+            ? []
+            : FromUnionRest(R, S)
+        : S);
+}
+// prettier-ignore
+function FromUnion(T, K) {
+    return ((0, index_3.UnionEvaluated)(FromUnionRest(FromRest(T, K))));
+}
+// prettier-ignore
+function FromTuple(T, K) {
+    return (K in T ? T[K] :
+        K === '[number]' ? (0, index_3.UnionEvaluated)(T) :
+            (0, index_1.Never)());
+}
+// prettier-ignore
+function FromArray(T, K) {
+    return (K === '[number]'
+        ? T
+        : (0, index_1.Never)());
+}
+// prettier-ignore
+function FromProperty(T, K) {
+    return (K in T
+        ? T[K]
+        : (0, index_1.Never)());
+}
+// prettier-ignore
+function FromKey(T, K) {
+    return ((0, type_2.TIntersect)(T) ? FromIntersect(T.allOf, K) :
+        (0, type_2.TUnion)(T) ? FromUnion(T.anyOf, K) :
+            (0, type_2.TTuple)(T) ? FromTuple(T.items ?? [], K) :
+                (0, type_2.TArray)(T) ? FromArray(T.items, K) :
+                    (0, type_2.TObject)(T) ? FromProperty(T.properties, K) :
+                        (0, index_1.Never)());
+}
+// prettier-ignore
+function FromKeys(T, K) {
+    const [L, ...R] = K;
+    return (K.length > 0
+        ? [FromKey(T, L), ...FromKeys(T, R)]
+        : []);
+}
+// prettier-ignore
+function FromSchema(T, K) {
+    return ((0, index_3.UnionEvaluated)(FromKeys(T, K)));
+}
+/** `[Json]` Returns an Indexed property type for the given keys */
 function Index(T, K, options = {}) {
+    // prettier-ignore
     return ((0, type_2.TMappedKey)(K) ? (0, type_1.CloneType)((0, indexed_from_mapped_key_1.IndexFromMappedKey)(T, K, options)) :
-        (0, type_2.TSchema)(K) ? (0, indexed_result_1.IndexResult)(T, (0, indexed_property_keys_1.IndexPropertyKeys)(K), options) :
-            (0, indexed_result_1.IndexResult)(T, K, options));
+        (0, type_2.TSchema)(K) ? (0, type_1.CloneType)(FromSchema(T, (0, indexed_property_keys_1.IndexPropertyKeys)(K)), options) :
+            (0, type_1.CloneType)(FromSchema(T, K), options));
 }
 exports.Index = Index;

package/build/require/type/instance-type/index.js

@@ -1,4 +1,5 @@
 "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);

package/build/require/type/instance-type/instance-type.d.ts

@@ -1,4 +1,5 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
 import type { TConstructor } from '../constructor/index';
 export type TInstanceType<T extends TConstructor<TSchema[], TSchema>> = T['returns'];
+/** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
 export declare function InstanceType<T extends TConstructor<any[], any>>(schema: T, options?: SchemaOptions): TInstanceType<T>;

package/build/require/type/instance-type/instance-type.js

@@ -1,7 +1,9 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InstanceType = void 0;
 const type_1 = require("../clone/type");
+/** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
 function InstanceType(schema, options = {}) {
     return (0, type_1.CloneType)(schema.returns, options);
 }

package/build/require/type/integer/index.js

@@ -1,4 +1,5 @@
 "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);

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

@@ -12,4 +12,5 @@ export interface TInteger extends TSchema, IntegerOptions {
     static: number;
     type: 'integer';
 }
+/** `[Json]` Creates an Integer type */
 export declare function Integer(options?: IntegerOptions): TInteger;

package/build/require/type/integer/integer.js

@@ -1,7 +1,9 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Integer = void 0;
 const index_1 = require("../symbols/index");
+/** `[Json]` Creates an Integer type */
 function Integer(options = {}) {
     return {
         ...options,

package/build/require/type/intersect/index.js

@@ -1,4 +1,5 @@
 "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);

package/build/require/type/intersect/intersect-create.js

@@ -1,9 +1,18 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IntersectCreate = void 0;
 const index_1 = require("../symbols/index");
 const type_1 = require("../clone/type");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 const type_2 = require("../guard/type");
+// ------------------------------------------------------------------
+// IntersectCreate
+// ------------------------------------------------------------------
+// prettier-ignore
 function IntersectCreate(T, options) {
     const allObjects = T.every((schema) => (0, type_2.TObject)(schema));
     const clonedUnevaluatedProperties = (0, type_2.TSchema)(options.unevaluatedProperties)

package/build/require/type/intersect/intersect-evaluated.d.ts

@@ -12,5 +12,6 @@ declare function RemoveOptionalFromType<T extends TSchema>(T: T): RemoveOptional
 type ResolveIntersect<T extends TSchema[]> = (IsIntersectOptional<T> extends true ? TOptional<TIntersect<RemoveOptionalFromRest<T>>> : TIntersect<RemoveOptionalFromRest<T>>);
 declare function ResolveIntersect<T extends TSchema[]>(T: [...T], options: SchemaOptions): ResolveIntersect<T>;
 export type IntersectEvaluated<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : ResolveIntersect<T>);
+/** `[Json]` Creates an evaluated Intersect type */
 export declare function IntersectEvaluated<T extends TSchema[], R = IntersectEvaluated<T>>(T: [...T], options?: IntersectOptions): R;
 export {};

package/build/require/type/intersect/intersect-evaluated.js

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IntersectEvaluated = void 0;
 const index_1 = require("../symbols/index");
@@ -7,7 +8,12 @@ const index_2 = require("../discard/index");
 const index_3 = require("../never/index");
 const index_4 = require("../optional/index");
 const intersect_create_1 = require("./intersect-create");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 const type_2 = require("../guard/type");
+// prettier-ignore
 function IsIntersectOptional(T) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -16,17 +22,21 @@ function IsIntersectOptional(T) {
             : false
         : true);
 }
+// prettier-ignore
 function RemoveOptionalFromRest(T) {
     return (T.map(T => RemoveOptionalFromType(T)));
 }
+// prettier-ignore
 function RemoveOptionalFromType(T) {
     return ((0, index_2.Discard)(T, [index_1.OptionalKind]));
 }
+// prettier-ignore
 function ResolveIntersect(T, options) {
     return (IsIntersectOptional(T)
         ? (0, index_4.Optional)((0, intersect_create_1.IntersectCreate)(RemoveOptionalFromRest(T), options))
         : (0, intersect_create_1.IntersectCreate)(RemoveOptionalFromRest(T), options));
 }
+/** `[Json]` Creates an evaluated Intersect type */
 function IntersectEvaluated(T, options = {}) {
     if (T.length === 0)
         return (0, index_3.Never)(options);

package/build/require/type/intersect/intersect-type.js

@@ -1,3 +1,4 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 const index_1 = require("../symbols/index");

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

@@ -2,4 +2,5 @@ import type { TSchema } from '../schema/index';
 import { type TNever } from '../never/index';
 import { TIntersect, IntersectOptions } from './intersect-type';
 export type Intersect<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : TIntersect<T>);
+/** `[Json]` Creates an evaluated Intersect type */
 export declare function Intersect<T extends TSchema[]>(T: [...T], options?: IntersectOptions): Intersect<T>;

package/build/require/type/intersect/intersect.js

@@ -1,10 +1,16 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Intersect = void 0;
 const type_1 = require("../clone/type");
 const index_1 = require("../never/index");
 const intersect_create_1 = require("./intersect-create");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 const type_2 = require("../guard/type");
+/** `[Json]` Creates an evaluated Intersect type */
 function Intersect(T, options = {}) {
     if (T.length === 0)
         return (0, index_1.Never)(options);

package/build/require/type/intrinsic/capitalize.d.ts

@@ -1,4 +1,5 @@
 import { TSchema, SchemaOptions } from '../schema/index';
 import { TIntrinsic } from './intrinsic';
 export type TCapitalize<T extends TSchema> = TIntrinsic<T, 'Capitalize'>;
+/** `[Json]` Intrinsic function to Capitalize LiteralString types */
 export declare function Capitalize<T extends TSchema>(T: T, options?: SchemaOptions): TCapitalize<T>;

package/build/require/type/intrinsic/capitalize.js

@@ -1,7 +1,9 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Capitalize = void 0;
 const intrinsic_1 = require("./intrinsic");
+/** `[Json]` Intrinsic function to Capitalize LiteralString types */
 function Capitalize(T, options = {}) {
     return (0, intrinsic_1.Intrinsic)(T, 'Capitalize', options);
 }

package/build/require/type/intrinsic/index.js

@@ -1,4 +1,5 @@
 "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);

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

@@ -1,23 +1,28 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IntrinsicFromMappedKey = void 0;
 const index_1 = require("../mapped/index");
 const intrinsic_1 = require("./intrinsic");
 const index_2 = require("../literal/index");
+// prettier-ignore
 function MappedIntrinsicPropertyKey(K, M, options) {
     return {
         [K]: (0, intrinsic_1.Intrinsic)((0, index_2.Literal)(K), M, options)
     };
 }
+// prettier-ignore
 function MappedIntrinsicPropertyKeys(K, M, options) {
     const [L, ...R] = K;
     return (K.length > 0
         ? { ...MappedIntrinsicPropertyKey(L, M, options), ...MappedIntrinsicPropertyKeys(R, M, options) }
         : {});
 }
+// prettier-ignore
 function MappedIntrinsicProperties(T, M, options) {
     return MappedIntrinsicPropertyKeys(T['keys'], M, options);
 }
+// prettier-ignore
 function IntrinsicFromMappedKey(T, M, options) {
     const P = MappedIntrinsicProperties(T, M, options);
     return (0, index_1.MappedResult)(P);

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

@@ -12,6 +12,8 @@ declare function FromLiteralValue(value: TLiteralValue, mode: IntrinsicMode): st
 type FromRest<T extends TSchema[], M extends IntrinsicMode> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [TIntrinsic<L, M>, ...FromRest<R, M>] : [];
 declare function FromRest<T extends TSchema[], M extends IntrinsicMode>(T: [...T], mode: M): FromRest<T, M>;
 export type TIntrinsic<T extends TSchema, M extends IntrinsicMode> = T extends TMappedKey ? TIntrinsicFromMappedKey<T, M> : T extends TTemplateLiteral<infer S> ? TTemplateLiteral<FromTemplateLiteral<S, M>> : T extends TUnion<infer S> ? TUnion<FromRest<S, M>> : T extends TLiteral<infer S> ? TLiteral<FromLiteralValue<S, M>> : T;
+/** Applies an intrinsic string manipulation to the given type. */
 export declare function Intrinsic<T extends TMappedKey, M extends IntrinsicMode>(schema: T, mode: M, options?: SchemaOptions): TIntrinsicFromMappedKey<T, M>;
+/** Applies an intrinsic string manipulation to the given type. */
 export declare function Intrinsic<T extends TSchema, M extends IntrinsicMode>(schema: T, mode: M, options?: SchemaOptions): TIntrinsic<T, M>;
 export {};

package/build/require/type/intrinsic/intrinsic.js

@@ -1,11 +1,19 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Intrinsic = void 0;
 const index_1 = require("../template-literal/index");
 const intrinsic_from_mapped_key_1 = require("./intrinsic-from-mapped-key");
 const index_2 = require("../literal/index");
 const index_3 = require("../union/index");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 const type_1 = require("../guard/type");
+// ------------------------------------------------------------------
+// Apply
+// ------------------------------------------------------------------
 function ApplyUncapitalize(value) {
     const [first, rest] = [value.slice(0, 1), value.slice(1)];
     return [first.toLowerCase(), rest].join('');
@@ -21,6 +29,8 @@ function ApplyLowercase(value) {
     return value.toLowerCase();
 }
 function FromTemplateLiteral(schema, mode, options) {
+    // note: template literals require special runtime handling as they are encoded in string patterns.
+    // This diverges from the mapped type which would otherwise map on the template literal kind.
     const expression = (0, index_1.TemplateLiteralParseExact)(schema.pattern);
     const finite = (0, index_1.IsTemplateLiteralFinite)(expression);
     if (!finite)
@@ -31,6 +41,7 @@ function FromTemplateLiteral(schema, mode, options) {
     const union = (0, index_3.Union)(mapped);
     return (0, index_1.TemplateLiteral)([union], options);
 }
+// prettier-ignore
 function FromLiteralValue(value, mode) {
     return (typeof value === 'string' ? (mode === 'Uncapitalize' ? ApplyUncapitalize(value) :
         mode === 'Capitalize' ? ApplyCapitalize(value) :
@@ -42,8 +53,13 @@ function FromRest(T, mode) {
     const [L, ...R] = T;
     return (T.length > 0 ? [Intrinsic(L, mode), ...FromRest(R, mode)] : []);
 }
+/** Applies an intrinsic string manipulation to the given type. */
 function Intrinsic(schema, mode, options = {}) {
-    return ((0, type_1.TMappedKey)(schema) ? (0, intrinsic_from_mapped_key_1.IntrinsicFromMappedKey)(schema, mode, options) :
+    // prettier-ignore
+    return (
+    // Intrinsic-Mapped-Inference
+    (0, type_1.TMappedKey)(schema) ? (0, intrinsic_from_mapped_key_1.IntrinsicFromMappedKey)(schema, mode, options) :
+        // Standard-Inference
         (0, type_1.TTemplateLiteral)(schema) ? FromTemplateLiteral(schema, mode, schema) :
             (0, type_1.TUnion)(schema) ? (0, index_3.Union)(FromRest(schema.anyOf, mode), options) :
                 (0, type_1.TLiteral)(schema) ? (0, index_2.Literal)(FromLiteralValue(schema.const, mode), options) :

package/build/require/type/intrinsic/lowercase.d.ts

@@ -1,4 +1,5 @@
 import { TSchema, SchemaOptions } from '../schema/index';
 import { TIntrinsic } from './intrinsic';
 export type TLowercase<T extends TSchema> = TIntrinsic<T, 'Lowercase'>;
+/** `[Json]` Intrinsic function to Lowercase LiteralString types */
 export declare function Lowercase<T extends TSchema>(T: T, options?: SchemaOptions): TLowercase<T>;

package/build/require/type/intrinsic/lowercase.js

@@ -1,7 +1,9 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Lowercase = void 0;
 const intrinsic_1 = require("./intrinsic");
+/** `[Json]` Intrinsic function to Lowercase LiteralString types */
 function Lowercase(T, options = {}) {
     return (0, intrinsic_1.Intrinsic)(T, 'Lowercase', options);
 }

package/build/require/type/intrinsic/uncapitalize.d.ts

@@ -1,4 +1,5 @@
 import { TSchema, SchemaOptions } from '../schema/index';
 import { TIntrinsic } from './intrinsic';
 export type TUncapitalize<T extends TSchema> = TIntrinsic<T, 'Uncapitalize'>;
+/** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
 export declare function Uncapitalize<T extends TSchema>(T: T, options?: SchemaOptions): TUncapitalize<T>;

package/build/require/type/intrinsic/uncapitalize.js

@@ -1,7 +1,9 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Uncapitalize = void 0;
 const intrinsic_1 = require("./intrinsic");
+/** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
 function Uncapitalize(T, options = {}) {
     return (0, intrinsic_1.Intrinsic)(T, 'Uncapitalize', options);
 }

package/build/require/type/intrinsic/uppercase.d.ts

@@ -1,4 +1,5 @@
 import { TSchema, SchemaOptions } from '../schema/index';
 import { TIntrinsic } from './intrinsic';
 export type TUppercase<T extends TSchema> = TIntrinsic<T, 'Uppercase'>;
+/** `[Json]` Intrinsic function to Uppercase LiteralString types */
 export declare function Uppercase<T extends TSchema>(T: T, options?: SchemaOptions): TUppercase<T>;

package/build/require/type/intrinsic/uppercase.js

@@ -1,7 +1,9 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Uppercase = void 0;
 const intrinsic_1 = require("./intrinsic");
+/** `[Json]` Intrinsic function to Uppercase LiteralString types */
 function Uppercase(T, options = {}) {
     return (0, intrinsic_1.Intrinsic)(T, 'Uppercase', options);
 }

package/build/require/type/iterator/index.js

@@ -1,4 +1,5 @@
 "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);

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

@@ -7,4 +7,5 @@ export interface TIterator<T extends TSchema = TSchema> extends TSchema {
     type: 'Iterator';
     items: T;
 }
+/** `[JavaScript]` Creates an Iterator type */
 export declare function Iterator<T extends TSchema>(items: T, options?: SchemaOptions): TIterator<T>;