@sinclair/typebox 0.32.0-dev-2 → 0.32.0-dev-4

package/esm/type/template-literal/syntax.mjs

@@ -1,83 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@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';
-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() :
-        trim === 'number' ? yield Number() :
-            trim === 'bigint' ? yield BigInt() :
-                trim === 'string' ? yield String() :
-                    yield (() => {
-                        const literals = trim.split('|').map((literal) => Literal(literal.trim()));
-                        return (literals.length === 0 ? Never() :
-                            literals.length === 1 ? literals[0] :
-                                Union(literals));
-                    })());
-}
-// prettier-ignore
-function* FromTerminal(syntax) {
-    if (syntax[1] !== '{') {
-        const L = Literal('$');
-        const R = FromSyntax(syntax.slice(1));
-        return yield* [L, ...R];
-    }
-    for (let i = 2; i < syntax.length; i++) {
-        if (syntax[i] === '}') {
-            const L = FromUnion(syntax.slice(2, i));
-            const R = FromSyntax(syntax.slice(i + 1));
-            return yield* [...L, ...R];
-        }
-    }
-    yield Literal(syntax);
-}
-// prettier-ignore
-function* FromSyntax(syntax) {
-    for (let i = 0; i < syntax.length; i++) {
-        if (syntax[i] === '$') {
-            const L = Literal(syntax.slice(0, i));
-            const R = FromTerminal(syntax.slice(i));
-            return yield* [L, ...R];
-        }
-    }
-    yield Literal(syntax);
-}
-// prettier-ignore
-/** Parses TemplateLiteralSyntax and returns a tuple of TemplateLiteralKinds */
-export function TemplateLiteralSyntax(syntax) {
-    return [...FromSyntax(syntax)];
-}

package/esm/type/template-literal/template-literal.d.mts

@@ -1,30 +0,0 @@
-import type { TSchema, SchemaOptions } from '../schema/index.mjs';
-import type { Assert } from '../helpers/index.mjs';
-import type { TUnion } from '../union/index.mjs';
-import type { TLiteral } from '../literal/index.mjs';
-import type { TInteger } from '../integer/index.mjs';
-import type { TNumber } from '../number/index.mjs';
-import type { TBigInt } from '../bigint/index.mjs';
-import type { TString } from '../string/index.mjs';
-import type { TBoolean } from '../boolean/index.mjs';
-import type { TNever } from '../never/index.mjs';
-import type { Static } from '../static/index.mjs';
-import { TemplateLiteralSyntax } from './syntax.mjs';
-import { EmptyString } from '../helpers/index.mjs';
-import { Kind } from '../symbols/index.mjs';
-type TemplateLiteralResolveConst<T, Acc extends string> = T extends TUnion<infer U> ? {
-    [K in keyof U]: TemplateLiteralResolve<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;
-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>;
-    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/esm/type/template-literal/template-literal.mjs

@@ -1,39 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@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))
-        : TemplateLiteralPattern(unresolved);
-    return { ...options, [Kind]: 'TemplateLiteral', type: 'string', pattern };
-}

package/esm/type/template-literal/union.d.mts

@@ -1,7 +0,0 @@
-import type { TTemplateLiteral } from './template-literal.mjs';
-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/esm/type/template-literal/union.mjs

@@ -1,44 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@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))
-        return String();
-    const literals = [...TemplateLiteralGenerate(expression)].map((value) => Literal(value));
-    return Union(literals);
-}

package/esm/type/transform/index.d.mts

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

package/esm/type/transform/index.mjs

@@ -1,28 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@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/esm/type/transform/transform.d.mts

@@ -1,29 +0,0 @@
-import type { TSchema } from '../schema/index.mjs';
-import type { Static, StaticDecode } from '../static/index.mjs';
-import { TransformKind } from '../symbols/index.mjs';
-export declare class TransformDecodeBuilder<T extends TSchema> {
-    private readonly schema;
-    constructor(schema: T);
-    Decode<U extends unknown, D extends TransformFunction<StaticDecode<T>, U>>(decode: D): TransformEncodeBuilder<T, D>;
-}
-export declare class TransformEncodeBuilder<T extends TSchema, D extends TransformFunction> {
-    private readonly schema;
-    private readonly decode;
-    constructor(schema: T, decode: D);
-    private EncodeTransform;
-    private EncodeSchema;
-    Encode<E extends TransformFunction<ReturnType<D>, StaticDecode<T>>>(encode: E): TTransform<T, ReturnType<D>>;
-}
-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']>;
-    [TransformKind]: TransformOptions<I, O>;
-    [key: string]: any;
-}
-/** `[Json]` Creates a Transform type */
-export declare function Transform<I extends TSchema>(schema: I): TransformDecodeBuilder<I>;

package/esm/type/transform/transform.mjs

@@ -1,69 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@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 { TTransform as IsTransform } from '../guard/type.mjs';
-import { CloneType } from '../clone/type.mjs';
-import { TransformKind } from '../symbols/index.mjs';
-// ------------------------------------------------------------------
-// TransformBuilders
-// ------------------------------------------------------------------
-export class TransformDecodeBuilder {
-    schema;
-    constructor(schema) {
-        this.schema = schema;
-    }
-    Decode(decode) {
-        return new TransformEncodeBuilder(this.schema, decode);
-    }
-}
-// prettier-ignore
-export class TransformEncodeBuilder {
-    schema;
-    decode;
-    constructor(schema, decode) {
-        this.schema = schema;
-        this.decode = decode;
-    }
-    EncodeTransform(encode, schema) {
-        const Encode = (value) => schema[TransformKind].Encode(encode(value));
-        const Decode = (value) => this.decode(schema[TransformKind].Decode(value));
-        const Codec = { Encode: Encode, Decode: Decode };
-        return { ...schema, [TransformKind]: Codec };
-    }
-    EncodeSchema(encode, schema) {
-        const Codec = { Decode: this.decode, Encode: encode };
-        return { ...schema, [TransformKind]: Codec };
-    }
-    Encode(encode) {
-        const schema = CloneType(this.schema);
-        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/esm/type/tuple/index.d.mts

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

package/esm/type/tuple/index.mjs

@@ -1,28 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@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/esm/type/tuple/tuple.d.mts

@@ -1,15 +0,0 @@
-import type { TSchema, SchemaOptions } from '../schema/index.mjs';
-import type { Static } from '../static/index.mjs';
-import { Kind } from '../symbols/index.mjs';
-export type TupleResolve<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...TupleResolve<R, P>] : [];
-export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
-    [Kind]: 'Tuple';
-    static: TupleResolve<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>;

package/esm/type/tuple/tuple.mjs

@@ -1,38 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@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/esm/type/type/index.d.mts

@@ -1,6 +0,0 @@
-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/esm/type/type/index.mjs

@@ -1,40 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@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/esm/type/type/javascript.d.mts

@@ -1,58 +0,0 @@
-import { JsonTypeBuilder } from './json.mjs';
-import { type TAsyncIterator } from '../async-iterator/index.mjs';
-import { type TAwaited } from '../awaited/index.mjs';
-import { type TBigInt, type BigIntOptions } from '../bigint/index.mjs';
-import { type TConstructor } from '../constructor/index.mjs';
-import { type TConstructorParameters } from '../constructor-parameters/index.mjs';
-import { type TDate, type DateOptions } from '../date/index.mjs';
-import { type TFunction } from '../function/index.mjs';
-import { type TInstanceType } from '../instance-type/index.mjs';
-import { type TIterator } from '../iterator/index.mjs';
-import { type TParameters } from '../parameters/index.mjs';
-import { type TPromise } from '../promise/index.mjs';
-import { type TRegExp } from '../regexp/index.mjs';
-import { type TReturnType } from '../return-type/index.mjs';
-import { type TSchema, type SchemaOptions } from '../schema/index.mjs';
-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;
-}

package/esm/type/type/javascript.mjs

@@ -1,116 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@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 { JsonTypeBuilder } from './json.mjs';
-import { AsyncIterator } from '../async-iterator/index.mjs';
-import { Awaited } from '../awaited/index.mjs';
-import { BigInt } from '../bigint/index.mjs';
-import { Constructor } from '../constructor/index.mjs';
-import { ConstructorParameters } from '../constructor-parameters/index.mjs';
-import { Date } from '../date/index.mjs';
-import { Function } from '../function/index.mjs';
-import { InstanceType } from '../instance-type/index.mjs';
-import { Iterator } from '../iterator/index.mjs';
-import { Parameters } from '../parameters/index.mjs';
-import { Promise } from '../promise/index.mjs';
-import { RegExp } from '../regexp/index.mjs';
-import { ReturnType } from '../return-type/index.mjs';
-import { Symbol } from '../symbol/index.mjs';
-import { Uint8Array } from '../uint8array/index.mjs';
-import { Undefined } from '../undefined/index.mjs';
-import { Void } from '../void/index.mjs';
-/** JavaScript Type Builder with Static Resolution for TypeScript */
-export class JavaScriptTypeBuilder extends JsonTypeBuilder {
-    /** `[JavaScript]` Creates a AsyncIterator type */
-    AsyncIterator(items, options = {}) {
-        return AsyncIterator(items, options);
-    }
-    /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
-    Awaited(schema, options = {}) {
-        return Awaited(schema, options);
-    }
-    /** `[JavaScript]` Creates a BigInt type */
-    BigInt(options = {}) {
-        return BigInt(options);
-    }
-    /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
-    ConstructorParameters(schema, options = {}) {
-        return ConstructorParameters(schema, options);
-    }
-    /** `[JavaScript]` Creates a Constructor type */
-    Constructor(parameters, returns, options) {
-        return Constructor(parameters, returns, options);
-    }
-    /** `[JavaScript]` Creates a Date type */
-    Date(options = {}) {
-        return Date(options);
-    }
-    /** `[JavaScript]` Creates a Function type */
-    Function(parameters, returns, options) {
-        return Function(parameters, returns, options);
-    }
-    /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
-    InstanceType(schema, options = {}) {
-        return InstanceType(schema, options);
-    }
-    /** `[JavaScript]` Creates an Iterator type */
-    Iterator(items, options = {}) {
-        return Iterator(items, options);
-    }
-    /** `[JavaScript]` Extracts the Parameters from the given Function type */
-    Parameters(schema, options = {}) {
-        return Parameters(schema, options);
-    }
-    /** `[JavaScript]` Creates a Promise type */
-    Promise(item, options = {}) {
-        return Promise(item, options);
-    }
-    /** `[JavaScript]` Creates a String type */
-    RegExp(unresolved, options = {}) {
-        return RegExp(unresolved, options);
-    }
-    /** `[JavaScript]` Extracts the ReturnType from the given Function type */
-    ReturnType(schema, options = {}) {
-        return ReturnType(schema, options);
-    }
-    /** `[JavaScript]` Creates a Symbol type */
-    Symbol(options) {
-        return Symbol(options);
-    }
-    /** `[JavaScript]` Creates a Undefined type */
-    Undefined(options = {}) {
-        return Undefined(options);
-    }
-    /** `[JavaScript]` Creates a Uint8Array type */
-    Uint8Array(options = {}) {
-        return Uint8Array(options);
-    }
-    /** `[JavaScript]` Creates a Void type */
-    Void(options = {}) {
-        return Void(options);
-    }
-}