@sinclair/typebox 0.34.10 → 0.34.12

package/build/cjs/compiler/compiler.js

@@ -13,10 +13,11 @@ const index_8 = require("../type/registry/index");
 const index_9 = require("../type/keyof/index");
 const extends_undefined_1 = require("../type/extends/extends-undefined");
 const index_10 = require("../type/never/index");
+const index_11 = require("../type/ref/index");
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-const index_11 = require("../value/guard/index");
+const index_12 = require("../value/guard/index");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -211,17 +212,17 @@ var TypeCompiler;
     function* FromArray(schema, references, value) {
         yield `Array.isArray(${value})`;
         const [parameter, accumulator] = [CreateParameter('value', 'any'), CreateParameter('acc', 'number')];
-        if ((0, index_11.IsNumber)(schema.maxItems))
+        if ((0, index_12.IsNumber)(schema.maxItems))
             yield `${value}.length <= ${schema.maxItems}`;
-        if ((0, index_11.IsNumber)(schema.minItems))
+        if ((0, index_12.IsNumber)(schema.minItems))
             yield `${value}.length >= ${schema.minItems}`;
         const elementExpression = CreateExpression(schema.items, references, 'value');
         yield `${value}.every((${parameter}) => ${elementExpression})`;
-        if ((0, type_1.IsSchema)(schema.contains) || (0, index_11.IsNumber)(schema.minContains) || (0, index_11.IsNumber)(schema.maxContains)) {
+        if ((0, type_1.IsSchema)(schema.contains) || (0, index_12.IsNumber)(schema.minContains) || (0, index_12.IsNumber)(schema.maxContains)) {
             const containsSchema = (0, type_1.IsSchema)(schema.contains) ? schema.contains : (0, index_10.Never)();
             const checkExpression = CreateExpression(containsSchema, references, 'value');
-            const checkMinContains = (0, index_11.IsNumber)(schema.minContains) ? [`(count >= ${schema.minContains})`] : [];
-            const checkMaxContains = (0, index_11.IsNumber)(schema.maxContains) ? [`(count <= ${schema.maxContains})`] : [];
+            const checkMinContains = (0, index_12.IsNumber)(schema.minContains) ? [`(count >= ${schema.minContains})`] : [];
+            const checkMaxContains = (0, index_12.IsNumber)(schema.maxContains) ? [`(count <= ${schema.maxContains})`] : [];
             const checkCount = `const count = value.reduce((${accumulator}, ${parameter}) => ${checkExpression} ? acc + 1 : acc, 0)`;
             const check = [`(count > 0)`, ...checkMinContains, ...checkMaxContains].join(' && ');
             yield `((${parameter}) => { ${checkCount}; return ${check}})(${value})`;
@@ -237,15 +238,15 @@ var TypeCompiler;
     }
     function* FromBigInt(schema, references, value) {
         yield `(typeof ${value} === 'bigint')`;
-        if ((0, index_11.IsBigInt)(schema.exclusiveMaximum))
+        if ((0, index_12.IsBigInt)(schema.exclusiveMaximum))
             yield `${value} < BigInt(${schema.exclusiveMaximum})`;
-        if ((0, index_11.IsBigInt)(schema.exclusiveMinimum))
+        if ((0, index_12.IsBigInt)(schema.exclusiveMinimum))
             yield `${value} > BigInt(${schema.exclusiveMinimum})`;
-        if ((0, index_11.IsBigInt)(schema.maximum))
+        if ((0, index_12.IsBigInt)(schema.maximum))
             yield `${value} <= BigInt(${schema.maximum})`;
-        if ((0, index_11.IsBigInt)(schema.minimum))
+        if ((0, index_12.IsBigInt)(schema.minimum))
             yield `${value} >= BigInt(${schema.minimum})`;
-        if ((0, index_11.IsBigInt)(schema.multipleOf))
+        if ((0, index_12.IsBigInt)(schema.multipleOf))
             yield `(${value} % BigInt(${schema.multipleOf})) === 0`;
     }
     function* FromBoolean(schema, references, value) {
@@ -256,36 +257,37 @@ var TypeCompiler;
     }
     function* FromDate(schema, references, value) {
         yield `(${value} instanceof Date) && Number.isFinite(${value}.getTime())`;
-        if ((0, index_11.IsNumber)(schema.exclusiveMaximumTimestamp))
+        if ((0, index_12.IsNumber)(schema.exclusiveMaximumTimestamp))
             yield `${value}.getTime() < ${schema.exclusiveMaximumTimestamp}`;
-        if ((0, index_11.IsNumber)(schema.exclusiveMinimumTimestamp))
+        if ((0, index_12.IsNumber)(schema.exclusiveMinimumTimestamp))
             yield `${value}.getTime() > ${schema.exclusiveMinimumTimestamp}`;
-        if ((0, index_11.IsNumber)(schema.maximumTimestamp))
+        if ((0, index_12.IsNumber)(schema.maximumTimestamp))
             yield `${value}.getTime() <= ${schema.maximumTimestamp}`;
-        if ((0, index_11.IsNumber)(schema.minimumTimestamp))
+        if ((0, index_12.IsNumber)(schema.minimumTimestamp))
             yield `${value}.getTime() >= ${schema.minimumTimestamp}`;
-        if ((0, index_11.IsNumber)(schema.multipleOfTimestamp))
+        if ((0, index_12.IsNumber)(schema.multipleOfTimestamp))
             yield `(${value}.getTime() % ${schema.multipleOfTimestamp}) === 0`;
     }
     function* FromFunction(schema, references, value) {
         yield `(typeof ${value} === 'function')`;
     }
     function* FromImport(schema, references, value) {
-        const definitions = globalThis.Object.values(schema.$defs);
-        const target = schema.$defs[schema.$ref];
-        yield* Visit(target, [...references, ...definitions], value);
+        const members = globalThis.Object.getOwnPropertyNames(schema.$defs).reduce((result, key) => {
+            return [...result, schema.$defs[key]];
+        }, []);
+        yield* Visit((0, index_11.Ref)(schema.$ref), [...references, ...members], value);
     }
     function* FromInteger(schema, references, value) {
         yield `Number.isInteger(${value})`;
-        if ((0, index_11.IsNumber)(schema.exclusiveMaximum))
+        if ((0, index_12.IsNumber)(schema.exclusiveMaximum))
             yield `${value} < ${schema.exclusiveMaximum}`;
-        if ((0, index_11.IsNumber)(schema.exclusiveMinimum))
+        if ((0, index_12.IsNumber)(schema.exclusiveMinimum))
             yield `${value} > ${schema.exclusiveMinimum}`;
-        if ((0, index_11.IsNumber)(schema.maximum))
+        if ((0, index_12.IsNumber)(schema.maximum))
             yield `${value} <= ${schema.maximum}`;
-        if ((0, index_11.IsNumber)(schema.minimum))
+        if ((0, index_12.IsNumber)(schema.minimum))
             yield `${value} >= ${schema.minimum}`;
-        if ((0, index_11.IsNumber)(schema.multipleOf))
+        if ((0, index_12.IsNumber)(schema.multipleOf))
             yield `(${value} % ${schema.multipleOf}) === 0`;
     }
     function* FromIntersect(schema, references, value) {
@@ -327,22 +329,22 @@ var TypeCompiler;
     }
     function* FromNumber(schema, references, value) {
         yield Policy.IsNumberLike(value);
-        if ((0, index_11.IsNumber)(schema.exclusiveMaximum))
+        if ((0, index_12.IsNumber)(schema.exclusiveMaximum))
             yield `${value} < ${schema.exclusiveMaximum}`;
-        if ((0, index_11.IsNumber)(schema.exclusiveMinimum))
+        if ((0, index_12.IsNumber)(schema.exclusiveMinimum))
             yield `${value} > ${schema.exclusiveMinimum}`;
-        if ((0, index_11.IsNumber)(schema.maximum))
+        if ((0, index_12.IsNumber)(schema.maximum))
             yield `${value} <= ${schema.maximum}`;
-        if ((0, index_11.IsNumber)(schema.minimum))
+        if ((0, index_12.IsNumber)(schema.minimum))
             yield `${value} >= ${schema.minimum}`;
-        if ((0, index_11.IsNumber)(schema.multipleOf))
+        if ((0, index_12.IsNumber)(schema.multipleOf))
             yield `(${value} % ${schema.multipleOf}) === 0`;
     }
     function* FromObject(schema, references, value) {
         yield Policy.IsObjectLike(value);
-        if ((0, index_11.IsNumber)(schema.minProperties))
+        if ((0, index_12.IsNumber)(schema.minProperties))
             yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
-        if ((0, index_11.IsNumber)(schema.maxProperties))
+        if ((0, index_12.IsNumber)(schema.maxProperties))
             yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`;
         const knownKeys = Object.getOwnPropertyNames(schema.properties);
         for (const knownKey of knownKeys) {
@@ -378,9 +380,9 @@ var TypeCompiler;
     }
     function* FromRecord(schema, references, value) {
         yield Policy.IsRecordLike(value);
-        if ((0, index_11.IsNumber)(schema.minProperties))
+        if ((0, index_12.IsNumber)(schema.minProperties))
             yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
-        if ((0, index_11.IsNumber)(schema.maxProperties))
+        if ((0, index_12.IsNumber)(schema.maxProperties))
             yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`;
         const [patternKey, patternSchema] = Object.entries(schema.patternProperties)[0];
         const variable = CreateVariable(`${new RegExp(patternKey)}`);
@@ -392,29 +394,25 @@ var TypeCompiler;
     function* FromRef(schema, references, value) {
         const target = (0, index_5.Deref)(schema, references);
         // Reference: If we have seen this reference before we can just yield and return the function call.
-        // If this isn't the case we defer to visit to generate and set the _recursion_end_for_ for subsequent
-        // passes. This operation is very awkward as we are using the functions state to store values to
-        // enable self referential types to terminate. This needs to be refactored.
-        const recursiveEnd = `_recursion_end_for_${schema.$ref}`;
-        if (state.functions.has(recursiveEnd))
+        // If this isn't the case we defer to visit to generate and set the function for subsequent passes.
+        if (state.functions.has(schema.$ref))
             return yield `${CreateFunctionName(schema.$ref)}(${value})`;
-        state.functions.set(recursiveEnd, ''); // terminate recursion here by setting the name.
         yield* Visit(target, references, value);
     }
     function* FromRegExp(schema, references, value) {
         const variable = CreateVariable(`${new RegExp(schema.source, schema.flags)};`);
         yield `(typeof ${value} === 'string')`;
-        if ((0, index_11.IsNumber)(schema.maxLength))
+        if ((0, index_12.IsNumber)(schema.maxLength))
             yield `${value}.length <= ${schema.maxLength}`;
-        if ((0, index_11.IsNumber)(schema.minLength))
+        if ((0, index_12.IsNumber)(schema.minLength))
             yield `${value}.length >= ${schema.minLength}`;
         yield `${variable}.test(${value})`;
     }
     function* FromString(schema, references, value) {
         yield `(typeof ${value} === 'string')`;
-        if ((0, index_11.IsNumber)(schema.maxLength))
+        if ((0, index_12.IsNumber)(schema.maxLength))
             yield `${value}.length <= ${schema.maxLength}`;
-        if ((0, index_11.IsNumber)(schema.minLength))
+        if ((0, index_12.IsNumber)(schema.minLength))
             yield `${value}.length >= ${schema.minLength}`;
         if (schema.pattern !== undefined) {
             const variable = CreateVariable(`${new RegExp(schema.pattern)};`);
@@ -455,9 +453,9 @@ var TypeCompiler;
     }
     function* FromUint8Array(schema, references, value) {
         yield `${value} instanceof Uint8Array`;
-        if ((0, index_11.IsNumber)(schema.maxByteLength))
+        if ((0, index_12.IsNumber)(schema.maxByteLength))
             yield `(${value}.length <= ${schema.maxByteLength})`;
-        if ((0, index_11.IsNumber)(schema.minByteLength))
+        if ((0, index_12.IsNumber)(schema.minByteLength))
             yield `(${value}.length >= ${schema.minByteLength})`;
     }
     function* FromUnknown(schema, references, value) {
@@ -472,17 +470,21 @@ var TypeCompiler;
         yield `kind('${schema[index_7.Kind]}', ${instance}, ${value})`;
     }
     function* Visit(schema, references, value, useHoisting = true) {
-        const references_ = (0, index_11.IsString)(schema.$id) ? [...references, schema] : references;
+        const references_ = (0, index_12.IsString)(schema.$id) ? [...references, schema] : references;
         const schema_ = schema;
         // --------------------------------------------------------------
         // Hoisting
         // --------------------------------------------------------------
-        if (useHoisting && (0, index_11.IsString)(schema.$id)) {
+        if (useHoisting && (0, index_12.IsString)(schema.$id)) {
             const functionName = CreateFunctionName(schema.$id);
             if (state.functions.has(functionName)) {
                 return yield `${functionName}(${value})`;
             }
             else {
+                // Note: In the case of cyclic types, we need to create a 'functions' record
+                // to prevent infinitely re-visiting the CreateFunction. Subsequent attempts
+                // to visit will be caught by the above condition.
+                state.functions.set(functionName, '<deferred>');
                 const functionCode = CreateFunction(functionName, schema, references, 'value', false);
                 state.functions.set(functionName, functionCode);
                 return yield `${functionName}(${value})`;
@@ -607,7 +609,7 @@ var TypeCompiler;
         const functions = [...state.functions.values()];
         const variables = [...state.variables.values()];
         // prettier-ignore
-        const checkFunction = (0, index_11.IsString)(schema.$id) // ensure top level schemas with $id's are hoisted
+        const checkFunction = (0, index_12.IsString)(schema.$id) // ensure top level schemas with $id's are hoisted
             ? `return function check(${parameter})${returns} {\n  return ${CreateFunctionName(schema.$id)}(value)\n}`
             : `return ${functionCode}`;
         return [...variables, ...functions, checkFunction].join('\n');
@@ -616,8 +618,8 @@ var TypeCompiler;
     function Code(...args) {
         const defaults = { language: 'javascript' };
         // prettier-ignore
-        const [schema, references, options] = (args.length === 2 && (0, index_11.IsArray)(args[1]) ? [args[0], args[1], defaults] :
-            args.length === 2 && !(0, index_11.IsArray)(args[1]) ? [args[0], [], args[1]] :
+        const [schema, references, options] = (args.length === 2 && (0, index_12.IsArray)(args[1]) ? [args[0], args[1], defaults] :
+            args.length === 2 && !(0, index_12.IsArray)(args[1]) ? [args[0], [], args[1]] :
                 args.length === 3 ? [args[0], args[1], args[2]] :
                     args.length === 1 ? [args[0], [], defaults] :
                         [null, [], defaults]);

package/build/cjs/value/mutate/mutate.js

@@ -8,6 +8,12 @@ const index_2 = require("../pointer/index");
 const index_3 = require("../clone/index");
 const index_4 = require("../../type/error/index");
 // ------------------------------------------------------------------
+// IsStandardObject
+// ------------------------------------------------------------------
+function IsStandardObject(value) {
+    return (0, index_1.IsObject)(value) && !(0, index_1.IsArray)(value);
+}
+// ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
 class ValueMutateError extends index_4.TypeBoxError {
@@ -17,7 +23,7 @@ class ValueMutateError extends index_4.TypeBoxError {
 }
 exports.ValueMutateError = ValueMutateError;
 function ObjectType(root, path, current, next) {
-    if (!(0, index_1.IsObject)(current)) {
+    if (!IsStandardObject(current)) {
         index_2.ValuePointer.Set(root, path, (0, index_3.Clone)(next));
     }
     else {
@@ -69,7 +75,7 @@ function Visit(root, path, current, next) {
         return ArrayType(root, path, current, next);
     if ((0, index_1.IsTypedArray)(next))
         return TypedArrayType(root, path, current, next);
-    if ((0, index_1.IsObject)(next))
+    if (IsStandardObject(next))
         return ObjectType(root, path, current, next);
     if ((0, index_1.IsValueType)(next))
         return ValueType(root, path, current, next);
@@ -82,8 +88,8 @@ function IsNonMutableValue(value) {
 }
 function IsMismatchedValue(current, next) {
     // prettier-ignore
-    return (((0, index_1.IsObject)(current) && (0, index_1.IsArray)(next)) ||
-        ((0, index_1.IsArray)(current) && (0, index_1.IsObject)(next)));
+    return ((IsStandardObject(current) && (0, index_1.IsArray)(next)) ||
+        ((0, index_1.IsArray)(current) && IsStandardObject(next)));
 }
 // ------------------------------------------------------------------
 // Mutate

package/build/esm/compiler/compiler.mjs

@@ -9,6 +9,7 @@ import { TypeRegistry, FormatRegistry } from '../type/registry/index.mjs';
 import { KeyOfPattern } from '../type/keyof/index.mjs';
 import { ExtendsUndefinedCheck } from '../type/extends/extends-undefined.mjs';
 import { Never } from '../type/never/index.mjs';
+import { Ref } from '../type/ref/index.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
@@ -264,9 +265,10 @@ export var TypeCompiler;
         yield `(typeof ${value} === 'function')`;
     }
     function* FromImport(schema, references, value) {
-        const definitions = globalThis.Object.values(schema.$defs);
-        const target = schema.$defs[schema.$ref];
-        yield* Visit(target, [...references, ...definitions], value);
+        const members = globalThis.Object.getOwnPropertyNames(schema.$defs).reduce((result, key) => {
+            return [...result, schema.$defs[key]];
+        }, []);
+        yield* Visit(Ref(schema.$ref), [...references, ...members], value);
     }
     function* FromInteger(schema, references, value) {
         yield `Number.isInteger(${value})`;
@@ -385,13 +387,9 @@ export var TypeCompiler;
     function* FromRef(schema, references, value) {
         const target = Deref(schema, references);
         // Reference: If we have seen this reference before we can just yield and return the function call.
-        // If this isn't the case we defer to visit to generate and set the _recursion_end_for_ for subsequent
-        // passes. This operation is very awkward as we are using the functions state to store values to
-        // enable self referential types to terminate. This needs to be refactored.
-        const recursiveEnd = `_recursion_end_for_${schema.$ref}`;
-        if (state.functions.has(recursiveEnd))
+        // If this isn't the case we defer to visit to generate and set the function for subsequent passes.
+        if (state.functions.has(schema.$ref))
             return yield `${CreateFunctionName(schema.$ref)}(${value})`;
-        state.functions.set(recursiveEnd, ''); // terminate recursion here by setting the name.
         yield* Visit(target, references, value);
     }
     function* FromRegExp(schema, references, value) {
@@ -476,6 +474,10 @@ export var TypeCompiler;
                 return yield `${functionName}(${value})`;
             }
             else {
+                // Note: In the case of cyclic types, we need to create a 'functions' record
+                // to prevent infinitely re-visiting the CreateFunction. Subsequent attempts
+                // to visit will be caught by the above condition.
+                state.functions.set(functionName, '<deferred>');
                 const functionCode = CreateFunction(functionName, schema, references, 'value', false);
                 state.functions.set(functionName, functionCode);
                 return yield `${functionName}(${value})`;

package/build/esm/value/mutate/mutate.mjs

@@ -3,6 +3,12 @@ import { ValuePointer } from '../pointer/index.mjs';
 import { Clone } from '../clone/index.mjs';
 import { TypeBoxError } from '../../type/error/index.mjs';
 // ------------------------------------------------------------------
+// IsStandardObject
+// ------------------------------------------------------------------
+function IsStandardObject(value) {
+    return IsObject(value) && !IsArray(value);
+}
+// ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
 export class ValueMutateError extends TypeBoxError {
@@ -11,7 +17,7 @@ export class ValueMutateError extends TypeBoxError {
     }
 }
 function ObjectType(root, path, current, next) {
-    if (!IsObject(current)) {
+    if (!IsStandardObject(current)) {
         ValuePointer.Set(root, path, Clone(next));
     }
     else {
@@ -63,7 +69,7 @@ function Visit(root, path, current, next) {
         return ArrayType(root, path, current, next);
     if (IsTypedArray(next))
         return TypedArrayType(root, path, current, next);
-    if (IsObject(next))
+    if (IsStandardObject(next))
         return ObjectType(root, path, current, next);
     if (IsValueType(next))
         return ValueType(root, path, current, next);
@@ -76,8 +82,8 @@ function IsNonMutableValue(value) {
 }
 function IsMismatchedValue(current, next) {
     // prettier-ignore
-    return ((IsObject(current) && IsArray(next)) ||
-        (IsArray(current) && IsObject(next)));
+    return ((IsStandardObject(current) && IsArray(next)) ||
+        (IsArray(current) && IsStandardObject(next)));
 }
 // ------------------------------------------------------------------
 // Mutate

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.10",
+  "version": "0.34.12",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/readme.md

@@ -68,6 +68,7 @@ License MIT
   - [Options](#types-options)
   - [Properties](#types-properties)
   - [Generics](#types-generics)
+  - [Recursive](#types-recursive)
   - [Modules](#types-modules)
   - [Template Literal](#types-template-literal)
   - [Indexed](#types-indexed)
@@ -759,21 +760,51 @@ const T = Nullable(Type.String())                    // const T = {
 type T = Static<typeof T>                            // type T = string | null
 ```
 
-<a name='types-modules'></a>
+<a name='types-recursive'></a>
 
-### Module Types
+### Recursive Types
 
-TypeBox Modules are containers for related types. They provide a referential namespace, enabling types to reference one another via string identifiers. Modules support both singular and mutually recursive referencing within the context of a module, as well as referential computed types (such as Partial + Ref). All Module types must be imported before use. TypeBox represents an imported type with the `$defs` Json Schema keyword. 
+Use the Recursive function to create a singular recursive type.
 
-#### Usage
+```typescript
+const Node = Type.Recursive(Self => Type.Object({    // const Node = {
+  id: Type.String(),                                 //   $id: 'Node',
+  nodes: Type.Array(Self)                            //   type: 'object',
+}), { $id: 'Node' })                                 //   properties: {
+                                                     //     id: {
+                                                     //       type: 'string'
+                                                     //     },
+                                                     //     nodes: {
+                                                     //       type: 'array',
+                                                     //       items: {
+                                                     //         $ref: 'Node'
+                                                     //       }
+                                                     //     }
+                                                     //   },
+                                                     //   required: [
+                                                     //     'id',
+                                                     //     'nodes'
+                                                     //   ]
+                                                     // }
 
-The following creates a Module with User and PartialUser types. Note that the PartialUser type is specified as a Partial + Ref to the User type. It is not possible to perform a Partial operation directly on a reference, so TypeBox will return a TComputed type that defers the Partial operation until all types are resolved. The TComputed type is evaluated when calling Import on the Module.
+type Node = Static<typeof Node>                      // type Node = {
+                                                     //   id: string
+                                                     //   nodes: Node[]
+                                                     // }
 
-```typescript
-// Module with PartialUser and User types
+function test(node: Node) {
+  const id = node.nodes[0].nodes[0].id               // id is string
+}
+```
 
-const Module = Type.Module({
+<a name='types-modules'></a>
+
+### Module Types
 
+Module types are containers for a set of referential types. Modules act as namespaces, enabling types to reference one another via string identifiers. Modules support both singular and mutually recursive references, as well as deferred dereferencing for computed types such as Partial. Types imported from a module are expressed using the Json Schema `$defs` keyword. 
+
+```typescript
+const Module = Type.Module({
   PartialUser: Type.Partial(Type.Ref('User')),  // TComputed<'Partial', [TRef<'User'>]>
 
   User: Type.Object({                           // TObject<{
@@ -781,11 +812,7 @@ const Module = Type.Module({
     name: Type.String(),                        //   name: TString,
     email: Type.String()                        //   email: TString
   }),                                           // }>
-  
 })
-
-// Types must be imported before use.
-
 const User = Module.Import('User')               // const User: TImport<{...}, 'User'>
 
 type User = Static<typeof User>                  // type User = { 
@@ -803,7 +830,6 @@ type PartialUser = Static<typeof PartialUser>    // type PartialUser = {
                                                  // }
 ```
 
-
 <a name='types-template-literal'></a>
 
 ### Template Literal Types