@sinclair/typebox 0.32.0-dev-15 → 0.32.0-dev-17

package/build/require/type/template-literal/parser.js

@@ -1,21 +1,56 @@
 "use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateLiteralParseExact = exports.TemplateLiteralParse = exports.TemplateLiteralParserError = void 0;
+// ------------------------------------------------------------------
+// TemplateLiteralParserError
+// ------------------------------------------------------------------
 class TemplateLiteralParserError extends Error {
 }
 exports.TemplateLiteralParserError = TemplateLiteralParserError;
+// prettier-ignore
 function IsNonEscaped(pattern, index, char) {
     return pattern[index] === char && pattern.charCodeAt(index - 1) !== 92;
 }
+// prettier-ignore
 function IsOpenParen(pattern, index) {
     return IsNonEscaped(pattern, index, '(');
 }
+// prettier-ignore
 function IsCloseParen(pattern, index) {
     return IsNonEscaped(pattern, index, ')');
 }
+// prettier-ignore
 function IsSeparator(pattern, index) {
     return IsNonEscaped(pattern, index, '|');
 }
+// prettier-ignore
 function IsGroup(pattern) {
     if (!(IsOpenParen(pattern, 0) && IsCloseParen(pattern, pattern.length - 1)))
         return false;
@@ -30,9 +65,11 @@ function IsGroup(pattern) {
     }
     return true;
 }
+// prettier-ignore
 function InGroup(pattern) {
     return pattern.slice(1, pattern.length - 1);
 }
+// prettier-ignore
 function IsPrecedenceOr(pattern) {
     let count = 0;
     for (let index = 0; index < pattern.length; index++) {
@@ -45,6 +82,7 @@ function IsPrecedenceOr(pattern) {
     }
     return false;
 }
+// prettier-ignore
 function IsPrecedenceAnd(pattern) {
     for (let index = 0; index < pattern.length; index++) {
         if (IsOpenParen(pattern, index))
@@ -52,6 +90,7 @@ function IsPrecedenceAnd(pattern) {
     }
     return false;
 }
+// prettier-ignore
 function Or(pattern) {
     let [count, start] = [0, 0];
     const expressions = [];
@@ -76,6 +115,7 @@ function Or(pattern) {
         return expressions[0];
     return { type: 'or', expr: expressions };
 }
+// prettier-ignore
 function And(pattern) {
     function Group(value, index) {
         if (!IsOpenParen(value, index))
@@ -118,6 +158,8 @@ function And(pattern) {
         (expressions.length === 1) ? expressions[0] :
             { type: 'and', expr: expressions });
 }
+/** Parses a pattern and returns an expression tree */
+// prettier-ignore
 function TemplateLiteralParse(pattern) {
     return (IsGroup(pattern) ? TemplateLiteralParse(InGroup(pattern)) :
         IsPrecedenceOr(pattern) ? Or(pattern) :
@@ -125,6 +167,8 @@ function TemplateLiteralParse(pattern) {
                 { type: 'const', const: pattern });
 }
 exports.TemplateLiteralParse = TemplateLiteralParse;
+/** Parses a pattern and strips forward and trailing ^ and $ */
+// prettier-ignore
 function TemplateLiteralParseExact(pattern) {
     return TemplateLiteralParse(pattern.slice(1, pattern.length - 1));
 }

package/build/require/type/template-literal/pattern.js

@@ -1,15 +1,53 @@
 "use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateLiteralPattern = exports.TemplateLiteralPatternError = void 0;
 const index_1 = require("../patterns/index");
 const index_2 = require("../symbols/index");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 const type_1 = require("../guard/type");
+// ------------------------------------------------------------------
+// TemplateLiteralPatternError
+// ------------------------------------------------------------------
 class TemplateLiteralPatternError extends Error {
 }
 exports.TemplateLiteralPatternError = TemplateLiteralPatternError;
+// ------------------------------------------------------------------
+// TemplateLiteralPattern
+// ------------------------------------------------------------------
 function Escape(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
+// prettier-ignore
 function Visit(schema, acc) {
     return ((0, type_1.TTemplateLiteral)(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) :
         (0, type_1.TUnion)(schema) ? `(${schema.anyOf.map((schema) => Visit(schema, acc)).join('|')})` :

package/build/require/type/template-literal/syntax.d.ts

@@ -1,19 +1,20 @@
-import type { Ensure, Assert, Trim } from '../helpers/index';
+import type { Assert, Trim } from '../helpers/index';
 import type { TTemplateLiteralKind, TTemplateLiteral } from './index';
 import { type TLiteral } from '../literal/index';
 import { type TBoolean } from '../boolean/index';
 import { type TBigInt } from '../bigint/index';
 import { type TNumber } from '../number/index';
 import { type TString } from '../string/index';
-import { UnionResolve } from '../union/index';
+import { UnionEvaluated } from '../union/index';
 declare function FromUnion(syntax: string): IterableIterator<TTemplateLiteralKind>;
 declare function FromTerminal(syntax: string): IterableIterator<TTemplateLiteralKind>;
 type FromUnionLiteral<T extends string> = T extends `${infer L}|${infer R}` ? [TLiteral<Trim<L>>, ...FromUnionLiteral<R>] : T extends `${infer L}` ? [TLiteral<Trim<L>>] : [
 ];
-type FromUnion<T extends string> = UnionResolve<FromUnionLiteral<T>>;
+type FromUnion<T extends string> = UnionEvaluated<FromUnionLiteral<T>>;
 type FromTerminal<T extends string> = T extends 'boolean' ? TBoolean : T extends 'bigint' ? TBigInt : T extends 'number' ? TNumber : T extends 'string' ? TString : FromUnion<T>;
 type FromString<T extends string> = T extends `{${infer L}}${infer R}` ? [FromTerminal<L>, ...FromString<R>] : T extends `${infer L}$${infer R}` ? [TLiteral<L>, ...FromString<R>] : T extends `${infer L}` ? [TLiteral<L>] : [
 ];
-export type TemplateLiteralSyntax<T extends string> = Ensure<TTemplateLiteral<Assert<FromString<T>, TTemplateLiteralKind[]>>>;
+export type TemplateLiteralSyntax<T extends string> = (TTemplateLiteral<Assert<FromString<T>, TTemplateLiteralKind[]>>);
+/** Parses TemplateLiteralSyntax and returns a tuple of TemplateLiteralKinds */
 export declare function TemplateLiteralSyntax(syntax: string): TTemplateLiteralKind[];
 export {};

package/build/require/type/template-literal/syntax.js

@@ -1,4 +1,31 @@
 "use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateLiteralSyntax = void 0;
 const index_1 = require("../literal/index");
@@ -8,6 +35,10 @@ const index_4 = require("../number/index");
 const index_5 = require("../string/index");
 const index_6 = require("../union/index");
 const index_7 = require("../never/index");
+// ------------------------------------------------------------------
+// SyntaxParsers
+// ------------------------------------------------------------------
+// prettier-ignore
 function* FromUnion(syntax) {
     const trim = syntax.trim().replace(/"|'/g, '');
     return (trim === 'boolean' ? yield (0, index_2.Boolean)() :
@@ -21,6 +52,7 @@ function* FromUnion(syntax) {
                                 (0, index_6.Union)(literals));
                     })());
 }
+// prettier-ignore
 function* FromTerminal(syntax) {
     if (syntax[1] !== '{') {
         const L = (0, index_1.Literal)('$');
@@ -36,6 +68,7 @@ function* FromTerminal(syntax) {
     }
     yield (0, index_1.Literal)(syntax);
 }
+// prettier-ignore
 function* FromSyntax(syntax) {
     for (let i = 0; i < syntax.length; i++) {
         if (syntax[i] === '$') {
@@ -46,6 +79,8 @@ function* FromSyntax(syntax) {
     }
     yield (0, index_1.Literal)(syntax);
 }
+// prettier-ignore
+/** Parses TemplateLiteralSyntax and returns a tuple of TemplateLiteralKinds */
 function TemplateLiteralSyntax(syntax) {
     return [...FromSyntax(syntax)];
 }

package/build/require/type/template-literal/template-literal.d.ts

@@ -12,17 +12,19 @@ import type { Static } from '../static/index';
 import { TemplateLiteralSyntax } from './syntax';
 import { EmptyString } from '../helpers/index';
 import { Kind } from '../symbols/index';
-type TemplateLiteralResolveConst<T, Acc extends string> = T extends TUnion<infer U> ? {
-    [K in keyof U]: TemplateLiteralResolve<Assert<[U[K]], TTemplateLiteralKind[]>, Acc>;
+type TemplateLiteralStaticKind<T, Acc extends string> = T extends TUnion<infer U> ? {
+    [K in keyof U]: TemplateLiteralStatic<Assert<[U[K]], TTemplateLiteralKind[]>, Acc>;
 }[number] : T extends TTemplateLiteral ? `${Static<T>}` : T extends TLiteral<infer U> ? `${U}` : T extends TString ? `${string}` : T extends TNumber ? `${number}` : T extends TBigInt ? `${bigint}` : T extends TBoolean ? `${boolean}` : never;
-export type TemplateLiteralResolve<T extends TTemplateLiteralKind[], Acc extends string> = T extends [infer L, ...infer R] ? `${TemplateLiteralResolveConst<L, Acc>}${TemplateLiteralResolve<Assert<R, TTemplateLiteralKind[]>, Acc>}` : Acc;
+type TemplateLiteralStatic<T extends TTemplateLiteralKind[], Acc extends string> = T extends [infer L, ...infer R] ? `${TemplateLiteralStaticKind<L, Acc>}${TemplateLiteralStatic<Assert<R, TTemplateLiteralKind[]>, Acc>}` : Acc;
 export type TTemplateLiteralKind = TTemplateLiteral | TUnion | TLiteral | TInteger | TNumber | TBigInt | TString | TBoolean | TNever;
 export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLiteralKind[]> extends TSchema {
     [Kind]: 'TemplateLiteral';
-    static: TemplateLiteralResolve<T, EmptyString>;
+    static: TemplateLiteralStatic<T, EmptyString>;
     type: 'string';
     pattern: string;
 }
+/** `[Json]` Creates a TemplateLiteral type from template dsl string */
 export declare function TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TemplateLiteralSyntax<T>;
+/** `[Json]` Creates a TemplateLiteral type */
 export declare function TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>;
 export {};

package/build/require/type/template-literal/template-literal.js

@@ -1,10 +1,39 @@
 "use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateLiteral = void 0;
 const pattern_1 = require("./pattern");
 const syntax_1 = require("./syntax");
 const value_1 = require("../guard/value");
 const index_1 = require("../symbols/index");
+/** `[Json]` Creates a TemplateLiteral type */
+// prettier-ignore
 function TemplateLiteral(unresolved, options = {}) {
     const pattern = (0, value_1.IsString)(unresolved)
         ? (0, pattern_1.TemplateLiteralPattern)((0, syntax_1.TemplateLiteralSyntax)(unresolved))

package/build/require/type/template-literal/union.d.ts

@@ -3,4 +3,5 @@ import { type TUnion } from '../union/index';
 import { type TLiteral } from '../literal/index';
 import { type TString } from '../string/index';
 import { type TNever } from '../never/index';
+/** Resolves a template literal as a TUnion */
 export declare function TemplateLiteralToUnion(template: TTemplateLiteral): TNever | TString | TUnion<TLiteral[]>;

package/build/require/type/template-literal/union.js

@@ -1,4 +1,31 @@
 "use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateLiteralToUnion = void 0;
 const index_1 = require("../union/index");
@@ -7,6 +34,10 @@ const index_3 = require("../string/index");
 const generate_1 = require("./generate");
 const parser_1 = require("./parser");
 const finite_1 = require("./finite");
+// ------------------------------------------------------------------
+// TemplateLiteralToUnion
+// ------------------------------------------------------------------
+/** Resolves a template literal as a TUnion */
 function TemplateLiteralToUnion(template) {
     const expression = (0, parser_1.TemplateLiteralParseExact)(template.pattern);
     if (!(0, finite_1.IsTemplateLiteralFinite)(expression))

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

@@ -1,4 +1,31 @@
 "use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
 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/transform/transform.d.ts

@@ -14,15 +14,17 @@ export declare class TransformEncodeBuilder<T extends TSchema, D extends Transfo
     private EncodeSchema;
     Encode<E extends TransformFunction<ReturnType<D>, StaticDecode<T>>>(encode: E): TTransform<T, ReturnType<D>>;
 }
+type TransformStatic<T extends TSchema, P extends unknown[] = []> = T extends TTransform<infer _, infer S> ? S : Static<T, P>;
 export type TransformFunction<T = any, U = any> = (value: T) => U;
 export interface TransformOptions<I extends TSchema = TSchema, O extends unknown = unknown> {
     Decode: TransformFunction<StaticDecode<I>, O>;
     Encode: TransformFunction<O, StaticDecode<I>>;
 }
-export type TTransformResolve<T extends TSchema, P extends unknown[] = []> = T extends TTransform<infer _, infer S> ? S : Static<T, P>;
 export interface TTransform<I extends TSchema = TSchema, O extends unknown = unknown> extends TSchema {
-    static: TTransformResolve<I, this['params']>;
+    static: TransformStatic<I, this['params']>;
     [TransformKind]: TransformOptions<I, O>;
     [key: string]: any;
 }
+/** `[Json]` Creates a Transform type */
 export declare function Transform<I extends TSchema>(schema: I): TransformDecodeBuilder<I>;
+export {};

package/build/require/type/transform/transform.js

@@ -1,9 +1,43 @@
 "use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Transform = exports.TransformEncodeBuilder = exports.TransformDecodeBuilder = void 0;
-const type_1 = require("../guard/type");
-const type_2 = require("../clone/type");
+const type_1 = require("../clone/type");
 const index_1 = require("../symbols/index");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
+const type_2 = require("../guard/type");
+// ------------------------------------------------------------------
+// TransformBuilders
+// ------------------------------------------------------------------
 class TransformDecodeBuilder {
     constructor(schema) {
         this.schema = schema;
@@ -13,6 +47,7 @@ class TransformDecodeBuilder {
     }
 }
 exports.TransformDecodeBuilder = TransformDecodeBuilder;
+// prettier-ignore
 class TransformEncodeBuilder {
     constructor(schema, decode) {
         this.schema = schema;
@@ -29,11 +64,12 @@ class TransformEncodeBuilder {
         return { ...schema, [index_1.TransformKind]: Codec };
     }
     Encode(encode) {
-        const schema = (0, type_2.CloneType)(this.schema);
-        return ((0, type_1.TTransform)(schema) ? this.EncodeTransform(encode, schema) : this.EncodeSchema(encode, schema));
+        const schema = (0, type_1.CloneType)(this.schema);
+        return ((0, type_2.TTransform)(schema) ? this.EncodeTransform(encode, schema) : this.EncodeSchema(encode, schema));
     }
 }
 exports.TransformEncodeBuilder = TransformEncodeBuilder;
+/** `[Json]` Creates a Transform type */
 function Transform(schema) {
     return new TransformDecodeBuilder(schema);
 }

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

@@ -1,4 +1,31 @@
 "use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
 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/tuple/tuple.d.ts

@@ -1,16 +1,17 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
 import type { Static } from '../static/index';
 import { Kind } from '../symbols/index';
-type FromRest<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...FromRest<R, P>] : [];
-type TupleResolve<T extends TSchema[], P extends unknown[], R extends unknown[] = FromRest<T, P>> = R;
+type TupleStaticRest<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...TupleStaticRest<R, P>] : [];
+type TupleStatic<T extends TSchema[], P extends unknown[], R extends unknown[] = TupleStaticRest<T, P>> = R;
 export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
     [Kind]: 'Tuple';
-    static: TupleResolve<T, this['params']>;
+    static: TupleStatic<T, this['params']>;
     type: 'array';
     items?: T;
     additionalItems?: false;
     minItems: number;
     maxItems: number;
 }
+/** `[Json]` Creates a Tuple type */
 export declare function Tuple<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TTuple<T>;
 export {};

package/build/require/type/tuple/tuple.js

@@ -1,10 +1,40 @@
 "use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Tuple = void 0;
 const type_1 = require("../clone/type");
 const index_1 = require("../symbols/index");
+/** `[Json]` Creates a Tuple type */
 function Tuple(items, options = {}) {
+    // return TupleResolver.Resolve(T)
     const [additionalItems, minItems, maxItems] = [false, items.length, items.length];
+    // prettier-ignore
     return (items.length > 0 ?
         { ...options, [index_1.Kind]: 'Tuple', type: 'array', items: (0, type_1.CloneRest)(items), additionalItems, minItems, maxItems } :
         { ...options, [index_1.Kind]: 'Tuple', type: 'array', minItems, maxItems });

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

@@ -1,5 +1,6 @@
 export { JsonTypeBuilder } from './json';
 import { JavaScriptTypeBuilder } from './javascript';
+/** JavaScript Type Builder with Static Resolution for TypeScript */
 declare const Type: JavaScriptTypeBuilder;
 export { JavaScriptTypeBuilder };
 export { Type };

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

@@ -1,10 +1,44 @@
 "use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Type = exports.JavaScriptTypeBuilder = exports.JsonTypeBuilder = void 0;
+// ------------------------------------------------------------------
+// JsonTypeBuilder
+// ------------------------------------------------------------------
 var json_1 = require("./json");
 Object.defineProperty(exports, "JsonTypeBuilder", { enumerable: true, get: function () { return json_1.JsonTypeBuilder; } });
+// ------------------------------------------------------------------
+// JavaScriptTypeBuilder
+// ------------------------------------------------------------------
 const TypeBuilder = require("./type");
 const javascript_1 = require("./javascript");
 Object.defineProperty(exports, "JavaScriptTypeBuilder", { enumerable: true, get: function () { return javascript_1.JavaScriptTypeBuilder; } });
+/** JavaScript Type Builder with Static Resolution for TypeScript */
 const Type = TypeBuilder;
 exports.Type = Type;