@sinclair/typebox 0.33.22 → 0.34.1

package/build/cjs/value/transform/has.js

@@ -5,76 +5,76 @@ exports.HasTransform = HasTransform;
 const index_1 = require("../deref/index");
 const index_2 = require("../../type/symbols/index");
 // ------------------------------------------------------------------
-// TypeGuard
+// KindGuard
 // ------------------------------------------------------------------
-const type_1 = require("../../type/guard/type");
+const kind_1 = require("../../type/guard/kind");
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
 const index_3 = require("../guard/index");
 // prettier-ignore
 function FromArray(schema, references) {
-    return (0, type_1.IsTransform)(schema) || Visit(schema.items, references);
+    return (0, kind_1.IsTransform)(schema) || Visit(schema.items, references);
 }
 // prettier-ignore
 function FromAsyncIterator(schema, references) {
-    return (0, type_1.IsTransform)(schema) || Visit(schema.items, references);
+    return (0, kind_1.IsTransform)(schema) || Visit(schema.items, references);
 }
 // prettier-ignore
 function FromConstructor(schema, references) {
-    return (0, type_1.IsTransform)(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references));
+    return (0, kind_1.IsTransform)(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references));
 }
 // prettier-ignore
 function FromFunction(schema, references) {
-    return (0, type_1.IsTransform)(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references));
+    return (0, kind_1.IsTransform)(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references));
 }
 // prettier-ignore
 function FromIntersect(schema, references) {
-    return (0, type_1.IsTransform)(schema) || (0, type_1.IsTransform)(schema.unevaluatedProperties) || schema.allOf.some((schema) => Visit(schema, references));
+    return (0, kind_1.IsTransform)(schema) || (0, kind_1.IsTransform)(schema.unevaluatedProperties) || schema.allOf.some((schema) => Visit(schema, references));
 }
 // prettier-ignore
 function FromIterator(schema, references) {
-    return (0, type_1.IsTransform)(schema) || Visit(schema.items, references);
+    return (0, kind_1.IsTransform)(schema) || Visit(schema.items, references);
 }
 // prettier-ignore
 function FromNot(schema, references) {
-    return (0, type_1.IsTransform)(schema) || Visit(schema.not, references);
+    return (0, kind_1.IsTransform)(schema) || Visit(schema.not, references);
 }
 // prettier-ignore
 function FromObject(schema, references) {
-    return ((0, type_1.IsTransform)(schema) ||
+    return ((0, kind_1.IsTransform)(schema) ||
         Object.values(schema.properties).some((schema) => Visit(schema, references)) ||
-        ((0, type_1.IsSchema)(schema.additionalProperties) && Visit(schema.additionalProperties, references)));
+        ((0, kind_1.IsSchema)(schema.additionalProperties) && Visit(schema.additionalProperties, references)));
 }
 // prettier-ignore
 function FromPromise(schema, references) {
-    return (0, type_1.IsTransform)(schema) || Visit(schema.item, references);
+    return (0, kind_1.IsTransform)(schema) || Visit(schema.item, references);
 }
 // prettier-ignore
 function FromRecord(schema, references) {
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const property = schema.patternProperties[pattern];
-    return (0, type_1.IsTransform)(schema) || Visit(property, references) || ((0, type_1.IsSchema)(schema.additionalProperties) && (0, type_1.IsTransform)(schema.additionalProperties));
+    return (0, kind_1.IsTransform)(schema) || Visit(property, references) || ((0, kind_1.IsSchema)(schema.additionalProperties) && (0, kind_1.IsTransform)(schema.additionalProperties));
 }
 // prettier-ignore
 function FromRef(schema, references) {
-    if ((0, type_1.IsTransform)(schema))
+    if ((0, kind_1.IsTransform)(schema))
         return true;
     return Visit((0, index_1.Deref)(schema, references), references);
 }
 // prettier-ignore
 function FromThis(schema, references) {
-    if ((0, type_1.IsTransform)(schema))
+    if ((0, kind_1.IsTransform)(schema))
         return true;
     return Visit((0, index_1.Deref)(schema, references), references);
 }
 // prettier-ignore
 function FromTuple(schema, references) {
-    return (0, type_1.IsTransform)(schema) || (!(0, index_3.IsUndefined)(schema.items) && schema.items.some((schema) => Visit(schema, references)));
+    return (0, kind_1.IsTransform)(schema) || (!(0, index_3.IsUndefined)(schema.items) && schema.items.some((schema) => Visit(schema, references)));
 }
 // prettier-ignore
 function FromUnion(schema, references) {
-    return (0, type_1.IsTransform)(schema) || schema.anyOf.some((schema) => Visit(schema, references));
+    return (0, kind_1.IsTransform)(schema) || schema.anyOf.some((schema) => Visit(schema, references));
 }
 // prettier-ignore
 function Visit(schema, references) {
@@ -114,7 +114,7 @@ function Visit(schema, references) {
         case 'Union':
             return FromUnion(schema_, references_);
         default:
-            return (0, type_1.IsTransform)(schema);
+            return (0, kind_1.IsTransform)(schema);
     }
 }
 const visited = new Set();

package/build/esm/compiler/compiler.d.mts

@@ -1,7 +1,7 @@
 import { ValueErrorIterator } from '../errors/index.mjs';
 import { TypeBoxError } from '../type/error/index.mjs';
 import type { TSchema } from '../type/schema/index.mjs';
-import type { Static, StaticDecode } from '../type/static/index.mjs';
+import type { Static, StaticDecode, StaticEncode } from '../type/static/index.mjs';
 export type CheckFunction = (value: unknown) => boolean;
 export declare class TypeCheck<T extends TSchema> {
     private readonly schema;
@@ -19,7 +19,7 @@ export declare class TypeCheck<T extends TSchema> {
     /** Decodes a value or throws if error */
     Decode<Static = StaticDecode<T>, Result extends Static = Static>(value: unknown): Result;
     /** Encodes a value or throws if error */
-    Encode<Static = StaticDecode<T>, Result extends Static = Static>(value: unknown): Result;
+    Encode<Static = StaticEncode<T>, Result extends Static = Static>(value: unknown): Result;
 }
 export declare class TypeCompilerUnknownTypeError extends TypeBoxError {
     readonly schema: TSchema;

package/build/esm/compiler/compiler.mjs

@@ -255,6 +255,11 @@ export var TypeCompiler;
     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);
+    }
     function* FromInteger(schema, references, value) {
         yield `Number.isInteger(${value})`;
         if (IsNumber(schema.exclusiveMaximum))
@@ -372,9 +377,13 @@ 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 function for subsequent passes.
-        if (state.functions.has(schema.$ref))
+        // 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))
             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) {
@@ -481,6 +490,8 @@ export var TypeCompiler;
                 return yield* FromDate(schema_, references_, value);
             case 'Function':
                 return yield* FromFunction(schema_, references_, value);
+            case 'Import':
+                return yield* FromImport(schema_, references_, value);
             case 'Integer':
                 return yield* FromInteger(schema_, references_, value);
             case 'Intersect':

package/build/esm/errors/errors.mjs

@@ -232,6 +232,11 @@ function* FromFunction(schema, references, path, value) {
     if (!IsFunction(value))
         yield Create(ValueErrorType.Function, schema, path, value);
 }
+function* FromImport(schema, references, path, value) {
+    const definitions = globalThis.Object.values(schema.$defs);
+    const target = schema.$defs[schema.$ref];
+    yield* Visit(target, [...references, ...definitions], path, value);
+}
 function* FromInteger(schema, references, path, value) {
     if (!IsInteger(value))
         return yield Create(ValueErrorType.Integer, schema, path, value);
@@ -523,6 +528,8 @@ function* Visit(schema, references, path, value) {
             return yield* FromDate(schema_, references_, path, value);
         case 'Function':
             return yield* FromFunction(schema_, references_, path, value);
+        case 'Import':
+            return yield* FromImport(schema_, references_, path, value);
         case 'Integer':
             return yield* FromInteger(schema_, references_, path, value);
         case 'Intersect':

package/build/esm/index.d.mts

@@ -18,7 +18,6 @@ export * from './type/const/index.mjs';
 export * from './type/constructor/index.mjs';
 export * from './type/constructor-parameters/index.mjs';
 export * from './type/date/index.mjs';
-export * from './type/deref/index.mjs';
 export * from './type/enum/index.mjs';
 export * from './type/exclude/index.mjs';
 export * from './type/extends/index.mjs';
@@ -32,6 +31,7 @@ export * from './type/iterator/index.mjs';
 export * from './type/intrinsic/index.mjs';
 export * from './type/keyof/index.mjs';
 export * from './type/literal/index.mjs';
+export * from './type/module/index.mjs';
 export * from './type/mapped/index.mjs';
 export * from './type/never/index.mjs';
 export * from './type/not/index.mjs';
@@ -55,7 +55,6 @@ export * from './type/rest/index.mjs';
 export * from './type/return-type/index.mjs';
 export * from './type/schema/index.mjs';
 export * from './type/static/index.mjs';
-export * from './type/strict/index.mjs';
 export * from './type/string/index.mjs';
 export * from './type/symbol/index.mjs';
 export * from './type/template-literal/index.mjs';

package/build/esm/index.mjs

@@ -24,7 +24,6 @@ export * from './type/const/index.mjs';
 export * from './type/constructor/index.mjs';
 export * from './type/constructor-parameters/index.mjs';
 export * from './type/date/index.mjs';
-export * from './type/deref/index.mjs';
 export * from './type/enum/index.mjs';
 export * from './type/exclude/index.mjs';
 export * from './type/extends/index.mjs';
@@ -38,6 +37,7 @@ export * from './type/iterator/index.mjs';
 export * from './type/intrinsic/index.mjs';
 export * from './type/keyof/index.mjs';
 export * from './type/literal/index.mjs';
+export * from './type/module/index.mjs';
 export * from './type/mapped/index.mjs';
 export * from './type/never/index.mjs';
 export * from './type/not/index.mjs';
@@ -61,7 +61,6 @@ export * from './type/rest/index.mjs';
 export * from './type/return-type/index.mjs';
 export * from './type/schema/index.mjs';
 export * from './type/static/index.mjs';
-export * from './type/strict/index.mjs';
 export * from './type/string/index.mjs';
 export * from './type/symbol/index.mjs';
 export * from './type/template-literal/index.mjs';

package/build/esm/syntax/parse.d.mts

@@ -1,16 +1,15 @@
+import * as Types from '../type/index.mjs';
 import { Static } from './parsebox/index.mjs';
-import { TSchema, SchemaOptions } from '../type/schema/index.mjs';
-import { StaticDecode } from '../type/static/index.mjs';
-import { Type } from './static.mjs';
-/** `[Experimental]` Infers a TypeBox type from TypeScript syntax. */
-export type StaticParseAsSchema<Context extends Record<PropertyKey, TSchema>, Code extends string> = Static.Parse<Type, Code, Context>[0];
-/** `[Experimental]` Infers a TypeScript type from TypeScript syntax. */
-export type StaticParseAsType<Context extends Record<PropertyKey, TSchema>, Code extends string> = StaticParseAsSchema<Context, Code> extends infer Type extends TSchema ? StaticDecode<Type> : undefined;
-/** `[Experimental]` Parses a TypeBox type from TypeScript syntax. */
-export declare function Parse<Context extends Record<PropertyKey, TSchema>, Code extends string>(context: Context, code: Code, options?: SchemaOptions): StaticParseAsSchema<Context, Code>;
-/** `[Experimental]` Parses a TypeBox type from TypeScript syntax. */
-export declare function Parse<Code extends string>(code: Code, options?: SchemaOptions): StaticParseAsSchema<{}, Code>;
-/** `[Experimental]` Parses a TypeBox TSchema from TypeScript syntax. This function does not infer the type. */
-export declare function ParseOnly<Context extends Record<PropertyKey, TSchema>, Code extends string>(context: Context, code: Code, options?: SchemaOptions): TSchema | undefined;
-/** `[Experimental]` Parses a TypeBox TSchema from TypeScript syntax */
-export declare function ParseOnly<Code extends string>(code: Code, options?: SchemaOptions): TSchema | undefined;
+import { Main } from './static.mjs';
+/** `[Syntax]` Infers a TypeBox type from TypeScript syntax. */
+export type StaticParseAsSchema<Context extends Record<PropertyKey, Types.TSchema>, Code extends string> = Static.Parse<Main, Code, Context>[0];
+/** `[Syntax]` Infers a TypeScript type from TypeScript syntax. */
+export type StaticParseAsType<Context extends Record<PropertyKey, Types.TSchema>, Code extends string> = StaticParseAsSchema<Context, Code> extends infer Type extends Types.TSchema ? Types.StaticDecode<Type> : undefined;
+/** `[Syntax]` Parses a TypeBox type from TypeScript syntax. */
+export declare function Parse<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): StaticParseAsSchema<Context, Code>;
+/** `[Syntax]` Parses a TypeBox type from TypeScript syntax. */
+export declare function Parse<Code extends string>(code: Code, options?: Types.SchemaOptions): StaticParseAsSchema<{}, Code>;
+/** `[Syntax]` Parses a TypeBox TSchema from TypeScript syntax. This function does not infer the type. */
+export declare function ParseOnly<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined;
+/** `[Syntax]` Parses a TypeBox TSchema from TypeScript syntax */
+export declare function ParseOnly<Code extends string>(code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined;

package/build/esm/syntax/parse.mjs

@@ -1,13 +1,14 @@
-import { CreateType } from '../type/create/type.mjs';
+import * as Types from '../type/index.mjs';
 import { Module } from './runtime.mjs';
-/** `[Experimental]` Parses a TypeBox type from TypeScript syntax. */
+/** `[Syntax]` Parses a TypeBox type from TypeScript syntax. */
 export function Parse(...args) {
     return ParseOnly.apply(null, args);
 }
-/** `[Experimental]` Parses a TypeBox TSchema from TypeScript syntax. This function does not infer the type. */
+/** `[Syntax]` Parses a TypeBox TSchema from TypeScript syntax. This function does not infer the type. */
 export function ParseOnly(...args) {
     const withContext = typeof args[0] === 'string' ? false : true;
     const [context, code, options] = withContext ? [args[0], args[1], args[2] || {}] : [{}, args[0], args[1] || {}];
-    const type = Module.Parse('Type', code, context)[0];
-    return (type !== undefined ? CreateType(type, options) : undefined);
+    const type = Module.Parse('Main', code, context)[0];
+    // Note: Parsing may return either a ModuleInstance or Type. We only apply options on the Type.
+    return Types.KindGuard.IsSchema(type) ? Types.CloneType(type, options) : type;
 }

package/build/esm/syntax/runtime.d.mts

@@ -1,6 +1,21 @@
 import { Runtime } from './parsebox/index.mjs';
 import * as Types from '../type/index.mjs';
 export declare const Module: Runtime.Module<{
+    ExportModifier: Runtime.IUnion<boolean>;
+    HeritageList: Runtime.IUnion<Types.TSchema[]>;
+    Heritage: Runtime.IUnion<unknown[]>;
+    InterfaceDeclaration: Runtime.ITuple<{
+        [x: string]: Types.TIntersect<[...Types.TRef<string>[], Types.TObject<Types.TProperties>]>;
+    }>;
+    TypeAliasDeclaration: Runtime.ITuple<{
+        [x: string]: Types.TSchema;
+    }>;
+    ModuleType: Runtime.IUnion<unknown>;
+    ModuleProperties: Runtime.IUnion<Types.TProperties>;
+    ModuleDeclaration: Runtime.ITuple<Types.TModule<Types.TProperties, {
+        [x: string]: Types.TSchema;
+        [x: number]: Types.TSchema;
+    }>>;
     Literal: Runtime.IUnion<Types.TLiteral<string> | Types.TLiteral<number> | Types.TLiteral<boolean>>;
     Keyword: Runtime.IUnion<Types.TAny | Types.TNever | Types.TString | Types.TBoolean | Types.TNumber | Types.TInteger | Types.TBigInt | Types.TNull | Types.TSymbol | Types.TUndefined | Types.TUnknown | Types.TVoid>;
     KeyOf: Runtime.IUnion<boolean>;
@@ -14,14 +29,14 @@ export declare const Module: Runtime.Module<{
     Expr: Runtime.ITuple<Types.TSchema>;
     Type: Runtime.IRef<unknown>;
     PropertyKey: Runtime.IUnion<string>;
-    PropertyReadonly: Runtime.IUnion<boolean>;
-    PropertyOptional: Runtime.IUnion<boolean>;
+    Readonly: Runtime.IUnion<boolean>;
+    Optional: Runtime.IUnion<boolean>;
     Property: Runtime.ITuple<{
         [x: string]: Types.TSchema;
     }>;
     PropertyDelimiter: Runtime.IUnion<[","] | [",", "\n"] | [";"] | [";", "\n"] | ["\n"]>;
-    Properties: Runtime.IUnion<unknown[]>;
-    Object: Runtime.ITuple<Types.TObject<Record<string, Types.TSchema>>>;
+    Properties: Runtime.IUnion<Types.TProperties>;
+    Object: Runtime.ITuple<Types.TObject<Types.TProperties>>;
     Elements: Runtime.IUnion<unknown[]>;
     Tuple: Runtime.ITuple<Types.TTuple<Types.TSchema[]>>;
     Parameter: Runtime.ITuple<Types.TSchema>;
@@ -52,4 +67,5 @@ export declare const Module: Runtime.Module<{
     Date: Runtime.IConst<Types.TDate>;
     Uint8Array: Runtime.IConst<Types.TUint8Array>;
     Reference: Runtime.IIdent<Types.TSchema>;
+    Main: Runtime.IUnion<unknown>;
 }>;

package/build/esm/syntax/runtime.mjs

@@ -19,6 +19,7 @@ const SemiColon = ';';
 const SingleQuote = "'";
 const DoubleQuote = '"';
 const Tilde = '`';
+const Equals = '=';
 // ------------------------------------------------------------------
 // DestructureRight
 // ------------------------------------------------------------------
@@ -29,12 +30,133 @@ function DestructureRight(values) {
         : [values, undefined];
 }
 // ------------------------------------------------------------------
+// Deref
+// ------------------------------------------------------------------
+const Deref = (context, key) => {
+    return key in context ? context[key] : Types.Ref(key);
+};
+// ------------------------------------------------------------------
+// ExportModifier
+// ------------------------------------------------------------------
+// prettier-ignore
+const ExportModifierMapping = (values) => {
+    return values.length === 1;
+};
+// prettier-ignore
+const ExportModifier = Runtime.Union([
+    Runtime.Tuple([Runtime.Const('export')]), Runtime.Tuple([])
+], ExportModifierMapping);
+// ------------------------------------------------------------------
+// TypeAliasDeclaration
+// ------------------------------------------------------------------
+// prettier-ignore
+const TypeAliasDeclarationMapping = (_Export, _Keyword, Ident, _Equals, Type) => {
+    return { [Ident]: Type };
+};
+// prettier-ignore
+const TypeAliasDeclaration = Runtime.Tuple([
+    Runtime.Ref('ExportModifier'),
+    Runtime.Const('type'),
+    Runtime.Ident(),
+    Runtime.Const(Equals),
+    Runtime.Ref('Type')
+], value => TypeAliasDeclarationMapping(...value));
+// ------------------------------------------------------------------
+// HeritageList
+// ------------------------------------------------------------------
+// prettier-ignore (note, heritage list should disallow trailing comma)
+const HeritageListDelimiter = Runtime.Union([Runtime.Tuple([Runtime.Const(Comma), Runtime.Const(Newline)]), Runtime.Tuple([Runtime.Const(Comma)])]);
+// prettier-ignore
+const HeritageListMapping = (values, context) => {
+    return (values.length === 3 ? [Deref(context, values[0]), ...values[2]] :
+        values.length === 1 ? [Deref(context, values[0])] :
+            []);
+};
+// prettier-ignore
+const HeritageList = Runtime.Union([
+    Runtime.Tuple([Runtime.Ident(), HeritageListDelimiter, Runtime.Ref('HeritageList')]),
+    Runtime.Tuple([Runtime.Ident()]),
+    Runtime.Tuple([])
+], HeritageListMapping);
+// ------------------------------------------------------------------
+// Heritage
+// ------------------------------------------------------------------
+// prettier-ignore
+const HeritageMapping = (values) => {
+    return (values.length === 2 ? values[1] : []);
+};
+// prettier-ignore
+const Heritage = Runtime.Union([
+    Runtime.Tuple([Runtime.Const('extends'), Runtime.Ref('HeritageList')]),
+    Runtime.Tuple([])
+], HeritageMapping);
+// ------------------------------------------------------------------
+// InterfaceDeclaration
+// ------------------------------------------------------------------
+// prettier-ignore
+const InterfaceDeclarationMapping = (_0, _1, Ident, Heritage, _4, Properties, _6) => {
+    return { [Ident]: Types.Intersect([...Heritage, Types.Object(Properties)]) };
+};
+// prettier-ignore
+const InterfaceDeclaration = Runtime.Tuple([
+    Runtime.Ref('ExportModifier'),
+    Runtime.Const('interface'),
+    Runtime.Ident(),
+    Runtime.Ref('Heritage'),
+    Runtime.Const(LBrace),
+    Runtime.Ref('Properties'),
+    Runtime.Const(RBrace),
+], values => InterfaceDeclarationMapping(...values));
+// ------------------------------------------------------------------
+// ModuleType
+// ------------------------------------------------------------------
+// prettier-ignore
+const ModuleType = Runtime.Union([
+    Runtime.Ref('InterfaceDeclaration'),
+    Runtime.Ref('TypeAliasDeclaration')
+]);
+// ------------------------------------------------------------------
+// ModuleProperties
+// ------------------------------------------------------------------
+// prettier-ignore
+const ModulePropertiesDelimiter = Runtime.Union([
+    Runtime.Tuple([Runtime.Const(SemiColon), Runtime.Const(Newline)]),
+    Runtime.Tuple([Runtime.Const(SemiColon)]),
+    Runtime.Tuple([Runtime.Const(Newline)]),
+]);
+// prettier-ignore
+const ModulePropertiesMapping = (values) => {
+    return (values.length === 3 ? { ...values[0], ...values[2] } :
+        values.length === 1 ? values[0] :
+            {});
+};
+// prettier-ignore
+const ModuleProperties = Runtime.Union([
+    Runtime.Tuple([Runtime.Ref('ModuleType'), ModulePropertiesDelimiter, Runtime.Ref('ModuleProperties')]),
+    Runtime.Tuple([Runtime.Ref('ModuleType')]),
+    Runtime.Tuple([]),
+], ModulePropertiesMapping);
+// ------------------------------------------------------------------
+// ModuleDeclaration
+// ------------------------------------------------------------------
+// prettier-ignore
+const ModuleIdentifier = Runtime.Union([
+    Runtime.Tuple([Runtime.Ident()]),
+    Runtime.Tuple([])
+]);
+// prettier-ignore
+const ModuleDeclarationMapping = (_1, _2, _Ident, _3, Properties, _5) => {
+    return Types.Module(Properties);
+};
+// prettier-ignore
+const ModuleDeclaration = Runtime.Tuple([
+    Runtime.Ref('ExportModifier'), Runtime.Const('module'), ModuleIdentifier, Runtime.Const(LBrace), Runtime.Ref('ModuleProperties'), Runtime.Const(RBrace)
+], values => ModuleDeclarationMapping(...values));
+// ------------------------------------------------------------------
 // Reference
 // ------------------------------------------------------------------
 // prettier-ignore
-const Reference = Runtime.Ident((value, context) => {
-    return value in context ? context[value] : Types.Ref(value);
-});
+const Reference = Runtime.Ident((value, context) => Deref(context, value));
 // ------------------------------------------------------------------
 // Literal
 // ------------------------------------------------------------------
@@ -157,7 +279,9 @@ const FactorExtends = (Type, Extends) => {
 // prettier-ignore
 const FactorIndexArray = (Type, IndexArray) => {
     const [Left, Right] = DestructureRight(IndexArray);
-    return (!Types.ValueGuard.IsUndefined(Right) ? (Right.length === 1 ? Types.Index(FactorIndexArray(Type, Left), Right[0]) :
+    return (!Types.ValueGuard.IsUndefined(Right) ? (
+    // note: Indexed types require reimplementation to replace `[number]` indexers
+    Right.length === 1 ? Types.Index(FactorIndexArray(Type, Left), Right[0]) :
         Right.length === 0 ? Types.Array(FactorIndexArray(Type, Left)) :
             Types.Never()) : Type);
 };
@@ -220,24 +344,21 @@ const Type = Runtime.Ref('Expr');
 // ------------------------------------------------------------------
 // Properties
 // ------------------------------------------------------------------
-// prettier-ignore
 const PropertyKey = Runtime.Union([Runtime.Ident(), Runtime.String([SingleQuote, DoubleQuote])]);
+const Readonly = Runtime.Union([Runtime.Tuple([Runtime.Const('readonly')]), Runtime.Tuple([])], (value) => value.length > 0);
+const Optional = Runtime.Union([Runtime.Tuple([Runtime.Const(Question)]), Runtime.Tuple([])], (value) => value.length > 0);
 // prettier-ignore
-const PropertyReadonly = Runtime.Union([Runtime.Tuple([Runtime.Const('readonly')]), Runtime.Tuple([])], value => value.length > 0);
-// prettier-ignore
-const PropertyOptional = Runtime.Union([Runtime.Tuple([Runtime.Const(Question)]), Runtime.Tuple([])], value => value.length > 0);
-// prettier-ignore
-const PropertyMapping = (Readonly, Key, Optional, _, Type) => ({
-    [Key]: (Readonly && Optional ? Types.ReadonlyOptional(Type) :
-        Readonly && !Optional ? Types.Readonly(Type) :
-            !Readonly && Optional ? Types.Optional(Type) :
+const PropertyMapping = (IsReadonly, Key, IsOptional, _, Type) => ({
+    [Key]: (IsReadonly && IsOptional ? Types.ReadonlyOptional(Type) :
+        IsReadonly && !IsOptional ? Types.Readonly(Type) :
+            !IsReadonly && IsOptional ? Types.Optional(Type) :
                 Type)
 });
 // prettier-ignore
 const Property = Runtime.Tuple([
-    Runtime.Ref('PropertyReadonly'),
+    Runtime.Ref('Readonly'),
     Runtime.Ref('PropertyKey'),
-    Runtime.Ref('PropertyOptional'),
+    Runtime.Ref('Optional'),
     Runtime.Const(Colon),
     Runtime.Ref('Type'),
 ], value => PropertyMapping(...value));
@@ -255,23 +376,21 @@ const Properties = Runtime.Union([
     Runtime.Tuple([Runtime.Ref('Property'), Runtime.Ref('PropertyDelimiter')]),
     Runtime.Tuple([Runtime.Ref('Property')]),
     Runtime.Tuple([])
-], values => (values.length === 3 ? [values[0], ...values[2]] :
-    values.length === 2 ? [values[0]] :
-        values.length === 1 ? [values[0]] :
-            []));
+], values => (values.length === 3 ? { ...values[0], ...values[2] } :
+    values.length === 2 ? values[0] :
+        values.length === 1 ? values[0] :
+            {}));
 // ------------------------------------------------------------------
 // Object
 // ------------------------------------------------------------------
 // prettier-ignore
-const ObjectMapping = (values) => Types.Object(values.reduce((properties, record) => {
-    return { ...properties, ...record };
-}, {}));
+const ObjectMapping = (_0, Properties, _2) => Types.Object(Properties);
 // prettier-ignore
 const _Object = Runtime.Tuple([
     Runtime.Const(LBrace),
     Runtime.Ref('Properties'),
     Runtime.Const(RBrace)
-], values => ObjectMapping(values[1]));
+], values => ObjectMapping(...values));
 // ------------------------------------------------------------------
 // Tuple
 // ------------------------------------------------------------------
@@ -340,7 +459,15 @@ const MappedMapping = (values) => {
 };
 // prettier-ignore
 const Mapped = Runtime.Tuple([
-    Runtime.Const(LBrace), Runtime.Const(LBracket), Runtime.Ident(), Runtime.Const('in'), Runtime.Ref('Type'), Runtime.Const(RBracket), Runtime.Const(Colon), Runtime.Ref('Type'), Runtime.Const(RBrace)
+    Runtime.Const(LBrace),
+    Runtime.Const(LBracket),
+    Runtime.Ident(),
+    Runtime.Const('in'),
+    Runtime.Ref('Type'),
+    Runtime.Const(RBracket),
+    Runtime.Const(Colon),
+    Runtime.Ref('Type'),
+    Runtime.Const(RBrace)
 ], MappedMapping);
 // ------------------------------------------------------------------
 // AsyncIterator
@@ -561,10 +688,34 @@ const Date = Runtime.Const('Date', Runtime.As(Types.Date()));
 // ------------------------------------------------------------------
 const Uint8Array = Runtime.Const('Uint8Array', Runtime.As(Types.Uint8Array()));
 // ------------------------------------------------------------------
+// Main
+// ------------------------------------------------------------------
+// prettier-ignore
+const Main = Runtime.Union([
+    ModuleDeclaration,
+    TypeAliasDeclaration,
+    InterfaceDeclaration,
+    Type
+]);
+// ------------------------------------------------------------------
 // Module
 // ------------------------------------------------------------------
 // prettier-ignore
 export const Module = new Runtime.Module({
+    // ----------------------------------------------------------------
+    // Modules, Interfaces and Type Aliases
+    // ----------------------------------------------------------------
+    ExportModifier,
+    HeritageList,
+    Heritage,
+    InterfaceDeclaration,
+    TypeAliasDeclaration,
+    ModuleType,
+    ModuleProperties,
+    ModuleDeclaration,
+    // ----------------------------------------------------------------
+    // Type Expressions
+    // ----------------------------------------------------------------
     Literal,
     Keyword,
     KeyOf,
@@ -576,10 +727,10 @@ export const Module = new Runtime.Module({
     ExprTerm,
     ExprTail,
     Expr,
-    Type,
+    Type, // Alias for Expr
     PropertyKey,
-    PropertyReadonly,
-    PropertyOptional,
+    Readonly,
+    Optional,
     Property,
     PropertyDelimiter,
     Properties,
@@ -613,5 +764,9 @@ export const Module = new Runtime.Module({
     Uncapitalize,
     Date,
     Uint8Array,
-    Reference
+    Reference,
+    // ----------------------------------------------------------------
+    // Main
+    // ----------------------------------------------------------------
+    Main
 });