@evalops/maestro 0.10.18 → 0.10.21

package/node_modules/@sinclair/typebox/build/cjs/type/symbol/index.js

@@ -1,18 +0,0 @@
-"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/node_modules/@sinclair/typebox/build/cjs/type/symbol/symbol.d.ts

@@ -1,10 +0,0 @@
-import { TSchema, SchemaOptions } from '../schema/index';
-import { Kind } from '../symbols/index';
-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/cjs/type/symbol/symbol.js

@@ -1,10 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Symbol = Symbol;
-const type_1 = require("../create/type");
-const index_1 = require("../symbols/index");
-/** `[JavaScript]` Creates a Symbol type */
-function Symbol(options) {
-    return (0, type_1.CreateType)({ [index_1.Kind]: 'Symbol', type: 'symbol' }, options);
-}

package/node_modules/@sinclair/typebox/build/cjs/type/symbols/index.d.ts

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

package/node_modules/@sinclair/typebox/build/cjs/type/symbols/index.js

@@ -1,18 +0,0 @@
-"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/node_modules/@sinclair/typebox/build/cjs/type/symbols/symbols.d.ts

@@ -1,10 +0,0 @@
-/** 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/cjs/type/symbols/symbols.js

@@ -1,14 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Kind = exports.Hint = exports.OptionalKind = exports.ReadonlyKind = exports.TransformKind = void 0;
-/** Symbol key applied to transform types */
-exports.TransformKind = Symbol.for('TypeBox.Transform');
-/** Symbol key applied to readonly types */
-exports.ReadonlyKind = Symbol.for('TypeBox.Readonly');
-/** Symbol key applied to optional types */
-exports.OptionalKind = Symbol.for('TypeBox.Optional');
-/** Symbol key applied to types */
-exports.Hint = Symbol.for('TypeBox.Hint');
-/** Symbol key applied to types */
-exports.Kind = Symbol.for('TypeBox.Kind');

package/node_modules/@sinclair/typebox/build/cjs/type/template-literal/finite.d.ts

@@ -1,19 +0,0 @@
-import { TypeBoxError } from '../error/index';
-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 './parse';
-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/cjs/type/template-literal/finite.js

@@ -1,56 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TemplateLiteralFiniteError = void 0;
-exports.IsTemplateLiteralExpressionFinite = IsTemplateLiteralExpressionFinite;
-exports.IsTemplateLiteralFinite = IsTemplateLiteralFinite;
-const parse_1 = require("./parse");
-const index_1 = require("../error/index");
-// ------------------------------------------------------------------
-// TemplateLiteralFiniteError
-// ------------------------------------------------------------------
-class TemplateLiteralFiniteError extends index_1.TypeBoxError {
-}
-exports.TemplateLiteralFiniteError = TemplateLiteralFiniteError;
-// ------------------------------------------------------------------
-// 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
-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 */
-function IsTemplateLiteralFinite(schema) {
-    const expression = (0, parse_1.TemplateLiteralParseExact)(schema.pattern);
-    return IsTemplateLiteralExpressionFinite(expression);
-}

package/node_modules/@sinclair/typebox/build/cjs/type/template-literal/generate.d.ts

@@ -1,21 +0,0 @@
-import { TIsTemplateLiteralFinite } from './finite';
-import { TypeBoxError } from '../error/index';
-import type { Assert } from '../helpers/index';
-import type { TBoolean } from '../boolean/index';
-import type { TTemplateLiteral, TTemplateLiteralKind } from './index';
-import type { TLiteral, TLiteralValue } from '../literal/index';
-import type { Expression } from './parse';
-import type { TUnion } from '../union/index';
-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/cjs/type/template-literal/generate.js

@@ -1,60 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TemplateLiteralGenerateError = void 0;
-exports.TemplateLiteralExpressionGenerate = TemplateLiteralExpressionGenerate;
-exports.TemplateLiteralGenerate = TemplateLiteralGenerate;
-const finite_1 = require("./finite");
-const parse_1 = require("./parse");
-const index_1 = require("../error/index");
-// ------------------------------------------------------------------
-// TemplateLiteralGenerateError
-// ------------------------------------------------------------------
-class TemplateLiteralGenerateError extends index_1.TypeBoxError {
-}
-exports.TemplateLiteralGenerateError = TemplateLiteralGenerateError;
-// ------------------------------------------------------------------
-// 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;
-}
-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. */
-function TemplateLiteralGenerate(schema) {
-    const expression = (0, parse_1.TemplateLiteralParseExact)(schema.pattern);
-    // prettier-ignore
-    return ((0, finite_1.IsTemplateLiteralExpressionFinite)(expression)
-        ? [...TemplateLiteralExpressionGenerate(expression)]
-        : []);
-}

package/node_modules/@sinclair/typebox/build/cjs/type/template-literal/index.d.ts

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

package/node_modules/@sinclair/typebox/build/cjs/type/template-literal/index.js

@@ -1,24 +0,0 @@
-"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("./parse"), exports);
-__exportStar(require("./pattern"), exports);
-__exportStar(require("./union"), exports);
-__exportStar(require("./template-literal"), exports);

package/node_modules/@sinclair/typebox/build/cjs/type/template-literal/parse.d.ts

@@ -1,20 +0,0 @@
-import { TypeBoxError } from '../error/index';
-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/cjs/type/template-literal/parse.js

@@ -1,174 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TemplateLiteralParserError = void 0;
-exports.TemplateLiteralParse = TemplateLiteralParse;
-exports.TemplateLiteralParseExact = TemplateLiteralParseExact;
-const index_1 = require("../error/index");
-// ------------------------------------------------------------------
-// TemplateLiteralParserError
-// ------------------------------------------------------------------
-class TemplateLiteralParserError extends index_1.TypeBoxError {
-}
-exports.TemplateLiteralParserError = TemplateLiteralParserError;
-// -------------------------------------------------------------------
-// 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 */
-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 $ */
-function TemplateLiteralParseExact(pattern) {
-    return TemplateLiteralParse(pattern.slice(1, pattern.length - 1));
-}

package/node_modules/@sinclair/typebox/build/cjs/type/template-literal/pattern.d.ts

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

package/node_modules/@sinclair/typebox/build/cjs/type/template-literal/pattern.js

@@ -1,39 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TemplateLiteralPatternError = void 0;
-exports.TemplateLiteralPattern = TemplateLiteralPattern;
-const index_1 = require("../patterns/index");
-const index_2 = require("../symbols/index");
-const index_3 = require("../error/index");
-// ------------------------------------------------------------------
-// TypeGuard
-// ------------------------------------------------------------------
-const kind_1 = require("../guard/kind");
-// ------------------------------------------------------------------
-// TemplateLiteralPatternError
-// ------------------------------------------------------------------
-class TemplateLiteralPatternError extends index_3.TypeBoxError {
-}
-exports.TemplateLiteralPatternError = TemplateLiteralPatternError;
-// ------------------------------------------------------------------
-// TemplateLiteralPattern
-// ------------------------------------------------------------------
-function Escape(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-// prettier-ignore
-function Visit(schema, acc) {
-    return ((0, kind_1.IsTemplateLiteral)(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) :
-        (0, kind_1.IsUnion)(schema) ? `(${schema.anyOf.map((schema) => Visit(schema, acc)).join('|')})` :
-            (0, kind_1.IsNumber)(schema) ? `${acc}${index_1.PatternNumber}` :
-                (0, kind_1.IsInteger)(schema) ? `${acc}${index_1.PatternNumber}` :
-                    (0, kind_1.IsBigInt)(schema) ? `${acc}${index_1.PatternNumber}` :
-                        (0, kind_1.IsString)(schema) ? `${acc}${index_1.PatternString}` :
-                            (0, kind_1.IsLiteral)(schema) ? `${acc}${Escape(schema.const.toString())}` :
-                                (0, kind_1.IsBoolean)(schema) ? `${acc}${index_1.PatternBoolean}` :
-                                    (() => { throw new TemplateLiteralPatternError(`Unexpected Kind '${schema[index_2.Kind]}'`); })());
-}
-function TemplateLiteralPattern(kinds) {
-    return `^${kinds.map((schema) => Visit(schema, '')).join('')}\$`;
-}

package/node_modules/@sinclair/typebox/build/cjs/type/template-literal/syntax.d.ts

@@ -1,20 +0,0 @@
-import type { Assert, Trim } from '../helpers/index';
-import type { TTemplateLiteral, TTemplateLiteralKind } 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 { type TUnionEvaluated } 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> = 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/cjs/type/template-literal/syntax.js

@@ -1,59 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TemplateLiteralSyntax = TemplateLiteralSyntax;
-const index_1 = require("../literal/index");
-const index_2 = require("../boolean/index");
-const index_3 = require("../bigint/index");
-const index_4 = require("../number/index");
-const index_5 = require("../string/index");
-const index_6 = require("../union/index");
-const index_7 = require("../never/index");
-// ------------------------------------------------------------------
-// SyntaxParsers
-// ------------------------------------------------------------------
-// prettier-ignore
-function* FromUnion(syntax) {
-    const trim = syntax.trim().replace(/"|'/g, '');
-    return (trim === 'boolean' ? yield (0, index_2.Boolean)() :
-        trim === 'number' ? yield (0, index_4.Number)() :
-            trim === 'bigint' ? yield (0, index_3.BigInt)() :
-                trim === 'string' ? yield (0, index_5.String)() :
-                    yield (() => {
-                        const literals = trim.split('|').map((literal) => (0, index_1.Literal)(literal.trim()));
-                        return (literals.length === 0 ? (0, index_7.Never)() :
-                            literals.length === 1 ? literals[0] :
-                                (0, index_6.UnionEvaluated)(literals));
-                    })());
-}
-// prettier-ignore
-function* FromTerminal(syntax) {
-    if (syntax[1] !== '{') {
-        const L = (0, index_1.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 (0, index_1.Literal)(syntax);
-}
-// prettier-ignore
-function* FromSyntax(syntax) {
-    for (let i = 0; i < syntax.length; i++) {
-        if (syntax[i] === '$') {
-            const L = (0, index_1.Literal)(syntax.slice(0, i));
-            const R = FromTerminal(syntax.slice(i));
-            return yield* [L, ...R];
-        }
-    }
-    yield (0, index_1.Literal)(syntax);
-}
-/** Parses TemplateLiteralSyntax and returns a tuple of TemplateLiteralKinds */
-function TemplateLiteralSyntax(syntax) {
-    return [...FromSyntax(syntax)];
-}

package/node_modules/@sinclair/typebox/build/cjs/type/template-literal/template-literal.d.ts

@@ -1,30 +0,0 @@
-import type { TSchema, SchemaOptions } from '../schema/index';
-import type { Assert } from '../helpers/index';
-import type { TUnion } from '../union/index';
-import type { TLiteral } from '../literal/index';
-import type { TInteger } from '../integer/index';
-import type { TNumber } from '../number/index';
-import type { TBigInt } from '../bigint/index';
-import type { TString } from '../string/index';
-import type { TBoolean } from '../boolean/index';
-import type { TNever } from '../never/index';
-import type { Static } from '../static/index';
-import { type TTemplateLiteralSyntax } from './syntax';
-import { EmptyString } from '../helpers/index';
-import { Kind } from '../symbols/index';
-type TemplateLiteralStaticKind<T, Acc extends string> = T extends TUnion<infer U> ? {
-    [K in keyof U]: TemplateLiteralStatic<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;
-type TemplateLiteralStatic<T extends TTemplateLiteralKind[], Acc extends string> = T extends [infer L, ...infer R] ? `${TemplateLiteralStaticKind<L, Acc>}${TemplateLiteralStatic<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: TemplateLiteralStatic<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): TTemplateLiteralSyntax<T>;
-/** `[Json]` Creates a TemplateLiteral type */
-export declare function TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>;
-export {};