@sinclair/typebox 0.33.19 → 0.33.21

package/build/cjs/parse/parsebox/runtime/types.d.ts

@@ -0,0 +1,68 @@
+export type IModuleProperties = Record<PropertyKey, IParser>;
+/** Infers the Output Parameter for a Parser */
+export type StaticParser<Parser extends IParser> = Parser extends IParser<infer Output extends unknown> ? Output : unknown;
+export type IMapping<Input extends unknown = any, Output extends unknown = unknown> = (input: Input, context: any) => Output;
+/** Maps input to output. This is the default Mapping */
+export declare const Identity: (value: unknown) => unknown;
+/** Maps the output as the given parameter T */
+export declare const As: <T>(mapping: T) => ((value: unknown) => T);
+export interface IParser<Output extends unknown = unknown> {
+    type: string;
+    mapping: IMapping<any, Output>;
+}
+export type TupleParameter<Parsers extends IParser[], Result extends unknown[] = []> = Parsers extends [infer L extends IParser, ...infer R extends IParser[]] ? TupleParameter<R, [...Result, StaticParser<L>]> : Result;
+export interface ITuple<Output extends unknown = unknown> extends IParser<Output> {
+    type: 'Tuple';
+    parsers: IParser[];
+}
+/** Creates a Tuple parser */
+export declare function Tuple<Parsers extends IParser[], Mapping extends IMapping = IMapping<TupleParameter<Parsers>>>(parsers: [...Parsers], mapping: Mapping): ITuple<ReturnType<Mapping>>;
+/** Creates a Tuple parser */
+export declare function Tuple<Parsers extends IParser[]>(parsers: [...Parsers]): ITuple<TupleParameter<Parsers>>;
+export type UnionParameter<Parsers extends IParser[], Result extends unknown = never> = Parsers extends [infer L extends IParser, ...infer R extends IParser[]] ? UnionParameter<R, Result | StaticParser<L>> : Result;
+export interface IUnion<Output extends unknown = unknown> extends IParser<Output> {
+    type: 'Union';
+    parsers: IParser[];
+}
+/** Creates a Union parser */
+export declare function Union<Parsers extends IParser[], Mapping extends IMapping = IMapping<UnionParameter<Parsers>>>(parsers: [...Parsers], mapping: Mapping): IUnion<ReturnType<Mapping>>;
+/** Creates a Union parser */
+export declare function Union<Parsers extends IParser[]>(parsers: [...Parsers]): IUnion<UnionParameter<Parsers>>;
+export interface IConst<Output extends unknown = unknown> extends IParser<Output> {
+    type: 'Const';
+    value: string;
+}
+/** Creates a Const parser */
+export declare function Const<Value extends string, Mapping extends IMapping<Value>>(value: Value, mapping: Mapping): IConst<ReturnType<Mapping>>;
+/** Creates a Const parser */
+export declare function Const<Value extends string>(value: Value): IConst<Value>;
+export interface IRef<Output extends unknown = unknown> extends IParser<Output> {
+    type: 'Ref';
+    ref: string;
+}
+/** Creates a Ref parser */
+export declare function Ref<Type extends unknown, Mapping extends IMapping<Type>>(ref: string, mapping: Mapping): IRef<ReturnType<Mapping>>;
+/** Creates a Ref parser */
+export declare function Ref<Type extends unknown>(ref: string): IRef<Type>;
+export interface IString<Output extends unknown = unknown> extends IParser<Output> {
+    type: 'String';
+    options: string[];
+}
+/** Creates a String Parser. Options are an array of permissable quote characters */
+export declare function String<Mapping extends IMapping<string>>(options: string[], mapping: Mapping): IString<ReturnType<Mapping>>;
+/** Creates a String Parser. Options are an array of permissable quote characters */
+export declare function String(options: string[]): IString<string>;
+export interface IIdent<Output extends unknown = unknown> extends IParser<Output> {
+    type: 'Ident';
+}
+/** Creates an Ident parser */
+export declare function Ident<Mapping extends IMapping<string>>(mapping: Mapping): IIdent<ReturnType<Mapping>>;
+/** Creates an Ident parser */
+export declare function Ident(): IIdent<string>;
+export interface INumber<Output extends unknown = unknown> extends IParser<Output> {
+    type: 'Number';
+}
+/** Creates a Number parser */
+export declare function Number<Mapping extends IMapping<string>>(mapping: Mapping): INumber<ReturnType<Mapping>>;
+/** Creates a Number parser */
+export declare function Number(): INumber<string>;

package/build/cjs/parse/parsebox/runtime/types.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.As = exports.Identity = void 0;
+exports.Tuple = Tuple;
+exports.Union = Union;
+exports.Const = Const;
+exports.Ref = Ref;
+exports.String = String;
+exports.Ident = Ident;
+exports.Number = Number;
+/** Maps input to output. This is the default Mapping */
+const Identity = (value) => value;
+exports.Identity = Identity;
+/** Maps the output as the given parameter T */
+const As = (mapping) => (_) => mapping;
+exports.As = As;
+function Tuple(...args) {
+    const [parsers, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], exports.Identity];
+    return { type: 'Tuple', parsers, mapping };
+}
+function Union(...args) {
+    const [parsers, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], exports.Identity];
+    return { type: 'Union', parsers, mapping };
+}
+function Const(...args) {
+    const [value, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], exports.Identity];
+    return { type: 'Const', value, mapping };
+}
+function Ref(...args) {
+    const [ref, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], exports.Identity];
+    return { type: 'Ref', ref, mapping };
+}
+function String(...params) {
+    const [options, mapping] = params.length === 2 ? [params[0], params[1]] : [params[0], exports.Identity];
+    return { type: 'String', options, mapping };
+}
+function Ident(...params) {
+    const mapping = params.length === 1 ? params[0] : exports.Identity;
+    return { type: 'Ident', mapping };
+}
+function Number(...params) {
+    const mapping = params.length === 1 ? params[0] : exports.Identity;
+    return { type: 'Number', mapping };
+}

package/build/cjs/parse/parsebox/static/index.d.ts

@@ -0,0 +1,3 @@
+export * as Token from './token';
+export * from './parse';
+export * from './types';

package/build/cjs/parse/parsebox/static/index.js

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

package/build/cjs/parse/parsebox/static/parse.d.ts

@@ -0,0 +1,17 @@
+import * as Tokens from './token';
+import * as Types from './types';
+type TupleParser<Parsers extends Types.IParser[], Code extends string, Context extends unknown, Result extends unknown[] = []> = (Parsers extends [infer Left extends Types.IParser, ...infer Right extends Types.IParser[]] ? Parse<Left, Code, Context> extends [infer Value extends unknown, infer Rest extends string] ? TupleParser<Right, Rest, Context, [...Result, Value]> : [] : [Result, Code]);
+type UnionParser<Parsers extends Types.IParser[], Code extends string, Context extends unknown> = (Parsers extends [infer Left extends Types.IParser, ...infer Right extends Types.IParser[]] ? Parse<Left, Code, Context> extends [infer Value extends unknown, infer Rest extends string] ? [Value, Rest] : UnionParser<Right, Code, Context> : []);
+type ConstParser<Value extends string, Code extends string, _Context extends unknown> = (Tokens.Const<Value, Code> extends [infer Match extends Value, infer Rest extends string] ? [Match, Rest] : []);
+type IdentParser<Code extends string, _Context extends unknown> = (Tokens.Ident<Code> extends [infer Match extends string, infer Rest extends string] ? [Match, Rest] : []);
+type NumberParser<Code extends string, _Context extends unknown> = (Tokens.Number<Code> extends [infer Match extends string, infer Rest extends string] ? [Match, Rest] : []);
+type StringParser<Options extends string[], Code extends string, _Context extends unknown> = (Tokens.String<Options, Code> extends [infer Match extends string, infer Rest extends string] ? [Match, Rest] : []);
+type ParseCode<Type extends Types.IParser, Code extends string, Context extends unknown = unknown> = (Type extends Types.Union<infer S extends Types.IParser[]> ? UnionParser<S, Code, Context> : Type extends Types.Tuple<infer S extends Types.IParser[]> ? TupleParser<S, Code, Context> : Type extends Types.Const<infer S extends string> ? ConstParser<S, Code, Context> : Type extends Types.String<infer S extends string[]> ? StringParser<S, Code, Context> : Type extends Types.Ident ? IdentParser<Code, Context> : Type extends Types.Number ? NumberParser<Code, Context> : [
+]);
+type ParseMapping<Parser extends Types.IParser, Result extends unknown, Context extends unknown = unknown> = ((Parser['mapping'] & {
+    input: Result;
+    context: Context;
+})['output']);
+/** Parses code with the given parser */
+export type Parse<Type extends Types.IParser, Code extends string, Context extends unknown = unknown> = (ParseCode<Type, Code, Context> extends [infer L extends unknown, infer R extends string] ? [ParseMapping<Type, L, Context>, R] : []);
+export {};

package/build/cjs/parse/parsebox/static/parse.js

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

package/build/cjs/parse/parsebox/static/token.d.ts

@@ -0,0 +1,108 @@
+declare namespace Chars {
+    type Empty = '';
+    type Space = ' ';
+    type Newline = '\n';
+    type Dot = '.';
+    type Hyphen = '-';
+    type Digit = [
+        '0',
+        '1',
+        '2',
+        '3',
+        '4',
+        '5',
+        '6',
+        '7',
+        '8',
+        '9'
+    ];
+    type Alpha = [
+        'a',
+        'b',
+        'c',
+        'd',
+        'e',
+        'f',
+        'g',
+        'h',
+        'i',
+        'j',
+        'k',
+        'l',
+        'm',
+        'n',
+        'o',
+        'p',
+        'q',
+        'r',
+        's',
+        't',
+        'u',
+        'v',
+        'w',
+        'x',
+        'y',
+        'z',
+        'A',
+        'B',
+        'C',
+        'D',
+        'E',
+        'F',
+        'G',
+        'H',
+        'I',
+        'J',
+        'K',
+        'L',
+        'M',
+        'N',
+        'O',
+        'P',
+        'Q',
+        'R',
+        'S',
+        'T',
+        'U',
+        'V',
+        'W',
+        'X',
+        'Y',
+        'Z'
+    ];
+}
+declare namespace Trim {
+    type W4 = `${W3}${W3}`;
+    type W3 = `${W2}${W2}`;
+    type W2 = `${W1}${W1}`;
+    type W1 = `${W0}${W0}`;
+    type W0 = ` `;
+    /** Trims whitespace only */
+    export type TrimWhitespace<Code extends string> = (Code extends `${W4}${infer Rest extends string}` ? TrimWhitespace<Rest> : Code extends `${W3}${infer Rest extends string}` ? TrimWhitespace<Rest> : Code extends `${W1}${infer Rest extends string}` ? TrimWhitespace<Rest> : Code extends `${W0}${infer Rest extends string}` ? TrimWhitespace<Rest> : Code);
+    /** Trims Whitespace and Newline */
+    export type TrimAll<Code extends string> = (Code extends `${W4}${infer Rest extends string}` ? TrimAll<Rest> : Code extends `${W3}${infer Rest extends string}` ? TrimAll<Rest> : Code extends `${W1}${infer Rest extends string}` ? TrimAll<Rest> : Code extends `${W0}${infer Rest extends string}` ? TrimAll<Rest> : Code extends `${Chars.Newline}${infer Rest extends string}` ? TrimAll<Rest> : Code);
+    export {};
+}
+/** Scans for the next match union */
+type NextUnion<Variants extends string[], Code extends string> = (Variants extends [infer Variant extends string, ...infer Rest1 extends string[]] ? NextConst<Variant, Code> extends [infer Match extends string, infer Rest2 extends string] ? [Match, Rest2] : NextUnion<Rest1, Code> : []);
+type NextConst<Value extends string, Code extends string> = (Code extends `${Value}${infer Rest extends string}` ? [Value, Rest] : []);
+/** Scans for the next constant value */
+export type Const<Value extends string, Code extends string> = (Value extends '' ? ['', Code] : Value extends `${infer First extends string}${string}` ? (First extends Chars.Newline ? NextConst<Value, Trim.TrimWhitespace<Code>> : First extends Chars.Space ? NextConst<Value, Code> : NextConst<Value, Trim.TrimAll<Code>>) : never);
+type NextNumberNegate<Code extends string> = (Code extends `${Chars.Hyphen}${infer Rest extends string}` ? [Chars.Hyphen, Rest] : [Chars.Empty, Code]);
+type NextNumberZeroCheck<Code extends string> = (Code extends `0${infer Rest}` ? NextUnion<Chars.Digit, Rest> extends [string, string] ? false : true : true);
+type NextNumberScan<Code extends string, HasDecimal extends boolean = false, Result extends string = Chars.Empty> = (NextUnion<[...Chars.Digit, Chars.Dot], Code> extends [infer Char extends string, infer Rest extends string] ? Char extends Chars.Dot ? HasDecimal extends false ? NextNumberScan<Rest, true, `${Result}${Char}`> : [Result, `.${Rest}`] : NextNumberScan<Rest, HasDecimal, `${Result}${Char}`> : [Result, Code]);
+export type NextNumber<Code extends string> = (NextNumberNegate<Code> extends [infer Negate extends string, infer Rest extends string] ? NextNumberZeroCheck<Rest> extends true ? NextNumberScan<Rest> extends [infer Number extends string, infer Rest2 extends string] ? Number extends Chars.Empty ? [] : [`${Negate}${Number}`, Rest2] : [] : [] : []);
+/** Scans for the next literal number */
+export type Number<Code extends string> = NextNumber<Trim.TrimAll<Code>>;
+type NextStringQuote<Options extends string[], Code extends string> = NextUnion<Options, Code>;
+type NextStringBody<Code extends string, Quote extends string, Result extends string = Chars.Empty> = (Code extends `${infer Char extends string}${infer Rest extends string}` ? Char extends Quote ? [Result, Rest] : NextStringBody<Rest, Quote, `${Result}${Char}`> : []);
+type NextString<Options extends string[], Code extends string> = (NextStringQuote<Options, Code> extends [infer Quote extends string, infer Rest extends string] ? NextStringBody<Rest, Quote> extends [infer String extends string, infer Rest extends string] ? [String, Rest] : [] : []);
+/** Scans for the next literal string */
+export type String<Options extends string[], Code extends string> = NextString<Options, Trim.TrimAll<Code>>;
+type IdentLeft = [...Chars.Alpha, '_', '$'];
+type IdentRight = [...Chars.Digit, ...IdentLeft];
+type NextIdentScan<Code extends string, Result extends string = Chars.Empty> = (NextUnion<IdentRight, Code> extends [infer Char extends string, infer Rest extends string] ? NextIdentScan<Rest, `${Result}${Char}`> : [Result, Code]);
+type NextIdent<Code extends string> = (NextUnion<IdentLeft, Code> extends [infer Left extends string, infer Rest1 extends string] ? NextIdentScan<Rest1> extends [infer Right extends string, infer Rest2 extends string] ? [`${Left}${Right}`, Rest2] : [] : []);
+/** Scans for the next Ident */
+export type Ident<Code extends string> = NextIdent<Trim.TrimAll<Code>>;
+export {};

package/build/cjs/parse/parsebox/static/token.js

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

package/build/cjs/parse/parsebox/static/types.d.ts

@@ -0,0 +1,46 @@
+export interface IMapping {
+    context: unknown;
+    input: unknown;
+    output: unknown;
+}
+/** Maps input to output. This is the default Mapping */
+export interface Identity extends IMapping {
+    output: this['input'];
+}
+/** Maps the output as the given parameter T */
+export interface As<T> extends IMapping {
+    output: T;
+}
+/** Base type Parser implemented by all other parsers */
+export interface IParser<Mapping extends IMapping = Identity> {
+    type: string;
+    mapping: Mapping;
+}
+/** Creates a Tuple Parser */
+export interface Tuple<Parsers extends IParser[] = [], Mapping extends IMapping = Identity> extends IParser<Mapping> {
+    type: 'Tuple';
+    parsers: [...Parsers];
+}
+/** Creates a Union Parser */
+export interface Union<Parsers extends IParser[] = [], Mapping extends IMapping = Identity> extends IParser<Mapping> {
+    type: 'Union';
+    parsers: [...Parsers];
+}
+/** Creates a Const Parser */
+export interface Const<Value extends string = string, Mapping extends IMapping = Identity> extends IParser<Mapping> {
+    type: 'Const';
+    value: Value;
+}
+/** Creates a String Parser. Options are an array of permissable quote characters */
+export interface String<Options extends string[], Mapping extends IMapping = Identity> extends IParser<Mapping> {
+    type: 'String';
+    quote: Options;
+}
+/** Creates an Ident Parser. */
+export interface Ident<Mapping extends IMapping = Identity> extends IParser<Mapping> {
+    type: 'Ident';
+}
+/** Creates a Number Parser. */
+export interface Number<Mapping extends IMapping = Identity> extends IParser<Mapping> {
+    type: 'Number';
+}

package/build/cjs/parse/parsebox/static/types.js

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

package/build/cjs/parse/runtime.d.ts

@@ -0,0 +1,55 @@
+import { Runtime } from './parsebox/index';
+import * as Types from '../type/index';
+export declare const Module: Runtime.Module<{
+    Literal: Runtime.IUnion<Types.TLiteral<string> | Types.TLiteral<number> | Types.TLiteral<boolean>>;
+    Keyword: Runtime.IUnion<Types.TAny | Types.TNever | Types.TString | Types.TBoolean | Types.TNumber | Types.TInteger | Types.TBigInt | Types.TNull | Types.TSymbol | Types.TUndefined | Types.TUnknown | Types.TVoid>;
+    KeyOf: Runtime.IUnion<boolean>;
+    IndexArray: Runtime.IUnion<unknown[]>;
+    Extends: Runtime.IUnion<unknown[]>;
+    Base: Runtime.IUnion<unknown>;
+    Factor: Runtime.ITuple<Types.TSchema>;
+    ExprTermTail: Runtime.IUnion<[] | ["&", unknown, unknown]>;
+    ExprTerm: Runtime.ITuple<Types.TSchema>;
+    ExprTail: Runtime.IUnion<[] | ["|", unknown, unknown]>;
+    Expr: Runtime.ITuple<Types.TSchema>;
+    Type: Runtime.IRef<unknown>;
+    PropertyKey: Runtime.IUnion<string>;
+    PropertyReadonly: Runtime.IUnion<boolean>;
+    PropertyOptional: Runtime.IUnion<boolean>;
+    Property: Runtime.ITuple<{
+        [x: string]: Types.TSchema;
+    }>;
+    PropertyDelimiter: Runtime.IUnion<[","] | [",", "\n"] | [";"] | [";", "\n"] | ["\n"]>;
+    Properties: Runtime.IUnion<unknown[]>;
+    Object: Runtime.ITuple<Types.TObject<Record<string, Types.TSchema>>>;
+    Elements: Runtime.IUnion<unknown[]>;
+    Tuple: Runtime.ITuple<Types.TTuple<Types.TSchema[]>>;
+    Parameter: Runtime.ITuple<Types.TSchema>;
+    Function: Runtime.ITuple<Types.TFunction<Types.TSchema[], Types.TSchema>>;
+    Parameters: Runtime.IUnion<unknown[]>;
+    Constructor: Runtime.ITuple<Types.TConstructor<Types.TSchema[], Types.TSchema>>;
+    Mapped: Runtime.ITuple<Types.TLiteral<"Mapped types not supported">>;
+    AsyncIterator: Runtime.ITuple<Types.TAsyncIterator<Types.TSchema>>;
+    Iterator: Runtime.ITuple<Types.TIterator<Types.TSchema>>;
+    Awaited: Runtime.ITuple<Types.TSchema>;
+    Array: Runtime.ITuple<Types.TArray<Types.TSchema>>;
+    Record: Runtime.ITuple<Types.TNever>;
+    Promise: Runtime.ITuple<Types.TPromise<Types.TSchema>>;
+    ConstructorParameters: Runtime.ITuple<Types.TTuple<Types.TSchema[]>>;
+    FunctionParameters: Runtime.ITuple<Types.TTuple<Types.TSchema[]>>;
+    InstanceType: Runtime.ITuple<Types.TSchema>;
+    ReturnType: Runtime.ITuple<Types.TSchema>;
+    Partial: Runtime.ITuple<Types.TObject<{}>>;
+    Required: Runtime.ITuple<Types.TObject<{}>>;
+    Pick: Runtime.ITuple<Types.TObject<{}>>;
+    Omit: Runtime.ITuple<Types.TObject<{}>>;
+    Exclude: Runtime.ITuple<Types.TNever>;
+    Extract: Runtime.ITuple<Types.TSchema>;
+    Uppercase: Runtime.ITuple<Types.TSchema>;
+    Lowercase: Runtime.ITuple<Types.TSchema>;
+    Capitalize: Runtime.ITuple<Types.TSchema>;
+    Uncapitalize: Runtime.ITuple<Types.TSchema>;
+    Date: Runtime.IConst<Types.TDate>;
+    Uint8Array: Runtime.IConst<Types.TUint8Array>;
+    Reference: Runtime.IIdent<Types.TSchema>;
+}>;