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

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

@@ -1,17 +1,52 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
+// ------------------------------------------------------------------
+// TemplateLiteralParserError
+// ------------------------------------------------------------------
 export class TemplateLiteralParserError extends Error {
 }
+// 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;
@@ -26,9 +61,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++) {
@@ -41,6 +78,7 @@ function IsPrecedenceOr(pattern) {
     }
     return false;
 }
+// prettier-ignore
 function IsPrecedenceAnd(pattern) {
     for (let index = 0; index < pattern.length; index++) {
         if (IsOpenParen(pattern, index))
@@ -48,6 +86,7 @@ function IsPrecedenceAnd(pattern) {
     }
     return false;
 }
+// prettier-ignore
 function Or(pattern) {
     let [count, start] = [0, 0];
     const expressions = [];
@@ -72,6 +111,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))
@@ -114,12 +154,16 @@ function And(pattern) {
         (expressions.length === 1) ? expressions[0] :
             { type: 'and', expr: expressions });
 }
+/** Parses a pattern and returns an expression tree */
+// prettier-ignore
 export function TemplateLiteralParse(pattern) {
     return (IsGroup(pattern) ? TemplateLiteralParse(InGroup(pattern)) :
         IsPrecedenceOr(pattern) ? Or(pattern) :
             IsPrecedenceAnd(pattern) ? And(pattern) :
                 { type: 'const', const: pattern });
 }
+/** Parses a pattern and strips forward and trailing ^ and $ */
+// prettier-ignore
 export function TemplateLiteralParseExact(pattern) {
     return TemplateLiteralParse(pattern.slice(1, pattern.length - 1));
 }

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

@@ -1,11 +1,49 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 import { PatternNumber, PatternString, PatternBoolean } from '../patterns/index.mjs';
 import { Kind } from '../symbols/index.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 import { TTemplateLiteral as IsTemplateLiteralType, TUnion as IsUnionType, TNumber as IsNumberType, TInteger as IsIntegerType, TBigInt as IsBigIntType, TString as IsStringType, TLiteral as IsLiteralType, TBoolean as IsBooleanType, } from '../guard/type.mjs';
+// ------------------------------------------------------------------
+// TemplateLiteralPatternError
+// ------------------------------------------------------------------
 export class TemplateLiteralPatternError extends Error {
 }
+// ------------------------------------------------------------------
+// TemplateLiteralPattern
+// ------------------------------------------------------------------
 function Escape(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
+// prettier-ignore
 function Visit(schema, acc) {
     return (IsTemplateLiteralType(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) :
         IsUnionType(schema) ? `(${schema.anyOf.map((schema) => Visit(schema, acc)).join('|')})` :

package/build/import/type/template-literal/syntax.d.mts

@@ -15,5 +15,6 @@ type FromTerminal<T extends string> = T extends 'boolean' ? TBoolean : T extends
 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> = (TTemplateLiteral<Assert<FromString<T>, TTemplateLiteralKind[]>>);
+/** Parses TemplateLiteralSyntax and returns a tuple of TemplateLiteralKinds */
 export declare function TemplateLiteralSyntax(syntax: string): TTemplateLiteralKind[];
 export {};

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

@@ -1,3 +1,30 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 import { Literal } from '../literal/index.mjs';
 import { Boolean } from '../boolean/index.mjs';
 import { BigInt } from '../bigint/index.mjs';
@@ -5,6 +32,10 @@ import { Number } from '../number/index.mjs';
 import { String } from '../string/index.mjs';
 import { Union } from '../union/index.mjs';
 import { Never } from '../never/index.mjs';
+// ------------------------------------------------------------------
+// SyntaxParsers
+// ------------------------------------------------------------------
+// prettier-ignore
 function* FromUnion(syntax) {
     const trim = syntax.trim().replace(/"|'/g, '');
     return (trim === 'boolean' ? yield Boolean() :
@@ -18,6 +49,7 @@ function* FromUnion(syntax) {
                                 Union(literals));
                     })());
 }
+// prettier-ignore
 function* FromTerminal(syntax) {
     if (syntax[1] !== '{') {
         const L = Literal('$');
@@ -33,6 +65,7 @@ function* FromTerminal(syntax) {
     }
     yield Literal(syntax);
 }
+// prettier-ignore
 function* FromSyntax(syntax) {
     for (let i = 0; i < syntax.length; i++) {
         if (syntax[i] === '$') {
@@ -43,6 +76,8 @@ function* FromSyntax(syntax) {
     }
     yield Literal(syntax);
 }
+// prettier-ignore
+/** Parses TemplateLiteralSyntax and returns a tuple of TemplateLiteralKinds */
 export function TemplateLiteralSyntax(syntax) {
     return [...FromSyntax(syntax)];
 }

package/build/import/type/template-literal/template-literal.d.mts

@@ -23,6 +23,8 @@ export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLi
     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/import/type/template-literal/template-literal.mjs

@@ -1,7 +1,36 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 import { TemplateLiteralPattern } from './pattern.mjs';
 import { TemplateLiteralSyntax } from './syntax.mjs';
 import { IsString } from '../guard/value.mjs';
 import { Kind } from '../symbols/index.mjs';
+/** `[Json]` Creates a TemplateLiteral type */
+// prettier-ignore
 export function TemplateLiteral(unresolved, options = {}) {
     const pattern = IsString(unresolved)
         ? TemplateLiteralPattern(TemplateLiteralSyntax(unresolved))

package/build/import/type/template-literal/union.d.mts

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

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

@@ -1,9 +1,40 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 import { Union } from '../union/index.mjs';
 import { Literal } from '../literal/index.mjs';
 import { String } from '../string/index.mjs';
 import { TemplateLiteralGenerate } from './generate.mjs';
 import { TemplateLiteralParseExact } from './parser.mjs';
 import { IsTemplateLiteralFinite } from './finite.mjs';
+// ------------------------------------------------------------------
+// TemplateLiteralToUnion
+// ------------------------------------------------------------------
+/** Resolves a template literal as a TUnion */
 export function TemplateLiteralToUnion(template) {
     const expression = TemplateLiteralParseExact(template.pattern);
     if (!IsTemplateLiteralFinite(expression))

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

@@ -1 +1,28 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 export * from './transform.mjs';

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

@@ -25,5 +25,6 @@ export interface TTransform<I extends TSchema = TSchema, O extends unknown = unk
     [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/import/type/transform/transform.mjs

@@ -1,6 +1,40 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 import { CloneType } from '../clone/type.mjs';
 import { TransformKind } from '../symbols/index.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 import { TTransform as IsTransform } from '../guard/type.mjs';
+// ------------------------------------------------------------------
+// TransformBuilders
+// ------------------------------------------------------------------
 export class TransformDecodeBuilder {
     schema;
     constructor(schema) {
@@ -10,6 +44,7 @@ export class TransformDecodeBuilder {
         return new TransformEncodeBuilder(this.schema, decode);
     }
 }
+// prettier-ignore
 export class TransformEncodeBuilder {
     schema;
     decode;
@@ -32,6 +67,7 @@ export class TransformEncodeBuilder {
         return (IsTransform(schema) ? this.EncodeTransform(encode, schema) : this.EncodeSchema(encode, schema));
     }
 }
+/** `[Json]` Creates a Transform type */
 export function Transform(schema) {
     return new TransformDecodeBuilder(schema);
 }

package/build/import/type/tuple/index.mjs

@@ -1 +1,28 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 export * from './tuple.mjs';

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

@@ -12,5 +12,6 @@ export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
     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/import/type/tuple/tuple.mjs

@@ -1,7 +1,37 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 import { CloneRest } from '../clone/type.mjs';
 import { Kind } from '../symbols/index.mjs';
+/** `[Json]` Creates a Tuple type */
 export function Tuple(items, options = {}) {
+    // return TupleResolver.Resolve(T)
     const [additionalItems, minItems, maxItems] = [false, items.length, items.length];
+    // prettier-ignore
     return (items.length > 0 ?
         { ...options, [Kind]: 'Tuple', type: 'array', items: CloneRest(items), additionalItems, minItems, maxItems } :
         { ...options, [Kind]: 'Tuple', type: 'array', minItems, maxItems });

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

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

package/build/import/type/type/index.mjs

@@ -1,6 +1,40 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
+// ------------------------------------------------------------------
+// JsonTypeBuilder
+// ------------------------------------------------------------------
 export { JsonTypeBuilder } from './json.mjs';
+// ------------------------------------------------------------------
+// JavaScriptTypeBuilder
+// ------------------------------------------------------------------
 import * as TypeBuilder from './type.mjs';
 import { JavaScriptTypeBuilder } from './javascript.mjs';
+/** JavaScript Type Builder with Static Resolution for TypeScript */
 const Type = TypeBuilder;
 export { JavaScriptTypeBuilder };
 export { Type };

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

@@ -17,23 +17,42 @@ import { type TSymbol } from '../symbol/index.mjs';
 import { type TUint8Array, type Uint8ArrayOptions } from '../uint8array/index.mjs';
 import { type TUndefined } from '../undefined/index.mjs';
 import { type TVoid } from '../void/index.mjs';
+/** JavaScript Type Builder with Static Resolution for TypeScript */
 export declare class JavaScriptTypeBuilder extends JsonTypeBuilder {
+    /** `[JavaScript]` Creates a AsyncIterator type */
     AsyncIterator<T extends TSchema>(items: T, options?: SchemaOptions): TAsyncIterator<T>;
+    /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
     Awaited<T extends TSchema>(schema: T, options?: SchemaOptions): TAwaited<T>;
+    /** `[JavaScript]` Creates a BigInt type */
     BigInt(options?: BigIntOptions): TBigInt;
+    /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
     ConstructorParameters<T extends TConstructor<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TConstructorParameters<T>;
+    /** `[JavaScript]` Creates a Constructor type */
     Constructor<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TConstructor<T, U>;
+    /** `[JavaScript]` Creates a Date type */
     Date(options?: DateOptions): TDate;
+    /** `[JavaScript]` Creates a Function type */
     Function<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunction<T, U>;
+    /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
     InstanceType<T extends TConstructor<any[], any>>(schema: T, options?: SchemaOptions): TInstanceType<T>;
+    /** `[JavaScript]` Creates an Iterator type */
     Iterator<T extends TSchema>(items: T, options?: SchemaOptions): TIterator<T>;
+    /** `[JavaScript]` Extracts the Parameters from the given Function type */
     Parameters<T extends TFunction<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TParameters<T>;
+    /** `[JavaScript]` Creates a Promise type */
     Promise<T extends TSchema>(item: T, options?: SchemaOptions): TPromise<T>;
+    /** `[JavaScript]` Creates a String type from a Regular Expression pattern */
     RegExp(pattern: string, options?: SchemaOptions): TRegExp;
+    /** `[JavaScript]` Creates a String type from a Regular Expression */
     RegExp(regex: RegExp, options?: SchemaOptions): TRegExp;
+    /** `[JavaScript]` Extracts the ReturnType from the given Function type */
     ReturnType<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TReturnType<T>;
+    /** `[JavaScript]` Creates a Symbol type */
     Symbol(options?: SchemaOptions): TSymbol;
+    /** `[JavaScript]` Creates a Undefined type */
     Undefined(options?: SchemaOptions): TUndefined;
+    /** `[JavaScript]` Creates a Uint8Array type */
     Uint8Array(options?: Uint8ArrayOptions): TUint8Array;
+    /** `[JavaScript]` Creates a Void type */
     Void(options?: SchemaOptions): TVoid;
 }