@omniaseo/cli 0.1.0

package/node_modules/@sinclair/typebox/build/esm/type/static/static.d.mts

@@ -0,0 +1,39 @@
+import type { Evaluate } from '../helpers/index.mjs';
+import type { TOptional } from '../optional/index.mjs';
+import type { TReadonly } from '../readonly/index.mjs';
+import type { TArray } from '../array/index.mjs';
+import type { TAsyncIterator } from '../async-iterator/index.mjs';
+import type { TConstructor } from '../constructor/index.mjs';
+import type { TEnum } from '../enum/index.mjs';
+import type { TFunction } from '../function/index.mjs';
+import type { TIntersect } from '../intersect/index.mjs';
+import type { TImport } from '../module/index.mjs';
+import type { TIterator } from '../iterator/index.mjs';
+import type { TNot } from '../not/index.mjs';
+import type { TObject, TProperties } from '../object/index.mjs';
+import type { TPromise } from '../promise/index.mjs';
+import type { TRecursive } from '../recursive/index.mjs';
+import type { TRecord } from '../record/index.mjs';
+import type { TRef } from '../ref/index.mjs';
+import type { TTuple } from '../tuple/index.mjs';
+import type { TUnion } from '../union/index.mjs';
+import type { TUnsafe } from '../unsafe/index.mjs';
+import type { TSchema } from '../schema/index.mjs';
+import type { TTransform } from '../transform/index.mjs';
+import type { TNever } from '../never/index.mjs';
+type TDecodeImport<ModuleProperties extends TProperties, Key extends PropertyKey> = (Key extends keyof ModuleProperties ? TDecodeType<ModuleProperties[Key]> extends infer Type extends TSchema ? Type extends TRef<infer Ref extends string> ? TDecodeImport<ModuleProperties, Ref> : Type : TNever : TNever);
+type TDecodeProperties<Properties extends TProperties> = {
+    [Key in keyof Properties]: TDecodeType<Properties[Key]>;
+};
+type TDecodeTypes<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TDecodeTypes<Right, [...Result, TDecodeType<Left>]> : Result);
+export type TDecodeType<Type extends TSchema> = (Type extends TOptional<infer Type extends TSchema> ? TOptional<TDecodeType<Type>> : Type extends TReadonly<infer Type extends TSchema> ? TReadonly<TDecodeType<Type>> : Type extends TTransform<infer _Input extends TSchema, infer Output> ? TUnsafe<Output> : Type extends TArray<infer Type extends TSchema> ? TArray<TDecodeType<Type>> : Type extends TAsyncIterator<infer Type extends TSchema> ? TAsyncIterator<TDecodeType<Type>> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TConstructor<TDecodeTypes<Parameters>, TDecodeType<InstanceType>> : Type extends TEnum<infer Values> ? TEnum<Values> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TDecodeTypes<Parameters>, TDecodeType<ReturnType>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TDecodeTypes<Types>> : Type extends TImport<infer ModuleProperties extends TProperties, infer Key> ? TDecodeImport<ModuleProperties, Key> : Type extends TIterator<infer Type extends TSchema> ? TIterator<TDecodeType<Type>> : Type extends TNot<infer Type extends TSchema> ? TNot<TDecodeType<Type>> : Type extends TObject<infer Properties extends TProperties> ? TObject<Evaluate<TDecodeProperties<Properties>>> : Type extends TPromise<infer Type extends TSchema> ? TPromise<TDecodeType<Type>> : Type extends TRecord<infer Key extends TSchema, infer Value extends TSchema> ? TRecord<Key, TDecodeType<Value>> : Type extends TRecursive<infer Type extends TSchema> ? TRecursive<TDecodeType<Type>> : Type extends TRef<infer Ref extends string> ? TRef<Ref> : Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TDecodeTypes<Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TDecodeTypes<Types>> : Type);
+export type StaticDecodeIsAny<Type> = boolean extends (Type extends TSchema ? true : false) ? true : false;
+/** Creates an decoded static type from a TypeBox type */
+export type StaticDecode<Type extends TSchema, Params extends unknown[] = [], Result = StaticDecodeIsAny<Type> extends true ? unknown : Static<TDecodeType<Type>, Params>> = Result;
+/** Creates an encoded static type from a TypeBox type */
+export type StaticEncode<Type extends TSchema, Params extends unknown[] = [], Result = Static<Type, Params>> = Result;
+/** Creates a static type from a TypeBox type */
+export type Static<Type extends TSchema, Params extends unknown[] = [], Result = (Type & {
+    params: Params;
+})['static']> = Result;
+export {};

package/node_modules/@sinclair/typebox/build/esm/type/static/static.mjs

@@ -0,0 +1 @@
+export {};

package/node_modules/@sinclair/typebox/build/esm/type/string/index.d.mts

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

package/node_modules/@sinclair/typebox/build/esm/type/string/index.mjs

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

package/node_modules/@sinclair/typebox/build/esm/type/string/string.d.mts

@@ -0,0 +1,25 @@
+import { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+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 {
+    /** The maximum string length */
+    maxLength?: number;
+    /** The minimum string length */
+    minLength?: number;
+    /** A regular expression pattern this string should match */
+    pattern?: string;
+    /** A format this string should match */
+    format?: StringFormatOption;
+    /** The content encoding for this string */
+    contentEncoding?: StringContentEncodingOption;
+    /** The content media type for this string */
+    contentMediaType?: string;
+}
+export interface TString extends TSchema, StringOptions {
+    [Kind]: 'String';
+    static: string;
+    type: 'string';
+}
+/** `[Json]` Creates a String type */
+export declare function String(options?: StringOptions): TString;

package/node_modules/@sinclair/typebox/build/esm/type/string/string.mjs

@@ -0,0 +1,6 @@
+import { CreateType } from '../create/type.mjs';
+import { Kind } from '../symbols/index.mjs';
+/** `[Json]` Creates a String type */
+export function String(options) {
+    return CreateType({ [Kind]: 'String', type: 'string' }, options);
+}

package/node_modules/@sinclair/typebox/build/esm/type/symbol/index.d.mts

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

package/node_modules/@sinclair/typebox/build/esm/type/symbol/index.mjs

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

package/node_modules/@sinclair/typebox/build/esm/type/symbol/symbol.d.mts

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

package/node_modules/@sinclair/typebox/build/esm/type/symbol/symbol.mjs

@@ -0,0 +1,6 @@
+import { CreateType } from '../create/type.mjs';
+import { Kind } from '../symbols/index.mjs';
+/** `[JavaScript]` Creates a Symbol type */
+export function Symbol(options) {
+    return CreateType({ [Kind]: 'Symbol', type: 'symbol' }, options);
+}

package/node_modules/@sinclair/typebox/build/esm/type/symbols/index.d.mts

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

package/node_modules/@sinclair/typebox/build/esm/type/symbols/index.mjs

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

package/node_modules/@sinclair/typebox/build/esm/type/symbols/symbols.d.mts

@@ -0,0 +1,10 @@
+/** Symbol key applied to transform types */
+export declare const TransformKind: unique symbol;
+/** Symbol key applied to readonly types */
+export declare const ReadonlyKind: unique symbol;
+/** Symbol key applied to optional types */
+export declare const OptionalKind: unique symbol;
+/** Symbol key applied to types */
+export declare const Hint: unique symbol;
+/** Symbol key applied to types */
+export declare const Kind: unique symbol;

package/node_modules/@sinclair/typebox/build/esm/type/symbols/symbols.mjs

@@ -0,0 +1,10 @@
+/** Symbol key applied to transform types */
+export const TransformKind = Symbol.for('TypeBox.Transform');
+/** Symbol key applied to readonly types */
+export const ReadonlyKind = Symbol.for('TypeBox.Readonly');
+/** Symbol key applied to optional types */
+export const OptionalKind = Symbol.for('TypeBox.Optional');
+/** Symbol key applied to types */
+export const Hint = Symbol.for('TypeBox.Hint');
+/** Symbol key applied to types */
+export const Kind = Symbol.for('TypeBox.Kind');

package/node_modules/@sinclair/typebox/build/esm/type/template-literal/finite.d.mts

@@ -0,0 +1,19 @@
+import { TypeBoxError } from '../error/index.mjs';
+import type { TTemplateLiteral, TTemplateLiteralKind } from './index.mjs';
+import type { TUnion } from '../union/index.mjs';
+import type { TString } from '../string/index.mjs';
+import type { TBoolean } from '../boolean/index.mjs';
+import type { TNumber } from '../number/index.mjs';
+import type { TInteger } from '../integer/index.mjs';
+import type { TBigInt } from '../bigint/index.mjs';
+import type { TLiteral } from '../literal/index.mjs';
+import type { Expression } from './parse.mjs';
+export declare class TemplateLiteralFiniteError extends TypeBoxError {
+}
+type TFromTemplateLiteralKind<T> = T extends TTemplateLiteral<infer U extends TTemplateLiteralKind[]> ? TFromTemplateLiteralKinds<U> : T extends TUnion<infer U extends TTemplateLiteralKind[]> ? TFromTemplateLiteralKinds<U> : T extends TString ? false : T extends TNumber ? false : T extends TInteger ? false : T extends TBigInt ? false : T extends TBoolean ? true : T extends TLiteral ? true : false;
+type TFromTemplateLiteralKinds<T extends TTemplateLiteralKind[]> = T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? TFromTemplateLiteralKind<L> extends false ? false : TFromTemplateLiteralKinds<R> : true;
+export declare function IsTemplateLiteralExpressionFinite(expression: Expression): boolean;
+export type TIsTemplateLiteralFinite<T> = T extends TTemplateLiteral<infer U> ? TFromTemplateLiteralKinds<U> : false;
+/** Returns true if this TemplateLiteral resolves to a finite set of values */
+export declare function IsTemplateLiteralFinite<T extends TTemplateLiteral>(schema: T): boolean;
+export {};

package/node_modules/@sinclair/typebox/build/esm/type/template-literal/finite.mjs

@@ -0,0 +1,49 @@
+import { TemplateLiteralParseExact } from './parse.mjs';
+import { TypeBoxError } from '../error/index.mjs';
+// ------------------------------------------------------------------
+// TemplateLiteralFiniteError
+// ------------------------------------------------------------------
+export class TemplateLiteralFiniteError extends TypeBoxError {
+}
+// ------------------------------------------------------------------
+// IsTemplateLiteralFiniteCheck
+// ------------------------------------------------------------------
+// prettier-ignore
+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]*');
+}
+// prettier-ignore
+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');
+}
+// prettier-ignore
+function IsStringExpression(expression) {
+    return expression.type === 'const' && expression.const === '.*';
+}
+// ------------------------------------------------------------------
+// IsTemplateLiteralExpressionFinite
+// ------------------------------------------------------------------
+// prettier-ignore
+export function IsTemplateLiteralExpressionFinite(expression) {
+    return (IsNumberExpression(expression) || IsStringExpression(expression) ? false :
+        IsBooleanExpression(expression) ? true :
+            (expression.type === 'and') ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) :
+                (expression.type === 'or') ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) :
+                    (expression.type === 'const') ? true :
+                        (() => { throw new TemplateLiteralFiniteError(`Unknown expression type`); })());
+}
+/** Returns true if this TemplateLiteral resolves to a finite set of values */
+export function IsTemplateLiteralFinite(schema) {
+    const expression = TemplateLiteralParseExact(schema.pattern);
+    return IsTemplateLiteralExpressionFinite(expression);
+}

package/node_modules/@sinclair/typebox/build/esm/type/template-literal/generate.d.mts

@@ -0,0 +1,21 @@
+import { TIsTemplateLiteralFinite } from './finite.mjs';
+import { TypeBoxError } from '../error/index.mjs';
+import type { Assert } from '../helpers/index.mjs';
+import type { TBoolean } from '../boolean/index.mjs';
+import type { TTemplateLiteral, TTemplateLiteralKind } from './index.mjs';
+import type { TLiteral, TLiteralValue } from '../literal/index.mjs';
+import type { Expression } from './parse.mjs';
+import type { TUnion } from '../union/index.mjs';
+export declare class TemplateLiteralGenerateError extends TypeBoxError {
+}
+type TStringReduceUnary<L extends string, R extends string[], Acc extends string[] = []> = R extends [infer A extends string, ...infer B extends string[]] ? TStringReduceUnary<L, B, [...Acc, `${L}${A}`]> : Acc;
+type TStringReduceBinary<L extends string[], R extends string[], Acc extends string[] = []> = L extends [infer A extends string, ...infer B extends string[]] ? TStringReduceBinary<B, R, [...Acc, ...TStringReduceUnary<A, R>]> : Acc;
+type TStringReduceMany<T extends string[][]> = T extends [infer L extends string[], infer R extends string[], ...infer Rest extends string[][]] ? TStringReduceMany<[TStringReduceBinary<L, R>, ...Rest]> : T;
+type TStringReduce<T extends string[][], O = TStringReduceMany<T>> = 0 extends keyof O ? Assert<O[0], string[]> : [];
+type TFromTemplateLiteralUnionKinds<T extends TTemplateLiteralKind[]> = T extends [infer L extends TLiteral, ...infer R extends TLiteral[]] ? [`${L['const']}`, ...TFromTemplateLiteralUnionKinds<R>] : [];
+type TFromTemplateLiteralKinds<T extends TTemplateLiteralKind[], Acc extends TLiteralValue[][] = []> = T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? (L extends TTemplateLiteral<infer S extends TTemplateLiteralKind[]> ? TFromTemplateLiteralKinds<[...S, ...R], Acc> : L extends TLiteral<infer S extends TLiteralValue> ? TFromTemplateLiteralKinds<R, [...Acc, [S]]> : L extends TUnion<infer S extends TTemplateLiteralKind[]> ? TFromTemplateLiteralKinds<R, [...Acc, TFromTemplateLiteralUnionKinds<S>]> : L extends TBoolean ? TFromTemplateLiteralKinds<R, [...Acc, ['true', 'false']]> : Acc) : Acc;
+export declare function TemplateLiteralExpressionGenerate(expression: Expression): IterableIterator<string>;
+export type TTemplateLiteralGenerate<T extends TTemplateLiteral, F = TIsTemplateLiteralFinite<T>> = F extends true ? (T extends TTemplateLiteral<infer S extends TTemplateLiteralKind[]> ? TFromTemplateLiteralKinds<S> extends infer R extends string[][] ? TStringReduce<R> : [] : []) : [];
+/** Generates a tuple of strings from the given TemplateLiteral. Returns an empty tuple if infinite. */
+export declare function TemplateLiteralGenerate<T extends TTemplateLiteral>(schema: T): TTemplateLiteralGenerate<T>;
+export {};

package/node_modules/@sinclair/typebox/build/esm/type/template-literal/generate.mjs

@@ -0,0 +1,53 @@
+import { IsTemplateLiteralExpressionFinite } from './finite.mjs';
+import { TemplateLiteralParseExact } from './parse.mjs';
+import { TypeBoxError } from '../error/index.mjs';
+// ------------------------------------------------------------------
+// TemplateLiteralGenerateError
+// ------------------------------------------------------------------
+export class TemplateLiteralGenerateError extends TypeBoxError {
+}
+// ------------------------------------------------------------------
+// TemplateLiteralExpressionGenerate
+// ------------------------------------------------------------------
+// prettier-ignore
+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}`;
+        }
+    }
+}
+// prettier-ignore
+function* GenerateAnd(expression) {
+    return yield* GenerateReduce(expression.expr.map((expr) => [...TemplateLiteralExpressionGenerate(expr)]));
+}
+// prettier-ignore
+function* GenerateOr(expression) {
+    for (const expr of expression.expr)
+        yield* TemplateLiteralExpressionGenerate(expr);
+}
+// prettier-ignore
+function* GenerateConst(expression) {
+    return yield expression.const;
+}
+export function* TemplateLiteralExpressionGenerate(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');
+                })();
+}
+/** Generates a tuple of strings from the given TemplateLiteral. Returns an empty tuple if infinite. */
+export function TemplateLiteralGenerate(schema) {
+    const expression = TemplateLiteralParseExact(schema.pattern);
+    // prettier-ignore
+    return (IsTemplateLiteralExpressionFinite(expression)
+        ? [...TemplateLiteralExpressionGenerate(expression)]
+        : []);
+}

package/node_modules/@sinclair/typebox/build/esm/type/template-literal/index.d.mts

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

package/node_modules/@sinclair/typebox/build/esm/type/template-literal/index.mjs

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

package/node_modules/@sinclair/typebox/build/esm/type/template-literal/parse.d.mts

@@ -0,0 +1,20 @@
+import { TypeBoxError } from '../error/index.mjs';
+export declare class TemplateLiteralParserError extends TypeBoxError {
+}
+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[];
+};
+/** Parses a pattern and returns an expression tree */
+export declare function TemplateLiteralParse(pattern: string): Expression;
+/** Parses a pattern and strips forward and trailing ^ and $ */
+export declare function TemplateLiteralParseExact(pattern: string): Expression;

package/node_modules/@sinclair/typebox/build/esm/type/template-literal/parse.mjs

@@ -0,0 +1,167 @@
+import { TypeBoxError } from '../error/index.mjs';
+// ------------------------------------------------------------------
+// TemplateLiteralParserError
+// ------------------------------------------------------------------
+export class TemplateLiteralParserError extends TypeBoxError {
+}
+// -------------------------------------------------------------------
+// Unescape
+//
+// Unescape for these control characters specifically. Note that this
+// function is only called on non union group content, and where we
+// still want to allow the user to embed control characters in that
+// content. For review.
+// -------------------------------------------------------------------
+// prettier-ignore
+function Unescape(pattern) {
+    return pattern
+        .replace(/\\\$/g, '$')
+        .replace(/\\\*/g, '*')
+        .replace(/\\\^/g, '^')
+        .replace(/\\\|/g, '|')
+        .replace(/\\\(/g, '(')
+        .replace(/\\\)/g, ')');
+}
+// -------------------------------------------------------------------
+// Control Characters
+// -------------------------------------------------------------------
+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, '|');
+}
+// -------------------------------------------------------------------
+// Control Groups
+// -------------------------------------------------------------------
+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;
+}
+// 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++) {
+        if (IsOpenParen(pattern, index))
+            count += 1;
+        if (IsCloseParen(pattern, index))
+            count -= 1;
+        if (IsSeparator(pattern, index) && count === 0)
+            return true;
+    }
+    return false;
+}
+// prettier-ignore
+function IsPrecedenceAnd(pattern) {
+    for (let index = 0; index < pattern.length; index++) {
+        if (IsOpenParen(pattern, index))
+            return true;
+    }
+    return false;
+}
+// prettier-ignore
+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 };
+}
+// prettier-ignore
+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 });
+}
+// ------------------------------------------------------------------
+// TemplateLiteralParse
+// ------------------------------------------------------------------
+/** Parses a pattern and returns an expression tree */
+export function TemplateLiteralParse(pattern) {
+    // prettier-ignore
+    return (IsGroup(pattern) ? TemplateLiteralParse(InGroup(pattern)) :
+        IsPrecedenceOr(pattern) ? Or(pattern) :
+            IsPrecedenceAnd(pattern) ? And(pattern) :
+                { type: 'const', const: Unescape(pattern) });
+}
+// ------------------------------------------------------------------
+// TemplateLiteralParseExact
+// ------------------------------------------------------------------
+/** Parses a pattern and strips forward and trailing ^ and $ */
+export function TemplateLiteralParseExact(pattern) {
+    return TemplateLiteralParse(pattern.slice(1, pattern.length - 1));
+}

package/node_modules/@sinclair/typebox/build/esm/type/template-literal/pattern.d.mts

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

package/node_modules/@sinclair/typebox/build/esm/type/template-literal/pattern.mjs

@@ -0,0 +1,33 @@
+import { PatternNumber, PatternString, PatternBoolean } from '../patterns/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+import { TypeBoxError } from '../error/index.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsTemplateLiteral, IsUnion, IsNumber, IsInteger, IsBigInt, IsString, IsLiteral, IsBoolean } from '../guard/kind.mjs';
+// ------------------------------------------------------------------
+// TemplateLiteralPatternError
+// ------------------------------------------------------------------
+export class TemplateLiteralPatternError extends TypeBoxError {
+}
+// ------------------------------------------------------------------
+// TemplateLiteralPattern
+// ------------------------------------------------------------------
+function Escape(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+// prettier-ignore
+function Visit(schema, acc) {
+    return (IsTemplateLiteral(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) :
+        IsUnion(schema) ? `(${schema.anyOf.map((schema) => Visit(schema, acc)).join('|')})` :
+            IsNumber(schema) ? `${acc}${PatternNumber}` :
+                IsInteger(schema) ? `${acc}${PatternNumber}` :
+                    IsBigInt(schema) ? `${acc}${PatternNumber}` :
+                        IsString(schema) ? `${acc}${PatternString}` :
+                            IsLiteral(schema) ? `${acc}${Escape(schema.const.toString())}` :
+                                IsBoolean(schema) ? `${acc}${PatternBoolean}` :
+                                    (() => { throw new TemplateLiteralPatternError(`Unexpected Kind '${schema[Kind]}'`); })());
+}
+export function TemplateLiteralPattern(kinds) {
+    return `^${kinds.map((schema) => Visit(schema, '')).join('')}\$`;
+}

package/node_modules/@sinclair/typebox/build/esm/type/template-literal/syntax.d.mts

@@ -0,0 +1,20 @@
+import type { Assert, Trim } from '../helpers/index.mjs';
+import type { TTemplateLiteral, TTemplateLiteralKind } from './index.mjs';
+import { type TLiteral } from '../literal/index.mjs';
+import { type TBoolean } from '../boolean/index.mjs';
+import { type TBigInt } from '../bigint/index.mjs';
+import { type TNumber } from '../number/index.mjs';
+import { type TString } from '../string/index.mjs';
+import { type TUnionEvaluated } from '../union/index.mjs';
+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> = TUnionEvaluated<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 R1}\}${infer R2}` ? [TLiteral<L>, ...FromString<`{${R1}}`>, ...FromString<R2>] : T extends `${infer L}$\{${infer R1}\}` ? [TLiteral<L>, ...FromString<`{${R1}}`>] : T extends `${infer L}` ? [TLiteral<L>] : [
+];
+export type TTemplateLiteralSyntax<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/node_modules/@sinclair/typebox/build/esm/type/template-literal/syntax.mjs

@@ -0,0 +1,55 @@
+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 { UnionEvaluated } 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] :
+                                UnionEvaluated(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);
+}
+/** Parses TemplateLiteralSyntax and returns a tuple of TemplateLiteralKinds */
+export function TemplateLiteralSyntax(syntax) {
+    return [...FromSyntax(syntax)];
+}