diff --git a/.eslintrc b/.eslintrc
index 24cca27..f9ee1d0 100644
--- a/.eslintrc
+++ b/.eslintrc
@@ -15,7 +15,6 @@
     "@typescript-eslint/no-unused-vars": "off",
     "import/no-anonymous-default-export": "off",
     "@typescript-eslint/prefer-ts-expect-error": "error",
-    "@typescript-eslint/ban-types": "error",
     "@typescript-eslint/explicit-module-boundary-types": [
       "error",
       { "allowArgumentsExplicitlyTypedAsAny": true }
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..f5c18e3
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Ronen Amiel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
\ No newline at end of file
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..ccb58b1
--- /dev/null
+++ b/README.md
@@ -0,0 +1,59 @@
+## 🐬 HypeScript
+
+> A simplified implementation of TypeScript's type-system written in TypeScript's own type-system
+
+### Introduction
+
+This is a simplified implementation of [TypeScript](https://github.com/microsoft/TypeScript)'s type-system that's written in [TypeScript](https://github.com/microsoft/TypeScript)'s type annotations. This means that it uses types only — with no runtime code whatsoever.
+
+You pass [TypeScript](https://github.com/microsoft/TypeScript) code as string to the `TypeCheck` generic and get possible type errors back (**[See the live demo]()**):
+
+```typescript
+import type { TypeCheck } from 'hypescript';
+
+type Errors = TypeCheck<`
+
+function foo(name: number) {
+  return name;
+}
+
+foo('not a number');
+
+`>;
+
+// Errors is now equal to the following type:
+type Expected = [
+  "7: Argument of type 'string' is not assignable to parameter of type 'number'."
+];
+```
+
+*☝ Please note that this project is meant to be used for fun and learning purposes and not for practical use.*
+
+### Try running the code
+
+See a live demo in your browser on the [TypeScript Playground]().
+
+Alternatively, install `hypescript` in your own project with `yarn` or `npm` ([TypeScript](https://github.com/microsoft/TypeScript) 4.7 or later is required):
+
+```
+yarn add hypescript
+```
+
+### Example showcase
+
+Some [TypeScript](https://github.com/microsoft/TypeScript) syntax and features haven't been implemented and won't work. Here's a list of examples (with browser demo links) for some capabilites:
+
+- [Calling a function with insufficient arguments]()
+- [Calling a function with wrong argument types]()
+- [Trying to access a variable that haven't been defined]()
+- [Accessing a property that doesn't exist on an object]()
+- [Trying to assign a value to a variable that doesn't match its type annotation]()
+- [Trying to access a variable that haven't been defined]()
+
+### Additional links
+
+- [TypeScripts Type System is Turing Complete](https://github.com/microsoft/TypeScript/issues/14833)
+- [Typing the Technical Interview in TypeScript](https://gal.hagever.com/posts/typing-the-technical-interview-in-typescript/)
+- [Functions and algorithms implemented purely with TypeScript's type system](https://github.com/ronami/meta-typing)
+- [A SQL database implemented purely in TypeScript type annotations](https://github.com/codemix/ts-sql)
+- [Collection of TypeScript type challenges with online judge](https://github.com/type-challenges/type-challenges)
diff --git a/TODO.md b/TODO.md
new file mode 100644
index 0000000..763f15b
--- /dev/null
+++ b/TODO.md
@@ -0,0 +1,4 @@
+### TODOs
+
+- Re-organize tests from a long list into reasonable groups
+- Add comments to explain the implementation
diff --git a/package.json b/package.json
index 13fa795..c1a2274 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,5 @@
 {
-  "name": "type-sys",
-  "private": true,
+  "name": "hypescript",
   "version": "0.0.0",
   "license": "MIT",
   "author": "Ronen Amiel",
@@ -22,7 +21,7 @@
     "eslint-plugin-react": "^7.30.1",
     "eslint-plugin-react-hooks": "^4.6.0",
     "prettier": "^2.7.1",
-    "typescript": "^4.7.4"
+    "typescript": "next"
   },
   "prettier": {
     "printWidth": 80,
@@ -30,4 +29,4 @@
     "singleQuote": true,
     "trailingComma": "all"
   }
-}
\ No newline at end of file
+}
diff --git a/src/ast.ts b/src/ast.ts
new file mode 100644
index 0000000..d4a0504
--- /dev/null
+++ b/src/ast.ts
@@ -0,0 +1,240 @@
+export type NodeData<StartLine extends number, EndLine extends number> = {
+  startLineNumber: StartLine;
+  endLineNumber: EndLine;
+};
+
+export type NullLiteral<Data extends NodeData<number, number>> = {
+  type: 'NullLiteral';
+  data: Data;
+};
+
+export type NumericLiteral<
+  Value extends string,
+  Data extends NodeData<number, number>,
+> = {
+  type: 'NumericLiteral';
+  value: Value;
+  data: Data;
+};
+
+export type BooleanLiteral<
+  Value extends boolean,
+  Data extends NodeData<number, number>,
+> = {
+  type: 'BooleanLiteral';
+  value: Value;
+  data: Data;
+};
+
+export type StringLiteral<
+  Value extends string,
+  Data extends NodeData<number, number>,
+> = {
+  type: 'StringLiteral';
+  value: Value;
+  data: Data;
+};
+
+export type ArrayExpression<
+  Elements extends Array<BaseNode<any>>,
+  Data extends NodeData<number, number>,
+> = {
+  type: 'ArrayExpression';
+  elements: Elements;
+  data: Data;
+};
+
+export type ObjectExpression<
+  Properties extends Array<ObjectProperty<any, any, any>>,
+  Data extends NodeData<number, number>,
+> = {
+  type: 'ObjectExpression';
+  properties: Properties;
+  data: Data;
+};
+
+export type ObjectProperty<
+  Key extends Identifier<any, any, any>,
+  Value extends BaseNode<any>,
+  Data extends NodeData<number, number>,
+> = {
+  type: 'ObjectProperty';
+  key: Key;
+  value: Value;
+  data: Data;
+};
+
+export type VariableDeclaration<
+  Declarations extends Array<VariableDeclarator<any, any, any>>,
+  Kind extends 'const' | 'let',
+  Data extends NodeData<number, number>,
+> = {
+  type: 'VariableDeclaration';
+  declarations: Declarations;
+  kind: Kind;
+  data: Data;
+};
+
+export type VariableDeclarator<
+  Id extends BaseNode<any>,
+  Init extends BaseNode<any>,
+  Data extends NodeData<number, number>,
+> = {
+  type: 'VariableDeclarator';
+  id: Id;
+  init: Init;
+  data: Data;
+};
+
+export type FunctionDeclaration<
+  Id extends Identifier<any, any, any>,
+  Params extends Array<BaseNode<any>>,
+  Body extends BaseNode<any>,
+  Data extends NodeData<number, number>,
+> = {
+  type: 'FunctionDeclaration';
+  id: Id;
+  params: Params;
+  body: Body;
+  data: Data;
+};
+
+export type Identifier<
+  Name extends string,
+  Annotation extends BaseNode<any> | null,
+  Data extends NodeData<number, number>,
+> = {
+  type: 'Identifier';
+  name: Name;
+  typeAnnotation: Annotation;
+  data: Data;
+};
+
+export type ExpressionStatement<
+  Expression extends BaseNode<any>,
+  Data extends NodeData<number, number>,
+> = {
+  type: 'ExpressionStatement';
+  expression: Expression;
+  data: Data;
+};
+
+export type CallExpression<
+  Callee extends BaseNode<any>,
+  Arguments extends Array<BaseNode<any>>,
+  Data extends NodeData<number, number>,
+> = {
+  type: 'CallExpression';
+  callee: Callee;
+  arguments: Arguments;
+  data: Data;
+};
+
+export type MemberExpression<
+  Object extends BaseNode<any>,
+  Property extends BaseNode<any>,
+  Computed extends boolean,
+  Data extends NodeData<number, number>,
+> = {
+  type: 'MemberExpression';
+  object: Object;
+  property: Property;
+  computed: Computed;
+  data: Data;
+};
+
+export type IfStatement<
+  Test extends BaseNode<any>,
+  Consequent extends BaseNode<any>,
+  Data extends NodeData<number, number>,
+> = {
+  type: 'IfStatement';
+  test: Test;
+  consequent: Consequent;
+  data: Data;
+  // alternate: A;
+};
+
+export type ReturnStatement<
+  Argument extends BaseNode<any> | null,
+  Data extends NodeData<number, number>,
+> = {
+  type: 'ReturnStatement';
+  argument: Argument;
+  data: Data;
+};
+
+export type BlockStatement<
+  Body extends Array<BaseNode<any>>,
+  Data extends NodeData<number, number>,
+> = {
+  type: 'BlockStatement';
+  body: Body;
+  data: Data;
+};
+
+export type TypeAnnotation<
+  Annotation extends BaseNode<any>,
+  Data extends NodeData<number, number>,
+> = {
+  type: 'TypeAnnotation';
+  typeAnnotation: Annotation;
+  data: Data;
+};
+
+export type StringTypeAnnotation<Data extends NodeData<number, number>> = {
+  type: 'StringTypeAnnotation';
+  data: Data;
+};
+
+export type NumberTypeAnnotation<Data extends NodeData<number, number>> = {
+  type: 'NumberTypeAnnotation';
+  data: Data;
+};
+
+export type NullLiteralTypeAnnotation<Data extends NodeData<number, number>> = {
+  type: 'NullLiteralTypeAnnotation';
+  data: Data;
+};
+
+export type BooleanTypeAnnotation<Data extends NodeData<number, number>> = {
+  type: 'BooleanTypeAnnotation';
+  data: Data;
+};
+
+export type GenericTypeAnnotation<I, Data extends NodeData<number, number>> = {
+  type: 'GenericTypeAnnotation';
+  id: I;
+  data: Data;
+};
+
+export type AnyTypeAnnotation<Data extends NodeData<number, number>> = {
+  type: 'AnyTypeAnnotation';
+  data: Data;
+};
+
+export type BaseNode<Data extends NodeData<number, number>> =
+  | NumericLiteral<any, Data>
+  | BooleanLiteral<any, Data>
+  | StringLiteral<any, Data>
+  | ArrayExpression<any, Data>
+  | ObjectExpression<any, Data>
+  | ObjectProperty<any, any, Data>
+  | VariableDeclaration<any, any, Data>
+  | VariableDeclarator<any, any, Data>
+  | FunctionDeclaration<any, any, any, Data>
+  | Identifier<any, any, Data>
+  | NullLiteral<Data>
+  | ExpressionStatement<any, Data>
+  | CallExpression<any, any, Data>
+  | MemberExpression<any, any, any, Data>
+  | IfStatement<any, any, Data>
+  | ReturnStatement<any, Data>
+  | BlockStatement<any, Data>
+  | TypeAnnotation<any, Data>
+  | StringTypeAnnotation<Data>
+  | NumberTypeAnnotation<Data>
+  | NullLiteralTypeAnnotation<Data>
+  | BooleanTypeAnnotation<Data>
+  | GenericTypeAnnotation<any, Data>
+  | AnyTypeAnnotation<Data>;
diff --git a/src/checker.ts b/src/checker.ts
new file mode 100644
index 0000000..2f7ae52
--- /dev/null
+++ b/src/checker.ts
@@ -0,0 +1,871 @@
+import type {
+  AnyTypeAnnotation,
+  ArrayExpression,
+  BlockStatement,
+  BooleanLiteral,
+  BooleanTypeAnnotation,
+  CallExpression,
+  ExpressionStatement,
+  FunctionDeclaration,
+  Identifier,
+  MemberExpression,
+  BaseNode,
+  NodeData,
+  NullLiteral,
+  NullLiteralTypeAnnotation,
+  NumberTypeAnnotation,
+  NumericLiteral,
+  ObjectExpression,
+  ObjectProperty,
+  ReturnStatement,
+  StringLiteral,
+  StringTypeAnnotation,
+  TypeAnnotation,
+  VariableDeclaration,
+  VariableDeclarator,
+  IfStatement,
+} from './ast';
+import type { TypeError } from './errors';
+import type { Serialize } from './serializer';
+import type {
+  AnyType,
+  ArrayType,
+  BooleanLiteralType,
+  BooleanType,
+  CallArgumentsType,
+  FunctionType,
+  NeverType,
+  NullType,
+  NumberLiteralType,
+  NumberType,
+  ObjectType,
+  StaticType,
+  StringLiteralType,
+  StringType,
+  UndefinedType,
+  UnionType,
+  UnknownType,
+  VoidType,
+} from './types';
+import type { Concat, Push, Tail, Unshift } from './utils/arrayUtils';
+import type { MergeWithOverride } from './utils/generalUtils';
+import type { StateType, TypeResult } from './utils/utilityTypes';
+
+export type Check<NodeList extends Array<BaseNode<any>>> = InferBlockStatement<
+  NodeList,
+  {}
+> extends TypeResult<any, any, infer Errors>
+  ? Errors
+  : never;
+
+type MergeFunctionTypes<
+  FunctionTypes extends Array<FunctionType<any, any>>,
+  ReturnType extends FunctionType<any, any>,
+> = FunctionTypes extends []
+  ? ReturnType
+  : FunctionTypes[0] extends FunctionType<infer Params, infer Return>
+  ? MergeFunctionTypes<
+      Tail<FunctionTypes>,
+      MergeFunctions<Params, Return, ReturnType>
+    >
+  : never;
+
+type MergeFunctions<
+  Params extends Array<[string, StaticType]>,
+  Return extends StaticType,
+  Function extends FunctionType<any, any>,
+> = Function extends FunctionType<infer OtherParams, infer OtherReturn>
+  ? MergeFunctionParams<Params, OtherParams> extends infer P
+    ? P extends Array<[string, StaticType]>
+      ? MergeTypes<Return, OtherReturn> extends infer ReturnType
+        ? ReturnType extends StaticType
+          ? FunctionType<P, ReturnType>
+          : never
+        : never
+      : never
+    : never
+  : never;
+
+type MergeFunctionParams<
+  ParamsA extends Array<[string, StaticType]>,
+  ParamsB extends Array<[string, StaticType]>,
+  Return extends Array<[string, StaticType]> = [],
+> = ParamsA extends []
+  ? ParamsB extends []
+    ? Return
+    : [...Return, ...ParamsB]
+  : ParamsB extends []
+  ? [...Return, ...ParamsA]
+  : MatchType<ParamsA[0][1], ParamsB[0][1]> extends true
+  ? MergeFunctionParams<Tail<ParamsA>, Tail<ParamsB>, Push<Return, ParamsB[0]>>
+  : MatchType<ParamsB[0][1], ParamsA[0][1]> extends true
+  ? MergeFunctionParams<Tail<ParamsA>, Tail<ParamsB>, Push<Return, ParamsA[0]>>
+  : MergeFunctionParams<
+      Tail<ParamsA>,
+      Tail<ParamsB>,
+      Push<Return, [ParamsA[0][0], NeverType]>
+    >;
+
+type MergeTypes<
+  TypeA extends StaticType,
+  TypeB extends StaticType,
+> = TypeA extends NeverType
+  ? TypeB
+  : TypeB extends NeverType
+  ? TypeA
+  : TypeA extends AnyType
+  ? AnyType
+  : TypeB extends AnyType
+  ? AnyType
+  : MatchType<TypeA, TypeB> extends true
+  ? TypeA
+  : MatchType<TypeB, TypeA> extends true
+  ? TypeB
+  : TypeA extends UnionType<infer UnionTypesA>
+  ? TypeB extends UnionType<infer UnionTypesB>
+    ? UnionType<[...UnionTypesA, ...UnionTypesB]>
+    : UnionType<[...UnionTypesA, TypeB]>
+  : TypeB extends UnionType<infer UnionTypesB>
+  ? UnionType<[...UnionTypesB, TypeA]>
+  : UnionType<[TypeA, TypeB]>;
+
+type InferBlockStatement<
+  NodeList extends Array<BaseNode<any>>,
+  State extends StateType,
+  Result extends StaticType = NeverType,
+  Errors extends Array<TypeError<any, any>> = [],
+> = NodeList extends []
+  ? MergeTypes<Result, VoidType> extends infer ReturnType
+    ? ReturnType extends StaticType
+      ? TypeResult<ReturnType, State, Errors>
+      : never
+    : never
+  : NodeList[0] extends ExpressionStatement<infer Expression, any>
+  ? InferExpression<Expression, State> extends TypeResult<
+      any,
+      infer ExpressionState,
+      infer ExpressionErrors
+    >
+    ? InferBlockStatement<
+        Tail<NodeList>,
+        ExpressionState,
+        Result,
+        Concat<Errors, ExpressionErrors>
+      >
+    : never
+  : NodeList[0] extends VariableDeclaration<
+      [
+        VariableDeclarator<
+          Identifier<
+            infer Name,
+            infer Annotation,
+            NodeData<infer StartLine, any>
+          >,
+          infer Init,
+          any
+        >,
+      ],
+      any,
+      any
+    >
+  ? InferVariableDeclaration<
+      Name,
+      Annotation,
+      Init,
+      State,
+      StartLine
+    > extends TypeResult<any, infer DeclarationState, infer DeclarationErrors>
+    ? InferBlockStatement<
+        Tail<NodeList>,
+        DeclarationState,
+        Result,
+        Concat<Errors, DeclarationErrors>
+      >
+    : never
+  : NodeList[0] extends FunctionDeclaration<
+      Identifier<infer Name, any, any>,
+      infer Params,
+      BlockStatement<infer Body, any>,
+      any
+    >
+  ? InferFunctionDeclaration<Name, Params, Body, State> extends TypeResult<
+      any,
+      infer DeclarationState,
+      infer DeclarationErrors
+    >
+    ? InferBlockStatement<
+        Tail<NodeList>,
+        DeclarationState,
+        Result,
+        Concat<Errors, DeclarationErrors>
+      >
+    : never
+  : NodeList[0] extends ReturnStatement<infer ReturnExpression, any>
+  ? InferReturnStatement<ReturnExpression, State> extends TypeResult<
+      infer ReturnValue,
+      infer ReturnState,
+      infer ReturnErrors
+    >
+    ? MergeTypes<Result, ReturnValue> extends infer ReturnType
+      ? ReturnType extends StaticType
+        ? TypeResult<ReturnType, ReturnState, Concat<Errors, ReturnErrors>>
+        : never
+      : never
+    : never
+  : NodeList[0] extends IfStatement<
+      infer Test,
+      BlockStatement<infer BlockBody, any>,
+      any
+    >
+  ? InferExpression<Test, State> extends TypeResult<
+      infer TestValue,
+      infer TestState,
+      infer TestErrors
+    >
+    ? InferBlockStatement<BlockBody, TestState> extends TypeResult<
+        infer IfStatementValue,
+        any,
+        infer IfStatementErrors
+      >
+      ? InferBlockStatement<
+          Tail<NodeList>,
+          TestState,
+          MergeTypes<Result, IfStatementValue> extends infer ReturnType
+            ? ReturnType extends StaticType
+              ? IfStatementValue extends VoidType
+                ? Result
+                : ReturnType
+              : never
+            : never,
+          [...Errors, ...TestErrors, ...IfStatementErrors]
+        >
+      : never
+    : never
+  : InferBlockStatement<Tail<NodeList>, State, Result, Errors>;
+
+type InferReturnStatement<
+  ReturnExpression extends BaseNode<any> | null,
+  State extends StateType,
+> = ReturnExpression extends BaseNode<any>
+  ? InferExpression<ReturnExpression, State> extends TypeResult<
+      infer ExpressionValue,
+      infer ExpressionState,
+      infer ExpressionErrors
+    >
+    ? TypeResult<
+        MapLiteralToType<ExpressionValue>,
+        ExpressionState,
+        ExpressionErrors
+      >
+    : never
+  : TypeResult<UndefinedType, State>;
+
+type MapAnnotationToType<AnnotationValue extends BaseNode<any>> =
+  AnnotationValue extends StringTypeAnnotation<any>
+    ? StringType
+    : AnnotationValue extends NumberTypeAnnotation<any>
+    ? NumberType
+    : AnnotationValue extends BooleanTypeAnnotation<any>
+    ? BooleanType
+    : AnnotationValue extends NullLiteralTypeAnnotation<any>
+    ? NullType
+    : AnnotationValue extends AnyTypeAnnotation<any>
+    ? AnyType
+    : UnknownType;
+
+type InferFunctionParams<
+  Params extends Array<BaseNode<any>>,
+  FunctionParams extends Array<[string, StaticType]> = [],
+  ParamsByName extends StateType = {},
+  Errors extends Array<TypeError<any, any>> = [],
+> = Params extends []
+  ? [FunctionParams, ParamsByName, Errors]
+  : Params[0] extends Identifier<
+      infer Name,
+      infer Annotation,
+      NodeData<infer LineNumber, any>
+    >
+  ? Annotation extends TypeAnnotation<infer AnnotationValue, any>
+    ? InferFunctionParamsHelper<
+        Params,
+        FunctionParams,
+        ParamsByName,
+        MapAnnotationToType<AnnotationValue>,
+        Name,
+        Errors
+      >
+    : InferFunctionParamsHelper<
+        Params,
+        FunctionParams,
+        ParamsByName,
+        AnyType,
+        Name,
+        Push<
+          Errors,
+          TypeError<
+            `Parameter '${Name}' implicitly has an 'any' type.`,
+            LineNumber
+          >
+        >
+      >
+  : never;
+
+type InferFunctionParamsHelper<
+  Params extends Array<BaseNode<any>>,
+  FunctionParams extends Array<[string, StaticType]>,
+  ParamsByName extends StateType,
+  Type extends StaticType,
+  Name extends string,
+  Errors extends Array<TypeError<any, any>>,
+> = InferFunctionParams<
+  Tail<Params>,
+  Push<FunctionParams, [Name, Type]>,
+  MergeWithOverride<ParamsByName, { [a in Name]: Type }>,
+  Errors
+>;
+
+type InferFunctionDeclaration<
+  Name extends string,
+  Params extends Array<BaseNode<any>>,
+  Body extends Array<BaseNode<any>>,
+  State extends StateType,
+> = InferFunctionParams<Params> extends [
+  infer FunctionParams,
+  infer ParamsByName,
+  infer Errors,
+]
+  ? FunctionParams extends Array<[string, StaticType]>
+    ? ParamsByName extends StateType
+      ? Errors extends Array<TypeError<any, any>>
+        ? InferBlockStatement<
+            Body,
+            MergeWithOverride<State, ParamsByName>
+          > extends TypeResult<
+            infer BlockStatementReturnType,
+            any,
+            infer BlockStatementErrors
+          >
+          ? TypeResult<
+              UndefinedType,
+              MergeWithOverride<
+                State,
+                {
+                  [a in Name]: FunctionType<
+                    FunctionParams,
+                    BlockStatementReturnType
+                  >;
+                }
+              >,
+              Concat<Errors, BlockStatementErrors>
+            >
+          : never
+        : never
+      : never
+    : never
+  : never;
+
+type MatchType<
+  TypeA extends StaticType,
+  TypeB extends StaticType,
+> = TypeA extends NeverType
+  ? false
+  : TypeB extends NeverType
+  ? false
+  : TypeA extends AnyType
+  ? true
+  : TypeB extends AnyType
+  ? true
+  : TypeA extends TypeB
+  ? TypeB extends TypeA
+    ? true
+    : false
+  : TypeA extends StringType
+  ? TypeB extends StringLiteralType<any>
+    ? true
+    : false
+  : TypeA extends BooleanType
+  ? TypeB extends BooleanLiteralType<any>
+    ? true
+    : false
+  : TypeA extends NumberType
+  ? TypeB extends NumberLiteralType<any>
+    ? true
+    : false
+  : TypeA extends UnionType<infer UnionTypesA>
+  ? TypeB extends UnionType<infer UnionTypesB>
+    ? UnionMatchUnion<UnionTypesA, UnionTypesB>
+    : TypeMatchUnion<UnionTypesA, TypeB>
+  : TypeB extends UnionType<infer UnionTypesB>
+  ? UnionMatchType<TypeA, UnionTypesB>
+  : false;
+
+type UnionMatchUnion<
+  UnionTypesA extends Array<StaticType>,
+  UnionTypesB extends Array<StaticType>,
+> = UnionTypesB extends []
+  ? true
+  : TypeMatchUnion<UnionTypesA, UnionTypesB[0]> extends true
+  ? UnionMatchUnion<UnionTypesA, Tail<UnionTypesB>>
+  : false;
+
+type TypeMatchUnion<
+  UnionTypes extends Array<StaticType>,
+  Type extends StaticType,
+> = UnionTypes extends []
+  ? false
+  : MatchType<UnionTypes[0], Type> extends true
+  ? true
+  : TypeMatchUnion<Tail<UnionTypes>, Type>;
+
+type UnionMatchType<
+  Type extends StaticType,
+  UnionTypes extends Array<StaticType>,
+> = UnionTypes extends []
+  ? true
+  : MatchType<Type, UnionTypes[0]> extends true
+  ? UnionMatchType<Type, Tail<UnionTypes>>
+  : false;
+
+type MatchTypeArrays<
+  ParamsType extends Array<[string, StaticType]>,
+  ArgumentsType extends Array<StaticType>,
+  StartLine extends number,
+> = ParamsType extends []
+  ? true
+  : MatchType<ParamsType[0][1], ArgumentsType[0]> extends true
+  ? MatchTypeArrays<Tail<ParamsType>, Tail<ArgumentsType>, StartLine>
+  : TypeError<
+      `Argument of type '${Serialize<
+        ArgumentsType[0]
+      >}' is not assignable to parameter of type '${Serialize<
+        ParamsType[0][1]
+      >}'.`,
+      StartLine
+    >;
+
+type InferVariableDeclaration<
+  Name extends string,
+  Annotation extends BaseNode<any> | null,
+  Init extends BaseNode<any>,
+  State extends StateType,
+  StartLine extends number,
+> = InferExpression<Init, State> extends TypeResult<
+  infer InitExpressionValue,
+  infer InitExpressionState,
+  infer InitExpressionErrors
+>
+  ? Annotation extends TypeAnnotation<infer AnnotationValue, any>
+    ? MapAnnotationToType<AnnotationValue> extends infer ExpectedType
+      ? ExpectedType extends StaticType
+        ? MatchType<ExpectedType, InitExpressionValue> extends true
+          ? TypeResult<
+              UndefinedType,
+              MergeWithOverride<
+                InitExpressionState,
+                { [a in Name]: ExpectedType }
+              >,
+              InitExpressionErrors
+            >
+          : TypeResult<
+              UndefinedType,
+              MergeWithOverride<
+                InitExpressionState,
+                { [a in Name]: ExpectedType }
+              >,
+              Push<
+                InitExpressionErrors,
+                TypeError<
+                  `Type '${Serialize<InitExpressionValue>}' is not assignable to type '${Serialize<ExpectedType>}'.`,
+                  StartLine
+                >
+              >
+            >
+        : never
+      : never
+    : TypeResult<
+        UndefinedType,
+        MergeWithOverride<State, { [a in Name]: InitExpressionValue }>,
+        InitExpressionErrors
+      >
+  : never;
+
+type InferExpression<
+  Node extends BaseNode<any>,
+  State extends StateType,
+> = Node extends StringLiteral<infer Value, any>
+  ? TypeResult<StringLiteralType<Value>, State>
+  : Node extends NumericLiteral<infer Value, any>
+  ? TypeResult<NumberLiteralType<Value>, State>
+  : Node extends NullLiteral<any>
+  ? TypeResult<NullType, State>
+  : Node extends BooleanLiteral<infer Value, any>
+  ? TypeResult<BooleanLiteralType<Value>, State>
+  : Node extends Identifier<infer Name, any, NodeData<infer StartLine, any>>
+  ? Name extends keyof State
+    ? TypeResult<State[Name], State>
+    : TypeResult<
+        AnyType,
+        State,
+        [TypeError<`Cannot find name '${Name}'.`, StartLine>]
+      >
+  : Node extends ObjectExpression<infer Properties, any>
+  ? InferObjectProperties<Properties, State>
+  : Node extends MemberExpression<
+      infer Object,
+      infer Property,
+      infer Computed,
+      any
+    >
+  ? InferMemberExpression<Object, Property, Computed, State>
+  : Node extends ArrayExpression<infer Elements, any>
+  ? InferArrayElements<Elements, State>
+  : Node extends CallExpression<
+      infer Callee,
+      infer Arguments,
+      NodeData<infer StartLine, any>
+    >
+  ? InferCallExpression<Callee, Arguments, State, StartLine>
+  : UnknownType;
+
+type InferCallExpression<
+  Callee extends BaseNode<any>,
+  Arguments extends Array<BaseNode<any>>,
+  State extends StateType,
+  StartLine extends number,
+> = InferExpression<Callee, State> extends TypeResult<
+  infer CalleeValue,
+  infer CalleeState,
+  infer CalleeErrors
+>
+  ? InferExpressionsArray<Arguments, CalleeState> extends TypeResult<
+      CallArgumentsType<infer ArgumentsType>,
+      infer ArgumentsState,
+      infer ArgumentsErrors
+    >
+    ? InferCallExpressionHelper<
+        CalleeValue,
+        ArgumentsType,
+        ArgumentsState,
+        Concat<CalleeErrors, ArgumentsErrors>,
+        StartLine
+      >
+    : never
+  : never;
+
+type InferCallExpressionHelper<
+  CalleeValue extends StaticType,
+  ArgumentsType extends Array<StaticType>,
+  State extends StateType,
+  Errors extends Array<TypeError<any, any>>,
+  StartLine extends number,
+> = CalleeValue extends FunctionType<infer ParamsType, infer ReturnType>
+  ? ParamsType['length'] extends ArgumentsType['length']
+    ? MatchTypeArrays<ParamsType, ArgumentsType, StartLine> extends TypeError<
+        infer Message,
+        infer StartLine
+      >
+      ? TypeResult<
+          ReturnType,
+          State,
+          Push<Errors, TypeError<Message, StartLine>>
+        >
+      : TypeResult<ReturnType, State, Errors>
+    : TypeResult<
+        ReturnType,
+        State,
+        Push<
+          Errors,
+          TypeError<
+            `Expected ${ParamsType['length']} arguments, but got ${ArgumentsType['length']}.`,
+            StartLine
+          >
+        >
+      >
+  : CalleeValue extends AnyType
+  ? TypeResult<AnyType, State, Errors>
+  : CalleeValue extends UnionType<infer UnionTypes>
+  ? InferCallExpressionUnionHelper<
+      CalleeValue,
+      UnionTypes,
+      ArgumentsType,
+      State,
+      StartLine,
+      Errors
+    >
+  : TypeResult<
+      AnyType,
+      State,
+      Unshift<
+        Errors,
+        TypeError<
+          `This expression is not callable. Type '${Serialize<CalleeValue>}' has no call signatures.`,
+          StartLine
+        >
+      >
+    >;
+
+type InferCallExpressionUnionHelper<
+  CalleeValue extends UnionType<any>,
+  UnionTypes extends Array<StaticType>,
+  ArgumentsType extends Array<StaticType>,
+  State extends StateType,
+  StartLine extends number,
+  Errors extends Array<TypeError<any, any>>,
+> = UnionTypes extends Array<FunctionType<any, any>>
+  ? InferCallExpressionHelper<
+      MergeFunctionTypes<Tail<UnionTypes>, UnionTypes[0]>,
+      ArgumentsType,
+      State,
+      Errors,
+      StartLine
+    >
+  : TypeResult<
+      AnyType,
+      State,
+      Push<
+        Errors,
+        TypeError<
+          `This expression is not callable. Not all constituents of type '${Serialize<CalleeValue>}' are callable.`,
+          StartLine
+        >
+      >
+    >;
+
+type InferExpressionsArray<
+  NodeList extends Array<BaseNode<any>>,
+  State extends StateType,
+  Result extends Array<StaticType> = [],
+  Errors extends Array<TypeError<any, any>> = [],
+> = NodeList extends []
+  ? TypeResult<CallArgumentsType<Result>, State, Errors>
+  : InferExpression<NodeList[0], State> extends TypeResult<
+      infer ExpressionValue,
+      infer ExpressionState,
+      infer ExpressionErrors
+    >
+  ? InferExpressionsArray<
+      Tail<NodeList>,
+      MergeWithOverride<State, ExpressionState>,
+      Push<Result, ExpressionValue>,
+      Concat<Errors, ExpressionErrors>
+    >
+  : never;
+
+type InferArrayElements<
+  Elements extends Array<BaseNode<any>>,
+  State extends StateType,
+  First extends boolean = true,
+  Result extends StaticType = AnyType,
+  Errors extends Array<TypeError<any, any>> = [],
+> = Elements extends []
+  ? TypeResult<ArrayType<Result>, State, Errors>
+  : Elements[0] extends BaseNode<any>
+  ? InferExpression<Elements[0], State> extends TypeResult<
+      infer ExpressionValue,
+      infer ExpressionState,
+      infer ExpressionErrors
+    >
+    ? MapLiteralToType<ExpressionValue> extends infer LiteralType
+      ? LiteralType extends StaticType
+        ? MergeTypes<Result, LiteralType> extends infer ReturnType
+          ? ReturnType extends StaticType
+            ? InferArrayElements<
+                Tail<Elements>,
+                ExpressionState,
+                false,
+                First extends true ? LiteralType : ReturnType,
+                Concat<Errors, ExpressionErrors>
+              >
+            : never
+          : never
+        : never
+      : never
+    : never
+  : never;
+
+type MapLiteralToType<Type extends StaticType> =
+  Type extends NumberLiteralType<any>
+    ? NumberType
+    : Type extends StringLiteralType<any>
+    ? StringType
+    : Type extends BooleanLiteralType<any>
+    ? BooleanType
+    : Type extends ObjectType<infer Properties>
+    ? ObjectType<{
+        [P in keyof Properties]: Properties[P] extends [infer Key, infer Value]
+          ? Value extends StaticType
+            ? [Key, MapLiteralToType<Value>]
+            : never
+          : never;
+      }>
+    : Type;
+
+type InferMemberExpression<
+  Object extends BaseNode<any>,
+  Property extends BaseNode<any>,
+  Computed extends boolean,
+  State extends StateType,
+> = InferExpression<Object, State> extends TypeResult<
+  infer ObjectExpressionValue,
+  infer ObjectExpressionState,
+  infer ObjectExpressionErrors
+>
+  ? Computed extends false
+    ? Property extends Identifier<
+        infer Name,
+        any,
+        NodeData<infer StartLine, any>
+      >
+      ? InferMemberExpressionHelper<
+          ObjectExpressionValue,
+          Name,
+          ObjectExpressionState,
+          StartLine,
+          ObjectExpressionErrors
+        >
+      : never
+    : InferExpression<Property, ObjectExpressionState> extends TypeResult<
+        infer PropertyExpressionValue,
+        infer PropertyExpressionState,
+        infer PropertyExpressionErrors
+      >
+    ? Property extends BaseNode<NodeData<infer StartLine, any>>
+      ? PropertyExpressionValue extends StringLiteralType<infer Value>
+        ? InferMemberExpressionHelper<
+            ObjectExpressionValue,
+            Value,
+            PropertyExpressionState,
+            StartLine,
+            Concat<ObjectExpressionErrors, PropertyExpressionErrors>
+          >
+        : PropertyExpressionValue extends NumberLiteralType<infer Value>
+        ? InferMemberExpressionHelper<
+            ObjectExpressionValue,
+            Value,
+            PropertyExpressionState,
+            StartLine,
+            Concat<ObjectExpressionErrors, PropertyExpressionErrors>
+          >
+        : PropertyExpressionValue extends AnyType
+        ? TypeResult<
+            AnyType,
+            PropertyExpressionState,
+            Concat<ObjectExpressionErrors, PropertyExpressionErrors>
+          >
+        : TypeResult<
+            AnyType,
+            PropertyExpressionState,
+            Push<
+              Concat<ObjectExpressionErrors, PropertyExpressionErrors>,
+              TypeError<
+                `Type '${Serialize<PropertyExpressionValue>}' cannot be used as an index type.`,
+                StartLine
+              >
+            >
+          >
+      : never
+    : never
+  : never;
+
+type GetObjectValueByKey<
+  ObjectProperties extends Array<[string, StaticType]>,
+  Key extends string,
+> = ObjectProperties extends []
+  ? null
+  : ObjectProperties[0] extends [infer PropertyName, infer PropertyValue]
+  ? PropertyName extends Key
+    ? PropertyValue
+    : GetObjectValueByKey<Tail<ObjectProperties>, Key>
+  : never;
+
+type InferMemberExpressionHelper<
+  Object extends StaticType,
+  Key extends string,
+  State extends StateType,
+  StartLine extends number,
+  Errors extends Array<TypeError<any, any>>,
+> = Object extends ObjectType<infer ObjectProperties>
+  ? GetObjectValueByKey<
+      ObjectProperties,
+      Key
+    > extends infer MemberExpressionValue
+    ? MemberExpressionValue extends StaticType
+      ? TypeResult<MemberExpressionValue, State, Errors>
+      : TypeResult<
+          UndefinedType,
+          State,
+          Push<
+            Errors,
+            TypeError<
+              `Property '${Key}' does not exist on type '${Serialize<Object>}'.`,
+              StartLine
+            >
+          >
+        >
+    : never
+  : Object extends ArrayType<infer ElementsType>
+  ? TypeResult<ElementsType, State, Errors>
+  : Object extends UnionType<infer UnionTypes>
+  ? InferMemberExpressionUnionHelper<UnionTypes, Key, State, StartLine, Errors>
+  : Object extends AnyType
+  ? TypeResult<AnyType, State, Errors>
+  : TypeError<
+      `Property '${Key}' does not exist on type '${Serialize<Object>}'.`,
+      StartLine
+    >;
+
+type InferMemberExpressionUnionHelper<
+  UnionTypes extends Array<StaticType>,
+  Key extends string,
+  State extends StateType,
+  StartLine extends number,
+  Errors extends Array<TypeError<any, any>>,
+  Result extends Array<any> = [],
+> = UnionTypes extends []
+  ? TypeResult<UnionType<Result>, State, Errors>
+  : InferMemberExpressionHelper<
+      UnionTypes[0],
+      Key,
+      State,
+      StartLine,
+      []
+    > extends TypeResult<
+      infer ExpressionValue,
+      infer ExpressionState,
+      infer ExpressionErrors
+    >
+  ? InferMemberExpressionUnionHelper<
+      Tail<UnionTypes>,
+      Key,
+      ExpressionState,
+      StartLine,
+      Errors,
+      Push<Result, ExpressionValue>
+    >
+  : never;
+
+type InferObjectProperties<
+  Properties extends Array<ObjectProperty<any, any, any>>,
+  State extends StateType,
+  Result extends Array<any> = [],
+  Errors extends Array<TypeError<any, any>> = [],
+> = Properties extends []
+  ? TypeResult<ObjectType<Result>, State, Errors>
+  : Properties[0] extends ObjectProperty<
+      Identifier<infer Name, any, any>,
+      infer Value,
+      any
+    >
+  ? InferExpression<Value, State> extends TypeResult<
+      infer ExpressionValue,
+      infer ExpressionState,
+      infer ExpressionErrors
+    >
+    ? InferObjectProperties<
+        Tail<Properties>,
+        ExpressionState,
+        Push<Result, [Name, MapLiteralToType<ExpressionValue>]>,
+        Concat<Errors, ExpressionErrors>
+      >
+    : never
+  : never;
diff --git a/src/dataTypes.ts b/src/dataTypes.ts
deleted file mode 100644
index eee1119..0000000
--- a/src/dataTypes.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-// Tokenizer types
-export type ParenToken<V> = { type: 'paren'; value: V };
-
-export type NumberToken<V> = { type: 'number'; value: V };
-
-export type StringToken<V> = { type: 'string'; value: V };
-
-export type SymbolToken<V> = { type: 'symbol'; value: V };
-
-export type Token<V> =
-  | ParenToken<V>
-  | NumberToken<V>
-  | StringToken<V>
-  | SymbolToken<V>;
diff --git a/src/errors.ts b/src/errors.ts
new file mode 100644
index 0000000..1573463
--- /dev/null
+++ b/src/errors.ts
@@ -0,0 +1,22 @@
+export type Error<Message extends string, LineNumber extends number> =
+  | SyntaxError<Message, LineNumber>
+  | ParsingError<Message, LineNumber>
+  | TypeError<Message, LineNumber>;
+
+export type SyntaxError<Message extends string, LineNumber extends number> = {
+  type: 'SyntaxError';
+  message: Message;
+  lineNumber: LineNumber;
+};
+
+export type ParsingError<Message extends string, LineNumber extends number> = {
+  type: 'ParsingError';
+  message: Message;
+  lineNumber: LineNumber;
+};
+
+export type TypeError<Message extends string, LineNumber extends number> = {
+  type: 'TypeError';
+  message: Message;
+  lineNumber: LineNumber;
+};
diff --git a/src/example.ts b/src/example.ts
new file mode 100644
index 0000000..d231cab
--- /dev/null
+++ b/src/example.ts
@@ -0,0 +1,16 @@
+// import type { TypeCheck } from '.';
+import type { Tokenize } from './tokenizer';
+import type { Parse } from './parser';
+import type { Check } from './checker';
+// import type { Format } from './formatter';
+// import type { Error } from './errors';
+// import type { Token } from './tokens';
+// import type { BaseNode } from './ast';
+
+type T = Tokenize<`
+
+[111, 222]
+
+`>;
+type P = Parse<T>;
+// type C = Check<P>;
diff --git a/src/formatter.ts b/src/formatter.ts
new file mode 100644
index 0000000..7642be3
--- /dev/null
+++ b/src/formatter.ts
@@ -0,0 +1,11 @@
+import type { Error } from './errors';
+import type { Push, Tail } from './utils/arrayUtils';
+
+export type Format<
+  Errors extends Array<Error<any, any>>,
+  Result extends Array<string> = [],
+> = Errors extends []
+  ? Result
+  : Errors[0] extends Error<infer Message, infer LineNumber>
+  ? Format<Tail<Errors>, Push<Result, `${LineNumber}: ${Message}`>>
+  : never;
diff --git a/src/index.ts b/src/index.ts
index 60d1c59..a5f9ba0 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,64 +1,22 @@
-import type { Reverse, Unshift } from './utils/arrayUtils';
-import type {
-  EatFirstChar,
-  FirstChar,
-  ConcatStrings,
-} from './utils/stringUtils';
-import type { Numbers, Symbols } from './utils/generalUtils';
-import type { Token } from './dataTypes';
+import type { Tokenize } from './tokenizer';
+import type { Parse } from './parser';
+import type { Check } from './checker';
+import type { Format } from './formatter';
+import type { Error } from './errors';
+import type { Token } from './tokens';
+import type { BaseNode } from './ast';
 
-type TokenizeInput<I extends string> = FirstChar<I> extends ' ' | '\n'
-  ? ['', EatFirstChar<I>]
-  : FirstChar<I> extends '('
-  ? [
-      {
-        type: 'paren';
-        value: '(';
-      },
-      EatFirstChar<I>,
-    ]
-  : FirstChar<I> extends ')'
-  ? [
-      {
-        type: 'paren';
-        value: ')';
-      },
-      EatFirstChar<I>,
-    ]
-  : FirstChar<I> extends Numbers
-  ? TokenizeNumber<I, '', FirstChar<I>>
-  : FirstChar<I> extends '"'
-  ? TokenizeString<EatFirstChar<I>>
-  : FirstChar<I> extends Symbols
-  ? TokenizeSymbol<I, '', FirstChar<I>>
-  : never;
-
-type TokenizeNumber<
-  I extends string,
-  A extends string = '',
-  C extends string = FirstChar<I>,
-> = C extends Numbers
-  ? TokenizeNumber<EatFirstChar<I>, ConcatStrings<A, C>>
-  : [{ type: 'number'; value: A }, I];
-
-type TokenizeString<I extends string> = I extends `${infer H}"${infer G}`
-  ? [{ type: 'string'; value: H }, G]
-  : never;
-
-type TokenizeSymbol<
-  I extends string,
-  A extends string = '',
-  C extends string = FirstChar<I>,
-> = C extends Symbols
-  ? TokenizeSymbol<EatFirstChar<I>, ConcatStrings<A, C>>
-  : [{ type: 'symbol'; value: A }, I];
-
-export type TokenizeSequence<
-  I extends string,
-  R extends Array<Token<any>> = [],
-  P extends [any, string] = TokenizeInput<I>,
-> = I extends ''
-  ? R
-  : TokenizeSequence<P[1], P[0] extends '' ? R : Unshift<R, P[0]>>;
-
-export type Tokenize<I extends string> = Reverse<TokenizeSequence<I>>;
+export type TypeCheck<Input extends string> =
+  Tokenize<Input> extends infer TokenList
+    ? TokenList extends Error<any, any>
+      ? Format<[TokenList]>
+      : TokenList extends Array<Token<any>>
+      ? Parse<TokenList> extends infer NodeList
+        ? NodeList extends Error<any, any>
+          ? Format<[NodeList]>
+          : NodeList extends Array<BaseNode<any>>
+          ? Format<Check<NodeList>>
+          : never
+        : never
+      : never
+    : never;
diff --git a/src/parser.ts b/src/parser.ts
new file mode 100644
index 0000000..f94a710
--- /dev/null
+++ b/src/parser.ts
@@ -0,0 +1,842 @@
+import type {
+  ArrayExpression,
+  BooleanLiteral,
+  NumericLiteral,
+  ObjectExpression,
+  StringLiteral,
+  ObjectProperty,
+  VariableDeclaration,
+  VariableDeclarator,
+  FunctionDeclaration,
+  Identifier,
+  NullLiteral,
+  ExpressionStatement,
+  CallExpression,
+  MemberExpression,
+  IfStatement,
+  ReturnStatement,
+  BlockStatement,
+  TypeAnnotation,
+  GenericTypeAnnotation,
+  StringTypeAnnotation,
+  BooleanTypeAnnotation,
+  NullLiteralTypeAnnotation,
+  NumberTypeAnnotation,
+  AnyTypeAnnotation,
+  NodeData,
+  BaseNode,
+} from './ast';
+import type { ParsingError } from './errors';
+import type {
+  GenericToken,
+  NumberToken,
+  StringToken,
+  SymbolToken,
+  Token,
+  TokenData,
+} from './tokens';
+import type { Push, Tail, TailBy } from './utils/arrayUtils';
+import type {
+  ParseArrayResult,
+  ParseError,
+  ParseErrorResult,
+  ParseResult,
+} from './utils/utilityTypes';
+
+type ParseIdentifier<
+  TokenList extends Array<Token<any>>,
+  CanBeAnnotated extends boolean,
+> = TokenList[0] extends SymbolToken<
+  infer Name,
+  TokenData<any, infer IdentifierLineNumber>
+>
+  ? CanBeAnnotated extends true
+    ? TokenList[1] extends GenericToken<
+        ':',
+        TokenData<any, infer ColonLineNumber>
+      >
+      ? ParseTypeAnnotation<TailBy<TokenList, 2>> extends ParseResult<
+          infer Node,
+          infer TokenList,
+          infer Error
+        >
+        ? Error extends ParsingError<any, any>
+          ? ParseError<Error>
+          : ParseResult<
+              Identifier<
+                Name,
+                Node,
+                NodeData<IdentifierLineNumber, IdentifierLineNumber>
+              >,
+              TokenList
+            >
+        : ParseErrorResult<'Type expected.', ColonLineNumber>
+      : ParseResult<
+          Identifier<
+            Name,
+            null,
+            NodeData<IdentifierLineNumber, IdentifierLineNumber>
+          >,
+          Tail<TokenList>
+        >
+    : ParseResult<
+        Identifier<
+          Name,
+          null,
+          NodeData<IdentifierLineNumber, IdentifierLineNumber>
+        >,
+        Tail<TokenList>
+      >
+  : null;
+
+type ParseVariableDeclarationHelper<
+  TokenList extends Array<Token<any>>,
+  Id extends BaseNode<any>,
+  KindLineNumber extends number,
+  IdentifierLineNumber extends number,
+  EqualsLineNumber extends number,
+> = ParseExpression<Tail<TokenList>> extends ParseResult<
+  infer Node,
+  infer TokenList,
+  infer Error
+>
+  ? Error extends ParsingError<any, any>
+    ? ParseError<Error>
+    : ParseResult<
+        VariableDeclaration<
+          [
+            VariableDeclarator<
+              Id,
+              Node,
+              NodeData<IdentifierLineNumber, Node['data']['startLineNumber']>
+            >,
+          ],
+          'const',
+          NodeData<KindLineNumber, Node['data']['startLineNumber']>
+        >,
+        TokenList
+      >
+  : ParseErrorResult<'Expression expected.', EqualsLineNumber>;
+
+type ParseTypeAnnotation<TokenList extends Array<Token<any>>> =
+  TokenList[0] extends SymbolToken<'string', TokenData<any, infer LineNumber>>
+    ? ParseResult<
+        TypeAnnotation<
+          StringTypeAnnotation<NodeData<LineNumber, LineNumber>>,
+          NodeData<LineNumber, LineNumber>
+        >,
+        Tail<TokenList>
+      >
+    : TokenList[0] extends SymbolToken<
+        'boolean',
+        TokenData<any, infer LineNumber>
+      >
+    ? ParseResult<
+        TypeAnnotation<
+          BooleanTypeAnnotation<NodeData<LineNumber, LineNumber>>,
+          NodeData<LineNumber, LineNumber>
+        >,
+        Tail<TokenList>
+      >
+    : TokenList[0] extends SymbolToken<'null', TokenData<any, infer LineNumber>>
+    ? ParseResult<
+        TypeAnnotation<
+          NullLiteralTypeAnnotation<NodeData<LineNumber, LineNumber>>,
+          NodeData<LineNumber, LineNumber>
+        >,
+        Tail<TokenList>
+      >
+    : TokenList[0] extends SymbolToken<
+        'number',
+        TokenData<any, infer LineNumber>
+      >
+    ? ParseResult<
+        TypeAnnotation<
+          NumberTypeAnnotation<NodeData<LineNumber, LineNumber>>,
+          NodeData<LineNumber, LineNumber>
+        >,
+        Tail<TokenList>
+      >
+    : TokenList[0] extends SymbolToken<'any', TokenData<any, infer LineNumber>>
+    ? ParseResult<
+        TypeAnnotation<
+          AnyTypeAnnotation<NodeData<LineNumber, LineNumber>>,
+          NodeData<LineNumber, LineNumber>
+        >,
+        Tail<TokenList>
+      >
+    : TokenList[0] extends SymbolToken<
+        infer E,
+        TokenData<any, infer LineNumber>
+      >
+    ? ParseResult<
+        TypeAnnotation<
+          GenericTypeAnnotation<E, NodeData<LineNumber, LineNumber>>,
+          NodeData<LineNumber, LineNumber>
+        >,
+        Tail<TokenList>
+      >
+    : null;
+
+type ParseVariableDeclaration<TokenList extends Array<Token<any>>> =
+  TokenList[0] extends SymbolToken<
+    'const',
+    TokenData<any, infer KindLineNumber>
+  >
+    ? ParseIdentifier<Tail<TokenList>, true> extends ParseResult<
+        infer Node,
+        infer TokenList,
+        infer Error
+      >
+      ? Error extends ParsingError<any, any>
+        ? ParseError<Error>
+        : TokenList[0] extends GenericToken<
+            '=',
+            TokenData<any, infer EqualsLineNumber>
+          >
+        ? ParseVariableDeclarationHelper<
+            TokenList,
+            Node,
+            KindLineNumber,
+            Node['data']['startLineNumber'],
+            EqualsLineNumber
+          >
+        : ParseError<
+            ParsingError<
+              "'const' declarations must be initialized.",
+              Node['data']['startLineNumber']
+            >
+          >
+      : ParseError<
+          ParsingError<
+            'Variable declaration list cannot be empty.',
+            KindLineNumber
+          >
+        >
+    : null;
+
+type ParseMemberExpression<
+  Node extends BaseNode<NodeData<number, number>>,
+  TokenList extends Array<Token<any>>,
+> = TokenList[0] extends GenericToken<'.', TokenData<any, infer DotLineNumber>>
+  ? TokenList[1] extends SymbolToken<
+      infer Name,
+      TokenData<any, infer IdentifierLineNumber>
+    >
+    ? ParseResult<
+        MemberExpression<
+          Node,
+          Identifier<
+            Name,
+            null,
+            NodeData<IdentifierLineNumber, IdentifierLineNumber>
+          >,
+          false,
+          NodeData<Node['data']['startLineNumber'], IdentifierLineNumber>
+        >,
+        TailBy<TokenList, 2>
+      >
+    : ParseErrorResult<'Identifier expected.', DotLineNumber>
+  : TokenList[0] extends GenericToken<
+      '[',
+      TokenData<any, infer BracketLineNumber>
+    >
+  ? ParseExpression<Tail<TokenList>> extends ParseResult<
+      infer ExpressionNode,
+      infer ExpressionTokenList,
+      infer ExpressionError
+    >
+    ? ExpressionError extends ParsingError<any, any>
+      ? ParseError<ExpressionError>
+      : ExpressionTokenList[0] extends GenericToken<
+          ']',
+          TokenData<any, infer ClosingBracketLineNumber>
+        >
+      ? ParseResult<
+          MemberExpression<
+            Node,
+            ExpressionNode,
+            true,
+            NodeData<
+              ExpressionNode['data']['startLineNumber'],
+              ClosingBracketLineNumber
+            >
+          >,
+          Tail<ExpressionTokenList>
+        >
+      : ParseError<
+          ParsingError<
+            "']' expected.",
+            ExpressionNode['data']['startLineNumber']
+          >
+        >
+    : ParseErrorResult<'Expression expected.', BracketLineNumber>
+  : null;
+
+type ParseCallExpression<
+  Node extends BaseNode<NodeData<number, number>>,
+  TokenList extends Array<Token<any>>,
+> = TokenList[0] extends GenericToken<
+  '(',
+  TokenData<any, infer ParenLineNumber>
+>
+  ? ParseCallExpressionArguments<
+      Tail<TokenList>,
+      ParenLineNumber,
+      ')'
+    > extends ParseArrayResult<infer NodeList, infer TokenList, infer Error>
+    ? Error extends ParsingError<any, any>
+      ? ParseError<Error>
+      : ParseResult<
+          CallExpression<
+            Node,
+            NodeList,
+            NodeData<
+              Node['data']['startLineNumber'],
+              TokenList[0]['data']['lineNumber']
+            >
+          >,
+          Tail<TokenList>
+        >
+    : null
+  : null;
+
+type ParseCallExpressionArguments<
+  TokenList extends Array<Token<any>>,
+  ParenLineNumber extends number,
+  ClosingString extends string,
+  NeedComma extends boolean = false,
+  Result extends Array<BaseNode<any>> = [],
+> = TokenList[0] extends GenericToken<ClosingString, any>
+  ? ParseArrayResult<Result, TokenList>
+  : TokenList extends []
+  ? ParseErrorResult<`'${ClosingString}' expected.`, ParenLineNumber>
+  : NeedComma extends true
+  ? TokenList[0] extends GenericToken<',', any>
+    ? ParseCallExpressionArgumentsHelper<
+        Tail<TokenList>,
+        ParenLineNumber,
+        ClosingString,
+        Result
+      >
+    : TokenList[0] extends Token<TokenData<any, infer LineNumber>>
+    ? ParseErrorResult<"',' expected.", LineNumber>
+    : never
+  : ParseCallExpressionArgumentsHelper<
+      TokenList,
+      ParenLineNumber,
+      ClosingString,
+      Result
+    >;
+
+type ParseCallExpressionArgumentsHelper<
+  TokenList extends Array<Token<any>>,
+  ParenLineNumber extends number,
+  ClosingString extends string,
+  Result extends Array<BaseNode<any>> = [],
+> = ParseExpression<TokenList> extends ParseResult<
+  infer Node,
+  infer TokenList,
+  infer Error
+>
+  ? Error extends ParsingError<any, any>
+    ? ParseError<Error>
+    : ParseCallExpressionArguments<
+        TokenList,
+        ParenLineNumber,
+        ClosingString,
+        true,
+        Push<Result, Node>
+      >
+  : null;
+
+type CheckExpression<
+  Node extends BaseNode<any>,
+  TokenList extends Array<Token<any>>,
+> = ParseMemberExpression<Node, TokenList> extends ParseResult<
+  infer Node,
+  infer TokenList,
+  infer Error
+>
+  ? Error extends ParsingError<any, any>
+    ? ParseError<Error>
+    : CheckExpression<Node, TokenList>
+  : ParseCallExpression<Node, TokenList> extends ParseResult<
+      infer Node,
+      infer TokenList,
+      infer Error
+    >
+  ? Error extends ParsingError<any, any>
+    ? ParseError<Error>
+    : CheckExpression<Node, TokenList>
+  : ParseResult<Node, TokenList>;
+
+type ParseExpression<TokenList extends Array<Token<any>>> =
+  ParseExpressionHelper<TokenList, Tail<TokenList>> extends ParseResult<
+    infer Node,
+    infer TokenList,
+    infer Error
+  >
+    ? Error extends ParsingError<any, any>
+      ? ParseError<Error>
+      : CheckExpression<Node, TokenList>
+    : null;
+
+type TokenToNodeData<InputToken extends Token<any>> = InputToken extends Token<
+  TokenData<any, infer LineNumber>
+>
+  ? NodeData<LineNumber, LineNumber>
+  : never;
+
+type ParseExpressionHelper<
+  TokenList extends Array<Token<any>>,
+  TokenTail extends Array<Token<any>> = Tail<TokenList>,
+  Data extends NodeData<any, any> = TokenToNodeData<TokenList[0]>,
+> = TokenList[0] extends SymbolToken<'true', any>
+  ? ParseResult<BooleanLiteral<true, Data>, TokenTail>
+  : TokenList[0] extends SymbolToken<'false', any>
+  ? ParseResult<BooleanLiteral<false, Data>, TokenTail>
+  : TokenList[0] extends SymbolToken<'null', any>
+  ? ParseResult<NullLiteral<Data>, TokenTail>
+  : TokenList[0] extends NumberToken<infer Value, any>
+  ? ParseResult<NumericLiteral<Value, Data>, TokenTail>
+  : TokenList[0] extends StringToken<infer Value, any>
+  ? ParseResult<StringLiteral<Value, Data>, TokenTail>
+  : TokenList[0] extends SymbolToken<infer Value, any>
+  ? ParseResult<Identifier<Value, null, Data>, TokenTail>
+  : TokenList[0] extends GenericToken<'[', TokenData<any, infer LineNumber>>
+  ? ParseArrayExpression<Tail<TokenList>, LineNumber>
+  : TokenList[0] extends GenericToken<'{', TokenData<any, infer LineNumber>>
+  ? ParseObject<Tail<TokenList>, LineNumber>
+  : null;
+
+type ParseObject<
+  TokenList extends Array<Token<any>>,
+  InitialLineNumber extends number,
+  Result extends Array<ObjectProperty<any, any, any>> = [],
+  NeedComma extends boolean = false,
+> = TokenList[0] extends GenericToken<'}', TokenData<any, infer L>>
+  ? ParseResult<
+      ObjectExpression<Result, NodeData<InitialLineNumber, L>>,
+      Tail<TokenList>
+    >
+  : TokenList extends []
+  ? ParseErrorResult<"'}' expected.", InitialLineNumber>
+  : NeedComma extends true
+  ? TokenList[0] extends GenericToken<',', any>
+    ? ParseObjectItem<Tail<TokenList>, InitialLineNumber, Result>
+    : TokenList[0] extends Token<TokenData<any, infer L>>
+    ? ParseErrorResult<"',' expected.", L>
+    : never
+  : ParseObjectItem<TokenList, InitialLineNumber, Result>;
+
+type ParseObjectItem<
+  TokenList extends Array<Token<any>>,
+  InitialLineNumber extends number,
+  Result extends Array<ObjectProperty<any, any, any>> = [],
+> = TokenList[0] extends SymbolToken<
+  infer Name,
+  TokenData<any, infer NameLineNumber>
+>
+  ? TokenList[1] extends GenericToken<':', any>
+    ? ParseExpression<TailBy<TokenList, 2>> extends ParseResult<
+        infer Node,
+        infer TokenList,
+        infer Error
+      >
+      ? Error extends ParsingError<any, any>
+        ? ParseError<Error>
+        : ParseObject<
+            TokenList,
+            InitialLineNumber,
+            Push<
+              Result,
+              ObjectProperty<
+                Identifier<
+                  Name,
+                  null,
+                  NodeData<NameLineNumber, NameLineNumber>
+                >,
+                Node,
+                NodeData<NameLineNumber, Node['data']['endLineNumber']>
+              >
+            >,
+            true
+          >
+      : ParseErrorResult<'Expression expected.', InitialLineNumber>
+    : ParseErrorResult<"'}' expected.", InitialLineNumber>
+  : ParseErrorResult<"'}' expected.", InitialLineNumber>;
+
+type ParseArrayExpression<
+  TokenList extends Array<Token<any>>,
+  StartLineNumber extends number,
+> = ParseCallExpressionArguments<
+  TokenList,
+  StartLineNumber,
+  ']'
+> extends ParseArrayResult<infer NodeList, infer TokenList, infer Error>
+  ? Error extends ParsingError<any, any>
+    ? ParseError<Error>
+    : ParseResult<
+        ArrayExpression<
+          NodeList,
+          NodeData<StartLineNumber, TokenList[0]['data']['lineNumber']>
+        >,
+        Tail<TokenList>
+      >
+  : null;
+
+type ParseExpressionStatement<TokenList extends Array<Token<any>>> =
+  ParseExpression<TokenList> extends ParseResult<
+    infer Node,
+    infer TokenList,
+    infer Error
+  >
+    ? Error extends ParsingError<any, any>
+      ? ParseError<Error>
+      : ParseResult<ExpressionStatement<Node, Node['data']>, TokenList>
+    : null;
+
+type ParseFunctionDeclaration<TokenList extends Array<Token<any>>> =
+  TokenList[0] extends SymbolToken<
+    'function',
+    TokenData<any, infer FunctionLineNumber>
+  >
+    ? TokenList[1] extends SymbolToken<
+        infer Name,
+        TokenData<any, infer FunctionNameLineNumber>
+      >
+      ? TokenList[2] extends GenericToken<
+          '(',
+          TokenData<any, infer ParenLineNumber>
+        >
+        ? ParseFunctionParams<
+            TailBy<TokenList, 3>,
+            ParenLineNumber
+          > extends ParseArrayResult<
+            infer NodeList,
+            infer TokenList,
+            infer Error
+          >
+          ? Error extends ParsingError<any, any>
+            ? ParseError<Error>
+            : ParseBlockStatement<
+                Tail<TokenList>,
+                TokenList[0]['data']['lineNumber'],
+                true
+              > extends ParseResult<infer Node, infer TokenList, infer Error>
+            ? Error extends ParsingError<any, any>
+              ? ParseError<Error>
+              : ParseResult<
+                  FunctionDeclaration<
+                    Identifier<
+                      Name,
+                      null,
+                      NodeData<FunctionNameLineNumber, FunctionNameLineNumber>
+                    >,
+                    NodeList,
+                    Node,
+                    NodeData<FunctionLineNumber, Node['data']['endLineNumber']>
+                  >,
+                  TokenList
+                >
+            : never
+          : never
+        : ParseErrorResult<"'(' expected.", FunctionNameLineNumber>
+      : ParseErrorResult<'Identifier expected.', FunctionLineNumber>
+    : null;
+
+type ParseFunctionParams<
+  TokenList extends Array<Token<any>>,
+  InitialLineNumber extends number,
+  Result extends Array<BaseNode<NodeData<number, number>>> = [],
+  NeedSemicolon extends boolean = false,
+> = TokenList[0] extends GenericToken<
+  ')',
+  TokenData<any, infer ParenLineNumber>
+>
+  ? TokenList[1] extends GenericToken<'{', any>
+    ? ParseArrayResult<Result, Tail<TokenList>>
+    : ParseErrorResult<"'{' expected.", ParenLineNumber>
+  : TokenList extends []
+  ? ParseErrorResult<"')' expected.", InitialLineNumber>
+  : NeedSemicolon extends true
+  ? TokenList[0] extends GenericToken<',', any>
+    ? ParseFunctionParamsHelper<Tail<TokenList>, InitialLineNumber, Result>
+    : ParseError<
+        ParsingError<"',' expected.", Result[0]['data']['endLineNumber']>
+      >
+  : ParseFunctionParamsHelper<TokenList, InitialLineNumber, Result>;
+
+type ParseFunctionParamsHelper<
+  TokenList extends Array<Token<any>>,
+  LineNumber extends number,
+  Result extends Array<BaseNode<any>>,
+> = ParseIdentifier<TokenList, true> extends ParseResult<
+  infer Node,
+  infer TokenList,
+  infer Error
+>
+  ? Error extends ParsingError<any, any>
+    ? ParseError<Error>
+    : ParseFunctionParams<TokenList, LineNumber, Push<Result, Node>, true>
+  : ParseErrorResult<'Identifier expected.', LineNumber>;
+
+type ParseBlockStatement<
+  TokenList extends Array<Token<any>>,
+  InitialLineNumber extends number,
+  InFunctionScope extends boolean,
+  Result extends Array<BaseNode<any>> = [],
+  NeedSemicolon extends boolean = false,
+> = TokenList extends []
+  ? Result[0] extends BaseNode<NodeData<any, infer LineNumber>>
+    ? ParseErrorResult<"'}' expected.", LineNumber>
+    : ParseErrorResult<"'}' expected.", InitialLineNumber>
+  : TokenList[0] extends GenericToken<'}', TokenData<any, infer LineNumber>>
+  ? ParseResult<
+      BlockStatement<Result, NodeData<InitialLineNumber, LineNumber>>,
+      Tail<TokenList>
+    >
+  : TokenList[0] extends GenericToken<';', any>
+  ? ParseBlockStatement<
+      Tail<TokenList>,
+      InitialLineNumber,
+      InFunctionScope,
+      Result,
+      false
+    >
+  : NeedSemicolon extends false
+  ? ParseBlockStatementHelper<
+      TokenList,
+      InitialLineNumber,
+      InFunctionScope,
+      Result
+    >
+  : TokenList[0] extends Token<
+      TokenData<infer PrecedingLinebreak, infer LineNumber>
+    >
+  ? PrecedingLinebreak extends true
+    ? ParseBlockStatementHelper<TokenList, LineNumber, InFunctionScope, Result>
+    : ParseErrorResult<"';' expected.", LineNumber>
+  : never;
+
+type ParseTopLevel<
+  TokenList extends Array<Token<any>>,
+  Result extends Array<BaseNode<any>> = [],
+  NeedSemicolon extends boolean = false,
+> = TokenList extends []
+  ? ParseArrayResult<Result, TokenList>
+  : TokenList[0] extends GenericToken<';', any>
+  ? ParseTopLevel<Tail<TokenList>, Result, false>
+  : NeedSemicolon extends false
+  ? ParseTopLevelHelper<TokenList, Result>
+  : TokenList[0] extends Token<
+      TokenData<infer PrecedingLinebreak, infer LineNumber>
+    >
+  ? PrecedingLinebreak extends true
+    ? ParseTopLevelHelper<TokenList, Result>
+    : ParseErrorResult<"';' expected.", LineNumber>
+  : never;
+
+type ParseBlockStatementHelper<
+  TokenList extends Array<Token<any>>,
+  LineNumber extends number,
+  InFunctionScope extends boolean,
+  Result extends Array<BaseNode<any>>,
+> = ParseStatementHelper<TokenList, InFunctionScope> extends ParseResult<
+  infer Node,
+  infer TokenList,
+  infer Error,
+  infer Data
+>
+  ? Error extends ParsingError<any, any>
+    ? ParseError<Error>
+    : Data extends boolean
+    ? ParseBlockStatement<
+        TokenList,
+        LineNumber,
+        InFunctionScope,
+        Push<Result, Node>,
+        Data
+      >
+    : never
+  : never;
+
+type ParseTopLevelHelper<
+  TokenList extends Array<Token<any>>,
+  Result extends Array<BaseNode<any>>,
+> = ParseStatementHelper<TokenList, false> extends ParseResult<
+  infer Node,
+  infer TokenList,
+  infer Error,
+  infer Data
+>
+  ? Error extends ParsingError<any, any>
+    ? ParseError<Error>
+    : Data extends boolean
+    ? ParseTopLevel<TokenList, Push<Result, Node>, Data>
+    : never
+  : never;
+
+type ParseIfStatement<
+  TokenList extends Array<Token<any>>,
+  InFunctionScope extends boolean,
+> = TokenList[0] extends SymbolToken<'if', TokenData<any, infer IfLineNumber>>
+  ? TokenList[1] extends GenericToken<
+      '(',
+      TokenData<any, infer ParenLineNumber>
+    >
+    ? ParseExpression<TailBy<TokenList, 2>> extends ParseResult<
+        infer Node,
+        infer TokenList,
+        infer Error
+      >
+      ? Error extends ParsingError<any, any>
+        ? ParseError<Error>
+        : ParseIfStatementHelper<
+            Node,
+            TokenList,
+            IfLineNumber,
+            InFunctionScope,
+            Node['data']['endLineNumber']
+          >
+      : ParseErrorResult<'Expression expected.', ParenLineNumber>
+    : ParseErrorResult<"'(' expected.", IfLineNumber>
+  : null;
+
+type ParseReturnStatementHelper<
+  TokenList extends Array<Token<any>>,
+  StartLineNumber extends number,
+> = TokenList[0] extends GenericToken<
+  ';',
+  TokenData<any, infer SemicolonLineNumber>
+>
+  ? ParseResult<
+      ReturnStatement<null, NodeData<StartLineNumber, SemicolonLineNumber>>,
+      Tail<TokenList>
+    >
+  : ParseExpression<TokenList> extends ParseResult<
+      infer Node,
+      infer TokenList,
+      infer Error
+    >
+  ? Error extends ParsingError<any, any>
+    ? ParseError<Error>
+    : ParseResult<
+        ReturnStatement<
+          Node,
+          NodeData<StartLineNumber, Node['data']['endLineNumber']>
+        >,
+        TokenList
+      >
+  : never;
+
+type ParseReturnStatement<
+  TokenList extends Array<Token<any>>,
+  InFunctionScope extends boolean,
+> = TokenList[0] extends SymbolToken<'return', TokenData<any, infer LineNumber>>
+  ? InFunctionScope extends true
+    ? TokenList[1] extends Token<TokenData<infer PrecedingLinebreak, any>, any>
+      ? PrecedingLinebreak extends false
+        ? ParseReturnStatementHelper<Tail<TokenList>, LineNumber>
+        : ParseResult<
+            ReturnStatement<null, NodeData<LineNumber, LineNumber>>,
+            Tail<TokenList>
+          >
+      : ParseResult<ReturnStatement<null, NodeData<LineNumber, LineNumber>>, []>
+    : ParseError<
+        ParsingError<
+          "A 'return' statement can only be used within a function body.",
+          LineNumber
+        >
+      >
+  : null;
+
+type ParseIfStatementHelper<
+  Node extends BaseNode<any>,
+  TokenList extends Array<Token<any>>,
+  StartLineNumber extends number,
+  InFunctionScope extends boolean,
+  IfExpressionLineNumber extends number,
+> = TokenList[0] extends GenericToken<
+  ')',
+  TokenData<any, infer ClosingParenLineNumber>
+>
+  ? TokenList[1] extends GenericToken<
+      '{',
+      TokenData<any, infer CurlyLineNumber>
+    >
+    ? ParseBlockStatement<
+        TailBy<TokenList, 2>,
+        CurlyLineNumber,
+        InFunctionScope
+      > extends ParseResult<infer BlockNode, infer TokenList, infer Error>
+      ? Error extends ParsingError<any, any>
+        ? ParseError<Error>
+        : ParseResult<
+            IfStatement<
+              Node,
+              BlockNode,
+              NodeData<StartLineNumber, BlockNode['data']['endLineNumber']>
+            >,
+            TokenList
+          >
+      : never
+    : ParseErrorResult<"'{' expected.", ClosingParenLineNumber>
+  : ParseErrorResult<"')' expected.", IfExpressionLineNumber>;
+
+type ParseStatementHelper<
+  TokenList extends Array<Token<any>>,
+  InFunctionScope extends boolean,
+> = ParseFunctionDeclaration<TokenList> extends ParseResult<
+  infer Node,
+  infer TokenList,
+  infer Error
+>
+  ? Error extends ParsingError<any, any>
+    ? ParseError<Error>
+    : ParseResult<Node, TokenList, null, false>
+  : ParseVariableDeclaration<TokenList> extends ParseResult<
+      infer Node,
+      infer TokenList,
+      infer Error
+    >
+  ? Error extends ParsingError<any, any>
+    ? ParseError<Error>
+    : ParseResult<Node, TokenList, null, true>
+  : ParseIfStatement<TokenList, InFunctionScope> extends ParseResult<
+      infer Node,
+      infer TokenList,
+      infer Error
+    >
+  ? Error extends ParsingError<any, any>
+    ? ParseError<Error>
+    : ParseResult<Node, TokenList, null, false>
+  : ParseReturnStatement<TokenList, InFunctionScope> extends ParseResult<
+      infer Node,
+      infer TokenList,
+      infer Error
+    >
+  ? Error extends ParsingError<any, any>
+    ? ParseError<Error>
+    : ParseResult<Node, TokenList, null, true>
+  : ParseExpressionStatement<TokenList> extends ParseResult<
+      infer Node,
+      infer TokenList,
+      infer Error
+    >
+  ? Error extends ParsingError<any, any>
+    ? ParseError<Error>
+    : ParseResult<Node, TokenList, null, true>
+  : ParseErrorResult<'Declaration or statement expected.', 1>;
+
+export type Parse<TokenList extends Array<Token<any>>> =
+  ParseTopLevel<TokenList> extends ParseArrayResult<
+    infer NodeList,
+    infer TokenList,
+    infer Error
+  >
+    ? Error extends ParsingError<any, any>
+      ? Error
+      : NodeList
+    : never;
diff --git a/src/serializer.ts b/src/serializer.ts
new file mode 100644
index 0000000..3b0d9b1
--- /dev/null
+++ b/src/serializer.ts
@@ -0,0 +1,148 @@
+import type {
+  AnyType,
+  ArrayType,
+  BooleanLiteralType,
+  BooleanType,
+  FunctionType,
+  NeverType,
+  NullType,
+  NumberLiteralType,
+  NumberType,
+  ObjectType,
+  StaticType,
+  StringLiteralType,
+  StringType,
+  UndefinedType,
+  UnionType,
+  UnknownType,
+  VoidType,
+} from './types';
+import type { Tail } from './utils/arrayUtils';
+
+export type Serialize<Type extends StaticType> =
+  MapLiteralToType<Type> extends infer MappedType
+    ? MappedType extends StringType
+      ? 'string'
+      : MappedType extends BooleanType
+      ? 'boolean'
+      : MappedType extends NumberType
+      ? 'number'
+      : MappedType extends NullType
+      ? 'null'
+      : MappedType extends UndefinedType
+      ? 'undefined'
+      : MappedType extends VoidType
+      ? 'void'
+      : MappedType extends AnyType
+      ? 'any'
+      : MappedType extends UnknownType
+      ? 'unknown'
+      : MappedType extends NeverType
+      ? 'never'
+      : MappedType extends ArrayType<infer ElementsType>
+      ? SerializeArray<ElementsType>
+      : MappedType extends UnionType<infer UnionTypes>
+      ? SerializeUnion<UnionTypes>
+      : MappedType extends ObjectType<infer Properties>
+      ? SerializeObject<Properties>
+      : MappedType extends FunctionType<infer Params, infer Return>
+      ? SerializeFunction<Params, Return>
+      : never
+    : never;
+
+type SerializeFunction<
+  Params extends Array<[string, StaticType]>,
+  Return extends StaticType,
+> = SerializeFunctionParams<Params> extends infer SerializedParams
+  ? SerializedParams extends string
+    ? `(${SerializedParams}) => ${Serialize<Return>}`
+    : never
+  : never;
+
+type SerializeFunctionParams<
+  Params extends Array<[string, StaticType]>,
+  Result extends string = '',
+> = Params extends []
+  ? Result
+  : Params[0] extends [infer Key, infer Value]
+  ? Value extends StaticType
+    ? Key extends string
+      ? SerializeFunctionParams<
+          Tail<Params>,
+          `${Result}${Key}: ${Serialize<Value>}` extends infer SerializedSignature
+            ? SerializedSignature extends string
+              ? Params['length'] extends 1
+                ? `${SerializedSignature}`
+                : `${SerializedSignature}, `
+              : never
+            : never
+        >
+      : never
+    : never
+  : never;
+
+type MapLiteralToType<Type extends StaticType> =
+  Type extends NumberLiteralType<any>
+    ? NumberType
+    : Type extends StringLiteralType<any>
+    ? StringType
+    : Type extends BooleanLiteralType<any>
+    ? BooleanType
+    : Type;
+
+type ShouldUseParens<Type extends StaticType> = Type extends UnionType<any>
+  ? true
+  : Type extends FunctionType<any, any>
+  ? true
+  : false;
+
+type SerializeArray<ElementsType extends StaticType> =
+  Serialize<ElementsType> extends infer SerializedElements
+    ? SerializedElements extends string
+      ? ShouldUseParens<ElementsType> extends true
+        ? `(${SerializedElements})[]`
+        : `${SerializedElements}[]`
+      : never
+    : never;
+
+type SerializeUnion<
+  UnionTypes extends Array<StaticType>,
+  Result extends string = '',
+> = UnionTypes extends []
+  ? Result
+  : UnionTypes[0] extends StaticType
+  ? Serialize<UnionTypes[0]> extends infer SerializedType
+    ? SerializedType extends string
+      ? SerializeUnion<
+          Tail<UnionTypes>,
+          UnionTypes['length'] extends 1
+            ? `${Result}${SerializedType}`
+            : `${Result}${SerializedType} | `
+        >
+      : never
+    : never
+  : never;
+
+type SerializeObject<
+  Properties extends Array<[string, StaticType]>,
+  Result extends string = '',
+> = Properties extends []
+  ? Result extends ''
+    ? '{}'
+    : `{ ${Result} }`
+  : Properties[0] extends [infer Key, infer Value]
+  ? Value extends StaticType
+    ? Key extends string
+      ? `${Key}: ${Serialize<Value>}` extends infer SerializedProperty
+        ? SerializedProperty extends string
+          ? SerializeObject<
+              Tail<Properties>,
+              Properties['length'] extends 1
+                ? `${Result}${SerializedProperty};`
+                : `${Result}${SerializedProperty}; `
+            >
+          : never
+        : never
+      : never
+    : never
+  : never;
diff --git a/src/test/checker.test.ts b/src/test/checker.test.ts
new file mode 100644
index 0000000..8abc851
--- /dev/null
+++ b/src/test/checker.test.ts
@@ -0,0 +1,1127 @@
+import type { Tokenize } from '../tokenizer';
+import type { Parse } from '../parser';
+import type { Check } from '../checker';
+import { expectType } from './utils';
+
+type TypeCheck<T extends string> = Tokenize<T> extends infer G
+  ? G extends Array<any>
+    ? Parse<G> extends infer J
+      ? J extends Array<any>
+        ? Check<J>
+        : never
+      : never
+    : never
+  : never;
+
+expectType<
+  TypeCheck<`
+
+hello
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Cannot find name 'hello'.",
+    lineNumber: 3,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+world;
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Cannot find name 'world'.",
+    lineNumber: 3,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+"string"
+
+`>
+>([]);
+
+expectType<
+  TypeCheck<`
+
+123;
+
+`>
+>([]);
+
+expectType<
+  TypeCheck<`
+
+const a = null
+
+`>
+>([]);
+
+expectType<
+  TypeCheck<`
+
+const b = "world";
+
+`>
+>([]);
+
+expectType<
+  TypeCheck<`
+
+const hello = 1;
+hello;
+
+`>
+>([]);
+
+expectType<
+  TypeCheck<`
+
+const hello = { foo: "bar" };
+hello.world
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Property 'world' does not exist on type '{ foo: string; }'.",
+    lineNumber: 4,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+const hello = { foo: "bar" };
+hello.foo;
+
+`>
+>([]);
+
+expectType<
+  TypeCheck<`
+
+const hello = {
+  foo: {
+    bar: "bazz"
+  }
+};
+
+hello.foo.bar;
+
+`>
+>([]);
+
+expectType<
+  TypeCheck<`
+
+const hello = {
+  foo: {
+    bar: "bazz"
+  }
+};
+
+hello
+  .foo
+  .hey;
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Property 'hey' does not exist on type '{ bar: string; }'.",
+    lineNumber: 11,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+const hello = "world";
+
+hello.foo
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Property 'foo' does not exist on type 'string'.",
+    lineNumber: 5,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+const hello = "world";
+const foo = hello;
+
+`>
+>([]);
+
+expectType<
+  TypeCheck<`
+
+const hello = "world";
+const foo = hello;
+
+foo;
+
+`>
+>([]);
+
+expectType<
+  TypeCheck<`
+
+const hello: string = "hello";
+
+`>
+>([]);
+
+expectType<
+  TypeCheck<`
+
+const hello: number = 123;
+
+`>
+>([]);
+
+expectType<
+  TypeCheck<`
+
+const hello: number = "hello";
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Type 'string' is not assignable to type 'number'.",
+    lineNumber: 3,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+const hello: string = 123;
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Type 'number' is not assignable to type 'string'.",
+    lineNumber: 3,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+const hello = "world";
+const foo: number = hello;
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Type 'string' is not assignable to type 'number'.",
+    lineNumber: 4,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+const hello = "world";
+
+const foo: string = hello;
+
+`>
+>([]);
+
+expectType<
+  TypeCheck<`
+  
+const hello = {hey: "world"};
+
+const foo: number = hello;
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Type '{ hey: string; }' is not assignable to type 'number'.",
+    lineNumber: 5,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+  
+const hello = {hey: "world"};
+
+const foo: number = hello.hey;
+  
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Type 'string' is not assignable to type 'number'.",
+    lineNumber: 5,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+const hello = {hey: "world"};
+
+const foo: string = hello.hey;
+
+`>
+>([]);
+
+expectType<
+  TypeCheck<`
+
+const o = {};
+
+o["hey"];
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Property 'hey' does not exist on type '{}'.",
+    lineNumber: 5,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+const o = {hey: "ho"};
+
+o["hey"];
+
+`>
+>([]);
+
+expectType<
+  TypeCheck<`
+
+const o = {};
+const k = "hey";
+
+o
+ [k];
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Property 'hey' does not exist on type '{}'.",
+    lineNumber: 7,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+const o = {hey: "ho"};
+const k = "hey";
+
+o[k];
+
+`>
+>([]);
+
+expectType<
+  TypeCheck<`
+  
+const o = {
+  hey: {
+    ho:"let's go"
+  }
+};
+
+const k = "hey";
+
+o[k]["ho"];
+  
+`>
+>([]);
+
+expectType<
+  TypeCheck<`
+
+const o = {
+  hey: {
+    ho:"let's go"
+  }
+};
+
+const k = "hey";
+
+o[k]["hi"];
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Property 'hi' does not exist on type '{ ho: string; }'.",
+    lineNumber: 11,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+const o = {
+  hey: {
+    ho:"let's go"
+  }
+};
+
+const k = "hey";
+
+o[k][{}];
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Type '{}' cannot be used as an index type.",
+    lineNumber: 11,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+const o = {
+  hey: "ho:"
+};
+
+o[true];
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Type 'boolean' cannot be used as an index type.",
+    lineNumber: 7,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+const a = [1,2,3];
+
+const b: string = a;
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Type 'number[]' is not assignable to type 'string'.",
+    lineNumber: 5,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+const a = [1,2,'3'];
+
+const b: string = a;
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Type '(number | string)[]' is not assignable to type 'string'.",
+    lineNumber: 5,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+const c: any = 1;
+
+const a = [c, 2, '3'];
+
+const b: string = a;
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Type 'any[]' is not assignable to type 'string'.",
+    lineNumber: 7,
+  },
+]);
+expectType<
+  TypeCheck<`
+
+const a = [1,2,'3'][0];
+
+const b: string = a;
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Type 'number | string' is not assignable to type 'string'.",
+    lineNumber: 5,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+const a = [[1, 2]];
+
+const b: string = a;
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Type 'number[][]' is not assignable to type 'string'.",
+    lineNumber: 5,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+hello
+
+world
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Cannot find name 'hello'.",
+    lineNumber: 3,
+  },
+  {
+    type: 'TypeError',
+    message: "Cannot find name 'world'.",
+    lineNumber: 5,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+const a: number = hello
+
+const b: number = a
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Cannot find name 'hello'.",
+    lineNumber: 3,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+const a: string = hello
+
+const b: number = a
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Cannot find name 'hello'.",
+    lineNumber: 3,
+  },
+  {
+    type: 'TypeError',
+    message: "Type 'string' is not assignable to type 'number'.",
+    lineNumber: 5,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+const a: string = hello()
+
+const b: number = a
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Cannot find name 'hello'.",
+    lineNumber: 3,
+  },
+  {
+    type: 'TypeError',
+    message: "Type 'string' is not assignable to type 'number'.",
+    lineNumber: 5,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+const a: string = hello(foo, bar)
+
+const b: number = a
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Cannot find name 'hello'.",
+    lineNumber: 3,
+  },
+  {
+    type: 'TypeError',
+    message: "Cannot find name 'foo'.",
+    lineNumber: 3,
+  },
+  {
+    type: 'TypeError',
+    message: "Cannot find name 'bar'.",
+    lineNumber: 3,
+  },
+  {
+    type: 'TypeError',
+    message: "Type 'string' is not assignable to type 'number'.",
+    lineNumber: 5,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+function foo(a: string, b: number) {}
+
+foo(1, 'a')
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message:
+      "Argument of type 'number' is not assignable to parameter of type 'string'.",
+    lineNumber: 5,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+function foo(a: number) {
+  return 5
+}
+
+const a = foo('a', bar, bazz)
+
+const b: string = a;
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Cannot find name 'bar'.",
+    lineNumber: 7,
+  },
+  {
+    type: 'TypeError',
+    message: "Cannot find name 'bazz'.",
+    lineNumber: 7,
+  },
+  {
+    type: 'TypeError',
+    message: 'Expected 1 arguments, but got 3.',
+    lineNumber: 7,
+  },
+  {
+    type: 'TypeError',
+    message: "Type 'number' is not assignable to type 'string'.",
+    lineNumber: 9,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+function foo(a: number, b: boolean) {
+  return 5
+}
+
+const b: string = foo;
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message:
+      "Type '(a: number, b: boolean) => number' is not assignable to type 'string'.",
+    lineNumber: 7,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+function foo(a: number, b: boolean) {
+  return 5
+}
+
+const b: string = { hello: true, world: foo, hey: [1, {}] };
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message:
+      "Type '{ hello: boolean; world: (a: number, b: boolean) => number; hey: (number | {})[]; }' is not assignable to type 'string'.",
+    lineNumber: 7,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+function bar() {
+  if (a) {
+    return 2;
+  }
+
+  return 1;
+}
+
+const b: number = bar;
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Cannot find name 'a'.",
+    lineNumber: 4,
+  },
+  {
+    type: 'TypeError',
+    message: "Type '() => number' is not assignable to type 'number'.",
+    lineNumber: 11,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+function bar() {
+  if (a) {
+    return 'foo';
+  }
+
+  return 1;
+}
+
+const b: number = bar;
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Cannot find name 'a'.",
+    lineNumber: 4,
+  },
+  {
+    type: 'TypeError',
+    message: "Type '() => string | number' is not assignable to type 'number'.",
+    lineNumber: 11,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+function bar() {
+  return {
+    hello: 'world'
+  }
+}
+
+const b: number = bar;
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message:
+      "Type '() => { hello: string; }' is not assignable to type 'number'.",
+    lineNumber: 9,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+const a = [1, 'a'];
+const b = [true, null];
+const c = [a[1], b[0]];
+
+const num: number = c;
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message:
+      "Type '(number | string | boolean | null)[]' is not assignable to type 'number'.",
+    lineNumber: 7,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+function bar() {
+  if (a) {
+    return {
+      hello: 'world'
+      };
+  }
+
+  if (a) {
+    return {
+      hello: 123
+    };
+  }
+
+  return {
+    hello: '1'
+  };
+}
+
+const b: string = bar().hello;
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Cannot find name 'a'.",
+    lineNumber: 4,
+  },
+  {
+    type: 'TypeError',
+    message: "Cannot find name 'a'.",
+    lineNumber: 10,
+  },
+  {
+    type: 'TypeError',
+    message: "Type 'string | number' is not assignable to type 'string'.",
+    lineNumber: 21,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+function bar() {
+  if (a) {
+    return {
+      hello: 'world'
+      };
+  }
+
+  if (a) {
+    return {
+      hello: '123'
+    };
+  }
+
+  return {
+    hello: '1'
+  };
+}
+
+const b: string = bar().hello;
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Cannot find name 'a'.",
+    lineNumber: 4,
+  },
+  {
+    type: 'TypeError',
+    message: "Cannot find name 'a'.",
+    lineNumber: 10,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+function bar() {
+  if (a) {
+    return {
+      hello: 'world'
+    };
+  }
+
+  if (a) {
+    return {
+      foo: '123'
+    };
+  }
+
+  return {
+    hello: '1'
+  };
+}
+
+const b: string = bar().hello;
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Cannot find name 'a'.",
+    lineNumber: 4,
+  },
+  {
+    type: 'TypeError',
+    message: "Cannot find name 'a'.",
+    lineNumber: 10,
+  },
+  {
+    type: 'TypeError',
+    message: "Type 'string | undefined' is not assignable to type 'string'.",
+    lineNumber: 21,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+const c: any = 1
+
+const a = [1, c, 'a'];
+
+const b: string = a;
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Type 'any[]' is not assignable to type 'string'.",
+    lineNumber: 7,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+function foo(bar, hello) {
+  hey()
+}
+
+const a: number = foo;
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Parameter 'bar' implicitly has an 'any' type.",
+    lineNumber: 3,
+  },
+  {
+    type: 'TypeError',
+    message: "Parameter 'hello' implicitly has an 'any' type.",
+    lineNumber: 3,
+  },
+  {
+    type: 'TypeError',
+    message: "Cannot find name 'hey'.",
+    lineNumber: 4,
+  },
+  {
+    type: 'TypeError',
+    message:
+      "Type '(bar: any, hello: any) => void' is not assignable to type 'number'.",
+    lineNumber: 7,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+function a (a: number) {
+  return '1';
+}
+
+function b () {
+    return 1;
+}
+
+const c = [a, 'b'];
+
+const d: number = c[0](1);
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message:
+      "This expression is not callable. Not all constituents of type '(a: number) => string | string' are callable.",
+    lineNumber: 13,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+function a (a: number) {
+  return '1';
+}
+
+function b () {
+    return 1;
+}
+
+const c = [a, b];
+
+const d: number = c[0](1);
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Type 'number | string' is not assignable to type 'number'.",
+    lineNumber: 13,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+function a (a: number) {
+  return '1';
+}
+
+function b () {
+    return 1;
+}
+
+const c = [a, b];
+
+const d: number = c[0]();
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: 'Expected 1 arguments, but got 0.',
+    lineNumber: 13,
+  },
+  {
+    type: 'TypeError',
+    message: "Type 'number | string' is not assignable to type 'number'.",
+    lineNumber: 13,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+function a (a: number) {
+  return '1';
+}
+
+function b (b: string) {
+    return 1;
+}
+
+const c = [a, b];
+
+const d: number = c[0](1);
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message:
+      "Argument of type 'number' is not assignable to parameter of type 'never'.",
+    lineNumber: 13,
+  },
+  {
+    type: 'TypeError',
+    message: "Type 'number | string' is not assignable to type 'number'.",
+    lineNumber: 13,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+function a (a: number) {
+  return '1';
+}
+
+function b (b: any) {
+    return 1;
+}
+
+const c = [a, b];
+
+const d: number = c[0](1);
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Type 'number | string' is not assignable to type 'number'.",
+    lineNumber: 13,
+  },
+]);
+
+expectType<
+  TypeCheck<`
+
+function a (a: number, c: boolean) {
+  return '1';
+}
+
+function b (b: any) {
+    return 1;
+}
+
+const c = [a, b];
+
+const d: number = c[0](1, false);
+
+`>
+>([
+  {
+    type: 'TypeError',
+    message: "Type 'number | string' is not assignable to type 'number'.",
+    lineNumber: 13,
+  },
+]);
diff --git a/src/test/parser.test.ts b/src/test/parser.test.ts
new file mode 100644
index 0000000..1d10817
--- /dev/null
+++ b/src/test/parser.test.ts
@@ -0,0 +1,2836 @@
+import type { Tokenize } from '../tokenizer';
+import type { Parse } from '../parser';
+import { expectType } from './utils';
+
+type ParseAst<T extends string> = Tokenize<T> extends infer G
+  ? G extends Array<any>
+    ? Parse<G>
+    : never
+  : never;
+
+expectType<ParseAst<`hello`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'Identifier',
+      name: 'hello',
+      typeAnnotation: null,
+      data: { startLineNumber: 1, endLineNumber: 1 },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`"hello"`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'StringLiteral',
+      value: 'hello',
+      data: { startLineNumber: 1, endLineNumber: 1 },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`123`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'NumericLiteral',
+      value: '123',
+      data: { startLineNumber: 1, endLineNumber: 1 },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`true`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'BooleanLiteral',
+      value: true,
+      data: { startLineNumber: 1, endLineNumber: 1 },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`\nfalse`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'BooleanLiteral',
+      value: false,
+      data: { startLineNumber: 2, endLineNumber: 2 },
+    },
+    data: {
+      startLineNumber: 2,
+      endLineNumber: 2,
+    },
+  },
+]);
+
+expectType<ParseAst<`null`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'NullLiteral',
+      data: { startLineNumber: 1, endLineNumber: 1 },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`\n\nnull`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'NullLiteral',
+      data: { startLineNumber: 3, endLineNumber: 3 },
+    },
+    data: {
+      startLineNumber: 3,
+      endLineNumber: 3,
+    },
+  },
+]);
+
+expectType<ParseAst<`hello world`>>({
+  type: 'ParsingError',
+  message: "';' expected.",
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`hello "world"`>>({
+  type: 'ParsingError',
+  message: "';' expected.",
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`function foo () { hello "world" }`>>({
+  type: 'ParsingError',
+  message: "';' expected.",
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`hello\n "world"`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'Identifier',
+      name: 'hello',
+      typeAnnotation: null,
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'StringLiteral',
+      value: 'world',
+      data: {
+        startLineNumber: 2,
+        endLineNumber: 2,
+      },
+    },
+    data: {
+      startLineNumber: 2,
+      endLineNumber: 2,
+    },
+  },
+]);
+
+expectType<ParseAst<`hello; "world"`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'Identifier',
+      name: 'hello',
+      typeAnnotation: null,
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'StringLiteral',
+      value: 'world',
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`hello;;;"world"`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'Identifier',
+      name: 'hello',
+      typeAnnotation: null,
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'StringLiteral',
+      value: 'world',
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`hello  ; "world"`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'Identifier',
+      name: 'hello',
+      typeAnnotation: null,
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'StringLiteral',
+      value: 'world',
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`const hello = "world"`>>([
+  {
+    type: 'VariableDeclaration',
+    kind: 'const',
+    declarations: [
+      {
+        type: 'VariableDeclarator',
+        init: {
+          type: 'StringLiteral',
+          value: 'world',
+          data: { startLineNumber: 1, endLineNumber: 1 },
+        },
+        id: {
+          type: 'Identifier',
+          name: 'hello',
+          typeAnnotation: null,
+          data: { startLineNumber: 1, endLineNumber: 1 },
+        },
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+    ],
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`\nconst \nhello\n = \n123;`>>([
+  {
+    type: 'VariableDeclaration',
+    kind: 'const',
+    declarations: [
+      {
+        type: 'VariableDeclarator',
+        init: {
+          type: 'NumericLiteral',
+          value: '123',
+          data: { startLineNumber: 5, endLineNumber: 5 },
+        },
+        id: {
+          type: 'Identifier',
+          name: 'hello',
+          typeAnnotation: null,
+          data: { startLineNumber: 3, endLineNumber: 3 },
+        },
+        data: { startLineNumber: 3, endLineNumber: 5 },
+      },
+    ],
+    data: { startLineNumber: 2, endLineNumber: 5 },
+  },
+]);
+
+expectType<ParseAst<`const`>>({
+  type: 'ParsingError',
+  message: 'Variable declaration list cannot be empty.',
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`const hello`>>({
+  type: 'ParsingError',
+  message: "'const' declarations must be initialized.",
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`const hello =`>>({
+  type: 'ParsingError',
+  message: 'Expression expected.',
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`const hello \n = ;`>>({
+  type: 'ParsingError',
+  message: 'Expression expected.',
+  lineNumber: 2,
+});
+
+expectType<ParseAst<`const hello: `>>({
+  type: 'ParsingError',
+  message: 'Type expected.',
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`hello.`>>({
+  type: 'ParsingError',
+  message: 'Identifier expected.',
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`hello..world`>>({
+  type: 'ParsingError',
+  message: 'Identifier expected.',
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`\nhello."world"`>>({
+  type: 'ParsingError',
+  message: 'Identifier expected.',
+  lineNumber: 2,
+});
+
+expectType<ParseAst<`hello.world`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'MemberExpression',
+      object: {
+        type: 'Identifier',
+        name: 'hello',
+        typeAnnotation: null,
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+      property: {
+        type: 'Identifier',
+        name: 'world',
+        typeAnnotation: null,
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+      computed: false,
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`hello.world.foo`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'MemberExpression',
+      object: {
+        type: 'MemberExpression',
+        object: {
+          type: 'Identifier',
+          name: 'hello',
+          typeAnnotation: null,
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+        property: {
+          type: 'Identifier',
+          name: 'world',
+          typeAnnotation: null,
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+        computed: false,
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+      property: {
+        type: 'Identifier',
+        name: 'foo',
+        typeAnnotation: null,
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+      computed: false,
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`hello.\nworld.\nfoo`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'MemberExpression',
+      object: {
+        type: 'MemberExpression',
+        object: {
+          type: 'Identifier',
+          name: 'hello',
+          typeAnnotation: null,
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+        property: {
+          type: 'Identifier',
+          name: 'world',
+          typeAnnotation: null,
+          data: {
+            startLineNumber: 2,
+            endLineNumber: 2,
+          },
+        },
+        computed: false,
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 2,
+        },
+      },
+      property: {
+        type: 'Identifier',
+        name: 'foo',
+        typeAnnotation: null,
+        data: {
+          startLineNumber: 3,
+          endLineNumber: 3,
+        },
+      },
+      computed: false,
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 3,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 3,
+    },
+  },
+]);
+
+expectType<ParseAst<`hello.\nworld..foo`>>({
+  type: 'ParsingError',
+  message: 'Identifier expected.',
+  lineNumber: 2,
+});
+
+expectType<ParseAst<`hello.\nworld.`>>({
+  type: 'ParsingError',
+  message: 'Identifier expected.',
+  lineNumber: 2,
+});
+
+expectType<ParseAst<`const hello = foo.bar;`>>([
+  {
+    type: 'VariableDeclaration',
+    declarations: [
+      {
+        type: 'VariableDeclarator',
+        id: {
+          type: 'Identifier',
+          name: 'hello',
+          typeAnnotation: null,
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+        init: {
+          type: 'MemberExpression',
+          object: {
+            type: 'Identifier',
+            name: 'foo',
+            typeAnnotation: null,
+            data: {
+              startLineNumber: 1,
+              endLineNumber: 1,
+            },
+          },
+          property: {
+            type: 'Identifier',
+            name: 'bar',
+            typeAnnotation: null,
+            data: {
+              startLineNumber: 1,
+              endLineNumber: 1,
+            },
+          },
+          computed: false,
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+    ],
+    kind: 'const',
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`hello()`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'CallExpression',
+      callee: {
+        type: 'Identifier',
+        name: 'hello',
+        typeAnnotation: null,
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+      arguments: [],
+      data: { startLineNumber: 1, endLineNumber: 1 },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`\n\nhello(\n)`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'CallExpression',
+      callee: {
+        type: 'Identifier',
+        name: 'hello',
+        typeAnnotation: null,
+        data: {
+          startLineNumber: 3,
+          endLineNumber: 3,
+        },
+      },
+      arguments: [],
+      data: { startLineNumber: 3, endLineNumber: 4 },
+    },
+    data: {
+      startLineNumber: 3,
+      endLineNumber: 4,
+    },
+  },
+]);
+
+expectType<ParseAst<`hello(1)`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'CallExpression',
+      callee: {
+        type: 'Identifier',
+        name: 'hello',
+        typeAnnotation: null,
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+      arguments: [
+        {
+          type: 'NumericLiteral',
+          value: '1',
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+      ],
+      data: { startLineNumber: 1, endLineNumber: 1 },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`hello(1, "2")`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'CallExpression',
+      callee: {
+        type: 'Identifier',
+        name: 'hello',
+        typeAnnotation: null,
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+      arguments: [
+        {
+          type: 'NumericLiteral',
+          value: '1',
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+        {
+          type: 'StringLiteral',
+          value: '2',
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+      ],
+      data: { startLineNumber: 1, endLineNumber: 1 },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`hello(1,\n null\n, true)`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'CallExpression',
+      callee: {
+        type: 'Identifier',
+        name: 'hello',
+        typeAnnotation: null,
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+      arguments: [
+        {
+          type: 'NumericLiteral',
+          value: '1',
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+        {
+          type: 'NullLiteral',
+          data: {
+            startLineNumber: 2,
+            endLineNumber: 2,
+          },
+        },
+        {
+          type: 'BooleanLiteral',
+          value: true,
+          data: {
+            startLineNumber: 3,
+            endLineNumber: 3,
+          },
+        },
+      ],
+      data: { startLineNumber: 1, endLineNumber: 3 },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 3,
+    },
+  },
+]);
+
+expectType<ParseAst<`hello.world(1)`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'CallExpression',
+      callee: {
+        type: 'MemberExpression',
+        object: {
+          type: 'Identifier',
+          name: 'hello',
+          typeAnnotation: null,
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+        property: {
+          type: 'Identifier',
+          name: 'world',
+          typeAnnotation: null,
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+        computed: false,
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+      arguments: [
+        {
+          type: 'NumericLiteral',
+          value: '1',
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+      ],
+      data: { startLineNumber: 1, endLineNumber: 1 },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`hello.world(foo(1))`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'CallExpression',
+      callee: {
+        type: 'MemberExpression',
+        object: {
+          type: 'Identifier',
+          name: 'hello',
+          typeAnnotation: null,
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+        property: {
+          type: 'Identifier',
+          name: 'world',
+          typeAnnotation: null,
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+        computed: false,
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+      arguments: [
+        {
+          type: 'CallExpression',
+          callee: {
+            type: 'Identifier',
+            name: 'foo',
+            typeAnnotation: null,
+            data: {
+              startLineNumber: 1,
+              endLineNumber: 1,
+            },
+          },
+          arguments: [
+            {
+              type: 'NumericLiteral',
+              value: '1',
+              data: {
+                startLineNumber: 1,
+                endLineNumber: 1,
+              },
+            },
+          ],
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+      ],
+      data: { startLineNumber: 1, endLineNumber: 1 },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`foo(`>>({
+  type: 'ParsingError',
+  message: "')' expected.",
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`foo(1 2`>>({
+  type: 'ParsingError',
+  message: "',' expected.",
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`[\n1 2`>>({
+  type: 'ParsingError',
+  message: "',' expected.",
+  lineNumber: 2,
+});
+expectType<ParseAst<`[`>>({
+  type: 'ParsingError',
+  message: "']' expected.",
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`[1 2`>>({
+  type: 'ParsingError',
+  message: "',' expected.",
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`[\n1 2`>>({
+  type: 'ParsingError',
+  message: "',' expected.",
+  lineNumber: 2,
+});
+
+expectType<ParseAst<`[]`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'ArrayExpression',
+      elements: [],
+      data: { startLineNumber: 1, endLineNumber: 1 },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`[1]`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'ArrayExpression',
+      elements: [
+        {
+          type: 'NumericLiteral',
+          value: '1',
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+      ],
+      data: { startLineNumber: 1, endLineNumber: 1 },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`[\n1]`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'ArrayExpression',
+      elements: [
+        {
+          type: 'NumericLiteral',
+          value: '1',
+          data: {
+            startLineNumber: 2,
+            endLineNumber: 2,
+          },
+        },
+      ],
+      data: { startLineNumber: 1, endLineNumber: 2 },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 2,
+    },
+  },
+]);
+
+expectType<ParseAst<`[1, "hello"]`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'ArrayExpression',
+      elements: [
+        {
+          type: 'NumericLiteral',
+          value: '1',
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+        {
+          type: 'StringLiteral',
+          value: 'hello',
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+      ],
+      data: { startLineNumber: 1, endLineNumber: 1 },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`[1, [2]]`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'ArrayExpression',
+      elements: [
+        {
+          type: 'NumericLiteral',
+          value: '1',
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+        {
+          type: 'ArrayExpression',
+          elements: [
+            {
+              type: 'NumericLiteral',
+              value: '2',
+              data: {
+                startLineNumber: 1,
+                endLineNumber: 1,
+              },
+            },
+          ],
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+      ],
+      data: { startLineNumber: 1, endLineNumber: 1 },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`const array = [1]`>>([
+  {
+    type: 'VariableDeclaration',
+    declarations: [
+      {
+        type: 'VariableDeclarator',
+        id: {
+          type: 'Identifier',
+          name: 'array',
+          typeAnnotation: null,
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+        init: {
+          type: 'ArrayExpression',
+          elements: [
+            {
+              type: 'NumericLiteral',
+              value: '1',
+              data: {
+                startLineNumber: 1,
+                endLineNumber: 1,
+              },
+            },
+          ],
+          data: { startLineNumber: 1, endLineNumber: 1 },
+        },
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+    ],
+    kind: 'const',
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`{`>>({
+  type: 'ParsingError',
+  message: "'}' expected.",
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`{ hello`>>({
+  type: 'ParsingError',
+  message: "'}' expected.",
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`{hello world`>>({
+  type: 'ParsingError',
+  message: "'}' expected.",
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`{\n1 2`>>({
+  type: 'ParsingError',
+  message: "'}' expected.",
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`{}`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'ObjectExpression',
+      properties: [],
+      data: { startLineNumber: 1, endLineNumber: 1 },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`{hello: "world"}`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'ObjectExpression',
+      properties: [
+        {
+          type: 'ObjectProperty',
+          key: {
+            type: 'Identifier',
+            name: 'hello',
+            typeAnnotation: null,
+            data: {
+              startLineNumber: 1,
+              endLineNumber: 1,
+            },
+          },
+          value: {
+            type: 'StringLiteral',
+            value: 'world',
+            data: {
+              startLineNumber: 1,
+              endLineNumber: 1,
+            },
+          },
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+      ],
+      data: { startLineNumber: 1, endLineNumber: 1 },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`{hello\n:\n"world"\n}`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'ObjectExpression',
+      properties: [
+        {
+          type: 'ObjectProperty',
+          key: {
+            type: 'Identifier',
+            name: 'hello',
+            typeAnnotation: null,
+            data: {
+              startLineNumber: 1,
+              endLineNumber: 1,
+            },
+          },
+          value: {
+            type: 'StringLiteral',
+            value: 'world',
+            data: {
+              startLineNumber: 3,
+              endLineNumber: 3,
+            },
+          },
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 3,
+          },
+        },
+      ],
+      data: { startLineNumber: 1, endLineNumber: 4 },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 4,
+    },
+  },
+]);
+
+expectType<ParseAst<`{hello: "hello", foo: bar()}`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'ObjectExpression',
+      properties: [
+        {
+          type: 'ObjectProperty',
+          key: {
+            type: 'Identifier',
+            name: 'hello',
+            typeAnnotation: null,
+            data: {
+              startLineNumber: 1,
+              endLineNumber: 1,
+            },
+          },
+          value: {
+            type: 'StringLiteral',
+            value: 'hello',
+            data: {
+              startLineNumber: 1,
+              endLineNumber: 1,
+            },
+          },
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+        {
+          type: 'ObjectProperty',
+          key: {
+            type: 'Identifier',
+            name: 'foo',
+            typeAnnotation: null,
+            data: {
+              startLineNumber: 1,
+              endLineNumber: 1,
+            },
+          },
+          value: {
+            type: 'CallExpression',
+            callee: {
+              type: 'Identifier',
+              name: 'bar',
+              typeAnnotation: null,
+              data: {
+                startLineNumber: 1,
+                endLineNumber: 1,
+              },
+            },
+            arguments: [],
+            data: {
+              startLineNumber: 1,
+              endLineNumber: 1,
+            },
+          },
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+      ],
+      data: { startLineNumber: 1, endLineNumber: 1 },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`{hello: {}}`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'ObjectExpression',
+      properties: [
+        {
+          type: 'ObjectProperty',
+          key: {
+            type: 'Identifier',
+            name: 'hello',
+            typeAnnotation: null,
+            data: {
+              startLineNumber: 1,
+              endLineNumber: 1,
+            },
+          },
+          value: {
+            type: 'ObjectExpression',
+            properties: [],
+            data: {
+              startLineNumber: 1,
+              endLineNumber: 1,
+            },
+          },
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+      ],
+      data: { startLineNumber: 1, endLineNumber: 1 },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`const array = {hello: "world"}`>>([
+  {
+    type: 'VariableDeclaration',
+    declarations: [
+      {
+        type: 'VariableDeclarator',
+        id: {
+          type: 'Identifier',
+          name: 'array',
+          typeAnnotation: null,
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+        init: {
+          type: 'ObjectExpression',
+          properties: [
+            {
+              type: 'ObjectProperty',
+              key: {
+                type: 'Identifier',
+                name: 'hello',
+                typeAnnotation: null,
+                data: {
+                  startLineNumber: 1,
+                  endLineNumber: 1,
+                },
+              },
+              value: {
+                type: 'StringLiteral',
+                value: 'world',
+                data: {
+                  startLineNumber: 1,
+                  endLineNumber: 1,
+                },
+              },
+              data: {
+                startLineNumber: 1,
+                endLineNumber: 1,
+              },
+            },
+          ],
+          data: { startLineNumber: 1, endLineNumber: 1 },
+        },
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+    ],
+    kind: 'const',
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`function foo() {}`>>([
+  {
+    type: 'FunctionDeclaration',
+    id: {
+      type: 'Identifier',
+      name: 'foo',
+      typeAnnotation: null,
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    params: [],
+    body: {
+      type: 'BlockStatement',
+      body: [],
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`function foo(a) {}`>>([
+  {
+    type: 'FunctionDeclaration',
+    id: {
+      type: 'Identifier',
+      name: 'foo',
+      typeAnnotation: null,
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    params: [
+      {
+        type: 'Identifier',
+        name: 'a',
+        typeAnnotation: null,
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+    ],
+    body: {
+      type: 'BlockStatement',
+      body: [],
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`function foo(a, b) {}`>>([
+  {
+    type: 'FunctionDeclaration',
+    id: {
+      type: 'Identifier',
+      name: 'foo',
+      typeAnnotation: null,
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    params: [
+      {
+        type: 'Identifier',
+        name: 'a',
+        typeAnnotation: null,
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+      {
+        type: 'Identifier',
+        name: 'b',
+        typeAnnotation: null,
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+    ],
+    body: {
+      type: 'BlockStatement',
+      body: [],
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`function foo(a, b) { foo() }`>>([
+  {
+    type: 'FunctionDeclaration',
+    id: {
+      type: 'Identifier',
+      name: 'foo',
+      typeAnnotation: null,
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    params: [
+      {
+        type: 'Identifier',
+        name: 'a',
+        typeAnnotation: null,
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+      {
+        type: 'Identifier',
+        name: 'b',
+        typeAnnotation: null,
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+    ],
+    body: {
+      type: 'BlockStatement',
+      body: [
+        {
+          type: 'ExpressionStatement',
+          expression: {
+            type: 'CallExpression',
+            callee: {
+              type: 'Identifier',
+              name: 'foo',
+              typeAnnotation: null,
+              data: {
+                startLineNumber: 1,
+                endLineNumber: 1,
+              },
+            },
+            arguments: [],
+            data: {
+              startLineNumber: 1,
+              endLineNumber: 1,
+            },
+          },
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+      ],
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`function foo(a, b) { foo(); "bar"; }`>>([
+  {
+    type: 'FunctionDeclaration',
+    id: {
+      type: 'Identifier',
+      name: 'foo',
+      typeAnnotation: null,
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    params: [
+      {
+        type: 'Identifier',
+        name: 'a',
+        typeAnnotation: null,
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+      {
+        type: 'Identifier',
+        name: 'b',
+        typeAnnotation: null,
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+    ],
+    body: {
+      type: 'BlockStatement',
+      body: [
+        {
+          type: 'ExpressionStatement',
+          expression: {
+            type: 'CallExpression',
+            callee: {
+              type: 'Identifier',
+              name: 'foo',
+              typeAnnotation: null,
+              data: {
+                startLineNumber: 1,
+                endLineNumber: 1,
+              },
+            },
+            arguments: [],
+            data: {
+              startLineNumber: 1,
+              endLineNumber: 1,
+            },
+          },
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+        {
+          type: 'ExpressionStatement',
+          expression: {
+            type: 'StringLiteral',
+            value: 'bar',
+            data: {
+              startLineNumber: 1,
+              endLineNumber: 1,
+            },
+          },
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+      ],
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`function foo(a, b) { function bar() {} }`>>([
+  {
+    type: 'FunctionDeclaration',
+    id: {
+      type: 'Identifier',
+      name: 'foo',
+      typeAnnotation: null,
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    params: [
+      {
+        type: 'Identifier',
+        name: 'a',
+        typeAnnotation: null,
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+      {
+        type: 'Identifier',
+        name: 'b',
+        typeAnnotation: null,
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+    ],
+    body: {
+      type: 'BlockStatement',
+      body: [
+        {
+          type: 'FunctionDeclaration',
+          id: {
+            type: 'Identifier',
+            name: 'bar',
+            typeAnnotation: null,
+            data: {
+              startLineNumber: 1,
+              endLineNumber: 1,
+            },
+          },
+          body: {
+            type: 'BlockStatement',
+            body: [],
+            data: {
+              startLineNumber: 1,
+              endLineNumber: 1,
+            },
+          },
+          params: [],
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+      ],
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`function`>>({
+  type: 'ParsingError',
+  message: 'Identifier expected.',
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`function foo`>>({
+  type: 'ParsingError',
+  message: "'(' expected.",
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`function foo(`>>({
+  type: 'ParsingError',
+  message: "')' expected.",
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`function foo()`>>({
+  type: 'ParsingError',
+  message: "'{' expected.",
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`function foo()`>>({
+  type: 'ParsingError',
+  message: "'{' expected.",
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`function foo() {`>>({
+  type: 'ParsingError',
+  message: "'}' expected.",
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`function foo(a, ) {}`>>({
+  type: 'ParsingError',
+  message: 'Identifier expected.',
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`function foo(a b) {}`>>({
+  type: 'ParsingError',
+  message: "',' expected.",
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`}`>>({
+  type: 'ParsingError',
+  message: 'Declaration or statement expected.',
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`function foo(a, b) { } foo()`>>([
+  {
+    type: 'FunctionDeclaration',
+    id: {
+      type: 'Identifier',
+      name: 'foo',
+      typeAnnotation: null,
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    params: [
+      {
+        type: 'Identifier',
+        name: 'a',
+        typeAnnotation: null,
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+      {
+        type: 'Identifier',
+        name: 'b',
+        typeAnnotation: null,
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+    ],
+    body: {
+      type: 'BlockStatement',
+      body: [],
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'CallExpression',
+      callee: {
+        type: 'Identifier',
+        name: 'foo',
+        typeAnnotation: null,
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+      arguments: [],
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`function foo(a, b) {}; foo()`>>([
+  {
+    type: 'FunctionDeclaration',
+    id: {
+      type: 'Identifier',
+      name: 'foo',
+      typeAnnotation: null,
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    params: [
+      {
+        type: 'Identifier',
+        name: 'a',
+        typeAnnotation: null,
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+      {
+        type: 'Identifier',
+        name: 'b',
+        typeAnnotation: null,
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+    ],
+    body: {
+      type: 'BlockStatement',
+      body: [],
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'CallExpression',
+      callee: {
+        type: 'Identifier',
+        name: 'foo',
+        typeAnnotation: null,
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+      arguments: [],
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`if (a) {}`>>([
+  {
+    type: 'IfStatement',
+    test: {
+      type: 'Identifier',
+      name: 'a',
+      typeAnnotation: null,
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    consequent: {
+      type: 'BlockStatement',
+      body: [],
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`if (foo()) {}`>>([
+  {
+    type: 'IfStatement',
+    test: {
+      type: 'CallExpression',
+      callee: {
+        type: 'Identifier',
+        name: 'foo',
+        typeAnnotation: null,
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+      arguments: [],
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    consequent: {
+      type: 'BlockStatement',
+      body: [],
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`if (foo()) { bar(); }`>>([
+  {
+    type: 'IfStatement',
+    test: {
+      type: 'CallExpression',
+      callee: {
+        type: 'Identifier',
+        name: 'foo',
+        typeAnnotation: null,
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+      arguments: [],
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    consequent: {
+      type: 'BlockStatement',
+      body: [
+        {
+          type: 'ExpressionStatement',
+          expression: {
+            type: 'CallExpression',
+            callee: {
+              type: 'Identifier',
+              name: 'bar',
+              typeAnnotation: null,
+              data: {
+                startLineNumber: 1,
+                endLineNumber: 1,
+              },
+            },
+            arguments: [],
+            data: {
+              startLineNumber: 1,
+              endLineNumber: 1,
+            },
+          },
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+      ],
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`if (foo()) { bar(); } bazz()`>>([
+  {
+    type: 'IfStatement',
+    test: {
+      type: 'CallExpression',
+      callee: {
+        type: 'Identifier',
+        name: 'foo',
+        typeAnnotation: null,
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+      arguments: [],
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    consequent: {
+      type: 'BlockStatement',
+      body: [
+        {
+          type: 'ExpressionStatement',
+          expression: {
+            type: 'CallExpression',
+            callee: {
+              type: 'Identifier',
+              name: 'bar',
+              typeAnnotation: null,
+              data: {
+                startLineNumber: 1,
+                endLineNumber: 1,
+              },
+            },
+            arguments: [],
+            data: {
+              startLineNumber: 1,
+              endLineNumber: 1,
+            },
+          },
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+      ],
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'CallExpression',
+      callee: {
+        type: 'Identifier',
+        name: 'bazz',
+        typeAnnotation: null,
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+      arguments: [],
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`if`>>({
+  type: 'ParsingError',
+  message: "'(' expected.",
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`if (`>>({
+  type: 'ParsingError',
+  message: 'Expression expected.',
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`if ("foo"`>>({
+  type: 'ParsingError',
+  message: "')' expected.",
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`if (123)`>>({
+  type: 'ParsingError',
+  message: "'{' expected.",
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`if (true) {`>>({
+  type: 'ParsingError',
+  message: "'}' expected.",
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`if () {`>>({
+  type: 'ParsingError',
+  message: 'Expression expected.',
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`return 123`>>({
+  type: 'ParsingError',
+  message: "A 'return' statement can only be used within a function body.",
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`if (a) { return 123 }`>>({
+  type: 'ParsingError',
+  message: "A 'return' statement can only be used within a function body.",
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`return;`>>({
+  type: 'ParsingError',
+  message: "A 'return' statement can only be used within a function body.",
+  lineNumber: 1,
+});
+
+expectType<ParseAst<`function foo() { return 1 }`>>([
+  {
+    type: 'FunctionDeclaration',
+    id: {
+      type: 'Identifier',
+      name: 'foo',
+      typeAnnotation: null,
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    params: [],
+    body: {
+      type: 'BlockStatement',
+      body: [
+        {
+          type: 'ReturnStatement',
+          argument: {
+            type: 'NumericLiteral',
+            value: '1',
+            data: {
+              startLineNumber: 1,
+              endLineNumber: 1,
+            },
+          },
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+      ],
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`function foo() { return 1; }`>>([
+  {
+    type: 'FunctionDeclaration',
+    id: {
+      type: 'Identifier',
+      name: 'foo',
+      typeAnnotation: null,
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    params: [],
+    body: {
+      type: 'BlockStatement',
+      body: [
+        {
+          type: 'ReturnStatement',
+          argument: {
+            type: 'NumericLiteral',
+            value: '1',
+            data: {
+              startLineNumber: 1,
+              endLineNumber: 1,
+            },
+          },
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+      ],
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`function foo() { return; }`>>([
+  {
+    type: 'FunctionDeclaration',
+    id: {
+      type: 'Identifier',
+      name: 'foo',
+      typeAnnotation: null,
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    params: [],
+    body: {
+      type: 'BlockStatement',
+      body: [
+        {
+          type: 'ReturnStatement',
+          argument: null,
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+      ],
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`function foo() { \nreturn\n }`>>([
+  {
+    type: 'FunctionDeclaration',
+    id: {
+      type: 'Identifier',
+      name: 'foo',
+      typeAnnotation: null,
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    params: [],
+    body: {
+      type: 'BlockStatement',
+      body: [
+        {
+          type: 'ReturnStatement',
+          argument: null,
+          data: {
+            startLineNumber: 2,
+            endLineNumber: 2,
+          },
+        },
+      ],
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 3,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 3,
+    },
+  },
+]);
+
+expectType<ParseAst<`const hello: string = "world"`>>([
+  {
+    type: 'VariableDeclaration',
+    kind: 'const',
+    declarations: [
+      {
+        type: 'VariableDeclarator',
+        init: {
+          type: 'StringLiteral',
+          value: 'world',
+          data: { startLineNumber: 1, endLineNumber: 1 },
+        },
+        id: {
+          type: 'Identifier',
+          name: 'hello',
+          typeAnnotation: {
+            type: 'TypeAnnotation',
+            typeAnnotation: {
+              type: 'StringTypeAnnotation',
+              data: { startLineNumber: 1, endLineNumber: 1 },
+            },
+            data: { startLineNumber: 1, endLineNumber: 1 },
+          },
+          data: { startLineNumber: 1, endLineNumber: 1 },
+        },
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+    ],
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`const \nhello: \nnumber = \n"world"`>>([
+  {
+    type: 'VariableDeclaration',
+    kind: 'const',
+    declarations: [
+      {
+        type: 'VariableDeclarator',
+        init: {
+          type: 'StringLiteral',
+          value: 'world',
+          data: { startLineNumber: 4, endLineNumber: 4 },
+        },
+        id: {
+          type: 'Identifier',
+          name: 'hello',
+          typeAnnotation: {
+            type: 'TypeAnnotation',
+            typeAnnotation: {
+              type: 'NumberTypeAnnotation',
+              data: { startLineNumber: 3, endLineNumber: 3 },
+            },
+            data: { startLineNumber: 3, endLineNumber: 3 },
+          },
+          data: { startLineNumber: 2, endLineNumber: 2 },
+        },
+        data: {
+          startLineNumber: 2,
+          endLineNumber: 4,
+        },
+      },
+    ],
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 4,
+    },
+  },
+]);
+
+expectType<ParseAst<`const \nhello: \nnull = \n"world"`>>([
+  {
+    type: 'VariableDeclaration',
+    kind: 'const',
+    declarations: [
+      {
+        type: 'VariableDeclarator',
+        init: {
+          type: 'StringLiteral',
+          value: 'world',
+          data: { startLineNumber: 4, endLineNumber: 4 },
+        },
+        id: {
+          type: 'Identifier',
+          name: 'hello',
+          typeAnnotation: {
+            type: 'TypeAnnotation',
+            typeAnnotation: {
+              type: 'NullLiteralTypeAnnotation',
+              data: { startLineNumber: 3, endLineNumber: 3 },
+            },
+            data: { startLineNumber: 3, endLineNumber: 3 },
+          },
+          data: { startLineNumber: 2, endLineNumber: 2 },
+        },
+        data: {
+          startLineNumber: 2,
+          endLineNumber: 4,
+        },
+      },
+    ],
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 4,
+    },
+  },
+]);
+
+expectType<ParseAst<`const \nhello: \nboolean = \n"world"`>>([
+  {
+    type: 'VariableDeclaration',
+    kind: 'const',
+    declarations: [
+      {
+        type: 'VariableDeclarator',
+        init: {
+          type: 'StringLiteral',
+          value: 'world',
+          data: { startLineNumber: 4, endLineNumber: 4 },
+        },
+        id: {
+          type: 'Identifier',
+          name: 'hello',
+          typeAnnotation: {
+            type: 'TypeAnnotation',
+            typeAnnotation: {
+              type: 'BooleanTypeAnnotation',
+              data: { startLineNumber: 3, endLineNumber: 3 },
+            },
+            data: { startLineNumber: 3, endLineNumber: 3 },
+          },
+          data: { startLineNumber: 2, endLineNumber: 2 },
+        },
+        data: {
+          startLineNumber: 2,
+          endLineNumber: 4,
+        },
+      },
+    ],
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 4,
+    },
+  },
+]);
+
+expectType<ParseAst<`const \nhello: \nany = \n"world"`>>([
+  {
+    type: 'VariableDeclaration',
+    kind: 'const',
+    declarations: [
+      {
+        type: 'VariableDeclarator',
+        init: {
+          type: 'StringLiteral',
+          value: 'world',
+          data: { startLineNumber: 4, endLineNumber: 4 },
+        },
+        id: {
+          type: 'Identifier',
+          name: 'hello',
+          typeAnnotation: {
+            type: 'TypeAnnotation',
+            typeAnnotation: {
+              type: 'AnyTypeAnnotation',
+              data: { startLineNumber: 3, endLineNumber: 3 },
+            },
+            data: { startLineNumber: 3, endLineNumber: 3 },
+          },
+          data: { startLineNumber: 2, endLineNumber: 2 },
+        },
+        data: {
+          startLineNumber: 2,
+          endLineNumber: 4,
+        },
+      },
+    ],
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 4,
+    },
+  },
+]);
+
+expectType<ParseAst<`const \nhello: \nFoo = \n"world"`>>([
+  {
+    type: 'VariableDeclaration',
+    kind: 'const',
+    declarations: [
+      {
+        type: 'VariableDeclarator',
+        init: {
+          type: 'StringLiteral',
+          value: 'world',
+          data: { startLineNumber: 4, endLineNumber: 4 },
+        },
+        id: {
+          type: 'Identifier',
+          name: 'hello',
+          typeAnnotation: {
+            type: 'TypeAnnotation',
+            typeAnnotation: {
+              type: 'GenericTypeAnnotation',
+              id: 'Foo',
+              data: { startLineNumber: 3, endLineNumber: 3 },
+            },
+            data: { startLineNumber: 3, endLineNumber: 3 },
+          },
+          data: { startLineNumber: 2, endLineNumber: 2 },
+        },
+        data: {
+          startLineNumber: 2,
+          endLineNumber: 4,
+        },
+      },
+    ],
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 4,
+    },
+  },
+]);
+
+expectType<ParseAst<`function foo(a: string) {}`>>([
+  {
+    type: 'FunctionDeclaration',
+    id: {
+      type: 'Identifier',
+      name: 'foo',
+      typeAnnotation: null,
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    params: [
+      {
+        type: 'Identifier',
+        name: 'a',
+        typeAnnotation: {
+          type: 'TypeAnnotation',
+          typeAnnotation: {
+            type: 'StringTypeAnnotation',
+            data: {
+              startLineNumber: 1,
+              endLineNumber: 1,
+            },
+          },
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+    ],
+    body: {
+      type: 'BlockStatement',
+      body: [],
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
+
+expectType<ParseAst<`function\n foo\n(\na: number)\n {\n}`>>([
+  {
+    type: 'FunctionDeclaration',
+    id: {
+      type: 'Identifier',
+      name: 'foo',
+      typeAnnotation: null,
+      data: {
+        startLineNumber: 2,
+        endLineNumber: 2,
+      },
+    },
+    params: [
+      {
+        type: 'Identifier',
+        name: 'a',
+        typeAnnotation: {
+          type: 'TypeAnnotation',
+          typeAnnotation: {
+            type: 'NumberTypeAnnotation',
+            data: {
+              startLineNumber: 4,
+              endLineNumber: 4,
+            },
+          },
+          data: {
+            startLineNumber: 4,
+            endLineNumber: 4,
+          },
+        },
+        data: {
+          startLineNumber: 4,
+          endLineNumber: 4,
+        },
+      },
+    ],
+    body: {
+      type: 'BlockStatement',
+      body: [],
+      data: {
+        startLineNumber: 5,
+        endLineNumber: 6,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 6,
+    },
+  },
+]);
+
+expectType<ParseAst<`function\n foo\n(\na: null, \nb: boolean)\n {\n}`>>([
+  {
+    type: 'FunctionDeclaration',
+    id: {
+      type: 'Identifier',
+      name: 'foo',
+      typeAnnotation: null,
+      data: {
+        startLineNumber: 2,
+        endLineNumber: 2,
+      },
+    },
+    params: [
+      {
+        type: 'Identifier',
+        name: 'a',
+        typeAnnotation: {
+          type: 'TypeAnnotation',
+          typeAnnotation: {
+            type: 'NullLiteralTypeAnnotation',
+            data: {
+              startLineNumber: 4,
+              endLineNumber: 4,
+            },
+          },
+          data: {
+            startLineNumber: 4,
+            endLineNumber: 4,
+          },
+        },
+        data: {
+          startLineNumber: 4,
+          endLineNumber: 4,
+        },
+      },
+      {
+        type: 'Identifier',
+        name: 'b',
+        typeAnnotation: {
+          type: 'TypeAnnotation',
+          typeAnnotation: {
+            type: 'BooleanTypeAnnotation',
+            data: {
+              startLineNumber: 5,
+              endLineNumber: 5,
+            },
+          },
+          data: {
+            startLineNumber: 5,
+            endLineNumber: 5,
+          },
+        },
+        data: {
+          startLineNumber: 5,
+          endLineNumber: 5,
+        },
+      },
+    ],
+    body: {
+      type: 'BlockStatement',
+      body: [],
+      data: {
+        startLineNumber: 6,
+        endLineNumber: 7,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 7,
+    },
+  },
+]);
+
+expectType<ParseAst<`\n\nhello[world]`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'MemberExpression',
+      object: {
+        type: 'Identifier',
+        name: 'hello',
+        typeAnnotation: null,
+        data: {
+          startLineNumber: 3,
+          endLineNumber: 3,
+        },
+      },
+      property: {
+        type: 'Identifier',
+        name: 'world',
+        typeAnnotation: null,
+        data: {
+          startLineNumber: 3,
+          endLineNumber: 3,
+        },
+      },
+      computed: true,
+      data: {
+        startLineNumber: 3,
+        endLineNumber: 3,
+      },
+    },
+    data: {
+      startLineNumber: 3,
+      endLineNumber: 3,
+    },
+  },
+]);
+
+expectType<ParseAst<`hello[world()]["foo"]`>>([
+  {
+    type: 'ExpressionStatement',
+    expression: {
+      type: 'MemberExpression',
+      object: {
+        type: 'MemberExpression',
+        object: {
+          type: 'Identifier',
+          name: 'hello',
+          typeAnnotation: null,
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+        property: {
+          type: 'CallExpression',
+          callee: {
+            type: 'Identifier',
+            name: 'world',
+            typeAnnotation: null,
+            data: {
+              startLineNumber: 1,
+              endLineNumber: 1,
+            },
+          },
+          arguments: [],
+          data: {
+            startLineNumber: 1,
+            endLineNumber: 1,
+          },
+        },
+        computed: true,
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+      property: {
+        type: 'StringLiteral',
+        value: 'foo',
+        data: {
+          startLineNumber: 1,
+          endLineNumber: 1,
+        },
+      },
+      computed: true,
+      data: {
+        startLineNumber: 1,
+        endLineNumber: 1,
+      },
+    },
+    data: {
+      startLineNumber: 1,
+      endLineNumber: 1,
+    },
+  },
+]);
diff --git a/src/test/tokenizer.test.ts b/src/test/tokenizer.test.ts
new file mode 100644
index 0000000..9d6c421
--- /dev/null
+++ b/src/test/tokenizer.test.ts
@@ -0,0 +1,392 @@
+import type { Tokenize } from '../tokenizer';
+import { expectType } from './utils';
+
+expectType<Tokenize<`hello`>>([
+  {
+    type: 'symbol',
+    value: 'hello',
+    data: {
+      precedingLinebreak: false,
+      lineNumber: 1,
+    },
+  },
+]);
+
+expectType<Tokenize<`hello world`>>([
+  {
+    type: 'symbol',
+    value: 'hello',
+    data: {
+      precedingLinebreak: false,
+      lineNumber: 1,
+    },
+  },
+  {
+    type: 'symbol',
+    value: 'world',
+    data: {
+      precedingLinebreak: false,
+      lineNumber: 1,
+    },
+  },
+]);
+
+expectType<Tokenize<`hello\n world`>>([
+  {
+    type: 'symbol',
+    value: 'hello',
+    data: {
+      precedingLinebreak: false,
+      lineNumber: 1,
+    },
+  },
+  {
+    type: 'symbol',
+    value: 'world',
+    data: {
+      precedingLinebreak: true,
+      lineNumber: 2,
+    },
+  },
+]);
+
+expectType<Tokenize<`hello\nworld`>>([
+  {
+    type: 'symbol',
+    value: 'hello',
+    data: {
+      precedingLinebreak: false,
+      lineNumber: 1,
+    },
+  },
+  {
+    type: 'symbol',
+    value: 'world',
+    data: {
+      precedingLinebreak: true,
+      lineNumber: 2,
+    },
+  },
+]);
+
+expectType<Tokenize<`hello\n\n world`>>([
+  {
+    type: 'symbol',
+    value: 'hello',
+    data: {
+      precedingLinebreak: false,
+      lineNumber: 1,
+    },
+  },
+  {
+    type: 'symbol',
+    value: 'world',
+    data: {
+      precedingLinebreak: true,
+      lineNumber: 3,
+    },
+  },
+]);
+
+expectType<Tokenize<`"hello" "world"`>>([
+  {
+    type: 'string',
+    value: 'hello',
+    data: {
+      precedingLinebreak: false,
+      lineNumber: 1,
+    },
+  },
+  {
+    type: 'string',
+    value: 'world',
+    data: {
+      precedingLinebreak: false,
+      lineNumber: 1,
+    },
+  },
+]);
+
+expectType<Tokenize<`"hello"\n "world"`>>([
+  {
+    type: 'string',
+    value: 'hello',
+    data: {
+      precedingLinebreak: false,
+      lineNumber: 1,
+    },
+  },
+  {
+    type: 'string',
+    value: 'world',
+    data: {
+      precedingLinebreak: true,
+      lineNumber: 2,
+    },
+  },
+]);
+
+expectType<Tokenize<`\n123 456 \n\n789`>>([
+  {
+    type: 'number',
+    value: '123',
+    data: {
+      precedingLinebreak: true,
+      lineNumber: 2,
+    },
+  },
+  {
+    type: 'number',
+    value: '456',
+    data: {
+      precedingLinebreak: false,
+      lineNumber: 2,
+    },
+  },
+  {
+    type: 'number',
+    value: '789',
+    data: {
+      precedingLinebreak: true,
+      lineNumber: 4,
+    },
+  },
+]);
+
+expectType<Tokenize<`"hello"\n \n"world"`>>([
+  {
+    type: 'string',
+    value: 'hello',
+    data: {
+      precedingLinebreak: false,
+      lineNumber: 1,
+    },
+  },
+  {
+    type: 'string',
+    value: 'world',
+    data: {
+      precedingLinebreak: true,
+      lineNumber: 3,
+    },
+  },
+]);
+
+expectType<Tokenize<`"hello"`>>([
+  {
+    type: 'string',
+    value: 'hello',
+    data: {
+      precedingLinebreak: false,
+      lineNumber: 1,
+    },
+  },
+]);
+
+expectType<Tokenize<`123`>>([
+  {
+    type: 'number',
+    value: '123',
+    data: {
+      precedingLinebreak: false,
+      lineNumber: 1,
+    },
+  },
+]);
+
+expectType<Tokenize<`[1, 2, 3]`>>([
+  {
+    type: 'generic',
+    value: '[',
+    data: {
+      precedingLinebreak: false,
+      lineNumber: 1,
+    },
+  },
+  {
+    type: 'number',
+    value: '1',
+    data: {
+      precedingLinebreak: false,
+      lineNumber: 1,
+    },
+  },
+  {
+    type: 'generic',
+    value: ',',
+    data: {
+      precedingLinebreak: false,
+      lineNumber: 1,
+    },
+  },
+  {
+    type: 'number',
+    value: '2',
+    data: {
+      precedingLinebreak: false,
+      lineNumber: 1,
+    },
+  },
+  {
+    type: 'generic',
+    value: ',',
+    data: {
+      precedingLinebreak: false,
+      lineNumber: 1,
+    },
+  },
+  {
+    type: 'number',
+    value: '3',
+    data: {
+      precedingLinebreak: false,
+      lineNumber: 1,
+    },
+  },
+  {
+    type: 'generic',
+    value: ']',
+    data: {
+      precedingLinebreak: false,
+      lineNumber: 1,
+    },
+  },
+]);
+
+expectType<Tokenize<`foo()`>>([
+  {
+    type: 'symbol',
+    value: 'foo',
+    data: {
+      precedingLinebreak: false,
+      lineNumber: 1,
+    },
+  },
+  {
+    type: 'generic',
+    value: '(',
+    data: {
+      precedingLinebreak: false,
+      lineNumber: 1,
+    },
+  },
+  {
+    type: 'generic',
+    value: ')',
+    data: {
+      precedingLinebreak: false,
+      lineNumber: 1,
+    },
+  },
+]);
+
+expectType<Tokenize<`"foo"()`>>([
+  {
+    type: 'string',
+    value: 'foo',
+    data: {
+      precedingLinebreak: false,
+      lineNumber: 1,
+    },
+  },
+  {
+    type: 'generic',
+    value: '(',
+    data: {
+      precedingLinebreak: false,
+      lineNumber: 1,
+    },
+  },
+  {
+    type: 'generic',
+    value: ')',
+    data: {
+      precedingLinebreak: false,
+      lineNumber: 1,
+    },
+  },
+]);
+
+expectType<Tokenize<`"foo"\n()`>>([
+  {
+    type: 'string',
+    value: 'foo',
+    data: {
+      precedingLinebreak: false,
+      lineNumber: 1,
+    },
+  },
+  {
+    type: 'generic',
+    value: '(',
+    data: {
+      precedingLinebreak: true,
+      lineNumber: 2,
+    },
+  },
+  {
+    type: 'generic',
+    value: ')',
+    data: {
+      precedingLinebreak: false,
+      lineNumber: 2,
+    },
+  },
+]);
+
+expectType<Tokenize<`"foo"(\n)`>>([
+  {
+    type: 'string',
+    value: 'foo',
+    data: {
+      precedingLinebreak: false,
+      lineNumber: 1,
+    },
+  },
+  {
+    type: 'generic',
+    value: '(',
+    data: {
+      precedingLinebreak: false,
+      lineNumber: 1,
+    },
+  },
+  {
+    type: 'generic',
+    value: ')',
+    data: {
+      precedingLinebreak: true,
+      lineNumber: 2,
+    },
+  },
+]);
+
+expectType<Tokenize<`"foo`>>({
+  type: 'SyntaxError',
+  message: 'Unterminated string literal.',
+  lineNumber: 1,
+});
+
+expectType<Tokenize<`foo\n\n"`>>({
+  type: 'SyntaxError',
+  message: 'Unterminated string literal.',
+  lineNumber: 3,
+});
+
+expectType<Tokenize<`%`>>({
+  type: 'SyntaxError',
+  message: 'Invalid character.',
+  lineNumber: 1,
+});
+
+expectType<Tokenize<`"hello"\n %`>>({
+  type: 'SyntaxError',
+  message: 'Invalid character.',
+  lineNumber: 2,
+});
+
+expectType<Tokenize<`\n"foo\n"`>>({
+  type: 'SyntaxError',
+  message: 'Unterminated string literal.',
+  lineNumber: 2,
+});
diff --git a/src/test/utils.ts b/src/test/utils.ts
new file mode 100644
index 0000000..2916b9e
--- /dev/null
+++ b/src/test/utils.ts
@@ -0,0 +1 @@
+export const expectType = <T>(_: T): any => {};
diff --git a/src/tokenizer.ts b/src/tokenizer.ts
new file mode 100644
index 0000000..19396c2
--- /dev/null
+++ b/src/tokenizer.ts
@@ -0,0 +1,109 @@
+import type { Push } from './utils/arrayUtils';
+import type {
+  EatFirstChar,
+  GetFirstChar,
+  ConcatStrings,
+  StringContains,
+} from './utils/stringUtils';
+import type { GenericTokens, Numbers, Symbols } from './utils/generalUtils';
+import type {
+  Token,
+  NumberToken,
+  SymbolToken,
+  StringToken,
+  TokenData,
+  GenericToken,
+} from './tokens';
+import type { SyntaxError } from './errors';
+import type { Succ } from './utils/math';
+
+type TokenizeInput<
+  Input extends string,
+  FirstChar extends string,
+  InputTail extends string,
+  PrecedingLinebreak extends boolean,
+  LineNumber extends number,
+  Data extends TokenData<any, any> = TokenData<PrecedingLinebreak, LineNumber>,
+> = FirstChar extends GenericTokens
+  ? [GenericToken<FirstChar, Data>, InputTail]
+  : FirstChar extends Numbers
+  ? TokenizeNumber<Input, '', Data, FirstChar>
+  : FirstChar extends '"'
+  ? TokenizeString<InputTail, '"', Data>
+  : FirstChar extends "'"
+  ? TokenizeString<InputTail, "'", Data>
+  : FirstChar extends Symbols
+  ? TokenizeSymbol<Input, '', Data, FirstChar>
+  : SyntaxError<`Invalid character.`, LineNumber>;
+
+type TokenizeNumber<
+  Input extends string,
+  Result extends string,
+  PrecedingLinebreak extends TokenData<any, any>,
+  FirstChar extends string = GetFirstChar<Input>,
+> = FirstChar extends Numbers
+  ? TokenizeNumber<
+      EatFirstChar<Input>,
+      ConcatStrings<Result, FirstChar>,
+      PrecedingLinebreak
+    >
+  : [NumberToken<Result, PrecedingLinebreak>, Input];
+
+type TokenizeString<
+  Input extends string,
+  QuoteType extends '"' | "'",
+  Data extends TokenData<any, any>,
+> = Input extends `${infer Before}${QuoteType}${infer After}`
+  ? StringContains<Before, '\n'> extends true
+    ? SyntaxError<'Unterminated string literal.', Data['lineNumber']>
+    : [StringToken<Before, Data>, After]
+  : SyntaxError<'Unterminated string literal.', Data['lineNumber']>;
+
+type TokenizeSymbol<
+  Input extends string,
+  Result extends string,
+  PrecedingLinebreak extends TokenData<any, any>,
+  FirstChar extends string = GetFirstChar<Input>,
+> = FirstChar extends Symbols
+  ? TokenizeSymbol<
+      EatFirstChar<Input>,
+      ConcatStrings<Result, FirstChar>,
+      PrecedingLinebreak
+    >
+  : [SymbolToken<Result, PrecedingLinebreak>, Input];
+
+export type Tokenize<
+  Input extends string,
+  Result extends Array<Token<any>> = [],
+  LineNumber extends number = 1,
+  PrecedingLinebreak extends boolean = false,
+  FirstChar extends string = GetFirstChar<Input>,
+  InputTail extends string = EatFirstChar<Input>,
+> = Input extends ''
+  ? Result
+  : FirstChar extends ' '
+  ? Tokenize<InputTail, Result, LineNumber, PrecedingLinebreak>
+  : FirstChar extends '\n'
+  ? Tokenize<InputTail, Result, Succ<LineNumber>, true>
+  : TokenizeInput<
+      Input,
+      FirstChar,
+      InputTail,
+      PrecedingLinebreak,
+      LineNumber
+    > extends infer TokenizeResult
+  ? TokenizeHelper<TokenizeResult, Result, LineNumber>
+  : never;
+
+type TokenizeHelper<
+  TokenizeResult,
+  Result extends Array<any>,
+  LineNumber extends number,
+> = TokenizeResult extends Array<any>
+  ? Tokenize<
+      TokenizeResult[1],
+      Push<Result, TokenizeResult[0]>,
+      LineNumber,
+      false
+    >
+  : TokenizeResult;
diff --git a/src/tokens.ts b/src/tokens.ts
new file mode 100644
index 0000000..838428d
--- /dev/null
+++ b/src/tokens.ts
@@ -0,0 +1,52 @@
+export type TokenData<
+  PrecedingLinebreak extends boolean,
+  LineNumber extends number,
+> = {
+  precedingLinebreak: PrecedingLinebreak;
+  lineNumber: LineNumber;
+};
+
+export type GenericToken<
+  Value extends string,
+  Data extends TokenData<boolean, number>,
+> = {
+  type: 'generic';
+  value: Value;
+  data: Data;
+};
+
+export type NumberToken<
+  Value extends string,
+  Data extends TokenData<boolean, number>,
+> = {
+  type: 'number';
+  value: Value;
+  data: Data;
+};
+
+export type StringToken<
+  Value extends string,
+  Data extends TokenData<boolean, number>,
+> = {
+  type: 'string';
+  value: Value;
+  data: Data;
+};
+
+export type SymbolToken<
+  Value extends string,
+  Data extends TokenData<boolean, number>,
+> = {
+  type: 'symbol';
+  value: Value;
+  data: Data;
+};
+
+export type Token<
+  Data extends TokenData<boolean, number>,
+  Value extends string = string,
+> =
+  | GenericToken<Value, Data>
+  | NumberToken<Value, Data>
+  | StringToken<Value, Data>
+  | SymbolToken<Value, Data>;
diff --git a/src/types.ts b/src/types.ts
new file mode 100644
index 0000000..7a42ac7
--- /dev/null
+++ b/src/types.ts
@@ -0,0 +1,104 @@
+export type StringType = {
+  type: 'StringType';
+};
+
+export type StringLiteralType<Value extends string> = {
+  type: 'StringLiteralType';
+  value: Value;
+};
+
+export type NumberType = {
+  type: 'NumberType';
+};
+
+export type NumberLiteralType<Value extends string> = {
+  type: 'NumberLiteralType';
+  value: Value;
+};
+
+export type BooleanType = {
+  type: 'BooleanType';
+};
+
+export type BooleanLiteralType<Value extends boolean> = {
+  type: 'BooleanLiteralType';
+  value: Value;
+};
+
+export type NullType = {
+  type: 'NullType';
+};
+
+export type UndefinedType = {
+  type: 'UndefinedType';
+};
+
+export type UnknownType = {
+  type: 'UnknownType';
+};
+
+export type VoidType = {
+  type: 'VoidType';
+};
+
+export type AnyType = {
+  type: 'AnyType';
+};
+
+export type NeverType = {
+  type: 'NeverType';
+};
+
+export type FunctionType<
+  Params extends Array<[string, StaticType]>,
+  Return extends StaticType,
+> = {
+  type: 'FunctionType';
+  params: Params;
+  return: Return;
+};
+
+export type ObjectType<Properties extends Array<[string, StaticType]>> = {
+  type: 'ObjectType';
+  properties: Properties;
+};
+
+export type ArrayType<ElementsType extends StaticType> = {
+  type: 'ArrayType';
+  elements: ElementsType;
+};
+
+export type UnionType<Types extends Array<StaticType>> = {
+  type: 'UnionType';
+  types: Types;
+};
+
+export type CallArgumentsType<Arguments extends Array<StaticType>> = {
+  type: 'CallArgumentsType';
+  arguments: Arguments;
+};
+
+// export type GenericType<T> = {
+//   type: 'GenericType';
+//   id: T;
+// };
+
+export type StaticType =
+  | StringType
+  | StringLiteralType<any>
+  | NumberType
+  | NumberLiteralType<any>
+  | BooleanType
+  | BooleanLiteralType<any>
+  | UnknownType
+  | VoidType
+  | AnyType
+  | NullType
+  | UndefinedType
+  | NeverType
+  | FunctionType<any, any>
+  | ObjectType<any>
+  | ArrayType<any>
+  | UnionType<any>
+  | CallArgumentsType<any>;
+// | GenericType<any>;
diff --git a/src/utils/arrayUtils.ts b/src/utils/arrayUtils.ts
index be3bc30..0a99723 100644
--- a/src/utils/arrayUtils.ts
+++ b/src/utils/arrayUtils.ts
@@ -5,14 +5,22 @@ export type Tail<T extends Array<any>> = ((...t: T) => void) extends (
   ? R
   : never;
 
-export type Unshift<T extends Array<any>, E> = ((
-  h: E,
-  ...t: T
-) => void) extends (...t: infer R) => void
-  ? R
-  : never;
+export type Push<T extends Array<any>, E> = [...T, E];
+
+export type Unshift<T extends Array<any>, E> = [E, ...T];
+
+export type Reverse<
+  T extends Array<any>,
+  R extends Array<any> = [],
+> = T extends [] ? R : Reverse<Tail<T>, Unshift<R, T[0]>>;
+
+export type Concat<T1 extends Array<any>, T2 extends Array<any>> = [
+  ...T1,
+  ...T2,
+];
 
-export type Reverse<T extends Array<any>, R extends Array<any> = []> = {
-  finish: R;
-  next: Reverse<Tail<T>, Unshift<R, T[0]>>;
-}[T extends [] ? 'finish' : 'next'];
+export type TailBy<
+  T extends Array<any>,
+  B extends number,
+  A extends Array<any> = [],
+> = B extends A['length'] ? T : TailBy<Tail<T>, B, Push<A, 0>>;
diff --git a/src/utils/generalUtils.ts b/src/utils/generalUtils.ts
index a1a5570..ed6e66c 100644
--- a/src/utils/generalUtils.ts
+++ b/src/utils/generalUtils.ts
@@ -1,7 +1,18 @@
-export type Cast<A, B> = A extends B ? A : B;
-
 export type MergeWithOverride<T1, T2> = Omit<T1, keyof T2> & T2;
 
+export type GenericTokens =
+  | ','
+  | '('
+  | ')'
+  | '['
+  | ']'
+  | '{'
+  | '}'
+  | '.'
+  | ';'
+  | ':'
+  | '=';
+
 export type Numbers = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
 
 export type Symbols =
@@ -68,8 +79,4 @@ export type Symbols =
   | '8'
   | '9'
   | '_'
-  | '-'
-  | '+'
-  | '='
-  | '|'
-  | '&';
+  | '$';
diff --git a/src/utils/math.ts b/src/utils/math.ts
new file mode 100644
index 0000000..ba2c4ee
--- /dev/null
+++ b/src/utils/math.ts
@@ -0,0 +1,64 @@
+type SuccTable = {
+  0: 1;
+  1: 2;
+  2: 3;
+  3: 4;
+  4: 5;
+  5: 6;
+  6: 7;
+  7: 8;
+  8: 9;
+  9: 10;
+  10: 11;
+  11: 12;
+  12: 13;
+  13: 14;
+  14: 15;
+  15: 16;
+  16: 17;
+  17: 18;
+  18: 19;
+  19: 20;
+  20: 21;
+  21: 22;
+  22: 23;
+  23: 24;
+  24: 25;
+  25: 26;
+  26: 27;
+  27: 28;
+  28: 29;
+  29: 30;
+  30: 31;
+  31: 32;
+  32: 33;
+  33: 34;
+  34: 35;
+  35: 36;
+  36: 37;
+  37: 38;
+  38: 39;
+  39: 40;
+  40: 41;
+  41: 42;
+  42: 43;
+  43: 44;
+  44: 45;
+  45: 46;
+  46: 47;
+  47: 48;
+  48: 49;
+  49: 50;
+  50: 51;
+  51: 52;
+  52: 53;
+  53: 54;
+  54: 55;
+  55: 56;
+  56: 57;
+  57: 58;
+  58: 59;
+  59: 60;
+};
+
+export type Succ<T> = T extends keyof SuccTable ? SuccTable[T] : never;
diff --git a/src/utils/stringUtils.ts b/src/utils/stringUtils.ts
index d33c361..0295832 100644
--- a/src/utils/stringUtils.ts
+++ b/src/utils/stringUtils.ts
@@ -1,5 +1,15 @@
 export type EatFirstChar<T> = T extends `${infer A}${infer B}` ? B : '';
 
-export type FirstChar<T> = T extends `${infer A}${infer B}` ? A : '';
+export type GetFirstChar<T> = T extends `${infer A}${infer B}` ? A : '';
 
 export type ConcatStrings<A extends string, B extends string> = `${A}${B}`;
+
+export type StringContains<I extends string, T extends string> = I extends T
+  ? true
+  : I extends `${T}${infer _}`
+  ? true
+  : I extends `${infer _0}${T}${infer _1}`
+  ? true
+  : I extends `${infer _}${T}`
+  ? true
+  : false;
diff --git a/src/utils/utilityTypes.ts b/src/utils/utilityTypes.ts
new file mode 100644
index 0000000..d9db8ee
--- /dev/null
+++ b/src/utils/utilityTypes.ts
@@ -0,0 +1,54 @@
+import type { StaticType } from '../types';
+import type { ParsingError, TypeError } from '../errors';
+import type { BaseNode, NodeData } from '../ast';
+import type { Token, TokenData } from '../tokens';
+
+export type TypeResult<
+  Value extends StaticType,
+  State extends StateType,
+  Errors extends Array<TypeError<any, any>> = [],
+> = {
+  type: 'TypeResult';
+  value: Value;
+  state: State;
+  errors: Errors;
+};
+
+export type ParseResult<
+  Node extends BaseNode<NodeData<number, number>>,
+  TokenList extends Array<Token<any>>,
+  Error extends ParsingError<any, any> | null = null,
+  Data extends any = null,
+> = {
+  type: 'ParseResult';
+  node: Node;
+  tokenList: TokenList;
+  error: Error;
+  data: Data;
+};
+
+export type ParseArrayResult<
+  NodeList extends Array<BaseNode<NodeData<number, number>>>,
+  TokenList extends Array<Token<TokenData<boolean, number>>>,
+  Error extends ParsingError<any, any> | null = null,
+  Data extends any = null,
+> = {
+  type: 'ParseResult';
+  node: NodeList;
+  tokenList: TokenList;
+  error: Error;
+  data: Data;
+};
+
+export type ParseError<Error extends ParsingError<any, any>> = ParseResult<
+  any,
+  any,
+  Error
+>;
+
+export type ParseErrorResult<
+  Message extends string,
+  LineNumber extends number,
+> = ParseError<ParsingError<Message, LineNumber>>;
+
+export type StateType = Record<string, StaticType>;
diff --git a/tsconfig.json b/tsconfig.json
index eef761d..0cfd4b8 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -2,20 +2,23 @@
   "compilerOptions": {
     "target": "es2019",
     "module": "es2022",
-    "lib": ["esnext", "dom"],
-    "declaration": true,
-    "composite": true,
+    "lib": ["esnext"],
+    "declaration": false,
+    "composite": false,
     "isolatedModules": true,
     "importsNotUsedAsValues": "error",
-    "jsx": "react",
+    "diagnostics": false,
 
     "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "skipDefaultLibCheck": true,
 
     "moduleResolution": "node",
     "esModuleInterop": true,
     "allowSyntheticDefaultImports": true,
     "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
+    "resolveJsonModule": false,
 
     "rootDir": "src",
     "outDir": "build"
diff --git a/yarn.lock b/yarn.lock
index fd6f210..635b045 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -851,10 +851,10 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.17.12"
 
-"@babel/plugin-transform-typescript@^7.17.12":
+"@babel/plugin-transform-typescript@^7.17.12", "@babel/plugin-transform-typescript@^7.18.4":
   version "7.18.4"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.18.4.tgz#587eaf6a39edb8c06215e550dc939faeadd750bf"
-  integrity sha512-l4vHuSLUajptpHNEOUDEGsnpl9pfRLsN1XUoDQDD/YBuXTM+v37SHGS+c6n4jdcZy96QtuUuSvZYMLSSsjH8Mw==
+  resolved "https://repo.dev.wixpress.com/artifactory/api/npm/npm-repos/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.18.4.tgz#587eaf6a39edb8c06215e550dc939faeadd750bf"
+  integrity sha1-WH6vajntuMBiFeVQ3JOfrq3XUL8=
   dependencies:
     "@babel/helper-create-class-features-plugin" "^7.18.0"
     "@babel/helper-plugin-utils" "^7.17.12"
@@ -2934,10 +2934,10 @@ type-fest@^0.20.2:
   resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.20.2.tgz#1bf207f4b28f91583666cb5fbd327887301cd5f4"
   integrity sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==
 
-typescript@^4.7.4:
-  version "4.7.4"
-  resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.7.4.tgz#1a88596d1cf47d59507a1bcdfb5b9dfe4d488235"
-  integrity sha512-C0WQT0gezHuw6AdY1M2jxUO83Rjf0HP7Sk1DtXj6j1EwkQNZrHAg2XPWlq62oqEhYvONq5pkC2Y9oPljWToLmQ==
+typescript@next:
+  version "4.8.0-dev.20220629"
+  resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.8.0-dev.20220629.tgz#9d719936f77a811d6859051f327c7868700ab250"
+  integrity sha512-QEp1M6iqlYpQXFF2f9ucXMkXbYcAoXcG0ws0IG8bWd7mjPGf8R5iVCbQVSm1dzV/GoOy0PsvfNe5/uL6D9TSPA==
 
 unbox-primitive@^1.0.2:
   version "1.0.2"