@sinclair/typebox 0.26.8 → 0.27.0

package/typebox.js

@@ -27,13 +27,22 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Type = exports.StandardType = exports.ExtendedTypeBuilder = exports.StandardTypeBuilder = exports.TypeBuilder = exports.KeyResolver = exports.ObjectMap = exports.TypeClone = exports.TypeExtends = exports.TypeExtendsResult = exports.ExtendsUndefined = exports.TypeGuard = exports.TypeGuardUnknownTypeError = exports.FormatRegistry = exports.TypeRegistry = exports.Kind = exports.Hint = exports.Modifier = void 0;
+exports.Type = exports.StandardType = exports.ExtendedTypeBuilder = exports.StandardTypeBuilder = exports.TypeBuilder = exports.TemplateLiteralGenerator = exports.TemplateLiteralFinite = exports.TemplateLiteralParser = exports.TemplateLiteralParserError = exports.TemplateLiteralResolver = exports.TemplateLiteralPattern = exports.KeyResolver = exports.ObjectMap = exports.TypeClone = exports.TypeExtends = exports.TypeExtendsResult = exports.ExtendsUndefined = exports.TypeGuard = exports.TypeGuardUnknownTypeError = exports.FormatRegistry = exports.TypeRegistry = exports.PatternStringExact = exports.PatternNumberExact = exports.PatternBooleanExact = exports.PatternString = exports.PatternNumber = exports.PatternBoolean = exports.Kind = exports.Hint = exports.Modifier = void 0;
 // --------------------------------------------------------------------------
-// Compositing Symbols
+// Symbols
 // --------------------------------------------------------------------------
 exports.Modifier = Symbol.for('TypeBox.Modifier');
 exports.Hint = Symbol.for('TypeBox.Hint');
 exports.Kind = Symbol.for('TypeBox.Kind');
+// --------------------------------------------------------------------------
+// Patterns
+// --------------------------------------------------------------------------
+exports.PatternBoolean = '(true|false)';
+exports.PatternNumber = '(0|[1-9][0-9]*)';
+exports.PatternString = '.*';
+exports.PatternBooleanExact = `^${exports.PatternBoolean}$`;
+exports.PatternNumberExact = `^${exports.PatternNumber}$`;
+exports.PatternStringExact = `^${exports.PatternString}$`;
 /** A registry for user defined types */
 var TypeRegistry;
 (function (TypeRegistry) {
@@ -183,7 +192,7 @@ var TypeGuard;
             IsOptionalBoolean(schema.uniqueItems));
     }
     TypeGuard.TArray = TArray;
-    /** Returns true if the given schema is TSymbol */
+    /** Returns true if the given schema is TBigInt */
     function TBigInt(schema) {
         // prettier-ignore
         return (TKind(schema) &&
@@ -404,15 +413,6 @@ var TypeGuard;
         return true;
     }
     TypeGuard.TRecord = TRecord;
-    /** Returns true if the given schema is TSelf */
-    function TSelf(schema) {
-        // prettier-ignore
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'Self' &&
-            IsOptionalString(schema.$id) &&
-            IsString(schema.$ref));
-    }
-    TypeGuard.TSelf = TSelf;
     /** Returns true if the given schema is TRef */
     function TRef(schema) {
         // prettier-ignore
@@ -444,6 +444,26 @@ var TypeGuard;
             IsOptionalString(schema.$id));
     }
     TypeGuard.TSymbol = TSymbol;
+    /** Returns true if the given schema is TTemplateLiteral */
+    function TTemplateLiteral(schema) {
+        // prettier-ignore
+        return (TKind(schema) &&
+            schema[exports.Kind] === 'TemplateLiteral' &&
+            schema.type === 'string' &&
+            IsString(schema.pattern) &&
+            schema.pattern[0] === '^' &&
+            schema.pattern[schema.pattern.length - 1] === '$');
+    }
+    TypeGuard.TTemplateLiteral = TTemplateLiteral;
+    /** Returns true if the given schema is TThis */
+    function TThis(schema) {
+        // prettier-ignore
+        return (TKind(schema) &&
+            schema[exports.Kind] === 'This' &&
+            IsOptionalString(schema.$id) &&
+            IsString(schema.$ref));
+    }
+    TypeGuard.TThis = TThis;
     /** Returns true if the given schema is TTuple */
     function TTuple(schema) {
         // prettier-ignore
@@ -565,10 +585,11 @@ var TypeGuard;
                 TObject(schema) ||
                 TPromise(schema) ||
                 TRecord(schema) ||
-                TSelf(schema) ||
                 TRef(schema) ||
                 TString(schema) ||
                 TSymbol(schema) ||
+                TTemplateLiteral(schema) ||
+                TThis(schema) ||
                 TTuple(schema) ||
                 TUndefined(schema) ||
                 TUnion(schema) ||
@@ -1038,17 +1059,17 @@ var TypeExtends;
     // Record
     // --------------------------------------------------------------------------
     function RecordKey(schema) {
-        if ('^(0|[1-9][0-9]*)$' in schema.patternProperties)
+        if (exports.PatternNumberExact in schema.patternProperties)
             return exports.Type.Number();
-        if ('^.*$' in schema.patternProperties)
+        if (exports.PatternStringExact in schema.patternProperties)
             return exports.Type.String();
         throw Error('TypeExtends: Cannot get record key');
     }
     function RecordValue(schema) {
-        if ('^(0|[1-9][0-9]*)$' in schema.patternProperties)
-            return schema.patternProperties['^(0|[1-9][0-9]*)$'];
-        if ('^.*$' in schema.patternProperties)
-            return schema.patternProperties['^.*$'];
+        if (exports.PatternNumberExact in schema.patternProperties)
+            return schema.patternProperties[exports.PatternNumberExact];
+        if (exports.PatternStringExact in schema.patternProperties)
+            return schema.patternProperties[exports.PatternStringExact];
         throw Error('TypeExtends: Cannot get record value');
     }
     function RecordRight(left, right) {
@@ -1269,6 +1290,12 @@ var TypeExtends;
         return TypeGuard.TVoid(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
     }
     function Visit(left, right) {
+        // template union remap
+        if (TypeGuard.TTemplateLiteral(left))
+            return Visit(TemplateLiteralResolver.Resolve(left), right);
+        if (TypeGuard.TTemplateLiteral(right))
+            return Visit(left, TemplateLiteralResolver.Resolve(right));
+        // standard extends
         if (TypeGuard.TAny(left))
             return Any(left, right);
         if (TypeGuard.TArray(left))
@@ -1295,14 +1322,14 @@ var TypeExtends;
             return Null(left, right);
         if (TypeGuard.TNumber(left))
             return Number(left, right);
+        if (TypeGuard.TObject(left))
+            return Object(left, right);
         if (TypeGuard.TRecord(left))
             return Record(left, right);
         if (TypeGuard.TString(left))
             return String(left, right);
         if (TypeGuard.TSymbol(left))
             return Symbol(left, right);
-        if (TypeGuard.TObject(left))
-            return Object(left, right);
         if (TypeGuard.TTuple(left))
             return Tuple(left, right);
         if (TypeGuard.TPromise(left))
@@ -1422,6 +1449,278 @@ var KeyResolver;
     KeyResolver.Resolve = Resolve;
 })(KeyResolver = exports.KeyResolver || (exports.KeyResolver = {}));
 // --------------------------------------------------------------------------
+// TemplateLiteralPattern
+// --------------------------------------------------------------------------
+var TemplateLiteralPattern;
+(function (TemplateLiteralPattern) {
+    function Escape(value) {
+        return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    function Visit(schema, acc) {
+        if (TypeGuard.TTemplateLiteral(schema)) {
+            const pattern = schema.pattern.slice(1, schema.pattern.length - 1);
+            return pattern;
+        }
+        else if (TypeGuard.TUnion(schema)) {
+            const tokens = schema.anyOf.map((schema) => Visit(schema, acc)).join('|');
+            return `(${tokens})`;
+        }
+        else if (TypeGuard.TNumber(schema)) {
+            return `${acc}${exports.PatternNumber}`;
+        }
+        else if (TypeGuard.TInteger(schema)) {
+            return `${acc}${exports.PatternNumber}`;
+        }
+        else if (TypeGuard.TBigInt(schema)) {
+            return `${acc}${exports.PatternNumber}`;
+        }
+        else if (TypeGuard.TString(schema)) {
+            return `${acc}${exports.PatternString}`;
+        }
+        else if (TypeGuard.TLiteral(schema)) {
+            return `${acc}${Escape(schema.const.toString())}`;
+        }
+        else if (TypeGuard.TBoolean(schema)) {
+            return `${acc}${exports.PatternBoolean}`;
+        }
+        else if (TypeGuard.TNever(schema)) {
+            throw Error('TemplateLiteralPattern: TemplateLiteral cannot operate on types of TNever');
+        }
+        else {
+            throw Error(`TemplateLiteralPattern: Unexpected Kind '${schema[exports.Kind]}'`);
+        }
+    }
+    function Create(kinds) {
+        return `^${kinds.map((schema) => Visit(schema, '')).join('')}\$`;
+    }
+    TemplateLiteralPattern.Create = Create;
+})(TemplateLiteralPattern = exports.TemplateLiteralPattern || (exports.TemplateLiteralPattern = {}));
+// --------------------------------------------------------------------------------------
+// TemplateLiteralResolver
+// --------------------------------------------------------------------------------------
+var TemplateLiteralResolver;
+(function (TemplateLiteralResolver) {
+    function Resolve(template) {
+        const expression = TemplateLiteralParser.ParseExact(template.pattern);
+        if (!TemplateLiteralFinite.Check(expression))
+            return exports.Type.String();
+        const literals = [...TemplateLiteralGenerator.Generate(expression)].map((value) => exports.Type.Literal(value));
+        return exports.Type.Union(literals);
+    }
+    TemplateLiteralResolver.Resolve = Resolve;
+})(TemplateLiteralResolver = exports.TemplateLiteralResolver || (exports.TemplateLiteralResolver = {}));
+// --------------------------------------------------------------------------------------
+// TemplateLiteralParser
+// --------------------------------------------------------------------------------------
+class TemplateLiteralParserError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+exports.TemplateLiteralParserError = TemplateLiteralParserError;
+var TemplateLiteralParser;
+(function (TemplateLiteralParser) {
+    function Unescape(value) {
+        return value.replace(/\\/g, '');
+    }
+    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(Parse(range));
+                start = index + 1;
+            }
+        }
+        const range = pattern.slice(start);
+        if (range.length > 0)
+            expressions.push(Parse(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(Parse(range));
+                index = end;
+            }
+            else {
+                const [start, end] = Range(pattern, index);
+                const range = pattern.slice(start, end);
+                if (range.length > 0)
+                    expressions.push(Parse(range));
+                index = end - 1;
+            }
+        }
+        if (expressions.length === 0)
+            return { type: 'const', const: '' };
+        if (expressions.length === 1)
+            return expressions[0];
+        return { type: 'and', expr: expressions };
+    }
+    /** Parses a pattern and returns an expression tree */
+    function Parse(pattern) {
+        if (IsGroup(pattern))
+            return Parse(InGroup(pattern));
+        if (IsPrecedenceOr(pattern))
+            return Or(pattern);
+        if (IsPrecedenceAnd(pattern))
+            return And(pattern);
+        return { type: 'const', const: Unescape(pattern) };
+    }
+    TemplateLiteralParser.Parse = Parse;
+    /** Parses a pattern and strips forward and trailing ^ and $ */
+    function ParseExact(pattern) {
+        return Parse(pattern.slice(1, pattern.length - 1));
+    }
+    TemplateLiteralParser.ParseExact = ParseExact;
+})(TemplateLiteralParser = exports.TemplateLiteralParser || (exports.TemplateLiteralParser = {}));
+// --------------------------------------------------------------------------------------
+// TemplateLiteralFinite
+// --------------------------------------------------------------------------------------
+var TemplateLiteralFinite;
+(function (TemplateLiteralFinite) {
+    function IsNumber(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 IsBoolean(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 IsString(expression) {
+        return expression.type === 'const' && expression.const === '.*';
+    }
+    function Check(expression) {
+        if (IsBoolean(expression))
+            return true;
+        if (IsNumber(expression) || IsString(expression))
+            return false;
+        if (expression.type === 'and')
+            return expression.expr.every((expr) => Check(expr));
+        if (expression.type === 'or')
+            return expression.expr.every((expr) => Check(expr));
+        if (expression.type === 'const')
+            return true;
+        throw Error(`TemplateLiteralFinite: Unknown expression type`);
+    }
+    TemplateLiteralFinite.Check = Check;
+})(TemplateLiteralFinite = exports.TemplateLiteralFinite || (exports.TemplateLiteralFinite = {}));
+// --------------------------------------------------------------------------------------
+// TemplateLiteralGenerator
+// --------------------------------------------------------------------------------------
+var TemplateLiteralGenerator;
+(function (TemplateLiteralGenerator) {
+    function* Reduce(buffer) {
+        if (buffer.length === 1)
+            return yield* buffer[0];
+        for (const left of buffer[0]) {
+            for (const right of Reduce(buffer.slice(1))) {
+                yield `${left}${right}`;
+            }
+        }
+    }
+    function* And(expression) {
+        return yield* Reduce(expression.expr.map((expr) => [...Generate(expr)]));
+    }
+    function* Or(expression) {
+        for (const expr of expression.expr)
+            yield* Generate(expr);
+    }
+    function* Const(expression) {
+        return yield expression.const;
+    }
+    function* Generate(expression) {
+        if (expression.type === 'and')
+            return yield* And(expression);
+        if (expression.type === 'or')
+            return yield* Or(expression);
+        if (expression.type === 'const')
+            return yield* Const(expression);
+        throw Error('TemplateLiteralGenerator: Unknown expression');
+    }
+    TemplateLiteralGenerator.Generate = Generate;
+})(TemplateLiteralGenerator = exports.TemplateLiteralGenerator || (exports.TemplateLiteralGenerator = {}));
+// --------------------------------------------------------------------------
 // TypeOrdinal: Used for auto $id generation
 // --------------------------------------------------------------------------
 let TypeOrdinal = 0;
@@ -1536,6 +1835,10 @@ class StandardTypeBuilder extends TypeBuilder {
     }
     /** `[Standard]` Excludes from the left type any type that is not assignable to the right */
     Exclude(left, right, options = {}) {
+        if (TypeGuard.TTemplateLiteral(left))
+            return this.Exclude(TemplateLiteralResolver.Resolve(left), right, options);
+        if (TypeGuard.TTemplateLiteral(right))
+            return this.Exclude(left, TemplateLiteralResolver.Resolve(right), options);
         if (TypeGuard.TUnion(left)) {
             const narrowed = left.anyOf.filter((inner) => TypeExtends.Extends(inner, right) === TypeExtendsResult.False);
             return (narrowed.length === 1 ? TypeClone.Clone(narrowed[0], options) : this.Union(narrowed, options));
@@ -1546,6 +1849,10 @@ class StandardTypeBuilder extends TypeBuilder {
     }
     /** `[Standard]` Extracts from the left type any type that is assignable to the right */
     Extract(left, right, options = {}) {
+        if (TypeGuard.TTemplateLiteral(left))
+            return this.Extract(TemplateLiteralResolver.Resolve(left), right, options);
+        if (TypeGuard.TTemplateLiteral(right))
+            return this.Extract(left, TemplateLiteralResolver.Resolve(right), options);
         if (TypeGuard.TUnion(left)) {
             const narrowed = left.anyOf.filter((inner) => TypeExtends.Extends(inner, right) !== TypeExtendsResult.False);
             return (narrowed.length === 1 ? TypeClone.Clone(narrowed[0], options) : this.Union(narrowed, options));
@@ -1575,10 +1882,21 @@ class StandardTypeBuilder extends TypeBuilder {
     }
     /** `[Standard]` Creates a KeyOf type */
     KeyOf(schema, options = {}) {
-        const keys = KeyResolver.Resolve(schema);
-        // prettier-ignore
-        const keyof = keys.length === 0 ? this.Never(options) : this.Union(keys.map((key) => this.Literal(key)), options);
-        return keyof;
+        if (TypeGuard.TRecord(schema)) {
+            const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
+            if (pattern === exports.PatternNumberExact)
+                return this.Number(options);
+            if (pattern === exports.PatternStringExact)
+                return this.String(options);
+            throw Error('StandardTypeBuilder: Unable to resolve key type from Record key pattern');
+        }
+        else {
+            const resolved = KeyResolver.Resolve(schema);
+            if (resolved.length === 0)
+                return this.Never(options);
+            const literals = resolved.map((key) => this.Literal(key));
+            return this.Union(literals, options);
+        }
     }
     /** `[Standard]` Creates a Literal type */
     Literal(value, options = {}) {
@@ -1680,15 +1998,16 @@ class StandardTypeBuilder extends TypeBuilder {
             return this.Create(schema);
         }, options);
     }
+    /** `[Standard]` Creates a Record type */
     Record(key, schema, options = {}) {
-        if (TypeGuard.TLiteral(key)) {
-            if (typeof key.const === 'string' || typeof key.const === 'number') {
-                return this.Object({ [key.const]: TypeClone.Clone(schema, {}) }, options);
-            }
-            else
-                throw Error('TypeBuilder: Record key can only be derived from literals of number or string');
+        if (TypeGuard.TTemplateLiteral(key)) {
+            const expression = TemplateLiteralParser.ParseExact(key.pattern);
+            // prettier-ignore
+            return TemplateLiteralFinite.Check(expression)
+                ? (this.Object([...TemplateLiteralGenerator.Generate(expression)].reduce((acc, key) => ({ ...acc, [key]: TypeClone.Clone(schema, {}) }), {}), options))
+                : this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [key.pattern]: TypeClone.Clone(schema, {}) }, additionalProperties: false });
         }
-        if (TypeGuard.TUnion(key)) {
+        else if (TypeGuard.TUnionLiteral(key)) {
             if (key.anyOf.every((schema) => TypeGuard.TLiteral(schema) && (typeof schema.const === 'string' || typeof schema.const === 'number'))) {
                 const properties = key.anyOf.reduce((acc, literal) => ({ ...acc, [literal.const]: TypeClone.Clone(schema, {}) }), {});
                 return this.Object(properties, { ...options, [exports.Hint]: 'Record' });
@@ -1696,22 +2015,32 @@ class StandardTypeBuilder extends TypeBuilder {
             else
                 throw Error('TypeBuilder: Record key can only be derived from union literal of number or string');
         }
-        const pattern = ['Integer', 'Number'].includes(key[exports.Kind]) ? '^(0|[1-9][0-9]*)$' : key[exports.Kind] === 'String' && key.pattern ? key.pattern : '^.*$';
-        return this.Create({
-            ...options,
-            [exports.Kind]: 'Record',
-            type: 'object',
-            patternProperties: { [pattern]: TypeClone.Clone(schema, {}) },
-            additionalProperties: false,
-        });
+        else if (TypeGuard.TLiteral(key)) {
+            if (typeof key.const === 'string' || typeof key.const === 'number') {
+                return this.Object({ [key.const]: TypeClone.Clone(schema, {}) }, options);
+            }
+            else
+                throw Error('TypeBuilder: Record key can only be derived from literals of number or string');
+        }
+        else if (TypeGuard.TInteger(key) || TypeGuard.TNumber(key)) {
+            const pattern = exports.PatternNumberExact;
+            return this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [pattern]: TypeClone.Clone(schema, {}) }, additionalProperties: false });
+        }
+        else if (TypeGuard.TString(key)) {
+            const pattern = key.pattern === undefined ? exports.PatternStringExact : key.pattern;
+            return this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [pattern]: TypeClone.Clone(schema, {}) }, additionalProperties: false });
+        }
+        else {
+            throw Error(`StandardTypeBuilder: Invalid Record Key`);
+        }
     }
     /** `[Standard]` Creates a Recursive type */
     Recursive(callback, options = {}) {
         if (options.$id === undefined)
             options.$id = `T${TypeOrdinal++}`;
-        const self = callback({ [exports.Kind]: 'Self', $ref: `${options.$id}` });
-        self.$id = options.$id;
-        return this.Create({ ...options, ...self });
+        const thisType = callback({ [exports.Kind]: 'This', $ref: `${options.$id}` });
+        thisType.$id = options.$id;
+        return this.Create({ ...options, ...thisType });
     }
     /** `[Standard]` Creates a Ref type. The referenced type must contain a $id */
     Ref(schema, options = {}) {
@@ -1749,6 +2078,11 @@ class StandardTypeBuilder extends TypeBuilder {
     String(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'String', type: 'string' });
     }
+    /** `[Standard]` Creates a template literal type */
+    TemplateLiteral(kinds, options = {}) {
+        const pattern = TemplateLiteralPattern.Create(kinds);
+        return this.Create({ ...options, [exports.Kind]: 'TemplateLiteral', type: 'string', pattern });
+    }
     /** `[Standard]` Creates a Tuple type */
     Tuple(items, options = {}) {
         const [additionalItems, minItems, maxItems] = [false, items.length, items.length];
@@ -1759,13 +2093,19 @@ class StandardTypeBuilder extends TypeBuilder {
             { ...options, [exports.Kind]: 'Tuple', type: 'array', minItems, maxItems });
         return this.Create(schema);
     }
-    Union(anyOf, options = {}) {
-        if (anyOf.length === 0)
-            return this.Never(options);
-        if (anyOf.length === 1)
-            return this.Create(TypeClone.Clone(anyOf[0], options));
-        const clonedAnyOf = anyOf.map((schema) => TypeClone.Clone(schema, {}));
-        return this.Create({ ...options, [exports.Kind]: 'Union', anyOf: clonedAnyOf });
+    Union(union, options = {}) {
+        if (TypeGuard.TTemplateLiteral(union)) {
+            return TemplateLiteralResolver.Resolve(union);
+        }
+        else {
+            const anyOf = union;
+            if (anyOf.length === 0)
+                return this.Never(options);
+            if (anyOf.length === 1)
+                return this.Create(TypeClone.Clone(anyOf[0], options));
+            const clonedAnyOf = anyOf.map((schema) => TypeClone.Clone(schema, {}));
+            return this.Create({ ...options, [exports.Kind]: 'Union', anyOf: clonedAnyOf });
+        }
     }
     /** `[Standard]` Creates an Unknown type */
     Unknown(options = {}) {
@@ -1778,7 +2118,7 @@ class StandardTypeBuilder extends TypeBuilder {
 }
 exports.StandardTypeBuilder = StandardTypeBuilder;
 // --------------------------------------------------------------------------
-// TypeBuilder
+// ExtendedTypeBuilder
 // --------------------------------------------------------------------------
 class ExtendedTypeBuilder extends StandardTypeBuilder {
     /** `[Extended]` Creates a BigInt type */

package/value/cast.d.ts

@@ -1,7 +1,7 @@
 import * as Types from '../typebox';
 export declare class ValueCastReferenceTypeError extends Error {
-    readonly schema: Types.TRef | Types.TSelf;
-    constructor(schema: Types.TRef | Types.TSelf);
+    readonly schema: Types.TRef | Types.TThis;
+    constructor(schema: Types.TRef | Types.TThis);
 }
 export declare class ValueCastArrayUniqueItemsTypeError extends Error {
     readonly schema: Types.TSchema;
@@ -21,8 +21,8 @@ export declare class ValueCastUnknownTypeError extends Error {
     constructor(schema: Types.TSchema);
 }
 export declare class ValueCastDereferenceError extends Error {
-    readonly schema: Types.TRef | Types.TSelf;
-    constructor(schema: Types.TRef | Types.TSelf);
+    readonly schema: Types.TRef | Types.TThis;
+    constructor(schema: Types.TRef | Types.TThis);
 }
 export declare namespace ValueCast {
     function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): any;

package/value/cast.js

@@ -255,19 +255,22 @@ var ValueCast;
         const target = references[index];
         return Visit(target, references, value);
     }
-    function Self(schema, references, value) {
-        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
-        if (index === -1)
-            throw new ValueCastDereferenceError(schema);
-        const target = references[index];
-        return Visit(target, references, value);
-    }
     function String(schema, references, value) {
         return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
     }
     function Symbol(schema, references, value) {
         return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
     }
+    function TemplateLiteral(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
+    }
+    function This(schema, references, value) {
+        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
+        if (index === -1)
+            throw new ValueCastDereferenceError(schema);
+        const target = references[index];
+        return Visit(target, references, value);
+    }
     function Tuple(schema, references, value) {
         if (check_1.ValueCheck.Check(schema, references, value))
             return clone_1.ValueClone.Clone(value);
@@ -335,12 +338,14 @@ var ValueCast;
                 return Record(schema_, references_, value);
             case 'Ref':
                 return Ref(schema_, references_, value);
-            case 'Self':
-                return Self(schema_, references_, value);
             case 'String':
                 return String(schema_, references_, value);
             case 'Symbol':
                 return Symbol(schema_, references_, value);
+            case 'TemplateLiteral':
+                return TemplateLiteral(schema_, references_, value);
+            case 'This':
+                return This(schema_, references_, value);
             case 'Tuple':
                 return Tuple(schema_, references_, value);
             case 'Undefined':

package/value/check.d.ts

@@ -4,8 +4,8 @@ export declare class ValueCheckUnknownTypeError extends Error {
     constructor(schema: Types.TSchema);
 }
 export declare class ValueCheckDereferenceError extends Error {
-    readonly schema: Types.TRef | Types.TSelf;
-    constructor(schema: Types.TRef | Types.TSelf);
+    readonly schema: Types.TRef | Types.TThis;
+    constructor(schema: Types.TRef | Types.TThis);
 }
 export declare namespace ValueCheck {
     function Check<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): boolean;