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

package/type/schema/index.js

@@ -0,0 +1,18 @@
+"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 });
+__exportStar(require("./anyschema"), exports);
+__exportStar(require("./schema"), exports);

package/type/schema/schema.d.ts

@@ -0,0 +1,22 @@
+import { Kind, Hint, ReadonlyKind, OptionalKind } from '../symbols/index';
+export interface SchemaOptions {
+    $schema?: string;
+    $id?: string;
+    title?: string;
+    description?: string;
+    default?: any;
+    examples?: any;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    [prop: string]: any;
+}
+export interface TKind {
+    [Kind]: string;
+}
+export interface TSchema extends SchemaOptions, TKind {
+    [ReadonlyKind]?: string;
+    [OptionalKind]?: string;
+    [Hint]?: string;
+    params: unknown[];
+    static: unknown;
+}

package/type/schema/schema.js

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

package/type/static/index.d.ts

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

package/type/static/index.js

@@ -0,0 +1,17 @@
+"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 });
+__exportStar(require("./static"), exports);

package/type/static/static.d.ts

@@ -0,0 +1,31 @@
+import type { Evaluate } from '../helpers/index';
+import type { TOptional } from '../optional/index';
+import type { TReadonly } from '../readonly/index';
+import type { TArray } from '../array/index';
+import type { TAsyncIterator } from '../async-iterator/index';
+import type { TConstructor } from '../constructor/index';
+import type { TEnum } from '../enum/index';
+import type { TFunction } from '../function/index';
+import type { TIntersect } from '../intersect/index';
+import type { TIterator } from '../iterator/index';
+import type { TNot } from '../not/index';
+import type { TObject, TProperties } from '../object/index';
+import type { TPromise } from '../promise/index';
+import type { TRecursive } from '../recursive/index';
+import type { TRecord } from '../record/index';
+import type { TRef } from '../ref/index';
+import type { TTuple } from '../tuple/index';
+import type { TUnion } from '../union/index';
+import type { TUnsafe } from '../unsafe/index';
+import type { TSchema } from '../schema/index';
+import type { TTransform } from '../transform/index';
+export type DecodeProperties<T extends TProperties> = {
+    [K in keyof T]: DecodeType<T[K]>;
+};
+export type DecodeRest<T extends TSchema[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [DecodeType<L>, ...DecodeRest<R>] : [];
+export type DecodeType<T extends TSchema> = (T extends TOptional<infer S extends TSchema> ? TOptional<DecodeType<S>> : T extends TReadonly<infer S extends TSchema> ? TReadonly<DecodeType<S>> : T extends TTransform<infer _, infer R> ? TUnsafe<R> : T extends TArray<infer S extends TSchema> ? TArray<DecodeType<S>> : T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<DecodeType<S>> : T extends TConstructor<infer P extends TSchema[], infer R extends TSchema> ? TConstructor<DecodeRest<P>, DecodeType<R>> : T extends TEnum<infer S> ? TEnum<S> : T extends TFunction<infer P extends TSchema[], infer R extends TSchema> ? TFunction<DecodeRest<P>, DecodeType<R>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<DecodeRest<S>> : T extends TIterator<infer S extends TSchema> ? TIterator<DecodeType<S>> : T extends TNot<infer S extends TSchema> ? TNot<DecodeType<S>> : T extends TObject<infer S> ? TObject<Evaluate<DecodeProperties<S>>> : T extends TPromise<infer S extends TSchema> ? TPromise<DecodeType<S>> : T extends TRecord<infer K, infer S> ? TRecord<K, DecodeType<S>> : T extends TRecursive<infer S extends TSchema> ? TRecursive<DecodeType<S>> : T extends TRef<infer S extends TSchema> ? TRef<DecodeType<S>> : T extends TTuple<infer S extends TSchema[]> ? TTuple<DecodeRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<DecodeRest<S>> : T);
+export type StaticDecode<T extends TSchema, P extends unknown[] = []> = Static<DecodeType<T>, P>;
+export type StaticEncode<T extends TSchema, P extends unknown[] = []> = Static<T, P>;
+export type Static<T extends TSchema, P extends unknown[] = []> = (T & {
+    params: P;
+})['static'];

package/type/static/static.js

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

package/type/strict/index.d.ts

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

package/type/strict/index.js

@@ -0,0 +1,17 @@
+"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 });
+__exportStar(require("./strict"), exports);

package/type/strict/strict.d.ts

@@ -0,0 +1,2 @@
+import type { TSchema } from '../schema/index';
+export declare function Strict<T extends TSchema>(schema: T): T;

package/type/strict/strict.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Strict = void 0;
+function Strict(schema) {
+    return JSON.parse(JSON.stringify(schema));
+}
+exports.Strict = Strict;

package/type/string/index.d.ts

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

package/type/string/index.js

@@ -0,0 +1,17 @@
+"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 });
+__exportStar(require("./string"), exports);

package/type/string/string.d.ts

@@ -0,0 +1,18 @@
+import { TSchema, SchemaOptions } from '../schema/index';
+import { Kind } from '../symbols/index';
+export type StringFormatOption = 'date-time' | 'time' | 'date' | 'email' | 'idn-email' | 'hostname' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'uri' | 'uri-reference' | 'iri' | 'uuid' | 'iri-reference' | 'uri-template' | 'json-pointer' | 'relative-json-pointer' | 'regex' | ({} & string);
+export type StringContentEncodingOption = '7bit' | '8bit' | 'binary' | 'quoted-printable' | 'base64' | ({} & string);
+export interface StringOptions extends SchemaOptions {
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    format?: StringFormatOption;
+    contentEncoding?: StringContentEncodingOption;
+    contentMediaType?: string;
+}
+export interface TString extends TSchema, StringOptions {
+    [Kind]: 'String';
+    static: string;
+    type: 'string';
+}
+export declare function String(options?: StringOptions): TString;

package/type/string/string.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.String = void 0;
+const index_1 = require("../symbols/index");
+function String(options = {}) {
+    return { ...options, [index_1.Kind]: 'String', type: 'string' };
+}
+exports.String = String;

package/type/symbol/index.d.ts

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

package/type/symbol/index.js

@@ -0,0 +1,17 @@
+"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 });
+__exportStar(require("./symbol"), exports);

package/type/symbol/symbol.d.ts

@@ -0,0 +1,9 @@
+import { TSchema, SchemaOptions } from '../schema/index';
+import { Kind } from '../symbols/index';
+export type SymbolValue = string | number | undefined;
+export interface TSymbol extends TSchema, SchemaOptions {
+    [Kind]: 'Symbol';
+    static: symbol;
+    type: 'symbol';
+}
+export declare function Symbol(options?: SchemaOptions): TSymbol;

package/type/symbol/symbol.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Symbol = void 0;
+const index_1 = require("../symbols/index");
+function Symbol(options) {
+    return { ...options, [index_1.Kind]: 'Symbol', type: 'symbol' };
+}
+exports.Symbol = Symbol;

package/type/symbols/index.d.ts

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

package/type/symbols/index.js

@@ -0,0 +1,17 @@
+"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 });
+__exportStar(require("./symbols"), exports);

package/type/symbols/symbols.d.ts

@@ -0,0 +1,5 @@
+export declare const TransformKind: unique symbol;
+export declare const ReadonlyKind: unique symbol;
+export declare const OptionalKind: unique symbol;
+export declare const Hint: unique symbol;
+export declare const Kind: unique symbol;

package/type/symbols/symbols.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Kind = exports.Hint = exports.OptionalKind = exports.ReadonlyKind = exports.TransformKind = void 0;
+exports.TransformKind = Symbol.for('TypeBox.Transform');
+exports.ReadonlyKind = Symbol.for('TypeBox.Readonly');
+exports.OptionalKind = Symbol.for('TypeBox.Optional');
+exports.Hint = Symbol.for('TypeBox.Hint');
+exports.Kind = Symbol.for('TypeBox.Kind');

package/type/template-literal/finite.d.ts

@@ -0,0 +1,16 @@
+import type { TTemplateLiteral, TTemplateLiteralKind } from './index';
+import type { TUnion } from '../union/index';
+import type { TString } from '../string/index';
+import type { TBoolean } from '../boolean/index';
+import type { TNumber } from '../number/index';
+import type { TInteger } from '../integer/index';
+import type { TBigInt } from '../bigint/index';
+import type { TLiteral } from '../literal/index';
+import type { Expression } from './parser';
+export declare class TemplateLiteralFiniteError extends Error {
+}
+type IsTemplateLiteralFiniteCheck<T> = T extends TTemplateLiteral<infer U extends TTemplateLiteralKind[]> ? IsTemplateLiteralFiniteArray<U> : T extends TUnion<infer U extends TTemplateLiteralKind[]> ? IsTemplateLiteralFiniteArray<U> : T extends TString ? false : T extends TBoolean ? false : T extends TNumber ? false : T extends TInteger ? false : T extends TBigInt ? false : T extends TLiteral ? true : false;
+type IsTemplateLiteralFiniteArray<T extends TTemplateLiteralKind[]> = T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? IsTemplateLiteralFiniteCheck<L> extends false ? false : IsTemplateLiteralFiniteArray<R> : true;
+export type IsTemplateLiteralFinite<T> = T extends TTemplateLiteral<infer U> ? IsTemplateLiteralFiniteArray<U> : false;
+export declare function IsTemplateLiteralFinite(expression: Expression): boolean;
+export {};

package/type/template-literal/finite.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsTemplateLiteralFinite = exports.TemplateLiteralFiniteError = void 0;
+class TemplateLiteralFiniteError extends Error {
+}
+exports.TemplateLiteralFiniteError = TemplateLiteralFiniteError;
+function IsNumberExpression(expression) {
+    return (expression.type === 'or' &&
+        expression.expr.length === 2 &&
+        expression.expr[0].type === 'const' &&
+        expression.expr[0].const === '0' &&
+        expression.expr[1].type === 'const' &&
+        expression.expr[1].const === '[1-9][0-9]*');
+}
+function IsBooleanExpression(expression) {
+    return (expression.type === 'or' &&
+        expression.expr.length === 2 &&
+        expression.expr[0].type === 'const' &&
+        expression.expr[0].const === 'true' &&
+        expression.expr[1].type === 'const' &&
+        expression.expr[1].const === 'false');
+}
+function IsStringExpression(expression) {
+    return expression.type === 'const' && expression.const === '.*';
+}
+function IsTemplateLiteralFinite(expression) {
+    return (IsBooleanExpression(expression) ? true :
+        IsNumberExpression(expression) || IsStringExpression(expression) ? false :
+            (expression.type === 'and') ? expression.expr.every((expr) => IsTemplateLiteralFinite(expr)) :
+                (expression.type === 'or') ? expression.expr.every((expr) => IsTemplateLiteralFinite(expr)) :
+                    (expression.type === 'const') ? true :
+                        (() => { throw new TemplateLiteralFiniteError(`Unknown expression type`); })());
+}
+exports.IsTemplateLiteralFinite = IsTemplateLiteralFinite;

package/type/template-literal/generate.d.ts

@@ -0,0 +1,15 @@
+import type { TTemplateLiteral, TTemplateLiteralKind } from './index';
+import type { TLiteral, TLiteralValue } from '../literal/index';
+import type { Expression } from './parser';
+import type { TUnion } from '../union/index';
+type StringReduceUnary<L extends string, R extends string[]> = R extends [infer A extends string, ...infer B extends string[]] ? [`${L}${A}`, ...StringReduceUnary<L, B>] : [];
+type StringReduceBinary<L extends string[], R extends string[]> = L extends [infer A extends string, ...infer B extends string[]] ? [...StringReduceUnary<A, R>, ...StringReduceBinary<B, R>] : [];
+type StringReduceMany<T extends string[][]> = T extends [infer L extends string[], infer R extends string[], ...infer Rest extends string[][]] ? StringReduceMany<[StringReduceBinary<L, R>, ...Rest]> : T;
+type StringReduce<T extends string[][], O = StringReduceMany<T>> = 0 extends keyof O ? O[0] : [];
+type TemplateLiteralReduceUnion<T extends TTemplateLiteralKind[]> = T extends [infer L extends TLiteral, ...infer R extends TLiteral[]] ? [L['const'], ...TemplateLiteralReduceUnion<R>] : [];
+type TemplateLiteralReduce<T extends TTemplateLiteralKind[]> = T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? L extends TLiteral<infer S extends TLiteralValue> ? [[S], ...TemplateLiteralReduce<R>] : L extends TUnion<infer S extends TTemplateLiteralKind[]> ? [TemplateLiteralReduceUnion<S>, ...TemplateLiteralReduce<R>] : [] : [];
+export declare class TemplateLiteralGenerateError extends Error {
+}
+export type TemplateLiteralGenerate<T> = T extends TTemplateLiteral<infer S extends TTemplateLiteralKind[]> ? TemplateLiteralReduce<S> extends infer R extends string[][] ? StringReduce<R> : [] : [];
+export declare function TemplateLiteralGenerate(expression: Expression): IterableIterator<string>;
+export {};

package/type/template-literal/generate.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateLiteralGenerate = exports.TemplateLiteralGenerateError = void 0;
+function* GenerateReduce(buffer) {
+    if (buffer.length === 1)
+        return yield* buffer[0];
+    for (const left of buffer[0]) {
+        for (const right of GenerateReduce(buffer.slice(1))) {
+            yield `${left}${right}`;
+        }
+    }
+}
+function* GenerateAnd(expression) {
+    return yield* GenerateReduce(expression.expr.map((expr) => [...TemplateLiteralGenerate(expr)]));
+}
+function* GenerateOr(expression) {
+    for (const expr of expression.expr)
+        yield* TemplateLiteralGenerate(expr);
+}
+function* GenerateConst(expression) {
+    return yield expression.const;
+}
+class TemplateLiteralGenerateError extends Error {
+}
+exports.TemplateLiteralGenerateError = TemplateLiteralGenerateError;
+function* TemplateLiteralGenerate(expression) {
+    return expression.type === 'and'
+        ? yield* GenerateAnd(expression)
+        : expression.type === 'or'
+            ? yield* GenerateOr(expression)
+            : expression.type === 'const'
+                ? yield* GenerateConst(expression)
+                : (() => {
+                    throw new TemplateLiteralGenerateError('Unknown expression');
+                })();
+}
+exports.TemplateLiteralGenerate = TemplateLiteralGenerate;

package/type/template-literal/index.d.ts

@@ -0,0 +1,7 @@
+export * from './finite';
+export * from './generate';
+export * from './syntax';
+export * from './parser';
+export * from './pattern';
+export * from './union';
+export * from './template-literal';

package/type/template-literal/index.js

@@ -0,0 +1,23 @@
+"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 });
+__exportStar(require("./finite"), exports);
+__exportStar(require("./generate"), exports);
+__exportStar(require("./syntax"), exports);
+__exportStar(require("./parser"), exports);
+__exportStar(require("./pattern"), exports);
+__exportStar(require("./union"), exports);
+__exportStar(require("./template-literal"), exports);

package/type/template-literal/parser.d.ts

@@ -0,0 +1,17 @@
+export declare class TemplateLiteralParserError extends Error {
+}
+export type Expression = ExpressionAnd | ExpressionOr | ExpressionConst;
+export type ExpressionConst = {
+    type: 'const';
+    const: string;
+};
+export type ExpressionAnd = {
+    type: 'and';
+    expr: Expression[];
+};
+export type ExpressionOr = {
+    type: 'or';
+    expr: Expression[];
+};
+export declare function TemplateLiteralParse(pattern: string): Expression;
+export declare function TemplateLiteralParseExact(pattern: string): Expression;

package/type/template-literal/parser.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateLiteralParseExact = exports.TemplateLiteralParse = exports.TemplateLiteralParserError = void 0;
+class TemplateLiteralParserError extends Error {
+}
+exports.TemplateLiteralParserError = TemplateLiteralParserError;
+function IsNonEscaped(pattern, index, char) {
+    return pattern[index] === char && pattern.charCodeAt(index - 1) !== 92;
+}
+function IsOpenParen(pattern, index) {
+    return IsNonEscaped(pattern, index, '(');
+}
+function IsCloseParen(pattern, index) {
+    return IsNonEscaped(pattern, index, ')');
+}
+function IsSeparator(pattern, index) {
+    return IsNonEscaped(pattern, index, '|');
+}
+function IsGroup(pattern) {
+    if (!(IsOpenParen(pattern, 0) && IsCloseParen(pattern, pattern.length - 1)))
+        return false;
+    let count = 0;
+    for (let index = 0; index < pattern.length; index++) {
+        if (IsOpenParen(pattern, index))
+            count += 1;
+        if (IsCloseParen(pattern, index))
+            count -= 1;
+        if (count === 0 && index !== pattern.length - 1)
+            return false;
+    }
+    return true;
+}
+function InGroup(pattern) {
+    return pattern.slice(1, pattern.length - 1);
+}
+function IsPrecedenceOr(pattern) {
+    let count = 0;
+    for (let index = 0; index < pattern.length; index++) {
+        if (IsOpenParen(pattern, index))
+            count += 1;
+        if (IsCloseParen(pattern, index))
+            count -= 1;
+        if (IsSeparator(pattern, index) && count === 0)
+            return true;
+    }
+    return false;
+}
+function IsPrecedenceAnd(pattern) {
+    for (let index = 0; index < pattern.length; index++) {
+        if (IsOpenParen(pattern, index))
+            return true;
+    }
+    return false;
+}
+function Or(pattern) {
+    let [count, start] = [0, 0];
+    const expressions = [];
+    for (let index = 0; index < pattern.length; index++) {
+        if (IsOpenParen(pattern, index))
+            count += 1;
+        if (IsCloseParen(pattern, index))
+            count -= 1;
+        if (IsSeparator(pattern, index) && count === 0) {
+            const range = pattern.slice(start, index);
+            if (range.length > 0)
+                expressions.push(TemplateLiteralParse(range));
+            start = index + 1;
+        }
+    }
+    const range = pattern.slice(start);
+    if (range.length > 0)
+        expressions.push(TemplateLiteralParse(range));
+    if (expressions.length === 0)
+        return { type: 'const', const: '' };
+    if (expressions.length === 1)
+        return expressions[0];
+    return { type: 'or', expr: expressions };
+}
+function And(pattern) {
+    function Group(value, index) {
+        if (!IsOpenParen(value, index))
+            throw new TemplateLiteralParserError(`TemplateLiteralParser: Index must point to open parens`);
+        let count = 0;
+        for (let scan = index; scan < value.length; scan++) {
+            if (IsOpenParen(value, scan))
+                count += 1;
+            if (IsCloseParen(value, scan))
+                count -= 1;
+            if (count === 0)
+                return [index, scan];
+        }
+        throw new TemplateLiteralParserError(`TemplateLiteralParser: Unclosed group parens in expression`);
+    }
+    function Range(pattern, index) {
+        for (let scan = index; scan < pattern.length; scan++) {
+            if (IsOpenParen(pattern, scan))
+                return [index, scan];
+        }
+        return [index, pattern.length];
+    }
+    const expressions = [];
+    for (let index = 0; index < pattern.length; index++) {
+        if (IsOpenParen(pattern, index)) {
+            const [start, end] = Group(pattern, index);
+            const range = pattern.slice(start, end + 1);
+            expressions.push(TemplateLiteralParse(range));
+            index = end;
+        }
+        else {
+            const [start, end] = Range(pattern, index);
+            const range = pattern.slice(start, end);
+            if (range.length > 0)
+                expressions.push(TemplateLiteralParse(range));
+            index = end - 1;
+        }
+    }
+    return ((expressions.length === 0) ? { type: 'const', const: '' } :
+        (expressions.length === 1) ? expressions[0] :
+            { type: 'and', expr: expressions });
+}
+function TemplateLiteralParse(pattern) {
+    return (IsGroup(pattern) ? TemplateLiteralParse(InGroup(pattern)) :
+        IsPrecedenceOr(pattern) ? Or(pattern) :
+            IsPrecedenceAnd(pattern) ? And(pattern) :
+                { type: 'const', const: pattern });
+}
+exports.TemplateLiteralParse = TemplateLiteralParse;
+function TemplateLiteralParseExact(pattern) {
+    return TemplateLiteralParse(pattern.slice(1, pattern.length - 1));
+}
+exports.TemplateLiteralParseExact = TemplateLiteralParseExact;

package/type/template-literal/pattern.d.ts

@@ -0,0 +1,4 @@
+import type { TTemplateLiteralKind } from './index';
+export declare class TemplateLiteralPatternError extends Error {
+}
+export declare function TemplateLiteralPattern(kinds: TTemplateLiteralKind[]): string;

package/type/template-literal/pattern.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateLiteralPattern = exports.TemplateLiteralPatternError = void 0;
+const index_1 = require("../patterns/index");
+const index_2 = require("../symbols/index");
+const type_1 = require("../guard/type");
+class TemplateLiteralPatternError extends Error {
+}
+exports.TemplateLiteralPatternError = TemplateLiteralPatternError;
+function Escape(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+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('|')})` :
+            (0, type_1.TNumber)(schema) ? `${acc}${index_1.PatternNumber}` :
+                (0, type_1.TInteger)(schema) ? `${acc}${index_1.PatternNumber}` :
+                    (0, type_1.TBigInt)(schema) ? `${acc}${index_1.PatternNumber}` :
+                        (0, type_1.TString)(schema) ? `${acc}${index_1.PatternString}` :
+                            (0, type_1.TLiteral)(schema) ? `${acc}${Escape(schema.const.toString())}` :
+                                (0, type_1.TBoolean)(schema) ? `${acc}${index_1.PatternBoolean}` :
+                                    (() => { throw new TemplateLiteralPatternError(`Unexpected Kind '${schema[index_2.Kind]}'`); })());
+}
+function TemplateLiteralPattern(kinds) {
+    return `^${kinds.map((schema) => Visit(schema, '')).join('')}\$`;
+}
+exports.TemplateLiteralPattern = TemplateLiteralPattern;

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

@@ -0,0 +1,19 @@
+import type { Ensure, 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';
+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 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 declare function TemplateLiteralSyntax(syntax: string): TTemplateLiteralKind[];
+export {};