From 058210fc6aa9b564322da69ec4767edc73348630 Mon Sep 17 00:00:00 2001
From: Shahar Soel <shahar.soel@gmail.com>
Date: Wed, 13 Jan 2016 02:16:54 +0200
Subject: [PATCH] * Using ES6 modules in the project files.

* New dev workflow without using karma/browsers for debugging/testing locally.
  (does not change CI flow which still tests on browsers AND node.js).

* npm release now contains individual files for easier debugging/custom bundling.

fixes #123
---
 .gitignore                                    |    2 +-
 .idea/codeStyleSettings.xml                   |    2 +
 .idea/runConfigurations/KARMA_DEBUG.xml       |    9 -
 .idea/runConfigurations/Mocha_Unit.xml        |   13 +
 bower.json                                    |    4 +-
 build/chevrotain.ts                           |   25 -
 .../typescript_ecma5/libs/chevrotain.d.ts     |  640 ----
 gruntfile.js                                  |  321 +-
 karma.conf.js                                 |   30 +-
 package.json                                  |    8 +-
 scripts/findRefs.js                           |   20 -
 scripts/findSpecs.js                          |   27 -
 src/api.ts                                    |   99 +-
 src/env.d.ts                                  |    2 +
 src/lang/lang_extensions.ts                   |  102 +-
 src/parse/cache.ts                            |  125 +-
 src/parse/constants.ts                        |    7 +-
 src/parse/exceptions_public.ts                |   31 +-
 src/parse/gast_builder.ts                     |  610 ++--
 src/parse/grammar/checks.ts                   |  437 +--
 src/parse/grammar/first.ts                    |  109 +-
 src/parse/grammar/follow.ts                   |   86 +-
 src/parse/grammar/gast.ts                     |  119 +-
 src/parse/grammar/gast_public.ts              |    7 +-
 src/parse/grammar/interpreter.ts              |  478 +--
 src/parse/grammar/lookahead.ts                |  253 +-
 src/parse/grammar/path.ts                     |   33 +-
 src/parse/grammar/resolver.ts                 |   63 +-
 src/parse/grammar/rest.ts                     |  179 +-
 src/parse/parse_tree.ts                       |    0
 src/parse/parser_public.ts                    | 2964 +++++++++--------
 src/scan/lexer.ts                             |  445 +--
 src/scan/lexer_public.ts                      |  464 ++-
 src/scan/tokens_public.ts                     |  161 +-
 src/text/range.ts                             |   67 +-
 src/utils/utils.ts                            |  416 ++-
 test/all.ts                                   |    3 +
 test/env.d.ts                                 |    1 +
 .../backtracking/backtracking_parser.ts       |  198 +-
 .../backtracking/backtracking_parser_spec.ts  |  104 +-
 .../sql_statements/sql_recovery_parser.ts     |  350 +-
 .../sql_statements/sql_recovery_spec.ts       |  434 +--
 .../sql_statements/sql_recovery_tokens.ts     |  161 +-
 .../switch_case/Switchcase_recovery_tokens.ts |   69 +-
 .../switch_case/switchcase_recovery_parser.ts |  220 +-
 .../switch_case/swithcase_recovery_spec.ts    |  351 +-
 test/full_flow/parse_tree.ts                  |   58 +-
 test/lang/hash_table_spec.ts                  |   37 +-
 test/mocha.opts                               |    4 +
 test/parse/gast_builder_spec.ts               |  819 ++---
 test/parse/grammar/checks_spec.ts             |  849 ++---
 test/parse/grammar/first_spec.ts              |  128 +-
 test/parse/grammar/follow_spec.ts             |   94 +-
 test/parse/grammar/gast_spec.ts               |   17 +-
 test/parse/grammar/interperter_spec.ts        | 1188 +++----
 test/parse/grammar/lookahead_spec.ts          |  176 +-
 test/parse/grammar/resolver_spec.ts           |   33 +-
 test/parse/grammar/samples.ts                 |  347 +-
 test/parse/recognizer_lookahead_spec.ts       | 1596 ++++-----
 test/parse/recognizer_spec.ts                 |  830 ++---
 test/requirejs_test_main.js                   |   12 -
 test/scan/lexer_spec.ts                       |  761 ++---
 test/scan/token_spec.ts                       |  106 +-
 test/test.config.js                           |   11 +-
 test/text/range_spec.ts                       |  112 +-
 test/utils/matchers.ts                        |   13 +-
 test/utils/utils_spec.ts                      |  341 +-
 tests_integration/definitions/es6_modules.ts  |    7 +
 tests_integration/definitions/namespaces.ts   |    8 +
 watch.bat                                     |    2 +-
 70 files changed, 8623 insertions(+), 9175 deletions(-)
 delete mode 100644 .idea/runConfigurations/KARMA_DEBUG.xml
 create mode 100644 .idea/runConfigurations/Mocha_Unit.xml
 delete mode 100644 build/chevrotain.ts
 delete mode 100644 examples/typescript_ecma5/libs/chevrotain.d.ts
 delete mode 100644 scripts/findRefs.js
 delete mode 100644 scripts/findSpecs.js
 create mode 100644 src/env.d.ts
 delete mode 100644 src/parse/parse_tree.ts
 create mode 100644 test/all.ts
 create mode 100644 test/mocha.opts
 delete mode 100644 test/requirejs_test_main.js
 create mode 100644 tests_integration/definitions/es6_modules.ts
 create mode 100644 tests_integration/definitions/namespaces.ts

diff --git a/.gitignore b/.gitignore
index 62bfb7651..21f1ecce4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,7 +4,7 @@
 
 /bin
 /.tscache
-/src/parse/.baseDir.ts
+.baseDir.ts
 /bower_components
 /package
 
diff --git a/.idea/codeStyleSettings.xml b/.idea/codeStyleSettings.xml
index c38a21bac..4987ac8cb 100644
--- a/.idea/codeStyleSettings.xml
+++ b/.idea/codeStyleSettings.xml
@@ -3,6 +3,8 @@
   <component name="ProjectCodeStyleSettingsManager">
     <option name="PER_PROJECT_SETTINGS">
       <value>
+        <option name="RIGHT_MARGIN" value="140" />
+        <option name="WRAP_WHEN_TYPING_REACHES_RIGHT_MARGIN" value="true" />
         <option name="FORMATTER_TAGS_ENABLED" value="true" />
         <JSCodeStyleSettings>
           <option name="ALIGN_OBJECT_PROPERTIES" value="1" />
diff --git a/.idea/runConfigurations/KARMA_DEBUG.xml b/.idea/runConfigurations/KARMA_DEBUG.xml
deleted file mode 100644
index 05bb77e56..000000000
--- a/.idea/runConfigurations/KARMA_DEBUG.xml
+++ /dev/null
@@ -1,9 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="KARMA_DEBUG" type="JavascriptDebugType" factoryName="JavaScript Debug" uri="http://localhost:9979/debug.html">
-    <mapping url="http://localhost:9979/base/bin/gen/src" local-file="$PROJECT_DIR$/bin/gen/src" />
-    <mapping url="http://localhost:9979/base/bin/gen/test" local-file="$PROJECT_DIR$/bin/gen/test" />
-    <mapping url="http://localhost:9979/base/test" local-file="$PROJECT_DIR$/test" />
-    <mapping url="http://localhost:9979/base/src" local-file="$PROJECT_DIR$/src" />
-    <method />
-  </configuration>
-</component>
\ No newline at end of file
diff --git a/.idea/runConfigurations/Mocha_Unit.xml b/.idea/runConfigurations/Mocha_Unit.xml
new file mode 100644
index 000000000..8be470f64
--- /dev/null
+++ b/.idea/runConfigurations/Mocha_Unit.xml
@@ -0,0 +1,13 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Mocha Unit" type="mocha-javascript-test-runner" factoryName="Mocha">
+    <node-options />
+    <working-directory>$PROJECT_DIR$</working-directory>
+    <pass-parent-env>true</pass-parent-env>
+    <envs />
+    <ui>bdd</ui>
+    <extra-mocha-options />
+    <test-kind>PATTERN</test-kind>
+    <test-pattern>./bin/test/**/*spec.js</test-pattern>
+    <method />
+  </configuration>
+</component>
\ No newline at end of file
diff --git a/bower.json b/bower.json
index e0e58bbdf..ae94e465a 100644
--- a/bower.json
+++ b/bower.json
@@ -4,9 +4,7 @@
   "description": "Chevrotain is a high performance fault Tolerant Javascript parsing DSL for building recursive decent parsers",
   "main": "release/chevrotain.js",
   "dependencies": {},
-  "devDependencies": {
-    "lodash": "^3.10.1"
-  },
+  "devDependencies": {},
   "moduleType": [
     "globals",
     "amd",
diff --git a/build/chevrotain.ts b/build/chevrotain.ts
deleted file mode 100644
index 32056a388..000000000
--- a/build/chevrotain.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-
-// production code
-/// <reference path="../src/utils/utils.ts" />
-// TODO: move lang --> utils ?
-/// <reference path="../src/lang/lang_extensions.ts" />
-/// <reference path="../src/scan/tokens_public.ts" />
-/// <reference path="../src/scan/lexer_public.ts" />
-/// <reference path="../src/scan/lexer.ts" />
-/// <reference path="../src/text/range.ts" />
-/// <reference path="../src/parse/constants.ts" />
-/// <reference path="../src/parse/grammar/path.ts" />
-/// <reference path="../src/parse/grammar/gast_public.ts" />
-/// <reference path="../src/parse/grammar/gast.ts" />
-/// <reference path="../src/parse/grammar/first.ts" />
-/// <reference path="../src/parse/grammar/rest.ts" />
-/// <reference path="../src/parse/grammar/follow.ts" />
-/// <reference path="../src/parse/grammar/interpreter.ts" />
-/// <reference path="../src/parse/cache.ts" />
-/// <reference path="../src/parse/grammar/lookahead.ts" />
-/// <reference path="../src/parse/gast_builder.ts" />
-/// <reference path="../src/parse/grammar/checks.ts" />
-/// <reference path="../src/parse/grammar/resolver.ts" />
-/// <reference path="../src/parse/exceptions_public.ts" />
-/// <reference path="../src/parse/parser_public.ts" />
-/// <reference path="../src/api.ts" />
diff --git a/examples/typescript_ecma5/libs/chevrotain.d.ts b/examples/typescript_ecma5/libs/chevrotain.d.ts
deleted file mode 100644
index fc1c386dd..000000000
--- a/examples/typescript_ecma5/libs/chevrotain.d.ts
+++ /dev/null
@@ -1,640 +0,0 @@
-/*! chevrotain - v0.4.2 - 2015-06-28 */
-declare module chevrotain {
-    module lang {
-        class HashTable<V>{}
-    }
-
-    function tokenName(clazz: Function): string;
-    /**
-     * utility to help the poor souls who are still stuck writing pure javascript 5.1
-     * extend and create Token subclasses in a less verbose manner
-     *
-     * @param {string} tokenName the name of the new TokenClass
-     * @param {*} patternOrParent Pa
-     * @param {Function} parentConstructor the Token class to be extended
-     * @returns {Function} a constructor for the new extended Token subclass
-     */
-    function extendToken(tokenName: string, patternOrParent?: any, parentConstructor?: Function): any;
-    class Token {
-        image: string;
-        offset: number;
-        startLine: number;
-        startColumn: number;
-        endLine: number;
-        endColumn: number;
-        isInsertedInRecovery: boolean;
-        /**
-         * @param {string} image the textual representation of the Token as it appeared in the text
-         * @param {number} offset offset of the first character of the Token
-         * @param {number} startLine line of the first character of the Token
-         * @param {number} startColumn column of the first character of the Token
-         * @param {number} endLine line of the last character of the Token
-         * @param {number} endColumn column of the last character of the Token
-         *
-         * Things to note:
-         * * "do"  {startColumn : 1, endColumn: 2} --> the range is inclusive to exclusive 1...2 (2 chars long).
-         * * "\n"  {startLine : 1, endLine: 1} --> a lineTerminator as the last character does not effect the Token's line numbering.
-         * * "'hello\tworld\uBBBB'"  {image: "'hello\tworld\uBBBB'"} --> a Token's image is the "literal" text
-         *                                                              (unicode escaping is untouched).
-         */
-        constructor(image: string, offset: number, startLine: number, startColumn: number, endLine?: number, endColumn?: number);
-    }
-    /**
-     * a special kind of Token which does not really exist in the input
-     * (hence the 'Virtual' prefix). These type of Tokens can be used as special markers:
-     * for example, EOF (end-of-file).
-     */
-    class VirtualToken extends Token {
-        constructor();
-    }
-    class EOF extends VirtualToken {
-    }
-
-    type TokenConstructor = Function;
-    interface ILexingResult {
-        tokens: Token[];
-        groups: {
-            [groupName: string]: Token;
-        };
-        errors: ILexingError[];
-    }
-    interface ILexingError {
-        line: number;
-        column: number;
-        message: string;
-    }
-    class Lexer {
-        protected tokenClasses: TokenConstructor[];
-        static SKIPPED: {
-            description: string;
-        };
-        static NA: RegExp;
-        protected allPatterns: RegExp[];
-        protected patternIdxToClass: Function[];
-        protected patternIdxToGroup: boolean[];
-        protected patternIdxToLongerAltIdx: number[];
-        protected patternIdxToCanLineTerminator: boolean[];
-        protected emptyGroups: {
-            [groupName: string]: Token;
-        };
-        /**
-         * @param {Function[]} tokenClasses constructor functions for the Tokens types this scanner will support
-         *                     These constructors must be in one of three forms:
-         *
-         *  1. With a PATTERN property that has a RegExp value for tokens to match:
-         *     example: -->class Integer extends Token { static PATTERN = /[1-9]\d }<--
-         *
-         *  2. With a PATTERN property that has a RegExp value AND an IGNORE property with boolean value true.
-         *     These tokens will be matched but not as part of the main token vector.
-         *     this is usually used for ignoring whitespace/comments
-         *     example: -->    class Whitespace extends Token { static PATTERN = /(\t| )/; static IGNORE = true}<--
-         *
-         *  3. With a PATTERN property that has the value of the var Lexer.NA defined above.
-         *     This is a convenience form used to avoid matching Token classes that only act as categories.
-         *     example: -->class Keyword extends Token { static PATTERN = NA }<--
-         *
-         *
-         *   The following RegExp patterns are not supported:
-         *   a. '$' for match at end of input
-         *   b. /b global flag
-         *   c. /m multi-line flag
-         *
-         *   The Lexer will identify the first pattern the matches, Therefor the order of Token Constructors passed
-         *   To the SimpleLexer's constructor is meaningful. If two patterns may match the same string, the longer one
-         *   should be before the shorter one.
-         *
-         *   Note that there are situations in which we may wish to place the longer pattern after the shorter one.
-         *   For example: keywords vs Identifiers.
-         *   'do'(/do/) and 'done'(/w+)
-         *
-         *   * If the Identifier pattern appears before the 'do' pattern both 'do' and 'done'
-         *     will be lexed as an Identifier.
-         *
-         *   * If the 'do' pattern appears before the Identifier pattern 'do' will be lexed correctly as a keyword.
-         *     however 'done' will be lexed as TWO tokens keyword 'do' and identifier 'ne'.
-         *
-         *   To resolve this problem, add a static property on the keyword's Tokens constructor named: LONGER_ALT
-         *   example:
-         *
-         *       export class Identifier extends Keyword { static PATTERN = /[_a-zA-Z][_a-zA-Z0-9]/ }
-         *       export class Keyword extends Token {
-         *          static PATTERN = lex.NA
-         *          static LONGER_ALT = Identifier
-         *       }
-         *       export class Do extends Keyword { static PATTERN = /do/ }
-         *       export class While extends Keyword { static PATTERN = /while/ }
-         *       export class Return extends Keyword { static PATTERN = /return/ }
-         *
-         *   The lexer will then also attempt to match a (longer) Identifier each time a keyword is matched
-         *
-         *
-         */
-        constructor(tokenClasses: TokenConstructor[]);
-        /**
-         * Will lex(Tokenize) a string.
-         * Note that this can be called repeatedly on different strings as this method
-         * does not modify the state of the Lexer.
-         *
-         * @param {string} text the string to lex
-         * @returns {{tokens: {Token}[], errors: string[]}}
-         */
-        tokenize(text: string): ILexingResult;
-    }
-
-    import gast = chevrotain.gast;
-    import lang = chevrotain.lang;
-    interface IFollowKey {
-        ruleName: string;
-        idxInCallingRule: number;
-        inRule: string;
-    }
-    /**
-     * OR([
-     *  { WHEN:LA1, THEN_DO:XXX },
-     *  { WHEN:LA2, THEN_DO:YYY },
-     *  { WHEN:LA3, THEN_DO:ZZZ },
-     * ])
-     */
-    interface IOrAlt<T> {
-        WHEN: () => boolean;
-        THEN_DO: () => T;
-    }
-    /**
-     * OR([
-     *  {ALT:XXX },
-     *  {ALT:YYY },
-     *  {ALT:ZZZ }
-     * ])
-     */
-    interface IOrAltImplicit<T> {
-        ALT: () => T;
-    }
-    interface IParserState {
-        errors: Error[];
-        inputIdx: number;
-        RULE_STACK: string[];
-    }
-    type LookAheadFunc = () => boolean;
-    type GrammarAction = () => void;
-    /**
-     * A Recognizer capable of self analysis to determine it's grammar structure
-     * This is used for more advanced features requiring such information.
-     * for example: Error Recovery, Automatic lookahead calculation
-     */
-    class Parser {
-        static IGNORE_AMBIGUITIES: boolean;
-        static NO_RESYNC: boolean;
-        protected static performSelfAnalysis(classInstance: Parser): void;
-        errors: Error[];
-        protected _input: Token[];
-        protected inputIdx: number;
-        protected isBackTrackingStack: any[];
-        protected className: string;
-        protected RULE_STACK: string[];
-        protected RULE_OCCURRENCE_STACK: number[];
-        protected tokensMap: {
-            [fqn: string]: Function;
-        };
-        private firstAfterRepMap;
-        private classLAFuncs;
-        private orLookaheadKeys;
-        private manyLookaheadKeys;
-        private atLeastOneLookaheadKeys;
-        private optionLookaheadKeys;
-        constructor(input: Token[], tokensMapOrArr: {
-            [fqn: string]: Function;
-        } | Function[]);
-        input: Token[];
-        reset(): void;
-        isAtEndOfInput(): boolean;
-        getGAstProductions(): lang.HashTable<gast.Rule>;
-        protected isBackTracking(): boolean;
-        protected SAVE_ERROR(error: Error): Error;
-        protected NEXT_TOKEN(): Token;
-        protected LA(howMuch: number): Token;
-        protected isNextRule<T>(ruleName: string): boolean;
-        /**
-         *
-         * @param grammarRule the rule to try and parse in backtracking mode
-         * @param isValid a predicate that given the result of the parse attempt will "decide" if the parse was successfully or not
-         * @return a lookahead function that will try to parse the given grammarRule and will return true if succeed
-         */
-        protected BACKTRACK<T>(grammarRule: (...args) => T, isValid: (T) => boolean): () => boolean;
-        protected SKIP_TOKEN(): Token;
-        /**
-         * Convenience method equivalent to CONSUME1
-         * @see CONSUME1
-         */
-        protected CONSUME(tokClass: Function): Token;
-        /**
-         *
-         * A Parsing DSL method use to consume a single terminal Token.
-         * a Token will be consumed, IFF the next token in the token vector is an instanceof tokClass.
-         * otherwise the parser will attempt to perform error recovery.
-         *
-         * The index in the method name indicates the unique occurrence of a terminal consumption
-         * inside a the top level rule. What this means is that if a terminal appears
-         * more than once in a single rule, each appearance must have a difference index.
-         *
-         * for example:
-         *
-         * function parseQualifiedName() {
-         *    this.CONSUME1(Identifier);
-         *    this.MANY(()=> {
-         *       this.CONSUME1(Dot);
-         *       this.CONSUME2(Identifier); // <-- here we use CONSUME2 because the terminal
-         *    });                           //     'Identifier' has already appeared previously in the
-         *                                  //     the rule 'parseQualifiedName'
-         * }
-         *
-         * @param {Function} tokClass A constructor function specifying the type of token
-         *        to be consumed.
-         *
-         * @returns {chevrotain.tokens.Token} The consumed token.
-         */
-        protected CONSUME1(tokClass: Function): Token;
-        /**
-         * @see CONSUME1
-         */
-        protected CONSUME2(tokClass: Function): Token;
-        /**
-         * @see CONSUME1
-         */
-        protected CONSUME3(tokClass: Function): Token;
-        /**
-         * @see CONSUME1
-         */
-        protected CONSUME4(tokClass: Function): Token;
-        /**
-         * @see CONSUME1
-         */
-        protected CONSUME5(tokClass: Function): Token;
-        /**
-         * Convenience method equivalent to SUBRULE1
-         * @see SUBRULE1
-         */
-        protected SUBRULE<T>(ruleToCall: (number) => T, args?: any[]): T;
-        /**
-         * The Parsing DSL Method is used by one rule to call another.
-         *
-         * This may seem redundant as it does not actually do much.
-         * However using it is mandatory for all sub rule invocations.
-         * calling another rule without wrapping in SUBRULE(...)
-         * will cause errors/mistakes in the Recognizer's self analysis
-         * which will lead to errors in error recovery/automatic lookahead calcualtion
-         * and any other functionality relying on the Recognizer's self analysis
-         * output.
-         *
-         * As in CONSUME the index in the method name indicates the occurrence
-         * of the sub rule invocation in its rule.
-         *
-         * @param {Function} ruleToCall the rule to invoke
-         * @param {*[]} args the arguments to pass to the invoked subrule
-         * @returns {*} the result of invoking ruleToCall
-         */
-        protected SUBRULE1<T>(ruleToCall: (number) => T, args?: any[]): T;
-        /**
-         * @see SUBRULE1
-         */
-        protected SUBRULE2<T>(ruleToCall: (number) => T, args?: any[]): T;
-        /**
-         * @see SUBRULE1
-         */
-        protected SUBRULE3<T>(ruleToCall: (number) => T, args?: any[]): T;
-        /**
-         * @see SUBRULE1
-         */
-        protected SUBRULE4<T>(ruleToCall: (number) => T, args?: any[]): T;
-        /**
-         * @see SUBRULE1
-         */
-        protected SUBRULE5<T>(ruleToCall: (number) => T, args?: any[]): T;
-        /**
-         * Convenience method equivalent to OPTION1
-         * @see OPTION1
-         */
-        protected OPTION(laFuncOrAction: LookAheadFunc | GrammarAction, action?: GrammarAction): boolean;
-        /**
-         * Parsing DSL Method that Indicates an Optional production
-         * in EBNF notation: [...]
-         *
-         * note that the 'action' param is optional. so both of the following forms are valid:
-         *
-         * short: this.OPTION(()=>{ this.CONSUME(Digit});
-         * long: this.OPTION(isDigit, ()=>{ this.CONSUME(Digit});
-         *
-         * using the short form is recommended as it will compute the lookahead function
-         * automatically. however this currently has one limitation:
-         * It only works if the lookahead for the grammar is one.
-         *
-         * As in CONSUME the index in the method name indicates the occurrence
-         * of the optional production in it's top rule.
-         *
-         * @param {Function} laFuncOrAction The lookahead function that 'decides'
-         *                                  whether or not the OPTION's action will be
-         *                                  invoked or the action to optionally invoke
-         * @param {Function} [action] The action to optionally invoke.
-         *
-         * @returns {boolean} true iff the OPTION's action has been invoked
-         */
-        protected OPTION1(laFuncOrAction: LookAheadFunc | GrammarAction, action?: GrammarAction): boolean;
-        /**
-         * @see OPTION1
-         */
-        protected OPTION2(laFuncOrAction: LookAheadFunc | GrammarAction, action?: GrammarAction): boolean;
-        /**
-         * @see OPTION1
-         */
-        protected OPTION3(laFuncOrAction: LookAheadFunc | GrammarAction, action?: GrammarAction): boolean;
-        /**
-         * @see OPTION1
-         */
-        protected OPTION4(laFuncOrAction: LookAheadFunc | GrammarAction, action?: GrammarAction): boolean;
-        /**
-         * @see OPTION1
-         */
-        protected OPTION5(laFuncOrAction: LookAheadFunc | GrammarAction, action?: GrammarAction): boolean;
-        /**
-         * Convenience method equivalent to OR1
-         * @see OR1
-         */
-        protected OR<T>(alts: IOrAlt<T>[] | IOrAltImplicit<T>[], errMsgTypes: string, ignoreAmbiguities?: boolean): T;
-        /**
-         * Parsing DSL method that indicates a choice between a set of alternatives must be made.
-         * This is equivalent to EBNF alternation (A | B | C | D ...)
-         *
-         * There are two forms:
-         *
-         * short: this.OR([
-         *           {ALT:()=>{this.CONSUME(One)}},
-         *           {ALT:()=>{this.CONSUME(Two)}},
-         *           {ALT:()=>{this.CONSUME(Three)}},
-         *        ], "a number")
-         *
-         * long: this.OR([
-         *           {WHEN: isOne, THEN_DO:()=>{this.CONSUME(One)}},
-         *           {WHEN: isTwo, THEN_DO:()=>{this.CONSUME(Two)}},
-         *           {WHEN: isThree, THEN_DO:()=>{this.CONSUME(Three)}},
-         *        ], "a number")
-         *
-         * using the short form is recommended as it will compute the lookahead function
-         * automatically. however this currently has one limitation:
-         * It only works if the lookahead for the grammar is one.
-         *
-         * As in CONSUME the index in the method name indicates the occurrence
-         * of the alternation production in it's top rule.
-         *
-         * @param {{ALT:Function}[] | {WHEN:Function, THEN_DO:Function}[]} alts An array of alternatives
-         * @param {string} errMsgTypes A description for the alternatives used in error messages
-         * @returns {*} The result of invoking the chosen alternative
-         * @param {boolean} [ignoreAmbiguities] if true this will ignore ambiguities caused when two alternatives can not
-         *                                      be distinguished by a lookahead of one. enabling this means the first alternative
-         *                                      that matches will be taken. This is sometimes the grammar's intent.
-         *                                      * only enable this if you know what you are doing!
-         */
-        protected OR1<T>(alts: IOrAlt<T>[] | IOrAltImplicit<T>[], errMsgTypes: string, ignoreAmbiguities?: boolean): T;
-        /**
-         * @see OR1
-         */
-        protected OR2<T>(alts: IOrAlt<T>[] | IOrAltImplicit<T>[], errMsgTypes: string, ignoreAmbiguities?: boolean): T;
-        /**
-         * @see OR1
-         */
-        protected OR3<T>(alts: IOrAlt<T>[] | IOrAltImplicit<T>[], errMsgTypes: string, ignoreAmbiguities?: boolean): T;
-        /**
-         * @see OR1
-         */
-        protected OR4<T>(alts: IOrAlt<T>[] | IOrAltImplicit<T>[], errMsgTypes: string, ignoreAmbiguities?: boolean): T;
-        /**
-         * @see OR1
-         */
-        protected OR5<T>(alts: IOrAlt<T>[] | IOrAltImplicit<T>[], errMsgTypes: string, ignoreAmbiguities?: boolean): T;
-        /**
-         * Convenience method equivalent to MANY1
-         * @see MANY1
-         */
-        protected MANY(lookAheadFunc: LookAheadFunc | GrammarAction, action?: GrammarAction): void;
-        /**
-         * Parsing DSL method, that indicates a repetition of zero or more.
-         * This is equivalent to EBNF repetition {...}
-         *
-         * note that the 'action' param is optional. so both of the following forms are valid:
-         *
-         * short: this.MANY(()=>{
-         *                       this.CONSUME(Comma};
-         *                       this.CONSUME(Digit});
-         * long: this.MANY(isComma, ()=>{
-         *                       this.CONSUME(Comma};
-         *                       this.CONSUME(Digit});
-         *
-         * using the short form is recommended as it will compute the lookahead function
-         * automatically. however this currently has one limitation:
-         * It only works if the lookahead for the grammar is one.
-         *
-         * As in CONSUME the index in the method name indicates the occurrence
-         * of the repetition production in it's top rule.
-         *
-         * @param {Function} laFuncOrAction The lookahead function that 'decides'
-         *                                  whether or not the MANY's action will be
-         *                                  invoked or the action to optionally invoke
-         * @param {Function} [action] The action to optionally invoke.
-         */
-        protected MANY1(laFuncOrAction: LookAheadFunc | GrammarAction, action?: GrammarAction): void;
-        /**
-         * @see MANY1
-         */
-        protected MANY2(laFuncOrAction: LookAheadFunc | GrammarAction, action?: GrammarAction): void;
-        /**
-         * @see MANY1
-         */
-        protected MANY3(laFuncOrAction: LookAheadFunc | GrammarAction, action?: GrammarAction): void;
-        /**
-         * @see MANY1
-         */
-        protected MANY4(laFuncOrAction: LookAheadFunc | GrammarAction, action?: GrammarAction): void;
-        /**
-         * @see MANY1
-         */
-        protected MANY5(laFuncOrAction: LookAheadFunc | GrammarAction, action?: GrammarAction): void;
-        /**
-         * Convenience method equivalent to AT_LEAST_ONE1
-         * @see AT_LEAST_ONE1
-         */
-        protected AT_LEAST_ONE(laFuncOrAction: LookAheadFunc | GrammarAction, action: GrammarAction | string, errMsg?: string): void;
-        /**
-         *
-         * convenience method, same as MANY but the repetition is of one or more.
-         * failing to match at least one repetition will result in a parsing error and
-         * cause the parser to attempt error recovery.
-         *
-         * @see MANY1
-         *
-         * @param {Function} laFuncOrAction The lookahead function that 'decides'
-         *                                  whether or not the AT_LEAST_ONE's action will be
-         *                                  invoked or the action to optionally invoke
-         * @param {Function} [action] The action to optionally invoke.
-         * @param {string} [errMsg] short title/classification to what is being matched
-         */
-        protected AT_LEAST_ONE1(laFuncOrAction: LookAheadFunc | GrammarAction, action: GrammarAction | string, errMsg?: string): void;
-        /**
-         * @see AT_LEAST_ONE1
-         */
-        protected AT_LEAST_ONE2(laFuncOrAction: LookAheadFunc | GrammarAction, action: GrammarAction | string, errMsg?: string): void;
-        /**
-         * @see AT_LEAST_ONE1
-         */
-        protected AT_LEAST_ONE3(laFuncOrAction: LookAheadFunc | GrammarAction, action: GrammarAction | string, errMsg?: string): void;
-        /**
-         * @see AT_LEAST_ONE1
-         */
-        protected AT_LEAST_ONE4(laFuncOrAction: LookAheadFunc | GrammarAction, action: GrammarAction | string, errMsg?: string): void;
-        /**
-         * @see AT_LEAST_ONE1
-         */
-        protected AT_LEAST_ONE5(laFuncOrAction: LookAheadFunc | GrammarAction, action: GrammarAction | string, errMsg?: string): void;
-        /**
-         * Convenience method, same as RULE with doReSync=false
-         * @see RULE
-         */
-        protected RULE_NO_RESYNC<T>(ruleName: string, impl: () => T, invalidRet: () => T): (idxInCallingRule: number, isEntryPoint?: boolean) => T;
-        /**
-         *
-         * @param {string} ruleName The name of the Rule. must match the var it is assigned to.
-         * @param {Function} impl The implementation of the Rule
-         * @param {Function} [invalidRet] A function that will return the chosen invalid value for the rule in case of
-         *                   re-sync recovery.
-         * @param {boolean} [doReSync] enable or disable re-sync recovery for this rule. defaults to true
-         * @returns {Function} The parsing rule which is the impl Function wrapped with the parsing logic that handles
-         *                     Parser state / error recovery / ...
-         */
-        protected RULE<T>(ruleName: string, impl: (...implArgs: any[]) => T, invalidRet?: () => T, doReSync?: boolean): (idxInCallingRule?: number, ...args: any[]) => T;
-        protected ruleInvocationStateUpdate(ruleName: string, idxInCallingRule: number): void;
-        protected ruleFinallyStateUpdate(): void;
-        protected getTokenToInsert(tokClass: Function): Token;
-        protected canTokenTypeBeInsertedInRecovery(tokClass: Function): boolean;
-        private defaultInvalidReturn();
-        private ruleNamePattern;
-        private definedRulesNames;
-        /**
-         * @param ruleFuncName name of the Grammar rule
-         * @throws Grammar validation errors if the name is invalid
-         */
-        private validateRuleName(ruleFuncName);
-        private tryInRepetitionRecovery(grammarRule, grammarRuleArgs, lookAheadFunc, expectedTokType);
-        private shouldInRepetitionRecoveryBeTried(expectTokAfterLastMatch?, nextTokIdx?);
-        private getFollowsForInRuleRecovery(tokClass, tokIdxInRule);
-        private tryInRuleRecovery(expectedTokType, follows);
-        private canPerformInRuleRecovery(expectedToken, follows);
-        private canRecoverWithSingleTokenInsertion(expectedTokType, follows);
-        private canRecoverWithSingleTokenDeletion(expectedTokType);
-        private isInCurrentRuleReSyncSet(token);
-        private findReSyncTokenType();
-        private getCurrFollowKey();
-        private buildFullFollowKeyStack();
-        private flattenFollowSet();
-        private getFollowSetFromFollowKey(followKey);
-        private reSyncTo(tokClass);
-        private attemptInRepetitionRecovery(prodFunc, args, lookaheadFunc, prodName, prodOccurrence, nextToksWalker, prodKeys);
-        private optionInternal(condition, action);
-        private atLeastOneInternal(prodFunc, prodName, prodOccurrence, lookAheadFunc, action, errMsg?);
-        private manyInternal(prodFunc, prodName, prodOccurrence, lookAheadFunc, action?);
-        private orInternal<T>(alts, errMsgTypes, occurrence, ignoreAmbiguities);
-        /**
-         * @param tokClass The Type of Token we wish to consume (Reference to its constructor function)
-         * @param idx occurrence index of consumed token in the invoking parser rule text
-         *         for example:
-         *         IDENT (DOT IDENT)*
-         *         the first ident will have idx 1 and the second one idx 2
-         *         * note that for the second ident the idx is always 2 even if its invoked 30 times in the same rule
-         *           the idx is about the position in grammar (source code) and has nothing to do with a specific invocation
-         *           details
-         *
-         * @returns the consumed Token
-         */
-        private consumeInternal(tokClass, idx);
-        private consumeInternalOptimized(tokClass);
-        private getKeyForAutomaticLookahead(prodName, prodKeys, occurrence);
-        private getLookaheadFuncForOption(occurence);
-        private getLookaheadFuncForOr(occurence, ignoreErrors);
-        private getLookaheadFuncForMany(occurence);
-        private getLookaheadFuncForAtLeastOne(occurence);
-        private getLookaheadFuncFor<T>(key, occurrence, laFuncBuilder, extraArgs?);
-        private saveRecogState();
-        private reloadRecogState(newState);
-        private raiseNoAltException(errMsgTypes);
-    }
-
-	module exceptions {
-    	function isRecognitionException(error: Error): boolean;
-    	function MismatchedTokenException(message: string, token: Token): void;
-    	function NoViableAltException(message: string, token: Token): void;
-    	function NotAllInputParsedException(message: string, token: Token): void;
-    	function EarlyExitException(message: string, token: Token): void;
-	}
-	
-
-	module gast {
-    	interface IProduction {
-        	accept(visitor: GAstVisitor): void;
-    	}
-    	interface IProductionWithOccurrence extends IProduction {
-        	occurrenceInParent: number;
-        	implicitOccurrenceIndex: boolean;
-    	}
-    	class AbstractProduction implements IProduction {
-        	definition: IProduction[];
-        	implicitOccurrenceIndex: boolean;
-        	constructor(definition: IProduction[]);
-        	accept(visitor: GAstVisitor): void;
-    	}
-    	class NonTerminal extends AbstractProduction implements IProductionWithOccurrence {
-        	nonTerminalName: string;
-        	referencedRule: Rule;
-        	occurrenceInParent: number;
-        	constructor(nonTerminalName: string, referencedRule?: Rule, occurrenceInParent?: number);
-        	definition: IProduction[];
-        	accept(visitor: GAstVisitor): void;
-    	}
-    	class Rule extends AbstractProduction {
-        	name: string;
-        	constructor(name: string, definition: IProduction[]);
-    	}
-    	class Flat extends AbstractProduction {
-        	constructor(definition: IProduction[]);
-    	}
-    	class Option extends AbstractProduction implements IProductionWithOccurrence {
-        	occurrenceInParent: number;
-        	constructor(definition: IProduction[], occurrenceInParent?: number);
-    	}
-    	class RepetitionMandatory extends AbstractProduction implements IProductionWithOccurrence {
-        	occurrenceInParent: number;
-        	constructor(definition: IProduction[], occurrenceInParent?: number);
-    	}
-    	class Repetition extends AbstractProduction implements IProductionWithOccurrence {
-        	occurrenceInParent: number;
-        	constructor(definition: IProduction[], occurrenceInParent?: number);
-    	}
-    	class Alternation extends AbstractProduction implements IProductionWithOccurrence {
-        	occurrenceInParent: number;
-        	constructor(definition: IProduction[], occurrenceInParent?: number);
-    	}
-    	class Terminal implements IProductionWithOccurrence {
-        	terminalType: Function;
-        	occurrenceInParent: number;
-        	implicitOccurrenceIndex: boolean;
-        	constructor(terminalType: Function, occurrenceInParent?: number);
-        	accept(visitor: GAstVisitor): void;
-    	}
-    	class GAstVisitor {
-        	visit(node: IProduction): void;
-        	visitNonTerminal(node: NonTerminal): void;
-        	visitFlat(node: Flat): void;
-        	visitOption(node: Option): void;
-        	visitRepetitionMandatory(node: RepetitionMandatory): void;
-        	visitRepetition(node: Repetition): void;
-        	visitAlternation(node: Alternation): void;
-        	visitTerminal(node: Terminal): void;
-    	}
-	}
-	
-}
\ No newline at end of file
diff --git a/gruntfile.js b/gruntfile.js
index ec42245ba..3bf23112d 100644
--- a/gruntfile.js
+++ b/gruntfile.js
@@ -1,7 +1,6 @@
 var _ = require('lodash')
-var specsFiles = require('./scripts/findSpecs')("bin/tsc/test/", "test")
-var srcFiles = require('./scripts/findRefs')('build/chevrotain.ts')
 var semver = require("semver")
+var webpack = require("webpack")
 
 var githubReleaseFiles = ['./package.json',
     './LICENSE.txt',
@@ -12,8 +11,21 @@ var githubReleaseFiles = ['./package.json',
     'bin/docs'
 ]
 
+var PUBLIC_API_DTS_FILES = [
+    'bin/src/scan/tokens_public.d.ts',
+    'bin/src/scan/lexer_public.d.ts',
+    'bin/src/parse/parser_public.d.ts',
+    'bin/src/parse/exceptions_public.d.ts',
+    'bin/src/parse/grammar/gast_public.d.ts']
+
+var PUBLIC_API_TS_FILES = _.map(PUBLIC_API_DTS_FILES, function(binDefFile) {
+    return binDefFile.replace("bin/", "").replace(".d", "")
+})
+
 var INSTALL_LINK_TEST = 'npm install && npm link chevrotain && npm test'
 
+var fourSpaces = "    "
+
 // Integration tests using older versions of node.js will
 // avoid running tests that require ES6 capabilities only aviliable in node.js >= 4
 var nodejs_examples_test_command = semver.gte(process.version, "4.0.0") ?
@@ -71,72 +83,43 @@ module.exports = function(grunt) {
                 browsers:   ['Chrome_travis_ci', "Firefox"]
             },
 
-            dev_build: {
-                options: {
-                    singleRun: false,
-                    browsers:  ['Chrome']
-                }
-            },
-
             browsers_tests: {
                 options: {
                     files: [
                         'test/test.config.js',
-                        'bin/chevrotain.js',
-                        'bower_components/lodash/lodash.js',
                         'bin/chevrotainSpecs.js'
                     ]
                 }
             },
 
-            browsers_tests_requirejs: {
+            browsers_tests_local: {
                 options: {
-                    frameworks: ["requirejs", 'mocha', 'chai'],
+                    browsers: ['Chrome', "Firefox", "IE"],
 
                     files: [
                         'test/test.config.js',
-                        'bin/chevrotain.js',
-                        'test/requirejs_test_main.js',
-                        {pattern: 'bower_components/lodash/lodash.js', included: false},
-                        {pattern: 'bin/chevrotainSpecs.js', included: false}
-                    ]
-                }
-            },
-
-            browsers_tests_minified: {
-                options: {
-                    files: [
-                        'test/test.config.js',
-                        'bin/chevrotain.min.js',
-                        'bower_components/lodash/lodash.js',
                         'bin/chevrotainSpecs.js'
                     ]
                 }
             },
 
-            browsers_tests_requirejs_minified: {
+            browsers_tests_minified: {
                 options: {
-                    frameworks: ["requirejs", 'mocha', 'chai'],
-
                     files: [
                         'test/test.config.js',
-                        'bin/chevrotain.min.js',
-                        'test/requirejs_test_main.js',
-                        {pattern: 'bower_components/lodash/lodash.js', included: false},
-                        {pattern: 'bin/chevrotainSpecs.js', included: false}
+                        'bin/chevrotainSpecs.min.js'
                     ]
                 }
             }
+
         },
 
         mocha_istanbul: {
             coverage: {
-                src:     'bin/chevrotain.js',
+                src:     'bin/test',
                 options: {
-                    root:           './bin/',
-                    mask:           '*tainSpecs.js',
-                    coverageFolder: 'bin/coverage',
-                    excludes:       ['*tainSpecs.js']
+                    mask:           '**/*spec.js',
+                    coverageFolder: 'bin/coverage'
                 }
             }
         },
@@ -167,73 +150,35 @@ module.exports = function(grunt) {
 
         ts: {
             options: {
-                bin:  "ES5",
-                fast: "never"
-
-            },
+                target:    "ES5",
+                fast:      "never",
+                sourceMap: false
 
-            dev_build: {
-                src:    ["**/*.ts", "!node_modules/**/*.ts", "!build/**/*.ts", "!bin/**/*.ts", "!release/**/*.ts"],
-                outDir: "bin/gen"
             },
 
             release: {
-                src:     ['build/chevrotain.ts'],
-                out:     'bin/chevrotain.js',
-                options: {
-                    removeComments: false,
-                    sourceMap:      false // due to UMD and concat generated headers the original source map will be invalid.
-                }
-            },
-
-            validate_definitions: {
-                src:    ["bin/chevrotain.d.ts"],
-                outDir: "bin/garbage"
-            },
-
-            // this is the same as the 'build' process, all .ts --> .js in gen directory
-            // in a later step those files will be aggregated into separate components
-            release_test_code: {
                 src:     ["src/**/*.ts", "test/**/*.ts", "libs/**/*.ts"],
-                outDir:  "bin/tsc",
+                outDir:  'bin',
                 options: {
+                    module:         "commonjs",
                     declaration:    true,
-                    removeComments: false,
-                    sourceMap:      false // due to UMD and concat generated headers the original source map will be invalid.
+                    removeComments: false
                 }
-            }
-        },
+            },
 
-        umd: {
-            release: {
+            validate_definitions: {
+                src:     ["tests_integration/definitions/es6_modules.ts"],
+                outDir:  "bin/garbage",
                 options: {
-                    src:            'bin/chevrotain.js',
-                    template:       'scripts/umd.hbs',
-                    objectToExport: 'API',
-                    amdModuleId:    'chevrotain',
-                    globalAlias:    'chevrotain',
-                    deps:           {
-                        'default': [],
-                        amd:       [],
-                        cjs:       [],
-                        global:    []
-                    }
+                    module: "commonjs"
                 }
             },
 
-            release_specs: {
-                options: {
-                    src:      'bin/chevrotainSpecs.js',
-                    template: 'scripts/umd.hbs',
-                    deps:     {
-                        'default': ['_', 'config', 'chevrotain'],
-                        // dummy empty <''> to align arguments and parameters
-                        // (sometimes two sometimes three depending on module loader)
-                        amd:       ['lodash', '', 'chevrotain'],
-                        cjs:       ['lodash', '../test/test.config.js', './chevrotain'],
-                        global:    ['_', "undefined", 'chevrotain']
-                    }
-                }
+            // the created d.ts should work with both Typescript projects using ES6
+            // modules syntax or those using the old namespace syntax.
+            validate_definitions_namespace: {
+                src:    ["tests_integration/definitions/namespaces.ts"],
+                outDir: "bin/garbage"
             }
         },
 
@@ -242,80 +187,60 @@ module.exports = function(grunt) {
             dev:     ['bin/gen']
         },
 
-        concat: {
-            release:             {
-                options: {
-                    banner: banner,
-
-                    process: function fixTSModulePatternForCoverage(src, filePath) {
-                        // prefix (lang = chevrotain.lang || (chevrotain.lang = {}) with /* istanbul ignore next */
-                        var fixed2PartsModules = src.replace(
-                            /(\((\w+) = (\w+\.\2) \|\|) (\(\3 = \{}\)\))/g, "/* istanbul ignore next */ $1 /* istanbul ignore next */ $4")
-
-                        var fixedAllModulesPattern = fixed2PartsModules.replace(
-                            /(\(chevrotain \|\| \(chevrotain = \{}\)\);)/g, "/* istanbul ignore next */ $1")
-
-                        var fixedTypeScriptExtends = fixedAllModulesPattern.replace("if (b.hasOwnProperty(p)) d[p] = b[p];",
-                            "/* istanbul ignore next */ " + " if (b.hasOwnProperty(p)) d[p] = b[p];")
-
-                        fixedTypeScriptExtends = fixedTypeScriptExtends.replace("d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());",
-                            "/* istanbul ignore next */ " + " d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());")
-
-                        // TODO: typescript compiler swallows comments in certain situations
-                        //       once this is fixed the string replacements below can be removed.
-
-                        // very little point in testing this, this is a pattern matching functionality missing in typescript/javascript
-                        // if the code reaches that point it will go "boom" which is the purpose, the going boom part is not part
-                        // of the contract, it just makes sure we fail fast if we supply invalid arguments.
-                        var fixedNoneExhaustive = fixedTypeScriptExtends.replace(/(\s+)(else if \(.+\s+.+\s+.+\s+else \{\s+throw Error\("non exhaustive match"\))/g,
-                            "/* istanbul ignore else */ $1$2")
-
-                        fixedNoneExhaustive = fixedNoneExhaustive.replace(/(throw\s*Error\s*\(\s*["']non exhaustive match["']\s*\))/g,
-                            "/* istanbul ignore next */ $1")
-
-                        return fixedNoneExhaustive
-                    }
-                },
+        "string-replace": {
+            coverage_ignore: {
                 files:   {
-                    'bin/chevrotain.js':      ['bin/chevrotain.js'],
-                    'bin/chevrotainSpecs.js': specsFiles
+                    'bin/src/': 'bin/src/**'
+                },
+                options: {
+                    replacements: [{
+                        pattern:     'if (b.hasOwnProperty(p)) d[p] = b[p];',
+                        replacement: '/* istanbul ignore next */ ' + ' if (b.hasOwnProperty(p)) d[p] = b[p];'
+                    }, {
+                        pattern:     'd.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());',
+                        replacement: '/* istanbul ignore next */ ' + ' d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());'
+                    }, {
+                        pattern:     /(\s+)(else if \(.+\s+.+\s+.+\s+else \{\s+throw Error\("non exhaustive match"\))/g,
+                        replacement: '/* istanbul ignore else */ $1$2'
+                    }, {
+                        pattern:     /(throw\s*Error\s*\(\s*["']non exhaustive match["']\s*\))/g,
+                        replacement: '/* istanbul ignore next */ $1'
+                    }]
                 }
-            },
+            }
+        },
+
+        concat: {
             release_definitions: {
                 options: {
-                    banner:  banner +
-                             'declare module chevrotain {\n' +
-                             '    module lang {\n' +
-                             '        class HashTable<V>{}\n' +
-                             '    }\n',
-                    process: function removeOriginalHeaderAndFooter(src, filePath) {
-                        var fixedModuleName, fixedIndentation
-                        if (_.contains(filePath, 'gast_public')) {
-                            fixedModuleName = src.replace('declare namespace chevrotain.gast {', '\nmodule gast {')
-                            fixedIndentation = fixedModuleName.replace(/([\n\r]+\s*)/g, '$1\t')
-                            return fixedIndentation
-                        }
-                        else if (_.contains(filePath, 'exceptions_public')) {
-                            fixedModuleName = src.replace('declare namespace chevrotain.exceptions {', '\nmodule exceptions {')
-                            fixedIndentation = fixedModuleName.replace(/([\n\r]+\s*)/g, '$1\t')
-                            return fixedIndentation
-                        }
-                        var result = src.replace("declare namespace chevrotain {", "")
-                        var lastRCurlyIdx = result.lastIndexOf("}")
-                        result = result.substring(0, lastRCurlyIdx)
-                        result = _.trimRight(result)
-                        return result
+                    // TODO: seems like the HashTable class may need to be included in the public API
+                    banner: banner +
+                            'declare namespace chevrotain {\n' +
+                            'class HashTable<V>{}\n',
+
+                    process: function processDefinitions(src, filePath) {
+                        var withOutImports = src.replace(/import.*;(\n|\r\n)/g, '')
+                        // TODO: investigate why do Typescript definition files include private members.
+                        var withoutPrivate = withOutImports.replace(/private.*;(\n|\r\n)/g, '')
+
+                        // need to remove inner declares as we are wrapping in a namespace
+                        var withoutDeclare = withoutPrivate.replace(/declare /g, '')
+                        var fixedInnerIdent = withoutDeclare.replace(/(\r\n|\n)/g, grunt.util.linefeed + fourSpaces)
+                        return fixedInnerIdent
                     },
 
-                    footer: '\n}'
+                    // this syntax allows usage of chevrotain.d.ts from either
+                    // ES6 modules / older namespaces style in typescript.
+                    footer: '}\n' +
+                            'declare module "chevrotain" {\n' +
+                            '    export = chevrotain;\n' +
+                            '}\n',
+
+                    // extra spaces needed to fix indentation.
+                    separator: grunt.util.linefeed + fourSpaces
                 },
                 files:   {
-                    'bin/chevrotain.d.ts': [
-                        'bin/tsc/src/scan/tokens_public.d.ts',
-                        'bin/tsc/src/scan/lexer_public.d.ts',
-                        'bin/tsc/src/parse/parser_public.d.ts',
-                        'bin/tsc/src/parse/exceptions_public.d.ts',
-                        'bin/tsc/src/parse/grammar/gast_public.d.ts']
+                    'bin/chevrotain.d.ts': PUBLIC_API_DTS_FILES
                 }
             }
         },
@@ -326,15 +251,45 @@ module.exports = function(grunt) {
                     mode:             'file',
                     target:           'es5',
                     out:              'bin/docs',
+                    module:           'commonjs',
                     name:             'Chevrotain',
-                    excludeExternals: '',
-                    // see: https://github.com/sebastian-lenz/typedoc/issues/73
-                    // double negative for the win!
-                    externalPattern:  '!**/*public**'
+                    excludeExternals: ''
                 },
-                // must include all the files explicitly instead of just targeting build/chevrotain.ts
-                // otherwise the include(exclude !...) won't work
-                src:     srcFiles
+                src:     PUBLIC_API_TS_FILES
+            }
+        },
+
+        webpack: {
+            options : {
+                stats:       {
+                    colors:  true,
+                    modules: true,
+                    reasons: true
+                },
+                failOnError: true
+            },
+
+            release: {
+                entry:  "./bin/src/api.js",
+                output: {
+                    path:           "bin/",
+                    filename:       "chevrotain.js",
+                    library:        "chevrotain",
+                    libraryTarget:  "umd",
+                    umdNamedDefine: true
+                },
+
+                plugins: [
+                    new webpack.BannerPlugin(banner, {raw: true})
+                ]
+            },
+
+            specs: {
+                entry: "./bin/test/all.js",
+                output: {
+                    path:           "bin/",
+                    filename:       "chevrotainSpecs.js"
+                }
             }
         },
 
@@ -362,13 +317,20 @@ module.exports = function(grunt) {
         uglify: {
             options: {
                 // not using name mangling because it may break usage of Function.name (functionName utility)
-                mangle: false,
-                banner: banner
+                mangle: false
             },
             release: {
-                files: {
+                options: {
+                    banner: banner
+                },
+                files:   {
                     'bin/chevrotain.min.js': ['bin/chevrotain.js']
                 }
+            },
+            specs:   {
+                files: {
+                    'bin/chevrotainSpecs.min.js': ['bin/chevrotainSpecs.js']
+                }
             }
         }
     })
@@ -377,15 +339,16 @@ module.exports = function(grunt) {
 
     var buildTasks = [
         'clean:release',
-        'ts:release',
-        'ts:release_test_code',
         'tslint',
-        'concat:release',
+        'ts:release',
+        'string-replace:coverage_ignore',
         'concat:release_definitions',
         'ts:validate_definitions',
-        'umd:release',
-        'umd:release_specs',
+        'ts:validate_definitions_namespace',
+        'webpack:release',
+        'webpack:specs',
         'uglify:release',
+        'uglify:specs',
         'typedoc:build_docs',
         'compress'
     ]
@@ -405,9 +368,7 @@ module.exports = function(grunt) {
 
     var browserUnitTests = [
         "karma:browsers_tests",
-        "karma:browsers_tests_requirejs",
-        "karma:browsers_tests_minified",
-        "karma:browsers_tests_requirejs_minified"
+        "karma:browsers_tests_minified"
     ]
 
     var buildTestTasks = buildTasks.concat(unitTestsTasks)
@@ -417,10 +378,4 @@ module.exports = function(grunt) {
     grunt.registerTask('unit_tests', unitTestsTasks)
     grunt.registerTask('integration_tests', integrationTestsTasks)
     grunt.registerTask('browsers_unit_tests', browserUnitTests)
-
-    grunt.registerTask('dev_build_test', [
-        'clean:dev',
-        'ts:dev_build',
-        'tslint',
-        'karma:dev_build'])
 }
diff --git a/karma.conf.js b/karma.conf.js
index eaef58273..a19291d06 100644
--- a/karma.conf.js
+++ b/karma.conf.js
@@ -1,20 +1,3 @@
-var specsFiles = require('./scripts/findSpecs')("bin/gen/test/", "test")
-var findRefs = require('./scripts/findRefs')
-var _ = require('lodash')
-
-var coreIncludes = findRefs('./build/chevrotain.ts', "bin/gen/");
-coreIncludes = _.reject(coreIncludes, function(srcFile) {
-    return /libs\//.test(srcFile)
-})
-
-coreIncludes = _.map(coreIncludes, function(srcFile) {
-    var fixedPath = srcFile.replace('src', 'bin/gen/src')
-    var fixedSuffix = fixedPath.replace('.ts', '.js')
-    return fixedSuffix
-})
-
-var allSrcsIncludes = coreIncludes.concat(specsFiles)
-
 module.exports = function(config) {
     "use strict";
 
@@ -26,14 +9,10 @@ module.exports = function(config) {
         // frameworks to use
         frameworks: ['mocha', 'chai'],
 
-        // list of files / patterns to load in the browser
-        files: ['bower_components/lodash/lodash.js'].concat(
-            [
-                {pattern: 'bin/gen/**/*.map', included: false},
-                {pattern: 'src/**/*.ts', included: false},
-                {pattern: 'test/**/*.ts', included: false}
-            ],
-            allSrcsIncludes),
+        files: [
+            'test/test.config.js',
+            'bin/chevrotainSpecs.js'
+        ],
 
         // test results reporter to use
         // possible values: 'dots', 'progress', 'junit', 'growl', 'coverage'
@@ -49,7 +28,6 @@ module.exports = function(config) {
         // possible values: config.LOG_DISABLE || config.LOG_ERROR || config.LOG_WARN || config.LOG_INFO || config.LOG_DEBUG
         logLevel: config.LOG_INFO,
 
-
         // enable / disable watching file and executing tests whenever any file changes
         autoWatch: false,
 
diff --git a/package.json b/package.json
index 81f369da3..17880550f 100644
--- a/package.json
+++ b/package.json
@@ -29,6 +29,7 @@
     }
   ],
   "files": [
+    "bin/src/**/*.js",
     "bin/docs",
     "bin/chevrotain.d.ts",
     "bin/chevrotain.min.js",
@@ -36,7 +37,7 @@
     "readme.md",
     "LICENSE.TXT"
   ],
-  "main": "bin/chevrotain.js",
+  "main": "bin/src/api.js",
   "repository": {
     "type": "git",
     "url": "git://github.com/SAP/chevrotain.git"
@@ -60,10 +61,11 @@
     "grunt-karma": "~0.12.1",
     "grunt-mocha-istanbul": "^3.0.1",
     "grunt-run": "^0.5.2",
+    "grunt-string-replace": "^1.2.1",
     "grunt-ts": "~5.3.0-beta.3",
     "grunt-tslint": "~3.0.1",
     "grunt-typedoc": "^0.2.3",
-    "grunt-umd": "~2.3.5",
+    "grunt-webpack": "^1.0.11",
     "istanbul": "^0.4.1",
     "jsonfile": "^2.2.3",
     "karma": "~0.13.19",
@@ -82,6 +84,8 @@
     "semver": "^5.1.0",
     "tslint": "^3.2.1",
     "typescript": "~1.7.5",
+    "webpack": "^1.12.11",
+    "webpack-dev-server": "^1.14.1",
     "wrench": "^1.5.8"
   }
 }
diff --git a/scripts/findRefs.js b/scripts/findRefs.js
deleted file mode 100644
index 75b8ff4a9..000000000
--- a/scripts/findRefs.js
+++ /dev/null
@@ -1,20 +0,0 @@
-var _ = require('lodash')
-var fs = require('fs')
-
-var tsRefRegex = /path\s*=\s*["']\.\.\/(.+\.ts)/g;
-
-function getCapturingGroups(targetStr, regex, i) {
-    var references = [];
-    var matched;
-    while (matched = regex.exec(targetStr)) {
-        var currRef = matched[i];
-        references.push(currRef);
-    }
-    return references;
-}
-
-module.exports = function getIncludesFromTsRefsFile(fileName) {
-    var contents = fs.readFileSync(fileName).toString();
-    var refs = getCapturingGroups(contents, tsRefRegex, 1);
-    return refs;
-}
diff --git a/scripts/findSpecs.js b/scripts/findSpecs.js
deleted file mode 100644
index 6a46ab92d..000000000
--- a/scripts/findSpecs.js
+++ /dev/null
@@ -1,27 +0,0 @@
-var wrench = require('wrench')
-var _ = require('lodash')
-
-
-module.exports = function(prefix, base) {
-    var testFolderContents = wrench.readdirSyncRecursive(base);
-
-    var testFolderJSContents = _.map(testFolderContents, function(currItem) {
-        var tsToJs = currItem.replace(".ts", ".js")
-        var toLinuxSlash = tsToJs.replace(/\\/g, "/")
-        return toLinuxSlash
-    })
-
-    var testFolderFiles = _.filter(testFolderJSContents, function(currItem) {
-        return _.endsWith(currItem, ".js")
-    })
-
-    var specs = _.filter(testFolderJSContents, function(currFileOrDir) {
-        return _.endsWith(currFileOrDir, 'spec.js')
-    })
-    var utilsAndExamples = _.difference(testFolderFiles, specs)
-
-    var allSpecsAndExamples = utilsAndExamples.concat(specs)
-    return _.map(allSpecsAndExamples, function(currFile) {
-        return prefix + currFile;
-    })
-}
\ No newline at end of file
diff --git a/src/api.ts b/src/api.ts
index 769ac9faa..bc302241d 100644
--- a/src/api.ts
+++ b/src/api.ts
@@ -1,57 +1,52 @@
+import {Parser, EMPTY_ALT} from "./parse/parser_public"
+import {Lexer} from "./scan/lexer_public"
+import {Token, VirtualToken, EOF, extendToken, tokenName} from "./scan/tokens_public"
+import {exceptions} from "./parse/exceptions_public"
+import {gast} from "./parse/grammar/gast_public"
+
 /**
- * defines the public API of Chevrotain.
+ * defines the public API of
  * changes here may require major version change. (semVer)
  */
-declare let global
-declare let CHEV_TEST_MODE
-/* istanbul ignore next */
-let testMode = (typeof global === "object" && (<any>global).CHEV_TEST_MODE) ||
-    (typeof window === "object" && (<any>window).CHEV_TEST_MODE)
-
 let API:any = {}
-/* istanbul ignore next */
-if (!testMode) {
-    // semantic version
-    API.VERSION = "0.5.14";
-
-    // runtime API
-    API.Parser = chevrotain.Parser
-    API.Lexer = chevrotain.Lexer
-    API.Token = chevrotain.Token
-    API.VirtualToken = chevrotain.VirtualToken
-    API.EOF = chevrotain.EOF
-
-    // Tokens utilities
-    API.extendToken = chevrotain.extendToken
-    API.tokenName = chevrotain.tokenName
-
-    // Other Utilities
-    API.EMPTY_ALT = chevrotain.EMPTY_ALT
-
-    API.exceptions = {}
-    API.exceptions.isRecognitionException = chevrotain.exceptions.isRecognitionException
-    API.exceptions.EarlyExitException = chevrotain.exceptions.EarlyExitException
-    API.exceptions.MismatchedTokenException = chevrotain.exceptions.MismatchedTokenException
-    API.exceptions.NotAllInputParsedException = chevrotain.exceptions.NotAllInputParsedException
-    API.exceptions.NoViableAltException = chevrotain.exceptions.NoViableAltException
-
-    // grammar reflection API
-    API.gast = {}
-    API.gast.GAstVisitor = chevrotain.gast.GAstVisitor
-    API.gast.Flat = chevrotain.gast.Flat
-    API.gast.Repetition = chevrotain.gast.Repetition
-    API.gast.RepetitionWithSeparator = chevrotain.gast.RepetitionWithSeparator
-    API.gast.RepetitionMandatory = chevrotain.gast.RepetitionMandatory
-    API.gast.RepetitionMandatoryWithSeparator = chevrotain.gast.RepetitionMandatoryWithSeparator
-    API.gast.Option = chevrotain.gast.Option
-    API.gast.Alternation = chevrotain.gast.Alternation
-    API.gast.NonTerminal = chevrotain.gast.NonTerminal
-    API.gast.Terminal = chevrotain.gast.Terminal
-    API.gast.Rule = chevrotain.gast.Rule
-}
-else {
-    console.log("running in TEST_MODE")
-    API = chevrotain
-}
-
 
+// semantic version
+API.VERSION = "0.5.14"
+
+// runtime API
+API.Parser = Parser
+API.Lexer = Lexer
+API.Token = Token
+API.VirtualToken = VirtualToken
+API.EOF = EOF
+
+// Tokens utilities
+API.extendToken = extendToken
+API.tokenName = tokenName
+
+// Other Utilities
+API.EMPTY_ALT = EMPTY_ALT
+
+API.exceptions = {}
+API.exceptions.isRecognitionException = exceptions.isRecognitionException
+API.exceptions.EarlyExitException = exceptions.EarlyExitException
+API.exceptions.MismatchedTokenException = exceptions.MismatchedTokenException
+API.exceptions.NotAllInputParsedException = exceptions.NotAllInputParsedException
+API.exceptions.NoViableAltException = exceptions.NoViableAltException
+
+
+// grammar reflection API
+API.gast = {}
+API.gast.GAstVisitor = gast.GAstVisitor
+API.gast.Flat = gast.Flat
+API.gast.Repetition = gast.Repetition
+API.gast.RepetitionWithSeparator = gast.RepetitionWithSeparator
+API.gast.RepetitionMandatory = gast.RepetitionMandatory
+API.gast.RepetitionMandatoryWithSeparator = gast.RepetitionMandatoryWithSeparator
+API.gast.Option = gast.Option
+API.gast.Alternation = gast.Alternation
+API.gast.NonTerminal = gast.NonTerminal
+API.gast.Terminal = gast.Terminal
+API.gast.Rule = gast.Rule
+
+module.exports =  API
diff --git a/src/env.d.ts b/src/env.d.ts
new file mode 100644
index 000000000..a4221028a
--- /dev/null
+++ b/src/env.d.ts
@@ -0,0 +1,2 @@
+declare let module:any;
+
diff --git a/src/lang/lang_extensions.ts b/src/lang/lang_extensions.ts
index 8702c37e7..b67839080 100644
--- a/src/lang/lang_extensions.ts
+++ b/src/lang/lang_extensions.ts
@@ -1,68 +1,66 @@
+import * as utils from "../utils/utils"
 
-namespace chevrotain.lang {
+let nameRegex = /^\s*function\s*(\S*)\s*\(/
+/* istanbul ignore next */
+let hasNativeName = typeof (<any>(function f() {})).name !== "undefined"
 
-    let nameRegex = /^\s*function\s*(\S*)\s*\(/
-    /* istanbul ignore next */
-    let hasNativeName = typeof (<any>(function f() {})).name !== "undefined"
+export function classNameFromInstance(instance:any):string {
+    return functionName(instance.constructor)
+}
 
-    export function classNameFromInstance(instance:any):string {
-        return functionName(instance.constructor)
+/* istanbul ignore next too many hacks for IE here*/
+export function functionName(func:Function):string {
+    if (hasNativeName) {
+        return (<any>func).name
     }
 
-    /* istanbul ignore next too many hacks for IE here*/
-    export function functionName(func:Function):string {
-        if (hasNativeName) {
-            return (<any>func).name
-        }
-
-        else if ((<any>func).rdtFuncNameCache666) {
-            // super 'special' property name on INSTANCE to avoid hurting those who use browsers that
-            // do not support name property even more (IE...)
-            return (<any>func).rdtFuncNameCache666
-        }
-        /* istanbul ignore next */
-        else {
-            let name = func.toString().match(nameRegex)[1];
-            (<any>func).rdtFuncNameCache666 = name
-            return name
-        }
+    else if ((<any>func).rdtFuncNameCache666) {
+        // super 'special' property name on INSTANCE to avoid hurting those who use browsers that
+        // do not support name property even more (IE...)
+        return (<any>func).rdtFuncNameCache666
     }
+    /* istanbul ignore next */
+    else {
+        let name = func.toString().match(nameRegex)[1];
+        (<any>func).rdtFuncNameCache666 = name
+        return name
+    }
+}
 
-    /**
-     * simple Hashtable between a string and some generic value
-     * this should be removed once typescript supports ES6 style Hashtable
-     */
-    export class HashTable<V> {
-
-        private _state = {}
+/**
+ * simple Hashtable between a string and some generic value
+ * this should be removed once typescript supports ES6 style Hashtable
+ */
+export class HashTable<V> {
 
-        keys():string[] {
-            return utils.keys(this._state)
-        }
+    private _state = {}
 
-        values():V[] {
-            return <any>utils.values(this._state)
-        }
+    keys():string[] {
+        return utils.keys(this._state)
+    }
 
-        put(key:string, value:V):void {
-            this._state[key] = value
-        }
+    values():V[] {
+        return <any>utils.values(this._state)
+    }
 
-        putAll(other:HashTable<V>):void {
-            this._state = utils.assign(this._state, other._state)
-        }
+    put(key:string, value:V):void {
+        this._state[key] = value
+    }
 
-        get(key:string):V {
-            // To avoid edge case with a key called "hasOwnProperty" we need to perform the commented out check below
-            // -> if (Object.prototype.hasOwnProperty.call(this._state, key)) { ... } <-
-            // however this costs nearly 25% of the parser's runtime.
-            // if someone decides to name their Parser class "hasOwnProperty" they deserve what they will get :)
-            return this._state[key]
-        }
+    putAll(other:HashTable<V>):void {
+        this._state = utils.assign(this._state, other._state)
+    }
 
-        containsKey(key:string):boolean {
-            return utils.has(this._state, key)
-        }
+    get(key:string):V {
+        // To avoid edge case with a key called "hasOwnProperty" we need to perform the commented out check below
+        // -> if (Object.prototype.hasOwnProperty.call(this._state, key)) { ... } <-
+        // however this costs nearly 25% of the parser's runtime.
+        // if someone decides to name their Parser class "hasOwnProperty" they deserve what they will get :)
+        return this._state[key]
     }
 
+    containsKey(key:string):boolean {
+        return utils.has(this._state, key)
+    }
 }
+
diff --git a/src/parse/cache.ts b/src/parse/cache.ts
index 8393f3a98..cc582d1a2 100644
--- a/src/parse/cache.ts
+++ b/src/parse/cache.ts
@@ -1,79 +1,82 @@
 /**
- *
-namespace used to cache static information about parsers,
+ * module used to cache static information about parsers,
  */
-namespace chevrotain.cache {
-    export let CLASS_TO_DEFINITION_ERRORS = new lang.HashTable<IParserDefinitionError[]>()
 
-    export let CLASS_TO_SELF_ANALYSIS_DONE = new lang.HashTable<boolean>()
+import {IParserDefinitionError} from "./parser_public"
+import {HashTable} from "../lang/lang_extensions"
+import {gast} from "./grammar/gast_public"
+import {IFirstAfterRepetition} from "./grammar/interpreter"
 
-    export let CLASS_TO_GRAMMAR_PRODUCTIONS = new lang.HashTable<lang.HashTable<gast.Rule>>()
+export let CLASS_TO_DEFINITION_ERRORS = new HashTable<IParserDefinitionError[]>()
 
-    export function getProductionsForClass(className:string):lang.HashTable<gast.Rule> {
-        return getFromNestedHashTable(className, CLASS_TO_GRAMMAR_PRODUCTIONS)
-    }
+export let CLASS_TO_SELF_ANALYSIS_DONE = new HashTable<boolean>()
 
-    export let CLASS_TO_RESYNC_FOLLOW_SETS = new lang.HashTable<lang.HashTable<Function[]>>()
+export let CLASS_TO_GRAMMAR_PRODUCTIONS = new HashTable<HashTable<gast.Rule>>()
 
-    export function getResyncFollowsForClass(className:string):lang.HashTable<Function[]> {
-        return getFromNestedHashTable(className, CLASS_TO_RESYNC_FOLLOW_SETS)
-    }
+export function getProductionsForClass(className:string):HashTable<gast.Rule> {
+    return getFromNestedHashTable(className, CLASS_TO_GRAMMAR_PRODUCTIONS)
+}
 
-    export function setResyncFollowsForClass(className:string, followSet:lang.HashTable<Function[]>):void {
-        CLASS_TO_RESYNC_FOLLOW_SETS.put(className, followSet)
-    }
+export let CLASS_TO_RESYNC_FOLLOW_SETS = new HashTable<HashTable<Function[]>>()
 
-    export let CLASS_TO_LOOKAHEAD_FUNCS = new lang.HashTable<lang.HashTable<Function>>()
+export function getResyncFollowsForClass(className:string):HashTable<Function[]> {
+    return getFromNestedHashTable(className, CLASS_TO_RESYNC_FOLLOW_SETS)
+}
 
-    export function getLookaheadFuncsForClass(className:string):lang.HashTable<Function> {
-        return getFromNestedHashTable(className, CLASS_TO_LOOKAHEAD_FUNCS)
-    }
+export function setResyncFollowsForClass(className:string, followSet:HashTable<Function[]>):void {
+    CLASS_TO_RESYNC_FOLLOW_SETS.put(className, followSet)
+}
 
-    export let CLASS_TO_FIRST_AFTER_REPETITION = new lang.HashTable<lang.HashTable<interpreter.IFirstAfterRepetition>>()
+export let CLASS_TO_LOOKAHEAD_FUNCS = new HashTable<HashTable<Function>>()
 
-    export function getFirstAfterRepForClass(className:string):lang.HashTable<interpreter.IFirstAfterRepetition> {
-        return getFromNestedHashTable(className, CLASS_TO_FIRST_AFTER_REPETITION)
-    }
+export function getLookaheadFuncsForClass(className:string):HashTable<Function> {
+    return getFromNestedHashTable(className, CLASS_TO_LOOKAHEAD_FUNCS)
+}
 
-    export let CLASS_TO_OR_LA_CACHE = new lang.HashTable<lang.HashTable<string>[]>()
-    export let CLASS_TO_MANY_LA_CACHE = new lang.HashTable<lang.HashTable<string>[]>()
-    export let CLASS_TO_MANY_SEP_LA_CACHE = new lang.HashTable<lang.HashTable<string>[]>()
-    export let CLASS_TO_AT_LEAST_ONE_LA_CACHE = new lang.HashTable<lang.HashTable<string>[]>()
-    export let CLASS_TO_AT_LEAST_ONE_SEP_LA_CACHE = new lang.HashTable<lang.HashTable<string>[]>()
-    export let CLASS_TO_OPTION_LA_CACHE = new lang.HashTable<lang.HashTable<string>[]>()
-
-    // TODO: CONST in typescript 1.5
-    // TODO reflective test to verify this has not changed, for example (OPTION6 added)
-    export let MAX_OCCURRENCE_INDEX = 5
-
-    export function initLookAheadKeyCache(className) {
-        CLASS_TO_OR_LA_CACHE[className] = new Array(MAX_OCCURRENCE_INDEX)
-        CLASS_TO_MANY_LA_CACHE[className] = new Array(MAX_OCCURRENCE_INDEX)
-        CLASS_TO_MANY_SEP_LA_CACHE[className] = new Array(MAX_OCCURRENCE_INDEX)
-        CLASS_TO_AT_LEAST_ONE_LA_CACHE[className] = new Array(MAX_OCCURRENCE_INDEX)
-        CLASS_TO_AT_LEAST_ONE_SEP_LA_CACHE[className] = new Array(MAX_OCCURRENCE_INDEX)
-        CLASS_TO_OPTION_LA_CACHE[className] = new Array(MAX_OCCURRENCE_INDEX)
-
-        initSingleLookAheadKeyCache(CLASS_TO_OR_LA_CACHE[className])
-        initSingleLookAheadKeyCache(CLASS_TO_MANY_LA_CACHE[className])
-        initSingleLookAheadKeyCache(CLASS_TO_MANY_SEP_LA_CACHE[className])
-        initSingleLookAheadKeyCache(CLASS_TO_AT_LEAST_ONE_LA_CACHE[className])
-        initSingleLookAheadKeyCache(CLASS_TO_AT_LEAST_ONE_SEP_LA_CACHE[className])
-        initSingleLookAheadKeyCache(CLASS_TO_OPTION_LA_CACHE[className])
-    }
+export let CLASS_TO_FIRST_AFTER_REPETITION = new HashTable<HashTable<IFirstAfterRepetition>>()
+
+export function getFirstAfterRepForClass(className:string):HashTable<IFirstAfterRepetition> {
+    return getFromNestedHashTable(className, CLASS_TO_FIRST_AFTER_REPETITION)
+}
 
-    function initSingleLookAheadKeyCache(laCache:lang.HashTable<string>[]):void {
-        for (let i = 0; i < MAX_OCCURRENCE_INDEX; i++) {
-            laCache[i] = new lang.HashTable<string>()
-        }
+export let CLASS_TO_OR_LA_CACHE = new HashTable<HashTable<string>[]>()
+export let CLASS_TO_MANY_LA_CACHE = new HashTable<HashTable<string>[]>()
+export let CLASS_TO_MANY_SEP_LA_CACHE = new HashTable<HashTable<string>[]>()
+export let CLASS_TO_AT_LEAST_ONE_LA_CACHE = new HashTable<HashTable<string>[]>()
+export let CLASS_TO_AT_LEAST_ONE_SEP_LA_CACHE = new HashTable<HashTable<string>[]>()
+export let CLASS_TO_OPTION_LA_CACHE = new HashTable<HashTable<string>[]>()
+
+// TODO: CONST in typescript 1.5
+// TODO reflective test to verify this has not changed, for example (OPTION6 added)
+export let MAX_OCCURRENCE_INDEX = 5
+
+export function initLookAheadKeyCache(className) {
+    CLASS_TO_OR_LA_CACHE[className] = new Array(MAX_OCCURRENCE_INDEX)
+    CLASS_TO_MANY_LA_CACHE[className] = new Array(MAX_OCCURRENCE_INDEX)
+    CLASS_TO_MANY_SEP_LA_CACHE[className] = new Array(MAX_OCCURRENCE_INDEX)
+    CLASS_TO_AT_LEAST_ONE_LA_CACHE[className] = new Array(MAX_OCCURRENCE_INDEX)
+    CLASS_TO_AT_LEAST_ONE_SEP_LA_CACHE[className] = new Array(MAX_OCCURRENCE_INDEX)
+    CLASS_TO_OPTION_LA_CACHE[className] = new Array(MAX_OCCURRENCE_INDEX)
+
+    initSingleLookAheadKeyCache(CLASS_TO_OR_LA_CACHE[className])
+    initSingleLookAheadKeyCache(CLASS_TO_MANY_LA_CACHE[className])
+    initSingleLookAheadKeyCache(CLASS_TO_MANY_SEP_LA_CACHE[className])
+    initSingleLookAheadKeyCache(CLASS_TO_AT_LEAST_ONE_LA_CACHE[className])
+    initSingleLookAheadKeyCache(CLASS_TO_AT_LEAST_ONE_SEP_LA_CACHE[className])
+    initSingleLookAheadKeyCache(CLASS_TO_OPTION_LA_CACHE[className])
+}
+
+function initSingleLookAheadKeyCache(laCache:HashTable<string>[]):void {
+    for (let i = 0; i < MAX_OCCURRENCE_INDEX; i++) {
+        laCache[i] = new HashTable<string>()
     }
+}
 
-    function getFromNestedHashTable(className:string, hashTable:lang.HashTable<any>) {
-        let result = hashTable.get(className)
-        if (result === undefined) {
-            hashTable.put(className, new lang.HashTable<any>())
-            result = hashTable.get(className)
-        }
-        return result
+function getFromNestedHashTable(className:string, hashTable:HashTable<any>) {
+    let result = hashTable.get(className)
+    if (result === undefined) {
+        hashTable.put(className, new HashTable<any>())
+        result = hashTable.get(className)
     }
+    return result
 }
diff --git a/src/parse/constants.ts b/src/parse/constants.ts
index 2505a0a3b..83edc96ac 100644
--- a/src/parse/constants.ts
+++ b/src/parse/constants.ts
@@ -1,5 +1,2 @@
-namespace chevrotain.constants {
-
-    export let IN = "_~IN~_"
-}
-
+// TODO: can this be removed? where is it used?
+export let IN = "_~IN~_"
diff --git a/src/parse/exceptions_public.ts b/src/parse/exceptions_public.ts
index 8c26b7185..d99d86b10 100644
--- a/src/parse/exceptions_public.ts
+++ b/src/parse/exceptions_public.ts
@@ -1,34 +1,37 @@
-namespace chevrotain.exceptions {
+import {Token} from "../scan/tokens_public"
+import {functionName} from "../lang/lang_extensions"
+import {contains} from "../utils/utils"
 
+export namespace exceptions {
     export interface IRecognitionException {
         name:string,
         message:string,
         token:Token
     }
 
-    // hacks to bypass no support for custom Errors in javascript/typescript
+// hacks to bypass no support for custom Errors in javascript/typescript
     export function isRecognitionException(error:Error) {
         let recognitionExceptions = [
-            lang.functionName(MismatchedTokenException),
-            lang.functionName(NoViableAltException),
-            lang.functionName(EarlyExitException),
-            lang.functionName(NotAllInputParsedException)]
+            functionName(MismatchedTokenException),
+            functionName(NoViableAltException),
+            functionName(EarlyExitException),
+            functionName(NotAllInputParsedException)]
         // can't do instanceof on hacked custom js exceptions
-        return utils.contains(recognitionExceptions, error.name)
+        return contains(recognitionExceptions, error.name)
     }
 
     export function MismatchedTokenException(message:string, token:Token) {
-        this.name = lang.functionName(MismatchedTokenException)
+        this.name = functionName(MismatchedTokenException)
         this.message = message
         this.token = token
     }
 
-    // must use the "Error.prototype" instead of "new Error"
-    // because the stack trace points to where "new Error" was invoked"
+// must use the "Error.prototype" instead of "new Error"
+// because the stack trace points to where "new Error" was invoked"
     MismatchedTokenException.prototype = Error.prototype
 
     export function NoViableAltException(message:string, token:Token) {
-        this.name = lang.functionName(NoViableAltException)
+        this.name = functionName(NoViableAltException)
         this.message = message
         this.token = token
     }
@@ -36,7 +39,7 @@ namespace chevrotain.exceptions {
     NoViableAltException.prototype = Error.prototype
 
     export function NotAllInputParsedException(message:string, token:Token) {
-        this.name = lang.functionName(NotAllInputParsedException)
+        this.name = functionName(NotAllInputParsedException)
         this.message = message
         this.token = token
     }
@@ -45,12 +48,10 @@ namespace chevrotain.exceptions {
 
 
     export function EarlyExitException(message:string, token:Token) {
-        this.name = lang.functionName(EarlyExitException)
+        this.name = functionName(EarlyExitException)
         this.message = message
         this.token = token
     }
 
     EarlyExitException.prototype = Error.prototype
-
-
 }
diff --git a/src/parse/gast_builder.ts b/src/parse/gast_builder.ts
index 2b929061f..8dd0dfc91 100644
--- a/src/parse/gast_builder.ts
+++ b/src/parse/gast_builder.ts
@@ -1,365 +1,361 @@
-// namespace for building the GAst representation of a Grammar
-namespace chevrotain.gastBuilder {
-
-    import r = chevrotain.range
-    import gast = chevrotain.gast
-    import lang = chevrotain.lang;
-
-    export enum ProdType {
-        OPTION,
-        OR,
-        MANY,
-        MANY_SEP,
-        AT_LEAST_ONE,
-        AT_LEAST_ONE_SEP,
-        REF,
-        TERMINAL,
-        FLAT
-    }
-
-    export interface IProdRange {
-        range:r.IRange
-        text:string
-        type:ProdType
-    }
+import {IRange, Range} from "../text/range"
+import {gast} from "./grammar/gast_public"
+import {sortBy, forEach, every, filter, partial, uniq, isEmpty} from "../utils/utils"
+
+export enum ProdType {
+    OPTION,
+    OR,
+    MANY,
+    MANY_SEP,
+    AT_LEAST_ONE,
+    AT_LEAST_ONE_SEP,
+    REF,
+    TERMINAL,
+    FLAT
+}
 
-    // TODO: this regexp creates a constraint on names of Terminals (Tokens).
-    // TODO: document and consider reducing the constraint by expanding the regexp
-    let terminalRegEx = /\.\s*CONSUME(\d)?\s*\(\s*(?:[a-zA-Z_$]\w*\s*\.\s*)*([a-zA-Z_$]\w*)/
-    let terminalRegGlobal = new RegExp(terminalRegEx.source, "g")
+export interface IProdRange {
+    range:IRange
+    text:string
+    type:ProdType
+}
 
-    let refRegEx = /\.\s*SUBRULE(\d)?\s*\(\s*(?:[a-zA-Z_$]\w*\s*\.\s*)*([a-zA-Z_$]\w*)/
-    let refRegExGlobal = new RegExp(refRegEx.source, "g")
+// TODO: this regexp creates a constraint on names of Terminals (Tokens).
+// TODO: document and consider reducing the constraint by expanding the regexp
+let terminalRegEx = /\.\s*CONSUME(\d)?\s*\(\s*(?:[a-zA-Z_$]\w*\s*\.\s*)*([a-zA-Z_$]\w*)/
+let terminalRegGlobal = new RegExp(terminalRegEx.source, "g")
 
-    let optionRegEx = /\.\s*OPTION(\d)?\s*\(/
-    let optionRegExGlobal = new RegExp(optionRegEx.source, "g")
+let refRegEx = /\.\s*SUBRULE(\d)?\s*\(\s*(?:[a-zA-Z_$]\w*\s*\.\s*)*([a-zA-Z_$]\w*)/
+let refRegExGlobal = new RegExp(refRegEx.source, "g")
 
-    let manyRegEx = /\.\s*MANY(\d)?\s*\(/
-    let manyRegExGlobal = new RegExp(manyRegEx.source, "g")
+let optionRegEx = /\.\s*OPTION(\d)?\s*\(/
+let optionRegExGlobal = new RegExp(optionRegEx.source, "g")
 
-    let manyWithSeparatorRegEx = /\.\s*MANY_SEP(\d)?\s*\(\s*(?:[a-zA-Z_$]\w*\s*\.\s*)*([a-zA-Z_$]\w*)/
-    let manyWithSeparatorRegExGlobal = new RegExp(manyWithSeparatorRegEx.source, "g")
+let manyRegEx = /\.\s*MANY(\d)?\s*\(/
+let manyRegExGlobal = new RegExp(manyRegEx.source, "g")
 
-    let atLeastOneWithSeparatorRegEx = /\.\s*AT_LEAST_ONE_SEP(\d)?\s*\(\s*(?:[a-zA-Z_$]\w*\s*\.\s*)*([a-zA-Z_$]\w*)/
-    let atLeastOneWithSeparatorRegExGlobal = new RegExp(atLeastOneWithSeparatorRegEx.source, "g")
+let manyWithSeparatorRegEx = /\.\s*MANY_SEP(\d)?\s*\(\s*(?:[a-zA-Z_$]\w*\s*\.\s*)*([a-zA-Z_$]\w*)/
+let manyWithSeparatorRegExGlobal = new RegExp(manyWithSeparatorRegEx.source, "g")
 
-    let atLeastOneRegEx = /\.\s*AT_LEAST_ONE(\d)?\s*\(/
-    let atLeastOneRegExGlobal = new RegExp(atLeastOneRegEx.source, "g")
+let atLeastOneWithSeparatorRegEx = /\.\s*AT_LEAST_ONE_SEP(\d)?\s*\(\s*(?:[a-zA-Z_$]\w*\s*\.\s*)*([a-zA-Z_$]\w*)/
+let atLeastOneWithSeparatorRegExGlobal = new RegExp(atLeastOneWithSeparatorRegEx.source, "g")
 
-    let orRegEx = /\.\s*OR(\d)?\s*\(/
-    let orRegExGlobal = new RegExp(orRegEx.source, "g")
+let atLeastOneRegEx = /\.\s*AT_LEAST_ONE(\d)?\s*\(/
+let atLeastOneRegExGlobal = new RegExp(atLeastOneRegEx.source, "g")
 
-    let orPartRegEx = /{\s*(WHEN|ALT)\s*:/g
+let orRegEx = /\.\s*OR(\d)?\s*\(/
+let orRegExGlobal = new RegExp(orRegEx.source, "g")
 
-    export interface ITerminalNameToConstructor {
-        [fqn: string]: Function
-    }
+let orPartRegEx = /{\s*(WHEN|ALT)\s*:/g
 
-    export let terminalNameToConstructor:ITerminalNameToConstructor = {}
-
-    export function buildTopProduction(impelText:string, name:string, terminals:ITerminalNameToConstructor):gast.Rule {
-        // pseudo state. so little state does not yet mandate the complexity of wrapping in a class...
-        // TODO: this is confusing, might be time to create a class..
-        terminalNameToConstructor = terminals
-        // the top most range must strictly contain all the other ranges
-        // which is why we prefix the text with " " (curr Range impel is only for positive ranges)
-        let spacedImpelText = " " + impelText
-        // TODO: why do we add whitespace twice?
-        let txtWithoutComments = removeComments(" " + spacedImpelText)
-        let textWithoutCommentsAndStrings = removeStringLiterals(txtWithoutComments)
-        let prodRanges = createRanges(textWithoutCommentsAndStrings)
-        let topRange = new r.Range(0, impelText.length + 2)
-        return buildTopLevel(name, topRange, prodRanges, impelText)
-    }
+export interface ITerminalNameToConstructor {
+    [fqn: string]: Function
+}
 
-    function buildTopLevel(name:string, topRange:r.IRange, allRanges:IProdRange[], orgText:string):gast.Rule {
-        let topLevelProd = new gast.Rule(name, [], orgText)
-        return buildAbstractProd(topLevelProd, topRange, allRanges)
-    }
+export let terminalNameToConstructor:ITerminalNameToConstructor = {}
+
+export function buildTopProduction(impelText:string, name:string, terminals:ITerminalNameToConstructor):gast.Rule {
+    // pseudo state. so little state does not yet mandate the complexity of wrapping in a class...
+    // TODO: this is confusing, might be time to create a class..
+    terminalNameToConstructor = terminals
+    // the top most range must strictly contain all the other ranges
+    // which is why we prefix the text with " " (curr Range impel is only for positive ranges)
+    let spacedImpelText = " " + impelText
+    // TODO: why do we add whitespace twice?
+    let txtWithoutComments = removeComments(" " + spacedImpelText)
+    let textWithoutCommentsAndStrings = removeStringLiterals(txtWithoutComments)
+    let prodRanges = createRanges(textWithoutCommentsAndStrings)
+    let topRange = new Range(0, impelText.length + 2)
+    return buildTopLevel(name, topRange, prodRanges, impelText)
+}
 
-    export function buildProdGast(prodRange:IProdRange, allRanges:IProdRange[]):gast.IProduction {
-        "use strict"
-        switch (prodRange.type) {
-            case ProdType.AT_LEAST_ONE:
-                return buildAtLeastOneProd(prodRange, allRanges)
-            case ProdType.AT_LEAST_ONE_SEP:
-                return buildAtLeastOneSepProd(prodRange, allRanges)
-            case ProdType.MANY_SEP:
-                return buildManySepProd(prodRange, allRanges)
-            case ProdType.MANY:
-                return buildManyProd(prodRange, allRanges)
-            case ProdType.OPTION:
-                return buildOptionProd(prodRange, allRanges)
-            case ProdType.OR:
-                return buildOrProd(prodRange, allRanges)
-            case ProdType.FLAT:
-                return buildAbstractProd(new gast.Flat([]), prodRange.range, allRanges)
-            case ProdType.REF:
-                return buildRefProd(prodRange)
-            case ProdType.TERMINAL:
-                return buildTerminalProd(prodRange)
-            /* istanbul ignore next */
-            default:
-                throw Error("non exhaustive match")
-        }
-    }
+function buildTopLevel(name:string, topRange:IRange, allRanges:IProdRange[], orgText:string):gast.Rule {
+    let topLevelProd = new gast.Rule(name, [], orgText)
+    return buildAbstractProd(topLevelProd, topRange, allRanges)
+}
 
-    function buildRefProd(prodRange:IProdRange):gast.NonTerminal {
-        let reResult = refRegEx.exec(prodRange.text)
-        let isImplicitOccurrenceIdx = reResult[1] === undefined
-        let refOccurrence = isImplicitOccurrenceIdx ? 1 : parseInt(reResult[1], 10)
-        let refProdName = reResult[2]
-        let newRef = new gast.NonTerminal(refProdName, undefined, refOccurrence)
-        newRef.implicitOccurrenceIndex = isImplicitOccurrenceIdx
-        return newRef
+export function buildProdGast(prodRange:IProdRange, allRanges:IProdRange[]):gast.IProduction {
+    "use strict"
+    switch (prodRange.type) {
+        case ProdType.AT_LEAST_ONE:
+            return buildAtLeastOneProd(prodRange, allRanges)
+        case ProdType.AT_LEAST_ONE_SEP:
+            return buildAtLeastOneSepProd(prodRange, allRanges)
+        case ProdType.MANY_SEP:
+            return buildManySepProd(prodRange, allRanges)
+        case ProdType.MANY:
+            return buildManyProd(prodRange, allRanges)
+        case ProdType.OPTION:
+            return buildOptionProd(prodRange, allRanges)
+        case ProdType.OR:
+            return buildOrProd(prodRange, allRanges)
+        case ProdType.FLAT:
+            return buildAbstractProd(new gast.Flat([]), prodRange.range, allRanges)
+        case ProdType.REF:
+            return buildRefProd(prodRange)
+        case ProdType.TERMINAL:
+            return buildTerminalProd(prodRange)
+        /* istanbul ignore next */
+        default:
+            throw Error("non exhaustive match")
     }
+}
 
-    function buildTerminalProd(prodRange:IProdRange):gast.Terminal {
-        let reResult = terminalRegEx.exec(prodRange.text)
-        let isImplicitOccurrenceIdx = reResult[1] === undefined
-        let terminalOccurrence = isImplicitOccurrenceIdx ? 1 : parseInt(reResult[1], 10)
-        let terminalName = reResult[2]
-        let terminalType = terminalNameToConstructor[terminalName]
-        if (!terminalType) {
-            throw Error("Terminal Token name: " + terminalName + " not found")
-        }
+function buildRefProd(prodRange:IProdRange):gast.NonTerminal {
+    let reResult = refRegEx.exec(prodRange.text)
+    let isImplicitOccurrenceIdx = reResult[1] === undefined
+    let refOccurrence = isImplicitOccurrenceIdx ? 1 : parseInt(reResult[1], 10)
+    let refProdName = reResult[2]
+    let newRef = new gast.NonTerminal(refProdName, undefined, refOccurrence)
+    newRef.implicitOccurrenceIndex = isImplicitOccurrenceIdx
+    return newRef
+}
 
-        let newTerminal = new gast.Terminal(terminalType, terminalOccurrence)
-        newTerminal.implicitOccurrenceIndex = isImplicitOccurrenceIdx
-        return newTerminal
+function buildTerminalProd(prodRange:IProdRange):gast.Terminal {
+    let reResult = terminalRegEx.exec(prodRange.text)
+    let isImplicitOccurrenceIdx = reResult[1] === undefined
+    let terminalOccurrence = isImplicitOccurrenceIdx ? 1 : parseInt(reResult[1], 10)
+    let terminalName = reResult[2]
+    let terminalType = terminalNameToConstructor[terminalName]
+    if (!terminalType) {
+        throw Error("Terminal Token name: " + terminalName + " not found")
     }
 
-    // http://stackoverflow.com/questions/17125764/can-you-specify-multiple-type-constraints-for-typescript-generics
-    interface AbsProdWithOccurrence extends gast.IProductionWithOccurrence, gast.AbstractProduction {}
-
-    function buildProdWithOccurrence<T extends AbsProdWithOccurrence>(regEx:RegExp,
-                                                                      prodInstance:T,
-                                                                      prodRange:IProdRange,
-                                                                      allRanges:IProdRange[]):T {
-        let reResult = regEx.exec(prodRange.text)
-        let isImplicitOccurrenceIdx = reResult[1] === undefined
-        prodInstance.occurrenceInParent = isImplicitOccurrenceIdx ? 1 : parseInt(reResult[1], 10)
-        prodInstance.implicitOccurrenceIndex = isImplicitOccurrenceIdx
-        // <any> due to intellij bugs
-        return <any>buildAbstractProd(prodInstance, prodRange.range, allRanges)
-    }
+    let newTerminal = new gast.Terminal(terminalType, terminalOccurrence)
+    newTerminal.implicitOccurrenceIndex = isImplicitOccurrenceIdx
+    return newTerminal
+}
 
-    function buildAtLeastOneProd(prodRange:IProdRange, allRanges:IProdRange[]):gast.RepetitionMandatory {
-        return buildProdWithOccurrence(atLeastOneRegEx, new gast.RepetitionMandatory([]), prodRange, allRanges)
-    }
+// http://stackoverflow.com/questions/17125764/can-you-specify-multiple-type-constraints-for-typescript-generics
+interface AbsProdWithOccurrence extends gast.IProductionWithOccurrence, gast.AbstractProduction {}
+
+function buildProdWithOccurrence<T extends AbsProdWithOccurrence>(regEx:RegExp,
+                                                                  prodInstance:T,
+                                                                  prodRange:IProdRange,
+                                                                  allRanges:IProdRange[]):T {
+    let reResult = regEx.exec(prodRange.text)
+    let isImplicitOccurrenceIdx = reResult[1] === undefined
+    prodInstance.occurrenceInParent = isImplicitOccurrenceIdx ? 1 : parseInt(reResult[1], 10)
+    prodInstance.implicitOccurrenceIndex = isImplicitOccurrenceIdx
+    // <any> due to intellij bugs
+    return <any>buildAbstractProd(prodInstance, prodRange.range, allRanges)
+}
 
-    function buildAtLeastOneSepProd(prodRange:IProdRange, allRanges:IProdRange[]):gast.RepetitionWithSeparator {
-        return buildRepetitionWithSep(prodRange, allRanges, gast.RepetitionMandatoryWithSeparator, atLeastOneWithSeparatorRegEx)
-    }
+function buildAtLeastOneProd(prodRange:IProdRange, allRanges:IProdRange[]):gast.RepetitionMandatory {
+    return buildProdWithOccurrence(atLeastOneRegEx, new gast.RepetitionMandatory([]), prodRange, allRanges)
+}
 
-    function buildManyProd(prodRange:IProdRange, allRanges:IProdRange[]):gast.Repetition {
-        return buildProdWithOccurrence(manyRegEx, new gast.Repetition([]), prodRange, allRanges)
-    }
+function buildAtLeastOneSepProd(prodRange:IProdRange, allRanges:IProdRange[]):gast.RepetitionWithSeparator {
+    return buildRepetitionWithSep(prodRange, allRanges, gast.RepetitionMandatoryWithSeparator, atLeastOneWithSeparatorRegEx)
+}
 
-    function buildManySepProd(prodRange:IProdRange, allRanges:IProdRange[]):gast.RepetitionWithSeparator {
-        return buildRepetitionWithSep(prodRange, allRanges, gast.RepetitionWithSeparator, manyWithSeparatorRegEx)
-    }
+function buildManyProd(prodRange:IProdRange, allRanges:IProdRange[]):gast.Repetition {
+    return buildProdWithOccurrence(manyRegEx, new gast.Repetition([]), prodRange, allRanges)
+}
 
-    function buildRepetitionWithSep(prodRange:IProdRange, allRanges:IProdRange[],
-                                    repConstructor:Function, regExp:RegExp):gast.RepetitionWithSeparator {
-        let reResult = regExp.exec(prodRange.text)
-        let isImplicitOccurrenceIdx = reResult[1] === undefined
-        let occurrenceIdx = isImplicitOccurrenceIdx ? 1 : parseInt(reResult[1], 10)
-        let sepName = reResult[2]
-        let separatorType = terminalNameToConstructor[sepName]
-        if (!separatorType) {
-            throw Error("Separator Terminal Token name: " + sepName + " not found")
-        }
+function buildManySepProd(prodRange:IProdRange, allRanges:IProdRange[]):gast.RepetitionWithSeparator {
+    return buildRepetitionWithSep(prodRange, allRanges, gast.RepetitionWithSeparator, manyWithSeparatorRegEx)
+}
 
-        let repetitionInstance:any = new (<any>repConstructor)([], separatorType, occurrenceIdx)
-        repetitionInstance.implicitOccurrenceIndex = isImplicitOccurrenceIdx
-        return <any>buildAbstractProd(repetitionInstance, prodRange.range, allRanges)
+function buildRepetitionWithSep(prodRange:IProdRange, allRanges:IProdRange[],
+                                repConstructor:Function, regExp:RegExp):gast.RepetitionWithSeparator {
+    let reResult = regExp.exec(prodRange.text)
+    let isImplicitOccurrenceIdx = reResult[1] === undefined
+    let occurrenceIdx = isImplicitOccurrenceIdx ? 1 : parseInt(reResult[1], 10)
+    let sepName = reResult[2]
+    let separatorType = terminalNameToConstructor[sepName]
+    if (!separatorType) {
+        throw Error("Separator Terminal Token name: " + sepName + " not found")
     }
 
-    function buildOptionProd(prodRange:IProdRange, allRanges:IProdRange[]):gast.Option {
-        return buildProdWithOccurrence(optionRegEx, new gast.Option([]), prodRange, allRanges)
-    }
+    let repetitionInstance:any = new (<any>repConstructor)([], separatorType, occurrenceIdx)
+    repetitionInstance.implicitOccurrenceIndex = isImplicitOccurrenceIdx
+    return <any>buildAbstractProd(repetitionInstance, prodRange.range, allRanges)
+}
 
-    function buildOrProd(prodRange:IProdRange, allRanges:IProdRange[]):gast.Alternation {
-        return buildProdWithOccurrence(orRegEx, new gast.Alternation([]), prodRange, allRanges)
-    }
+function buildOptionProd(prodRange:IProdRange, allRanges:IProdRange[]):gast.Option {
+    return buildProdWithOccurrence(optionRegEx, new gast.Option([]), prodRange, allRanges)
+}
 
-    function buildAbstractProd<T extends AbsProdWithOccurrence | gast.AbstractProduction >(prod:T,
-                                                                                           topLevelRange:r.IRange,
-                                                                                           allRanges:IProdRange[]):T {
-        let secondLevelProds = getDirectlyContainedRanges(topLevelRange, allRanges)
-        let secondLevelInOrder = utils.sortBy(secondLevelProds, (prodRng) => { return prodRng.range.start })
+function buildOrProd(prodRange:IProdRange, allRanges:IProdRange[]):gast.Alternation {
+    return buildProdWithOccurrence(orRegEx, new gast.Alternation([]), prodRange, allRanges)
+}
 
-        let definition:gast.IProduction[] = []
-        utils.forEach(secondLevelInOrder, (prodRng) => {
-            definition.push(buildProdGast(prodRng, allRanges))
-        });
+function buildAbstractProd<T extends AbsProdWithOccurrence | gast.AbstractProduction >(prod:T,
+                                                                                  topLevelRange:IRange,
+                                                                                  allRanges:IProdRange[]):T {
+    let secondLevelProds = getDirectlyContainedRanges(topLevelRange, allRanges)
+    let secondLevelInOrder = sortBy(secondLevelProds, (prodRng) => { return prodRng.range.start })
 
-        // IntelliJ bug workaround
-        (<any>prod).definition = definition
-        return prod
-    }
+    let definition:gast.IProduction[] = []
+    forEach(secondLevelInOrder, (prodRng) => {
+        definition.push(buildProdGast(prodRng, allRanges))
+    });
 
-    export function getDirectlyContainedRanges(y:r.IRange, prodRanges:IProdRange[]):IProdRange[] {
-        return utils.filter(prodRanges, (x:IProdRange) => {
-            let isXDescendantOfY = y.strictlyContainsRange(x.range)
-            let xDoesNotHaveAnyAncestorWhichIsDecendantOfY = utils.every(prodRanges, (maybeAnotherParent:IProdRange) => {
-                let isParentOfX = maybeAnotherParent.range.strictlyContainsRange(x.range)
-                let isChildOfY = maybeAnotherParent.range.isStrictlyContainedInRange(y)
-                return !(isParentOfX && isChildOfY)
-            })
-            return isXDescendantOfY && xDoesNotHaveAnyAncestorWhichIsDecendantOfY
+    // IntelliJ bug workaround
+    (<any>prod).definition = definition
+    return prod
+}
+
+export function getDirectlyContainedRanges(y:IRange, prodRanges:IProdRange[]):IProdRange[] {
+    return filter(prodRanges, (x:IProdRange) => {
+        let isXDescendantOfY = y.strictlyContainsRange(x.range)
+        let xDoesNotHaveAnyAncestorWhichIsDecendantOfY = every(prodRanges, (maybeAnotherParent:IProdRange) => {
+            let isParentOfX = maybeAnotherParent.range.strictlyContainsRange(x.range)
+            let isChildOfY = maybeAnotherParent.range.isStrictlyContainedInRange(y)
+            return !(isParentOfX && isChildOfY)
         })
-    }
+        return isXDescendantOfY && xDoesNotHaveAnyAncestorWhichIsDecendantOfY
+    })
+}
 
-    let singleLineCommentRegEx = /\/\/.*/g
-    let multiLineCommentRegEx = /\/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*+\//g
-    let doubleQuoteStringLiteralRegEx = /"([^\\"]+|\\([bfnrtv"\\/]|u[0-9a-fA-F]{4}))*"/g
-    let singleQuoteStringLiteralRegEx = /'([^\\']+|\\([bfnrtv'\\/]|u[0-9a-fA-F]{4}))*'/g
+let singleLineCommentRegEx = /\/\/.*/g
+let multiLineCommentRegEx = /\/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*+\//g
+let doubleQuoteStringLiteralRegEx = /"([^\\"]+|\\([bfnrtv"\\/]|u[0-9a-fA-F]{4}))*"/g
+let singleQuoteStringLiteralRegEx = /'([^\\']+|\\([bfnrtv'\\/]|u[0-9a-fA-F]{4}))*'/g
 
-    export function removeComments(text:string):string {
-        let noSingleLine = text.replace(singleLineCommentRegEx, "")
-        let noComments = noSingleLine.replace(multiLineCommentRegEx, "")
-        return noComments
-    }
+export function removeComments(text:string):string {
+    let noSingleLine = text.replace(singleLineCommentRegEx, "")
+    let noComments = noSingleLine.replace(multiLineCommentRegEx, "")
+    return noComments
+}
 
-    export function removeStringLiterals(text:string):string {
-        let noDoubleQuotes = text.replace(doubleQuoteStringLiteralRegEx, "")
-        let noSingleQuotes = noDoubleQuotes.replace(singleQuoteStringLiteralRegEx, "")
-        return noSingleQuotes
-    }
+export function removeStringLiterals(text:string):string {
+    let noDoubleQuotes = text.replace(doubleQuoteStringLiteralRegEx, "")
+    let noSingleQuotes = noDoubleQuotes.replace(singleQuoteStringLiteralRegEx, "")
+    return noSingleQuotes
+}
 
-    export function createRanges(text:string):IProdRange[] {
-        let terminalRanges = createTerminalRanges(text)
-        let refsRanges = createRefsRanges(text)
-        let atLeastOneRanges = createAtLeastOneRanges(text)
-        let atLeastOneSepRanges = createAtLeastOneSepRanges(text)
-        let manyRanges = createManyRanges(text)
-        let manySepRanges = createManySepRanges(text)
-        let optionRanges = createOptionRanges(text)
-        let orRanges = createOrRanges(text)
-
-        return [].concat(terminalRanges, refsRanges, atLeastOneRanges, atLeastOneSepRanges,
-            manyRanges, manySepRanges, optionRanges, orRanges)
-    }
+export function createRanges(text:string):IProdRange[] {
+    let terminalRanges = createTerminalRanges(text)
+    let refsRanges = createRefsRanges(text)
+    let atLeastOneRanges = createAtLeastOneRanges(text)
+    let atLeastOneSepRanges = createAtLeastOneSepRanges(text)
+    let manyRanges = createManyRanges(text)
+    let manySepRanges = createManySepRanges(text)
+    let optionRanges = createOptionRanges(text)
+    let orRanges = createOrRanges(text)
+
+    return [].concat(terminalRanges, refsRanges, atLeastOneRanges, atLeastOneSepRanges,
+        manyRanges, manySepRanges, optionRanges, orRanges)
+}
 
-    export function createTerminalRanges(text:string):IProdRange[] {
-        return createRefOrTerminalProdRangeInternal(text, ProdType.TERMINAL, terminalRegGlobal)
-    }
+export function createTerminalRanges(text:string):IProdRange[] {
+    return createRefOrTerminalProdRangeInternal(text, ProdType.TERMINAL, terminalRegGlobal)
+}
 
-    export function createRefsRanges(text:string):IProdRange[] {
-        return createRefOrTerminalProdRangeInternal(text, ProdType.REF, refRegExGlobal)
-    }
+export function createRefsRanges(text:string):IProdRange[] {
+    return createRefOrTerminalProdRangeInternal(text, ProdType.REF, refRegExGlobal)
+}
 
-    export function createAtLeastOneRanges(text:string):IProdRange[] {
-        return createOperatorProdRangeParenthesis(text, ProdType.AT_LEAST_ONE, atLeastOneRegExGlobal)
-    }
+export function createAtLeastOneRanges(text:string):IProdRange[] {
+    return createOperatorProdRangeParenthesis(text, ProdType.AT_LEAST_ONE, atLeastOneRegExGlobal)
+}
 
-    export function createAtLeastOneSepRanges(text:string):IProdRange[] {
-        return createOperatorProdRangeParenthesis(text, ProdType.AT_LEAST_ONE_SEP, atLeastOneWithSeparatorRegExGlobal)
-    }
+export function createAtLeastOneSepRanges(text:string):IProdRange[] {
+    return createOperatorProdRangeParenthesis(text, ProdType.AT_LEAST_ONE_SEP, atLeastOneWithSeparatorRegExGlobal)
+}
 
-    export function createManyRanges(text:string):IProdRange[] {
-        return createOperatorProdRangeParenthesis(text, ProdType.MANY, manyRegExGlobal)
-    }
+export function createManyRanges(text:string):IProdRange[] {
+    return createOperatorProdRangeParenthesis(text, ProdType.MANY, manyRegExGlobal)
+}
 
-    export function createManySepRanges(text:string):IProdRange[] {
-        return createOperatorProdRangeParenthesis(text, ProdType.MANY_SEP, manyWithSeparatorRegExGlobal)
-    }
+export function createManySepRanges(text:string):IProdRange[] {
+    return createOperatorProdRangeParenthesis(text, ProdType.MANY_SEP, manyWithSeparatorRegExGlobal)
+}
 
-    export function createOptionRanges(text:string):IProdRange[] {
-        return createOperatorProdRangeParenthesis(text, ProdType.OPTION, optionRegExGlobal)
-    }
+export function createOptionRanges(text:string):IProdRange[] {
+    return createOperatorProdRangeParenthesis(text, ProdType.OPTION, optionRegExGlobal)
+}
 
-    export function createOrRanges(text):IProdRange[] {
-        let orRanges = createOperatorProdRangeParenthesis(text, ProdType.OR, orRegExGlobal)
-        // have to split up the OR cases into separate FLAT productions
-        // (A |BB | CDE) ==> or.def[0] --> FLAT(A) , or.def[1] --> FLAT(BB) , or.def[2] --> FLAT(CCDE)
-        let orSubPartsRanges = createOrPartRanges(orRanges)
-        return orRanges.concat(orSubPartsRanges)
-    }
+export function createOrRanges(text):IProdRange[] {
+    let orRanges = createOperatorProdRangeParenthesis(text, ProdType.OR, orRegExGlobal)
+    // have to split up the OR cases into separate FLAT productions
+    // (A |BB | CDE) ==> or.def[0] --> FLAT(A) , or.def[1] --> FLAT(BB) , or.def[2] --> FLAT(CCDE)
+    let orSubPartsRanges = createOrPartRanges(orRanges)
+    return orRanges.concat(orSubPartsRanges)
+}
 
-    let findClosingCurly:(start:number, text:string) => number = <any>utils.partial(findClosingOffset, "{", "}")
-
-    let findClosingParen:(start:number, text:string) => number = <any>utils.partial(findClosingOffset, "(", ")")
-
-    export function createOrPartRanges(orRanges:IProdRange[]):IProdRange[] {
-        let orPartRanges:IProdRange[] = []
-        utils.forEach(orRanges, (orRange) => {
-            let currOrParts = createOperatorProdRangeInternal(orRange.text, ProdType.FLAT, orPartRegEx, findClosingCurly)
-            let currOrRangeStart = orRange.range.start
-            // fix offsets as we are working on a subset of the text
-            utils.forEach(currOrParts, (orPart) => {
-                orPart.range.start += currOrRangeStart
-                orPart.range.end += currOrRangeStart
-            })
-            orPartRanges = orPartRanges.concat(currOrParts)
-        })
+let findClosingCurly:(start:number, text:string) => number = <any>partial(findClosingOffset, "{", "}")
 
-        let uniqueOrPartRanges = utils.uniq(orPartRanges, (prodRange:IProdRange) => {
-            // using "~" as a separator for the identify function as its not a valid char in javascript
-            return prodRange.type + "~" + prodRange.range.start + "~" + prodRange.range.end + "~" + prodRange.text
+let findClosingParen:(start:number, text:string) => number = <any>partial(findClosingOffset, "(", ")")
+
+export function createOrPartRanges(orRanges:IProdRange[]):IProdRange[] {
+    let orPartRanges:IProdRange[] = []
+    forEach(orRanges, (orRange) => {
+        let currOrParts = createOperatorProdRangeInternal(orRange.text, ProdType.FLAT, orPartRegEx, findClosingCurly)
+        let currOrRangeStart = orRange.range.start
+        // fix offsets as we are working on a subset of the text
+        forEach(currOrParts, (orPart) => {
+            orPart.range.start += currOrRangeStart
+            orPart.range.end += currOrRangeStart
         })
+        orPartRanges = orPartRanges.concat(currOrParts)
+    })
 
-        return uniqueOrPartRanges
-    }
+    let uniqueOrPartRanges = uniq(orPartRanges, (prodRange:IProdRange) => {
+        // using "~" as a separator for the identify function as its not a valid char in javascript
+        return prodRange.type + "~" + prodRange.range.start + "~" + prodRange.range.end + "~" + prodRange.text
+    })
 
-    function createRefOrTerminalProdRangeInternal(text:string, prodType:ProdType, pattern:RegExp):IProdRange[] {
-        let prodRanges:IProdRange[] = []
-        let matched:RegExpExecArray
-        while (matched = pattern.exec(text)) {
-            let start = matched.index
-            let stop = pattern.lastIndex
-            let currRange = new r.Range(start, stop)
-            let currText = matched[0]
-            prodRanges.push({range: currRange, text: currText, type: prodType})
-        }
-        return prodRanges
-    }
+    return uniqueOrPartRanges
+}
 
-    function createOperatorProdRangeParenthesis(text:string, prodType:ProdType, pattern:RegExp):IProdRange[] {
-        return createOperatorProdRangeInternal(text, prodType, pattern, findClosingParen)
-    }
+function createRefOrTerminalProdRangeInternal(text:string, prodType:ProdType, pattern:RegExp):IProdRange[] {
+    let prodRanges:IProdRange[] = []
+    let matched:RegExpExecArray
+    while (matched = pattern.exec(text)) {
+        let start = matched.index
+        let stop = pattern.lastIndex
+        let currRange = new Range(start, stop)
+        let currText = matched[0]
+        prodRanges.push({range: currRange, text: currText, type: prodType})
+    }
+    return prodRanges
+}
 
-    function createOperatorProdRangeInternal(text:string,
-                                             prodType:ProdType,
-                                             pattern:RegExp,
-                                             findTerminatorOffSet:(startAt:number,
-                                                                   text:string) => number):IProdRange[] {
-        let operatorRanges:IProdRange[] = []
-        let matched:RegExpExecArray
-        while (matched = pattern.exec(text)) {
-            let start = matched.index
-            // note that (start + matched[0].length) is the first character AFTER the match
-            let stop = findTerminatorOffSet(start + matched[0].length, text)
-            let currRange = new r.Range(start, stop)
-            let currText = text.substr(start, stop - start + 1)
-            operatorRanges.push({range: currRange, text: currText, type: prodType})
-        }
-        return operatorRanges
-    }
+function createOperatorProdRangeParenthesis(text:string, prodType:ProdType, pattern:RegExp):IProdRange[] {
+    return createOperatorProdRangeInternal(text, prodType, pattern, findClosingParen)
+}
 
-    export function findClosingOffset(opening:string, closing:string, start:number, text:string):number {
-        let parenthesisStack = [1]
-
-        let i = -1
-        while (!(utils.isEmpty(parenthesisStack)) && i + start < text.length) {
-            i++
-            let nextChar = text.charAt(start + i)
-            if (nextChar === opening) {
-                parenthesisStack.push(1)
-            }
-            else if (nextChar === closing) {
-                parenthesisStack.pop()
-            }
-        }
+function createOperatorProdRangeInternal(text:string,
+                                         prodType:ProdType,
+                                         pattern:RegExp,
+                                         findTerminatorOffSet:(startAt:number,
+                                                               text:string) => number):IProdRange[] {
+    let operatorRanges:IProdRange[] = []
+    let matched:RegExpExecArray
+    while (matched = pattern.exec(text)) {
+        let start = matched.index
+        // note that (start + matched[0].length) is the first character AFTER the match
+        let stop = findTerminatorOffSet(start + matched[0].length, text)
+        let currRange = new Range(start, stop)
+        let currText = text.substr(start, stop - start + 1)
+        operatorRanges.push({range: currRange, text: currText, type: prodType})
+    }
+    return operatorRanges
+}
 
-        // valid termination of the search loop
-        if (utils.isEmpty(parenthesisStack)) {
-            return i + start
+export function findClosingOffset(opening:string, closing:string, start:number, text:string):number {
+    let parenthesisStack = [1]
+
+    let i = -1
+    while (!(isEmpty(parenthesisStack)) && i + start < text.length) {
+        i++
+        let nextChar = text.charAt(start + i)
+        if (nextChar === opening) {
+            parenthesisStack.push(1)
         }
-        else {
-            throw new Error("INVALID INPUT TEXT, UNTERMINATED PARENTHESIS")
+        else if (nextChar === closing) {
+            parenthesisStack.pop()
         }
     }
+
+    // valid termination of the search loop
+    if (isEmpty(parenthesisStack)) {
+        return i + start
+    }
+    else {
+        throw new Error("INVALID INPUT TEXT, UNTERMINATED PARENTHESIS")
+    }
 }
diff --git a/src/parse/grammar/checks.ts b/src/parse/grammar/checks.ts
index 760c55cd9..4acaedc14 100644
--- a/src/parse/grammar/checks.ts
+++ b/src/parse/grammar/checks.ts
@@ -1,56 +1,62 @@
-namespace chevrotain.checks {
-
-    import gast = chevrotain.gast
-    import GAstVisitor = chevrotain.gast.GAstVisitor
-    import IProduction = chevrotain.gast.IProduction
-
-    export function validateGrammar(topLevels:gast.Rule[]):IParserDefinitionError[] {
-        let duplicateErrors = utils.map(topLevels, validateDuplicateProductions)
-        let leftRecursionErrors:any = utils.map(topLevels, currTopRule => validateNoLeftRecursion(currTopRule, currTopRule))
-        let emptyAltErrors = utils.map(topLevels, validateEmptyOrAlternative)
-        return <any>utils.flatten(duplicateErrors.concat(leftRecursionErrors, emptyAltErrors))
-    }
-
-    function validateDuplicateProductions(topLevelRule:gast.Rule):IParserDuplicatesDefinitionError[] {
-        let collectorVisitor = new OccurrenceValidationCollector()
-        topLevelRule.accept(collectorVisitor)
-        let allRuleProductions = collectorVisitor.allProductions
-
-        let productionGroups = utils.groupBy(allRuleProductions, identifyProductionForDuplicates)
-
-        let duplicates:any = utils.pick(productionGroups, (currGroup) => {
-            return currGroup.length > 1
-        })
+import * as utils from "../../utils/utils"
+import {
+    IParserDefinitionError,
+    IParserDuplicatesDefinitionError,
+    ParserDefinitionErrorType,
+    IParserEmptyAlternativeDefinitionError
+} from "../parser_public"
+import {gast} from "./gast_public"
+import {getProductionDslName, isOptionalProd} from "./gast"
+import {tokenName} from "../../scan/tokens_public"
+import {first} from "./first"
+
+export function validateGrammar(topLevels:gast.Rule[]):IParserDefinitionError[] {
+    let duplicateErrors = utils.map(topLevels, validateDuplicateProductions)
+    let leftRecursionErrors:any = utils.map(topLevels, currTopRule => validateNoLeftRecursion(currTopRule, currTopRule))
+    let emptyAltErrors = utils.map(topLevels, validateEmptyOrAlternative)
+    return <any>utils.flatten(duplicateErrors.concat(leftRecursionErrors, emptyAltErrors))
+}
 
-        let errors = utils.map(utils.values(duplicates), (currDuplicates:any) => {
-            let firstProd:any = utils.first(currDuplicates)
-            let msg = createDuplicatesErrorMessage(currDuplicates, topLevelRule.name)
-            let dslName = gast.getProductionDslName(firstProd)
-            let defError:IParserDuplicatesDefinitionError = {
-                message:    msg,
-                type:       ParserDefinitionErrorType.DUPLICATE_PRODUCTIONS,
-                ruleName:   topLevelRule.name,
-                dslName:    dslName,
-                occurrence: firstProd.occurrenceInParent
-            }
+function validateDuplicateProductions(topLevelRule:gast.Rule):IParserDuplicatesDefinitionError[] {
+    let collectorVisitor = new OccurrenceValidationCollector()
+    topLevelRule.accept(collectorVisitor)
+    let allRuleProductions = collectorVisitor.allProductions
+
+    let productionGroups = utils.groupBy(allRuleProductions, identifyProductionForDuplicates)
+
+    let duplicates:any = utils.pick(productionGroups, (currGroup) => {
+        return currGroup.length > 1
+    })
+
+    let errors = utils.map(utils.values(duplicates), (currDuplicates:any) => {
+        let firstProd:any = utils.first(currDuplicates)
+        let msg = createDuplicatesErrorMessage(currDuplicates, topLevelRule.name)
+        let dslName = getProductionDslName(firstProd)
+        let defError:IParserDuplicatesDefinitionError = {
+            message:    msg,
+            type:       ParserDefinitionErrorType.DUPLICATE_PRODUCTIONS,
+            ruleName:   topLevelRule.name,
+            dslName:    dslName,
+            occurrence: firstProd.occurrenceInParent
+        }
 
-            let param = getExtraProductionArgument(firstProd)
-            if (param) {
-                defError.parameter = param
-            }
+        let param = getExtraProductionArgument(firstProd)
+        if (param) {
+            defError.parameter = param
+        }
 
-            return defError
-        })
-        return errors
-    }
+        return defError
+    })
+    return errors
+}
 
-    function createDuplicatesErrorMessage(duplicateProds:gast.IProductionWithOccurrence[], topLevelName):string {
-        let firstProd = utils.first(duplicateProds)
-        let index = firstProd.occurrenceInParent
-        let dslName = gast.getProductionDslName(firstProd)
-        let extraArgument = getExtraProductionArgument(firstProd)
+function createDuplicatesErrorMessage(duplicateProds:gast.IProductionWithOccurrence[], topLevelName):string {
+    let firstProd = utils.first(duplicateProds)
+    let index = firstProd.occurrenceInParent
+    let dslName = getProductionDslName(firstProd)
+    let extraArgument = getExtraProductionArgument(firstProd)
 
-        let msg = `->${dslName}<- with occurrence index: ->${index}<-
+    let msg = `->${dslName}<- with occurrence index: ->${index}<-
                   ${extraArgument ? `and argument: ${extraArgument}` : ""}
                   appears more than once (${duplicateProds.length} times) in the top level rule: ${topLevelName}.
                   ${index === 1 ? `note that ${dslName} and ${dslName}1 both have the same occurrence index 1}` : ""}}
@@ -58,212 +64,211 @@ namespace chevrotain.checks {
                   in the rule ${topLevelName} has a different occurrence index (1-5), as that combination acts as a unique
                   position key in the grammar, which is needed by the parsing engine.`
 
-        // white space trimming time! better to trim afterwards as it allows to use WELL formatted multi line template strings...
-        msg = msg.replace(/[ \t]+/g, " ")
-        msg = msg.replace(/\s\s+/g, "\n")
+    // white space trimming time! better to trim afterwards as it allows to use WELL formatted multi line template strings...
+    msg = msg.replace(/[ \t]+/g, " ")
+    msg = msg.replace(/\s\s+/g, "\n")
+
+    return msg
+}
 
-        return msg;
+export function identifyProductionForDuplicates(prod:gast.IProductionWithOccurrence):string {
+    return `${getProductionDslName(prod)}_#_${prod.occurrenceInParent}_#_${getExtraProductionArgument(prod)}`
+}
+
+function getExtraProductionArgument(prod:gast.IProductionWithOccurrence):string {
+    if (prod instanceof gast.Terminal) {
+        return tokenName(prod.terminalType)
+    }
+    else if (prod instanceof gast.NonTerminal) {
+        return prod.nonTerminalName
     }
+    else {
+        return ""
+    }
+}
 
-    export function identifyProductionForDuplicates(prod:gast.IProductionWithOccurrence):string {
-        return `${gast.getProductionDslName(prod)}_#_${prod.occurrenceInParent}_#_${getExtraProductionArgument(prod)}`
+export class OccurrenceValidationCollector extends gast.GAstVisitor {
+    public allProductions:gast.IProduction[] = []
+
+    public visitNonTerminal(subrule:gast.NonTerminal):void {
+        this.allProductions.push(subrule)
     }
 
-    function getExtraProductionArgument(prod:gast.IProductionWithOccurrence):string {
-        if (prod instanceof gast.Terminal) {
-            return tokenName(prod.terminalType)
-        }
-        else if (prod instanceof gast.NonTerminal) {
-            return prod.nonTerminalName
-        }
-        else {
-            return ""
-        }
+    public visitOption(option:gast.Option):void {
+        this.allProductions.push(option)
     }
 
-    export class OccurrenceValidationCollector extends gast.GAstVisitor {
-        public allProductions:gast.IProduction[] = []
+    public visitRepetitionWithSeparator(manySep:gast.RepetitionWithSeparator):void {
+        this.allProductions.push(manySep)
+    }
 
-        public visitNonTerminal(subrule:gast.NonTerminal):void {
-            this.allProductions.push(subrule)
-        }
+    public visitRepetitionMandatory(atLeastOne:gast.RepetitionMandatory):void {
+        this.allProductions.push(atLeastOne)
+    }
 
-        public visitOption(option:gast.Option):void {
-            this.allProductions.push(option)
-        }
+    public visitRepetitionMandatoryWithSeparator(atLeastOneSep:gast.RepetitionMandatoryWithSeparator):void {
+        this.allProductions.push(atLeastOneSep)
+    }
 
-        public visitRepetitionWithSeparator(manySep:gast.RepetitionWithSeparator):void {
-            this.allProductions.push(manySep)
-        }
+    public visitRepetition(many:gast.Repetition):void {
+        this.allProductions.push(many)
+    }
 
-        public visitRepetitionMandatory(atLeastOne:gast.RepetitionMandatory):void {
-            this.allProductions.push(atLeastOne)
-        }
+    public visitAlternation(or:gast.Alternation):void {
+        this.allProductions.push(or)
+    }
 
-        public visitRepetitionMandatoryWithSeparator(atLeastOneSep:gast.RepetitionMandatoryWithSeparator):void {
-            this.allProductions.push(atLeastOneSep)
-        }
+    public visitTerminal(terminal:gast.Terminal):void {
+        this.allProductions.push(terminal)
+    }
+}
 
-        public visitRepetition(many:gast.Repetition):void {
-            this.allProductions.push(many)
-        }
+let ruleNamePattern = /^[a-zA-Z_]\w*$/
 
-        public visitAlternation(or:gast.Alternation):void {
-            this.allProductions.push(or)
-        }
+export function validateRuleName(ruleName:string, definedRulesNames:string[], className):IParserDefinitionError[] {
+    let errors = []
+    let errMsg
 
-        public visitTerminal(terminal:gast.Terminal):void {
-            this.allProductions.push(terminal)
-        }
+    if (!ruleName.match(ruleNamePattern)) {
+        errMsg = `Invalid Grammar rule name --> ${ruleName} it must match the pattern: ${ruleNamePattern.toString()}`
+        errors.push({
+            message:  errMsg,
+            type:     ParserDefinitionErrorType.INVALID_RULE_NAME,
+            ruleName: ruleName
+        })
     }
 
-    let ruleNamePattern = /^[a-zA-Z_]\w*$/
+    if ((utils.contains(definedRulesNames, ruleName))) {
+        errMsg = `Duplicate definition, rule: ${ruleName} is already defined in the grammar: ${className}`
+        errors.push({
+            message:  errMsg,
+            type:     ParserDefinitionErrorType.DUPLICATE_RULE_NAME,
+            ruleName: ruleName
+        })
+    }
 
-    export function validateRuleName(ruleName:string, definedRulesNames:string[], className):IParserDefinitionError[] {
-        let errors = []
-        let errMsg
+    return errors
+}
 
-        if (!ruleName.match(ruleNamePattern)) {
-            errMsg = `Invalid Grammar rule name --> ${ruleName} it must match the pattern: ${ruleNamePattern.toString()}`
+export function validateNoLeftRecursion(topRule:gast.Rule,
+                                        currRule:gast.Rule,
+                                        path:gast.Rule[] = []):IParserDefinitionError[] {
+    let errors = []
+    let nextNonTerminals = getFirstNoneTerminal(currRule.definition)
+    if (utils.isEmpty(nextNonTerminals)) {
+        return []
+    }
+    else {
+        let ruleName = topRule.name
+        let foundLeftRecursion = utils.contains(<any>nextNonTerminals, topRule)
+        let pathNames = utils.map(path, currRule => currRule.name)
+        let leftRecursivePath = `${ruleName} --> ${pathNames.concat([ruleName]).join(" --> ")}`
+        if (foundLeftRecursion) {
+            let errMsg = `Left Recursion found in grammar.\n` +
+                `rule: <${ruleName}> can be invoked from itself (directly or indirectly)\n` +
+                `without consuming any Tokens. The grammar path that causes this is: \n ${leftRecursivePath}\n` +
+                ` To fix this refactor your grammar to remove the left recursion.\n` +
+                `see: https://en.wikipedia.org/wiki/LL_parser#Left_Factoring.`
             errors.push({
                 message:  errMsg,
-                type:     ParserDefinitionErrorType.INVALID_RULE_NAME,
+                type:     ParserDefinitionErrorType.LEFT_RECURSION,
                 ruleName: ruleName
             })
         }
 
-        if ((utils.contains(definedRulesNames, ruleName))) {
-            errMsg = `Duplicate definition, rule: ${ruleName} is already defined in the grammar: ${className}`
-            errors.push({
-                message:  errMsg,
-                type:     ParserDefinitionErrorType.DUPLICATE_RULE_NAME,
-                ruleName: ruleName
-            })
-        }
+        // we are only looking for cyclic paths leading back to the specific topRule
+        // other cyclic paths are ignored, we still need this difference to avoid infinite loops...
+        let validNextSteps = utils.difference(nextNonTerminals, path.concat([topRule]))
+        let errorsFromNextSteps = utils.map(validNextSteps, (currRefRule) => {
+            let newPath = utils.cloneArr(path)
+            newPath.push(currRefRule)
+            return validateNoLeftRecursion(topRule, currRefRule, newPath)
+        })
 
-        return errors
+        return errors.concat(utils.flatten(errorsFromNextSteps))
     }
+}
 
-    export function validateNoLeftRecursion(topRule:gast.Rule,
-                                            currRule:gast.Rule,
-                                            path:gast.Rule[] = []):IParserDefinitionError[] {
-        let errors = []
-        let nextNonTerminals = getFirstNoneTerminal(currRule.definition)
-        if (utils.isEmpty(nextNonTerminals)) {
-            return []
-        }
-        else {
-            let ruleName = topRule.name
-            let foundLeftRecursion = utils.contains(<any>nextNonTerminals, topRule)
-            let pathNames = utils.map(path, currRule => currRule.name)
-            let leftRecursivePath = `${ruleName} --> ${pathNames.concat([ruleName]).join(" --> ")}`
-            if (foundLeftRecursion) {
-                let errMsg = `Left Recursion found in grammar.\n` +
-                    `rule: <${ruleName}> can be invoked from itself (directly or indirectly)\n` +
-                    `without consuming any Tokens. The grammar path that causes this is: \n ${leftRecursivePath}\n` +
-                    ` To fix this refactor your grammar to remove the left recursion.\n` +
-                    `see: https://en.wikipedia.org/wiki/LL_parser#Left_Factoring.`
-                errors.push({
-                    message:  errMsg,
-                    type:     ParserDefinitionErrorType.LEFT_RECURSION,
-                    ruleName: ruleName
-                })
-            }
-
-            // we are only looking for cyclic paths leading back to the specific topRule
-            // other cyclic paths are ignored, we still need this difference to avoid infinite loops...
-            let validNextSteps = utils.difference(nextNonTerminals, path.concat([topRule]))
-            let errorsFromNextSteps = utils.map(validNextSteps, (currRefRule) => {
-                let newPath = utils.cloneArr(path)
-                newPath.push(currRefRule)
-                return validateNoLeftRecursion(topRule, currRefRule, newPath)
-            })
-
-            return errors.concat(utils.flatten(errorsFromNextSteps))
-        }
+export function getFirstNoneTerminal(definition:gast.IProduction[]):gast.Rule[] {
+    let result = []
+    if (utils.isEmpty(definition)) {
+        return result
     }
-
-    export function getFirstNoneTerminal(definition:gast.IProduction[]):gast.Rule[] {
-        let result = []
-        if (utils.isEmpty(definition)) {
-            return result
-        }
-        let firstProd = utils.first(definition)
+    let firstProd = utils.first(definition)
 
 
-        if (firstProd instanceof gast.NonTerminal) {
-            // this allows the check to be performed on partially valid grammars that have not been completly resolved.
-            if (firstProd.referencedRule === undefined) {
-                return result
-            }
-            result.push(firstProd.referencedRule)
-        }
-        else if (firstProd instanceof gast.Flat ||
-            firstProd instanceof gast.Option ||
-            firstProd instanceof gast.RepetitionMandatory ||
-            firstProd instanceof gast.RepetitionMandatoryWithSeparator ||
-            firstProd instanceof gast.RepetitionWithSeparator ||
-            firstProd instanceof gast.Repetition
-        ) {
-            result = result.concat(getFirstNoneTerminal(<gast.IProduction[]>firstProd.definition))
-        }
-        else if (firstProd instanceof gast.Alternation) {
-            // each sub definition in alternation is a FLAT
-            result = utils.flatten(
-                utils.map(firstProd.definition, currSubDef => getFirstNoneTerminal((<gast.Flat>currSubDef).definition)))
-        }
-        else if (firstProd instanceof gast.Terminal) {
-            // nothing to see, move along
-        }
-        else {
-            throw Error("non exhaustive match")
-        }
-
-        let isFirstOptional = gast.isOptionalProd(firstProd)
-        let hasMore = definition.length > 1
-        if (isFirstOptional && hasMore) {
-            let rest = utils.drop(definition)
-            return result.concat(getFirstNoneTerminal(rest))
-        }
-        else {
+    if (firstProd instanceof gast.NonTerminal) {
+        // this allows the check to be performed on partially valid grammars that have not been completly resolved.
+        if (firstProd.referencedRule === undefined) {
             return result
         }
+        result.push(firstProd.referencedRule)
+    }
+    else if (firstProd instanceof gast.Flat ||
+        firstProd instanceof gast.Option ||
+        firstProd instanceof gast.RepetitionMandatory ||
+        firstProd instanceof gast.RepetitionMandatoryWithSeparator ||
+        firstProd instanceof gast.RepetitionWithSeparator ||
+        firstProd instanceof gast.Repetition
+    ) {
+        result = result.concat(getFirstNoneTerminal(<gast.IProduction[]>firstProd.definition))
+    }
+    else if (firstProd instanceof gast.Alternation) {
+        // each sub definition in alternation is a FLAT
+        result = utils.flatten(
+            utils.map(firstProd.definition, currSubDef => getFirstNoneTerminal((<gast.Flat>currSubDef).definition)))
+    }
+    else if (firstProd instanceof gast.Terminal) {
+        // nothing to see, move along
+    }
+    else {
+        throw Error("non exhaustive match")
     }
 
-    class OrCollector extends GAstVisitor {
-        public alternations = []
+    let isFirstOptional = isOptionalProd(firstProd)
+    let hasMore = definition.length > 1
+    if (isFirstOptional && hasMore) {
+        let rest = utils.drop(definition)
+        return result.concat(getFirstNoneTerminal(rest))
+    }
+    else {
+        return result
+    }
+}
 
-        public visitAlternation(node:gast.Alternation):void {
-            this.alternations.push(node)
-        }
+class OrCollector extends gast.GAstVisitor {
+    public alternations = []
+
+    public visitAlternation(node:gast.Alternation):void {
+        this.alternations.push(node)
     }
+}
 
-    export function validateEmptyOrAlternative(topLevelRule:gast.Rule):IParserEmptyAlternativeDefinitionError[] {
-        let orCollector = new OrCollector()
-        topLevelRule.accept(orCollector)
-        let ors = orCollector.alternations
-
-        let errors = utils.reduce(ors, (errors, currOr) => {
-            let exceptLast = utils.dropRight(currOr.definition)
-            let currErrors = utils.map(exceptLast, (currAlternative:IProduction, currAltIdx) => {
-                if (utils.isEmpty(first.first(currAlternative))) {
-                    return {
-                        message:     `Ambiguous empty alternative: <${currAltIdx + 1}>` +
-                                     ` in <OR${currOr.occurrenceInParent}> inside <${topLevelRule.name}> Rule.\n` +
-                                     `Only the last alternative may be an empty alternative.`,
-                        type:        ParserDefinitionErrorType.NONE_LAST_EMPTY_ALT,
-                        ruleName:    topLevelRule.name,
-                        occurrence:  currOr.occurrenceInParent,
-                        alternative: currAltIdx + 1
-                    }
-                }
-                else {
-                    return null
+export function validateEmptyOrAlternative(topLevelRule:gast.Rule):IParserEmptyAlternativeDefinitionError[] {
+    let orCollector = new OrCollector()
+    topLevelRule.accept(orCollector)
+    let ors = orCollector.alternations
+
+    let errors = utils.reduce(ors, (errors, currOr) => {
+        let exceptLast = utils.dropRight(currOr.definition)
+        let currErrors = utils.map(exceptLast, (currAlternative:gast.IProduction, currAltIdx) => {
+            if (utils.isEmpty(first(currAlternative))) {
+                return {
+                    message:     `Ambiguous empty alternative: <${currAltIdx + 1}>` +
+                                 ` in <OR${currOr.occurrenceInParent}> inside <${topLevelRule.name}> Rule.\n` +
+                                 `Only the last alternative may be an empty alternative.`,
+                    type:        ParserDefinitionErrorType.NONE_LAST_EMPTY_ALT,
+                    ruleName:    topLevelRule.name,
+                    occurrence:  currOr.occurrenceInParent,
+                    alternative: currAltIdx + 1
                 }
-            })
-            return errors.concat(utils.compact(currErrors))
-        }, [])
+            }
+            else {
+                return null
+            }
+        })
+        return errors.concat(utils.compact(currErrors))
+    }, [])
 
-        return errors
-    }
+    return errors
 }
diff --git a/src/parse/grammar/first.ts b/src/parse/grammar/first.ts
index 67d854e86..4d42cd29a 100644
--- a/src/parse/grammar/first.ts
+++ b/src/parse/grammar/first.ts
@@ -1,64 +1,61 @@
+import {gast} from "./gast_public"
+import {getProductionDslName, isSequenceProd, isBranchingProd, isOptionalProd} from "./gast"
+import {uniq, map, flatten} from "../../utils/utils"
+
+export function first(prod:gast.IProduction):Function[] {
+    if (prod instanceof gast.NonTerminal) {
+        // this could in theory cause infinite loops if
+        // (1) prod A refs prod B.
+        // (2) prod B refs prod A
+        // (3) AB can match the empty set
+        // in other words a cycle where everything is optional so the first will keep
+        // looking ahead for the next optional part and will never exit
+        // currently there is no safeguard for this unique edge case because
+        // (1) not sure a grammar in which this can happen is useful for anything (productive)
+        return first((<gast.NonTerminal>prod).referencedRule)
 
-namespace chevrotain.first {
-
-    import gast = chevrotain.gast
-
-    export function first(prod:gast.IProduction):Function[] {
-        if (prod instanceof gast.NonTerminal) {
-            // this could in theory cause infinite loops if
-            // (1) prod A refs prod B.
-            // (2) prod B refs prod A
-            // (3) AB can match the empty set
-            // in other words a cycle where everything is optional so the first will keep
-            // looking ahead for the next optional part and will never exit
-            // currently there is no safeguard for this unique edge case because
-            // (1) not sure a grammar in which this can happen is useful for anything (productive)
-            return first((<gast.NonTerminal>prod).referencedRule)
-
-        }
-        else if (prod instanceof gast.Terminal) {
-            return firstForTerminal(<gast.Terminal>prod)
-        }
-        else if (gast.isSequenceProd(prod)) {
-            return firstForSequence(<gast.AbstractProduction>prod)
-        }
-        else if (gast.isBranchingProd(prod)) {
-            return firstForBranching(<gast.AbstractProduction>prod)
-        }
-        else {
-            throw Error("non exhaustive match")
-        }
     }
-
-    export function firstForSequence(prod:gast.AbstractProduction):Function[] {
-        let firstSet:Function[] = []
-        let seq = prod.definition
-        let nextSubProdIdx = 0
-        let hasInnerProdsRemaining = seq.length > nextSubProdIdx
-        let currSubProd
-        // so we enter the loop at least once (if the definition is not empty
-        let isLastInnerProdOptional = true
-        // scan a sequence until it's end or until we have found a NONE optional production in it
-        while (hasInnerProdsRemaining && isLastInnerProdOptional) {
-            currSubProd = seq[nextSubProdIdx]
-            isLastInnerProdOptional = gast.isOptionalProd(currSubProd)
-            firstSet = firstSet.concat(first(currSubProd))
-            nextSubProdIdx = nextSubProdIdx + 1
-            hasInnerProdsRemaining = seq.length > nextSubProdIdx
-        }
-
-        return utils.uniq(firstSet)
+    else if (prod instanceof gast.Terminal) {
+        return firstForTerminal(<gast.Terminal>prod)
     }
-
-    export function firstForBranching(prod:gast.AbstractProduction):Function[] {
-        let allAlternativesFirsts:Function[][] = utils.map(prod.definition, (innerProd) => {
-            return first(innerProd)
-        })
-        return utils.uniq(utils.flatten<Function>(allAlternativesFirsts))
+    else if (isSequenceProd(prod)) {
+        return firstForSequence(<gast.AbstractProduction>prod)
+    }
+    else if (isBranchingProd(prod)) {
+        return firstForBranching(<gast.AbstractProduction>prod)
     }
+    else {
+        throw Error("non exhaustive match")
+    }
+}
 
-    export function firstForTerminal(terminal:gast.Terminal):Function[] {
-        return [terminal.terminalType]
+export function firstForSequence(prod:gast.AbstractProduction):Function[] {
+    let firstSet:Function[] = []
+    let seq = prod.definition
+    let nextSubProdIdx = 0
+    let hasInnerProdsRemaining = seq.length > nextSubProdIdx
+    let currSubProd
+    // so we enter the loop at least once (if the definition is not empty
+    let isLastInnerProdOptional = true
+    // scan a sequence until it's end or until we have found a NONE optional production in it
+    while (hasInnerProdsRemaining && isLastInnerProdOptional) {
+        currSubProd = seq[nextSubProdIdx]
+        isLastInnerProdOptional = isOptionalProd(currSubProd)
+        firstSet = firstSet.concat(first(currSubProd))
+        nextSubProdIdx = nextSubProdIdx + 1
+        hasInnerProdsRemaining = seq.length > nextSubProdIdx
     }
 
+    return uniq(firstSet)
+}
+
+export function firstForBranching(prod:gast.AbstractProduction):Function[] {
+    let allAlternativesFirsts:Function[][] = map(prod.definition, (innerProd) => {
+        return first(innerProd)
+    })
+    return uniq(flatten<Function>(allAlternativesFirsts))
+}
+
+export function firstForTerminal(terminal:gast.Terminal):Function[] {
+    return [terminal.terminalType]
 }
diff --git a/src/parse/grammar/follow.ts b/src/parse/grammar/follow.ts
index 8a73bd34e..14aefe3bd 100644
--- a/src/parse/grammar/follow.ts
+++ b/src/parse/grammar/follow.ts
@@ -1,54 +1,52 @@
+import {RestWalker} from "./rest"
+import {HashTable} from "../../lang/lang_extensions"
+import {gast} from "./gast_public"
+import {first} from "./first"
+import {forEach} from "../../utils/utils"
+import {IN} from "../constants"
+import {tokenName} from "../../scan/tokens_public"
 
-namespace chevrotain.follow {
-
-    import g = chevrotain.gast
-    import r = chevrotain.rest
-    import f = chevrotain.first
-    import IN = chevrotain.constants.IN
-    import lang = chevrotain.lang
-
-    // This ResyncFollowsWalker computes all of the follows required for RESYNC
-    // (skipping reference production).
-    export class ResyncFollowsWalker extends r.RestWalker {
-        public follows = new lang.HashTable<Function[]>()
-
-        constructor(private topProd:g.Rule) { super() }
-
-        startWalking():lang.HashTable<Function[]> {
-            this.walk(this.topProd)
-            return this.follows
-        }
-
-        walkTerminal(terminal:g.Terminal, currRest:g.IProduction[], prevRest:g.IProduction[]):void {
-            // do nothing! just like in the public sector after 13:00
-        }
-
-        walkProdRef(refProd:g.NonTerminal, currRest:g.IProduction[], prevRest:g.IProduction[]):void {
-            let followName = buildBetweenProdsFollowPrefix(refProd.referencedRule, refProd.occurrenceInParent) + this.topProd.name
-            let fullRest:g.IProduction[] = currRest.concat(prevRest)
-            let restProd = new g.Flat(fullRest)
-            let t_in_topProd_follows = f.first(restProd)
-            this.follows.put(followName, t_in_topProd_follows)
-        }
-    }
 
-    export function computeAllProdsFollows(topProductions:g.Rule[]):lang.HashTable<Function[]> {
-        let reSyncFollows = new lang.HashTable<Function[]>()
+// This ResyncFollowsWalker computes all of the follows required for RESYNC
+// (skipping reference production).
+export class ResyncFollowsWalker extends RestWalker {
+    public follows = new HashTable<Function[]>()
+
+    constructor(private topProd:gast.Rule) { super() }
 
-        utils.forEach(topProductions, (topProd) => {
-            let currRefsFollow = new ResyncFollowsWalker(topProd).startWalking()
-            reSyncFollows.putAll(currRefsFollow)
-        })
-        return reSyncFollows
+    startWalking():HashTable<Function[]> {
+        this.walk(this.topProd)
+        return this.follows
     }
 
-    export function buildBetweenProdsFollowPrefix(inner:g.Rule, occurenceInParent:number):string {
-        return inner.name + occurenceInParent + IN
+    walkTerminal(terminal:gast.Terminal, currRest:gast.IProduction[], prevRest:gast.IProduction[]):void {
+        // do nothing! just like in the public sector after 13:00
     }
 
-    export function buildInProdFollowPrefix(terminal:g.Terminal):string {
-        let terminalName = tokenName(terminal.terminalType)
-        return terminalName + terminal.occurrenceInParent + IN
+    walkProdRef(refProd:gast.NonTerminal, currRest:gast.IProduction[], prevRest:gast.IProduction[]):void {
+        let followName = buildBetweenProdsFollowPrefix(refProd.referencedRule, refProd.occurrenceInParent) + this.topProd.name
+        let fullRest:gast.IProduction[] = currRest.concat(prevRest)
+        let restProd = new gast.Flat(fullRest)
+        let t_in_topProd_follows = first(restProd)
+        this.follows.put(followName, t_in_topProd_follows)
     }
+}
+
+export function computeAllProdsFollows(topProductions:gast.Rule[]):HashTable<Function[]> {
+    let reSyncFollows = new HashTable<Function[]>()
+
+    forEach(topProductions, (topProd) => {
+        let currRefsFollow = new ResyncFollowsWalker(topProd).startWalking()
+        reSyncFollows.putAll(currRefsFollow)
+    })
+    return reSyncFollows
+}
+
+export function buildBetweenProdsFollowPrefix(inner:gast.Rule, occurenceInParent:number):string {
+    return inner.name + occurenceInParent + IN
+}
 
+export function buildInProdFollowPrefix(terminal:gast.Terminal):string {
+    let terminalName = tokenName(terminal.terminalType)
+    return terminalName + terminal.occurrenceInParent + IN
 }
diff --git a/src/parse/grammar/gast.ts b/src/parse/grammar/gast.ts
index e3f9945b5..86386b90d 100644
--- a/src/parse/grammar/gast.ts
+++ b/src/parse/grammar/gast.ts
@@ -1,72 +1,69 @@
-namespace chevrotain.gast {
+import {gast} from "./gast_public"
+import {some, every, contains} from "../../utils/utils"
+import {functionName} from "../../lang/lang_extensions"
 
-    import lang = chevrotain.lang
 
-    export function isSequenceProd(prod:IProduction):boolean {
-        return prod instanceof Flat ||
-            prod instanceof Option ||
-            prod instanceof Repetition ||
-            prod instanceof RepetitionMandatory ||
-            prod instanceof RepetitionMandatoryWithSeparator ||
-            prod instanceof RepetitionWithSeparator ||
-            prod instanceof Terminal ||
-            prod instanceof Rule
-    }
+export function isSequenceProd(prod:gast.IProduction):boolean {
+    return prod instanceof gast.Flat ||
+        prod instanceof gast.Option ||
+        prod instanceof gast.Repetition ||
+        prod instanceof gast.RepetitionMandatory ||
+        prod instanceof gast.RepetitionMandatoryWithSeparator ||
+        prod instanceof gast.RepetitionWithSeparator ||
+        prod instanceof gast.Terminal ||
+        prod instanceof gast.Rule
+}
 
-    export function isOptionalProd(prod:IProduction, alreadyVisited:NonTerminal[] = []):boolean {
-        let isDirectlyOptional = prod instanceof Option ||
-            prod instanceof Repetition ||
-            prod instanceof RepetitionWithSeparator
-        if (isDirectlyOptional) {
-            return true
-        }
+export function isOptionalProd(prod:gast.IProduction, alreadyVisited:gast.NonTerminal[] = []):boolean {
+    let isDirectlyOptional = prod instanceof gast.Option ||
+        prod instanceof gast.Repetition ||
+        prod instanceof gast.RepetitionWithSeparator
+    if (isDirectlyOptional) {
+        return true
+    }
 
-        // note that this can cause infinite loop if one optional empty TOP production has a cyclic dependency with another
-        // empty optional top rule
-        // may be indirectly optional ((A?B?C?) | (D?E?F?))
-        if (prod instanceof Alternation) {
-            // for OR its enough for just one of the alternatives to be optional
-            return utils.some((<Alternation>prod).definition, (subProd:IProduction) => {
-                return isOptionalProd(subProd, alreadyVisited)
-            })
-        }
-        else if (prod instanceof NonTerminal && utils.contains(alreadyVisited, prod)) {
-            // avoiding stack overflow due to infinite recursion
-            return false
-        }
-        else if (prod instanceof AbstractProduction) {
-            if (prod instanceof NonTerminal) {
-                alreadyVisited.push(prod)
-            }
-            return utils.every((<AbstractProduction>prod).definition, (subProd:IProduction) => {
-                return isOptionalProd(subProd, alreadyVisited)
-            })
-        }
-        else {
-            return false
+    // note that this can cause infinite loop if one optional empty TOP production has a cyclic dependency with another
+    // empty optional top rule
+    // may be indirectly optional ((A?B?C?) | (D?E?F?))
+    if (prod instanceof gast.Alternation) {
+        // for OR its enough for just one of the alternatives to be optional
+        return some((<gast.Alternation>prod).definition, (subProd:gast.IProduction) => {
+            return isOptionalProd(subProd, alreadyVisited)
+        })
+    }
+    else if (prod instanceof gast.NonTerminal && contains(alreadyVisited, prod)) {
+        // avoiding stack overflow due to infinite recursion
+        return false
+    }
+    else if (prod instanceof gast.AbstractProduction) {
+        if (prod instanceof gast.NonTerminal) {
+            alreadyVisited.push(prod)
         }
+        return every((<gast.AbstractProduction>prod).definition, (subProd:gast.IProduction) => {
+            return isOptionalProd(subProd, alreadyVisited)
+        })
     }
-
-    export function isBranchingProd(prod:IProduction):boolean {
-        return prod instanceof Alternation
+    else {
+        return false
     }
+}
 
-    let productionToDslName = {}
-    productionToDslName[lang.functionName(NonTerminal)] = "SUBRULE"
-    productionToDslName[lang.functionName(Option)] = "OPTION"
-    productionToDslName[lang.functionName(RepetitionMandatory)] = "AT_LEAST_ONE"
-    productionToDslName[lang.functionName(RepetitionMandatoryWithSeparator)] = "AT_LEAST_ONE_SEP"
-    productionToDslName[lang.functionName(RepetitionWithSeparator)] = "MANY_SEP"
-    productionToDslName[lang.functionName(Repetition)] = "MANY"
-    productionToDslName[lang.functionName(Alternation)] = "OR"
-    productionToDslName[lang.functionName(Terminal)] = "CONSUME"
-
+export function isBranchingProd(prod:gast.IProduction):boolean {
+    return prod instanceof gast.Alternation
+}
 
-    export function getProductionDslName(prod:IProductionWithOccurrence):string {
-        let clazz = prod.constructor
-        let prodName = lang.functionName(clazz)
-        return productionToDslName[prodName]
-    }
+let productionToDslName = {}
+productionToDslName[functionName(gast.NonTerminal)] = "SUBRULE"
+productionToDslName[functionName(gast.Option)] = "OPTION"
+productionToDslName[functionName(gast.RepetitionMandatory)] = "AT_LEAST_ONE"
+productionToDslName[functionName(gast.RepetitionMandatoryWithSeparator)] = "AT_LEAST_ONE_SEP"
+productionToDslName[functionName(gast.RepetitionWithSeparator)] = "MANY_SEP"
+productionToDslName[functionName(gast.Repetition)] = "MANY"
+productionToDslName[functionName(gast.Alternation)] = "OR"
+productionToDslName[functionName(gast.Terminal)] = "CONSUME"
 
+export function getProductionDslName(prod:gast.IProductionWithOccurrence):string {
+    let clazz = prod.constructor
+    let prodName = functionName(clazz)
+    return productionToDslName[prodName]
 }
-
diff --git a/src/parse/grammar/gast_public.ts b/src/parse/grammar/gast_public.ts
index a1036c621..1cc52e3d7 100644
--- a/src/parse/grammar/gast_public.ts
+++ b/src/parse/grammar/gast_public.ts
@@ -1,7 +1,6 @@
-namespace chevrotain.gast {
-
-    import lang = chevrotain.lang
+import {forEach} from "../../utils/utils"
 
+export namespace gast {
     export interface IProduction {
         accept(visitor:GAstVisitor):void
     }
@@ -18,7 +17,7 @@ namespace chevrotain.gast {
 
         accept(visitor:GAstVisitor):void {
             visitor.visit(this)
-            utils.forEach(this.definition, (prod) => {
+            forEach(this.definition, (prod) => {
                 prod.accept(visitor)
             })
         }
diff --git a/src/parse/grammar/interpreter.ts b/src/parse/grammar/interpreter.ts
index 5b7b98169..a978737aa 100644
--- a/src/parse/grammar/interpreter.ts
+++ b/src/parse/grammar/interpreter.ts
@@ -1,331 +1,335 @@
+import {RestWalker} from "./rest"
+import {gast} from "./gast_public"
+import {IGrammarPath, ITokenGrammarPath, IRuleGrammarPath} from "./path"
+/* tslint:disable:no-use-before-declare */
+import {cloneArr, isEmpty, map, first as _first} from "../../utils/utils"
+/* tslint:enable:no-use-before-declare */
+import {tokenName} from "../../scan/tokens_public"
+import {first} from "./first"
 
-namespace chevrotain.interpreter {
+export abstract class AbstractNextPossibleTokensWalker extends RestWalker {
 
-    import g = chevrotain.gast
-    import f = chevrotain.first
-    import r = chevrotain.rest
-    import p = chevrotain.path
+    protected possibleTokTypes:Function[] = []
+    protected ruleStack:string[]
+    protected occurrenceStack:number[]
 
-    export abstract class AbstractNextPossibleTokensWalker extends r.RestWalker {
+    protected nextProductionName = ""
+    protected nextProductionOccurrence = 0
+    protected found = false
+    protected isAtEndOfPath = false
 
-        protected possibleTokTypes:Function[] = []
-        protected ruleStack:string[]
-        protected occurrenceStack:number[]
+    constructor(protected topProd:gast.Rule, protected path:IGrammarPath) {super() }
 
-        protected nextProductionName = ""
-        protected nextProductionOccurrence = 0
-        protected found = false
-        protected isAtEndOfPath = false;
+    startWalking():Function[] {
 
-        constructor(protected topProd:g.Rule, protected path:p.IGrammarPath) {super() }
+        this.found = false
 
-        startWalking():Function[] {
+        if (this.path.ruleStack[0] !== this.topProd.name) {
+            throw Error("The path does not start with the walker's top Rule!")
+        }
 
-            this.found = false
+        // immutable for the win
+        this.ruleStack = (cloneArr(this.path.ruleStack)).reverse() // intelij bug requires assertion
+        this.occurrenceStack = (cloneArr(this.path.occurrenceStack)).reverse() // intelij bug requires assertion
 
-            if (this.path.ruleStack[0] !== this.topProd.name) {
-                throw Error("The path does not start with the walker's top Rule!")
-            }
+        // already verified that the first production is valid, we now seek the 2nd production
+        this.ruleStack.pop()
+        this.occurrenceStack.pop()
 
-            // immutable for the win
-            this.ruleStack = (utils.cloneArr(this.path.ruleStack)).reverse() // intelij bug requires assertion
-            this.occurrenceStack = (utils.cloneArr(this.path.occurrenceStack)).reverse() // intelij bug requires assertion
+        this.updateExpectedNext()
+        this.walk(this.topProd)
 
-            // already verified that the first production is valid, we now seek the 2nd production
-            this.ruleStack.pop()
-            this.occurrenceStack.pop()
+        return this.possibleTokTypes
+    }
 
-            this.updateExpectedNext()
-            this.walk(this.topProd)
 
-            return this.possibleTokTypes
+    walk(prod:gast.AbstractProduction, prevRest:gast.IProduction[] = []):void {
+        // stop scanning once we found the path
+        if (!this.found) {
+            super.walk(prod, prevRest)
         }
+    }
 
-
-        walk(prod:g.AbstractProduction, prevRest:gast.IProduction[] = []):void {
-            // stop scanning once we found the path
-            if (!this.found) {
-                super.walk(prod, prevRest)
-            }
+    walkProdRef(refProd:gast.NonTerminal, currRest:gast.IProduction[], prevRest:gast.IProduction[]):void {
+        // found the next production, need to keep walking in it
+        if (refProd.referencedRule.name === this.nextProductionName &&
+            refProd.occurrenceInParent === this.nextProductionOccurrence
+        ) {
+            let fullRest = currRest.concat(prevRest)
+            this.updateExpectedNext()
+            this.walk(refProd.referencedRule, <any>fullRest)
         }
+    }
 
-        walkProdRef(refProd:g.NonTerminal, currRest:g.IProduction[], prevRest:g.IProduction[]):void {
-            // found the next production, need to keep walking in it
-            if (refProd.referencedRule.name === this.nextProductionName &&
-                refProd.occurrenceInParent === this.nextProductionOccurrence
-            ) {
-                let fullRest = currRest.concat(prevRest)
-                this.updateExpectedNext()
-                this.walk(refProd.referencedRule, <any>fullRest)
-            }
+    updateExpectedNext():void {
+        // need to consume the Terminal
+        if (isEmpty(this.ruleStack)) {
+            // must reset nextProductionXXX to avoid walking down another Top Level production while what we are
+            // really seeking is the last Terminal...
+            this.nextProductionName = ""
+            this.nextProductionOccurrence = 0
+            this.isAtEndOfPath = true
         }
-
-        updateExpectedNext():void {
-            // need to consume the Terminal
-            if (utils.isEmpty(this.ruleStack)) {
-                // must reset nextProductionXXX to avoid walking down another Top Level production while what we are
-                // really seeking is the last Terminal...
-                this.nextProductionName = ""
-                this.nextProductionOccurrence = 0
-                this.isAtEndOfPath = true
-            }
-            else {
-                this.nextProductionName = this.ruleStack.pop()
-                this.nextProductionOccurrence = this.occurrenceStack.pop()
-            }
-
+        else {
+            this.nextProductionName = this.ruleStack.pop()
+            this.nextProductionOccurrence = this.occurrenceStack.pop()
         }
+
     }
+}
 
-    export class NextAfterTokenWalker extends AbstractNextPossibleTokensWalker {
-        private nextTerminalName = ""
-        private nextTerminalOccurrence = 0
+export class NextAfterTokenWalker extends AbstractNextPossibleTokensWalker {
+    private nextTerminalName = ""
+    private nextTerminalOccurrence = 0
 
-        constructor(topProd:g.Rule, protected path:p.ITokenGrammarPath) {
-            super(topProd, path)
-            this.nextTerminalName = tokenName(this.path.lastTok)
-            this.nextTerminalOccurrence = this.path.lastTokOccurrence
-        }
+    constructor(topProd:gast.Rule, protected path:ITokenGrammarPath) {
+        super(topProd, path)
+        this.nextTerminalName = tokenName(this.path.lastTok)
+        this.nextTerminalOccurrence = this.path.lastTokOccurrence
+    }
 
-        walkTerminal(terminal:g.Terminal, currRest:g.IProduction[], prevRest:g.IProduction[]):void {
-            if (this.isAtEndOfPath && tokenName(terminal.terminalType) === this.nextTerminalName &&
-                terminal.occurrenceInParent === this.nextTerminalOccurrence && !(this.found)
-            ) {
-                let fullRest = currRest.concat(prevRest)
-                let restProd = new g.Flat(<any>fullRest)
-                this.possibleTokTypes = f.first(restProd)
-                this.found = true
-            }
+    walkTerminal(terminal:gast.Terminal, currRest:gast.IProduction[], prevRest:gast.IProduction[]):void {
+        if (this.isAtEndOfPath && tokenName(terminal.terminalType) === this.nextTerminalName &&
+            terminal.occurrenceInParent === this.nextTerminalOccurrence && !(this.found)
+        ) {
+            let fullRest = currRest.concat(prevRest)
+            let restProd = new gast.Flat(<any>fullRest)
+            this.possibleTokTypes = first(restProd)
+            this.found = true
         }
     }
+}
 
-    export class NextInsideOptionWalker extends AbstractNextPossibleTokensWalker {
+export class NextInsideOptionWalker extends AbstractNextPossibleTokensWalker {
 
-        private nextOptionOccurrence = 0
+    private nextOptionOccurrence = 0
 
-        constructor(topProd:g.Rule, protected path:p.IRuleGrammarPath) {
-            super(topProd, path)
-            this.nextOptionOccurrence = this.path.occurrence
-        }
+    constructor(topProd:gast.Rule, protected path:IRuleGrammarPath) {
+        super(topProd, path)
+        this.nextOptionOccurrence = this.path.occurrence
+    }
 
-        walkOption(optionProd:g.Option, currRest:g.IProduction[], prevRest:g.IProduction[]):void {
-            if (this.isAtEndOfPath && optionProd.occurrenceInParent === this.nextOptionOccurrence && !(this.found)) {
-                let restProd = new g.Flat(optionProd.definition)
-                this.possibleTokTypes = f.first(restProd)
-                this.found = true
-            }
-            else {
-                super.walkOption(optionProd, currRest, prevRest)
-            }
+    walkOption(optionProd:gast.Option, currRest:gast.IProduction[], prevRest:gast.IProduction[]):void {
+        if (this.isAtEndOfPath && optionProd.occurrenceInParent === this.nextOptionOccurrence && !(this.found)) {
+            let restProd = new gast.Flat(optionProd.definition)
+            this.possibleTokTypes = first(restProd)
+            this.found = true
+        }
+        else {
+            super.walkOption(optionProd, currRest, prevRest)
         }
     }
+}
 
-    export class NextInsideManyWalker extends AbstractNextPossibleTokensWalker {
+export class NextInsideManyWalker extends AbstractNextPossibleTokensWalker {
 
-        private nextOccurrence = 0
+    private nextOccurrence = 0
 
-        constructor(topProd:g.Rule, protected path:p.IRuleGrammarPath) {
-            super(topProd, path)
-            this.nextOccurrence = this.path.occurrence
-        }
+    constructor(topProd:gast.Rule, protected path:IRuleGrammarPath) {
+        super(topProd, path)
+        this.nextOccurrence = this.path.occurrence
+    }
 
-        walkMany(manyProd:g.Repetition, currRest:g.IProduction[], prevRest:g.IProduction[]):void {
-            if (this.isAtEndOfPath && manyProd.occurrenceInParent === this.nextOccurrence && !(this.found)) {
-                let restProd = new g.Flat(manyProd.definition)
-                this.possibleTokTypes = f.first(restProd)
-                this.found = true
-            }
-            else {
-                super.walkMany(manyProd, currRest, prevRest)
-            }
+    walkMany(manyProd:gast.Repetition, currRest:gast.IProduction[], prevRest:gast.IProduction[]):void {
+        if (this.isAtEndOfPath && manyProd.occurrenceInParent === this.nextOccurrence && !(this.found)) {
+            let restProd = new gast.Flat(manyProd.definition)
+            this.possibleTokTypes = first(restProd)
+            this.found = true
+        }
+        else {
+            super.walkMany(manyProd, currRest, prevRest)
         }
     }
+}
 
-    export class NextInsideManySepWalker extends AbstractNextPossibleTokensWalker {
+export class NextInsideManySepWalker extends AbstractNextPossibleTokensWalker {
 
-        private nextOccurrence = 0
+    private nextOccurrence = 0
 
-        constructor(topProd:g.Rule, protected path:p.IRuleGrammarPath) {
-            super(topProd, path)
-            this.nextOccurrence = this.path.occurrence
-        }
+    constructor(topProd:gast.Rule, protected path:IRuleGrammarPath) {
+        super(topProd, path)
+        this.nextOccurrence = this.path.occurrence
+    }
 
-        walkManySep(manySepProd:g.RepetitionWithSeparator, currRest:g.IProduction[], prevRest:g.IProduction[]):void {
-            if (this.isAtEndOfPath && manySepProd.occurrenceInParent === this.nextOccurrence && !(this.found)) {
-                let restProd = new g.Flat(manySepProd.definition)
-                this.possibleTokTypes = f.first(restProd)
-                this.found = true
-            }
-            else {
-                super.walkManySep(manySepProd, currRest, prevRest)
-            }
+    walkManySep(manySepProd:gast.RepetitionWithSeparator, currRest:gast.IProduction[], prevRest:gast.IProduction[]):void {
+        if (this.isAtEndOfPath && manySepProd.occurrenceInParent === this.nextOccurrence && !(this.found)) {
+            let restProd = new gast.Flat(manySepProd.definition)
+            this.possibleTokTypes = first(restProd)
+            this.found = true
+        }
+        else {
+            super.walkManySep(manySepProd, currRest, prevRest)
         }
     }
+}
 
-    export class NextInsideAtLeastOneWalker extends AbstractNextPossibleTokensWalker {
+export class NextInsideAtLeastOneWalker extends AbstractNextPossibleTokensWalker {
 
-        private nextOccurrence = 0
+    private nextOccurrence = 0
 
-        constructor(topProd:g.Rule, protected path:p.IRuleGrammarPath) {
-            super(topProd, path)
-            this.nextOccurrence = this.path.occurrence
-        }
+    constructor(topProd:gast.Rule, protected path:IRuleGrammarPath) {
+        super(topProd, path)
+        this.nextOccurrence = this.path.occurrence
+    }
 
-        walkAtLeastOne(atLeastOneProd:g.RepetitionMandatory, currRest:g.IProduction[], prevRest:g.IProduction[]):void {
-            if (this.isAtEndOfPath && atLeastOneProd.occurrenceInParent === this.nextOccurrence && !(this.found)) {
-                let restProd = new g.Flat(atLeastOneProd.definition)
-                this.possibleTokTypes = f.first(restProd)
-                this.found = true
-            }
-            else {
-                super.walkAtLeastOne(atLeastOneProd, currRest, prevRest)
-            }
+    walkAtLeastOne(atLeastOneProd:gast.RepetitionMandatory, currRest:gast.IProduction[], prevRest:gast.IProduction[]):void {
+        if (this.isAtEndOfPath && atLeastOneProd.occurrenceInParent === this.nextOccurrence && !(this.found)) {
+            let restProd = new gast.Flat(atLeastOneProd.definition)
+            this.possibleTokTypes = first(restProd)
+            this.found = true
+        }
+        else {
+            super.walkAtLeastOne(atLeastOneProd, currRest, prevRest)
         }
     }
+}
 
-    export class NextInsideAtLeastOneSepWalker extends AbstractNextPossibleTokensWalker {
+export class NextInsideAtLeastOneSepWalker extends AbstractNextPossibleTokensWalker {
 
-        private nextOccurrence = 0
+    private nextOccurrence = 0
 
-        constructor(topProd:g.Rule, protected path:p.IRuleGrammarPath) {
-            super(topProd, path)
-            this.nextOccurrence = this.path.occurrence
-        }
+    constructor(topProd:gast.Rule, protected path:IRuleGrammarPath) {
+        super(topProd, path)
+        this.nextOccurrence = this.path.occurrence
+    }
 
-        walkAtLeastOneSep(atLeastOneSepProd:g.RepetitionMandatoryWithSeparator, currRest:g.IProduction[], prevRest:g.IProduction[]):void {
-            if (this.isAtEndOfPath && atLeastOneSepProd.occurrenceInParent === this.nextOccurrence && !(this.found)) {
-                let restProd = new g.Flat(atLeastOneSepProd.definition)
-                this.possibleTokTypes = f.first(restProd)
-                this.found = true
-            }
-            else {
-                super.walkAtLeastOneSep(atLeastOneSepProd, currRest, prevRest)
-            }
+    walkAtLeastOneSep(atLeastOneSepProd:gast.RepetitionMandatoryWithSeparator,
+                      currRest:gast.IProduction[],
+                      prevRest:gast.IProduction[]):void {
+        if (this.isAtEndOfPath && atLeastOneSepProd.occurrenceInParent === this.nextOccurrence && !(this.found)) {
+            let restProd = new gast.Flat(atLeastOneSepProd.definition)
+            this.possibleTokTypes = first(restProd)
+            this.found = true
+        }
+        else {
+            super.walkAtLeastOneSep(atLeastOneSepProd, currRest, prevRest)
         }
     }
+}
 
-    export type AlternativesFirstTokens = Function[][]
+export type AlternativesFirstTokens = Function[][]
 
-    export class NextInsideOrWalker extends r.RestWalker {
+export class NextInsideOrWalker extends RestWalker {
 
-        public result:AlternativesFirstTokens = []
+    public result:AlternativesFirstTokens = []
 
-        constructor(protected topRule:g.Rule, protected occurrence:number) {
-            super()
-        }
+    constructor(protected topRule:gast.Rule, protected occurrence:number) {
+        super()
+    }
 
-        startWalking():AlternativesFirstTokens {
-            this.walk(this.topRule)
-            return this.result
-        }
+    startWalking():AlternativesFirstTokens {
+        this.walk(this.topRule)
+        return this.result
+    }
 
-        walkOr(orProd:g.Alternation, currRest:g.IProduction[], prevRest:g.IProduction[]):void {
-            if (orProd.occurrenceInParent === this.occurrence) {
-                this.result = utils.map(orProd.definition, (alt) => {
-                    let altWrapper = new gast.Flat([alt])
-                    return f.first(altWrapper)
-                })
-            }
-            else {
-                super.walkOr(orProd, currRest, prevRest)
-            }
+    walkOr(orProd:gast.Alternation, currRest:gast.IProduction[], prevRest:gast.IProduction[]):void {
+        if (orProd.occurrenceInParent === this.occurrence) {
+            this.result = map(orProd.definition, (alt) => {
+                let altWrapper = new gast.Flat([alt])
+                return first(altWrapper)
+            })
+        }
+        else {
+            super.walkOr(orProd, currRest, prevRest)
         }
     }
+}
 
-    export interface IFirstAfterRepetition {
-        token:Function
-        occurrence:number
-        isEndOfRule:boolean
-    }
+export interface IFirstAfterRepetition {
+    token:Function
+    occurrence:number
+    isEndOfRule:boolean
+}
 
-    /**
-     * This walker only "walks" a single "TOP" level in the Grammar Ast, this means
-     * it never "follows" production refs
-     */
-    export class AbstractNextTerminalAfterProductionWalker extends r.RestWalker {
+/**
+ * This walker only "walks" a single "TOP" level in the Grammar Ast, this means
+ * it never "follows" production refs
+ */
+export class AbstractNextTerminalAfterProductionWalker extends RestWalker {
 
-        protected result = {token: undefined, occurrence: undefined, isEndOfRule: undefined}
+    protected result = {token: undefined, occurrence: undefined, isEndOfRule: undefined}
 
-        constructor(protected topRule:g.Rule, protected occurrence:number) {
-            super()
-        }
+    constructor(protected topRule:gast.Rule, protected occurrence:number) {
+        super()
+    }
 
-        startWalking():IFirstAfterRepetition {
-            this.walk(this.topRule)
-            return this.result
-        }
+    startWalking():IFirstAfterRepetition {
+        this.walk(this.topRule)
+        return this.result
     }
+}
 
-    export class NextTerminalAfterManyWalker extends AbstractNextTerminalAfterProductionWalker {
+export class NextTerminalAfterManyWalker extends AbstractNextTerminalAfterProductionWalker {
 
-        walkMany(manyProd:g.Repetition, currRest:g.IProduction[], prevRest:g.IProduction[]):void {
-            if (manyProd.occurrenceInParent === this.occurrence) {
+    walkMany(manyProd:gast.Repetition, currRest:gast.IProduction[], prevRest:gast.IProduction[]):void {
+        if (manyProd.occurrenceInParent === this.occurrence) {
 
-                let firstAfterMany = utils.first(currRest.concat(prevRest))
-                this.result.isEndOfRule = firstAfterMany === undefined
-                if (firstAfterMany instanceof gast.Terminal) {
-                    this.result.token = firstAfterMany.terminalType
-                    this.result.occurrence = firstAfterMany.occurrenceInParent
-                }
-            }
-            else {
-                super.walkMany(manyProd, currRest, prevRest)
+            let firstAfterMany = _first(currRest.concat(prevRest))
+            this.result.isEndOfRule = firstAfterMany === undefined
+            if (firstAfterMany instanceof gast.Terminal) {
+                this.result.token = firstAfterMany.terminalType
+                this.result.occurrence = firstAfterMany.occurrenceInParent
             }
         }
+        else {
+            super.walkMany(manyProd, currRest, prevRest)
+        }
     }
+}
 
-    export class NextTerminalAfterManySepWalker extends AbstractNextTerminalAfterProductionWalker {
+export class NextTerminalAfterManySepWalker extends AbstractNextTerminalAfterProductionWalker {
 
-        walkManySep(manySepProd:g.RepetitionWithSeparator, currRest:g.IProduction[], prevRest:g.IProduction[]):void {
-            if (manySepProd.occurrenceInParent === this.occurrence) {
+    walkManySep(manySepProd:gast.RepetitionWithSeparator, currRest:gast.IProduction[], prevRest:gast.IProduction[]):void {
+        if (manySepProd.occurrenceInParent === this.occurrence) {
 
-                let firstAfterManySep = utils.first(currRest.concat(prevRest))
-                this.result.isEndOfRule = firstAfterManySep === undefined
-                if (firstAfterManySep instanceof gast.Terminal) {
-                    this.result.token = firstAfterManySep.terminalType
-                    this.result.occurrence = firstAfterManySep.occurrenceInParent
-                }
-            }
-            else {
-                super.walkManySep(manySepProd, currRest, prevRest)
+            let firstAfterManySep = _first(currRest.concat(prevRest))
+            this.result.isEndOfRule = firstAfterManySep === undefined
+            if (firstAfterManySep instanceof gast.Terminal) {
+                this.result.token = firstAfterManySep.terminalType
+                this.result.occurrence = firstAfterManySep.occurrenceInParent
             }
         }
+        else {
+            super.walkManySep(manySepProd, currRest, prevRest)
+        }
     }
+}
 
-    export class NextTerminalAfterAtLeastOneWalker extends AbstractNextTerminalAfterProductionWalker {
+export class NextTerminalAfterAtLeastOneWalker extends AbstractNextTerminalAfterProductionWalker {
 
-        walkAtLeastOne(atLeastOneProd:g.RepetitionMandatory, currRest:g.IProduction[], prevRest:g.IProduction[]):void {
-            if (atLeastOneProd.occurrenceInParent === this.occurrence) {
+    walkAtLeastOne(atLeastOneProd:gast.RepetitionMandatory, currRest:gast.IProduction[], prevRest:gast.IProduction[]):void {
+        if (atLeastOneProd.occurrenceInParent === this.occurrence) {
 
-                let firstAfterAtLeastOne = utils.first(currRest.concat(prevRest))
-                this.result.isEndOfRule = firstAfterAtLeastOne === undefined
-                if (firstAfterAtLeastOne instanceof gast.Terminal) {
-                    this.result.token = firstAfterAtLeastOne.terminalType
-                    this.result.occurrence = firstAfterAtLeastOne.occurrenceInParent
-                }
-            }
-            else {
-                super.walkAtLeastOne(atLeastOneProd, currRest, prevRest)
+            let firstAfterAtLeastOne = _first(currRest.concat(prevRest))
+            this.result.isEndOfRule = firstAfterAtLeastOne === undefined
+            if (firstAfterAtLeastOne instanceof gast.Terminal) {
+                this.result.token = firstAfterAtLeastOne.terminalType
+                this.result.occurrence = firstAfterAtLeastOne.occurrenceInParent
             }
         }
+        else {
+            super.walkAtLeastOne(atLeastOneProd, currRest, prevRest)
+        }
     }
+}
 
-    // TODO: reduce code duplication in the AfterWalkers
-    export class NextTerminalAfterAtLeastOneSepWalker extends AbstractNextTerminalAfterProductionWalker {
+// TODO: reduce code duplication in the AfterWalkers
+export class NextTerminalAfterAtLeastOneSepWalker extends AbstractNextTerminalAfterProductionWalker {
 
-        walkAtLeastOneSep(atleastOneSepProd:g.RepetitionMandatoryWithSeparator, currRest:g.IProduction[], prevRest:g.IProduction[]):void {
-            if (atleastOneSepProd.occurrenceInParent === this.occurrence) {
+    walkAtLeastOneSep(atleastOneSepProd:gast.RepetitionMandatoryWithSeparator,
+                      currRest:gast.IProduction[],
+                      prevRest:gast.IProduction[]):void {
+        if (atleastOneSepProd.occurrenceInParent === this.occurrence) {
 
-                let firstAfterfirstAfterAtLeastOneSep = utils.first(currRest.concat(prevRest))
-                this.result.isEndOfRule = firstAfterfirstAfterAtLeastOneSep === undefined
-                if (firstAfterfirstAfterAtLeastOneSep instanceof gast.Terminal) {
-                    this.result.token = firstAfterfirstAfterAtLeastOneSep.terminalType
-                    this.result.occurrence = firstAfterfirstAfterAtLeastOneSep.occurrenceInParent
-                }
-            }
-            else {
-                super.walkAtLeastOneSep(atleastOneSepProd, currRest, prevRest)
+            let firstAfterfirstAfterAtLeastOneSep = _first(currRest.concat(prevRest))
+            this.result.isEndOfRule = firstAfterfirstAfterAtLeastOneSep === undefined
+            if (firstAfterfirstAfterAtLeastOneSep instanceof gast.Terminal) {
+                this.result.token = firstAfterfirstAfterAtLeastOneSep.terminalType
+                this.result.occurrence = firstAfterfirstAfterAtLeastOneSep.occurrenceInParent
             }
         }
+        else {
+            super.walkAtLeastOneSep(atleastOneSepProd, currRest, prevRest)
+        }
     }
 }
diff --git a/src/parse/grammar/lookahead.ts b/src/parse/grammar/lookahead.ts
index a43164163..64c608664 100644
--- a/src/parse/grammar/lookahead.ts
+++ b/src/parse/grammar/lookahead.ts
@@ -1,163 +1,170 @@
-namespace chevrotain.lookahead {
-
-    import gast = chevrotain.gast
-    import p = chevrotain.path
-    import interp = chevrotain.interpreter
-    import f = chevrotain.first
-    import AlternativesFirstTokens = chevrotain.interpreter.AlternativesFirstTokens
-
-    export function buildLookaheadForTopLevel(rule:gast.Rule):() => boolean {
-        let restProd = new gast.Flat(rule.definition)
-        let possibleTokTypes = f.first(restProd)
-        return getSimpleLookahead(possibleTokTypes)
-    }
+import {gast} from "./gast_public"
+import {first} from "./first"
+import {
+    NextInsideOptionWalker,
+    NextInsideManySepWalker,
+    NextInsideManyWalker,
+    NextInsideAtLeastOneWalker,
+    NextInsideAtLeastOneSepWalker,
+    NextInsideOrWalker,
+    AlternativesFirstTokens,
+    AbstractNextPossibleTokensWalker
+} from "./interpreter"
+import {last, isEmpty, map, flatten, uniq, filter, find, keys, pick} from "../../utils/utils"
+import {tokenName} from "../../scan/tokens_public"
+import {IRuleGrammarPath} from "./path"
+
+export function buildLookaheadForTopLevel(rule:gast.Rule):() => boolean {
+    let restProd = new gast.Flat(rule.definition)
+    let possibleTokTypes = first(restProd)
+    return getSimpleLookahead(possibleTokTypes)
+}
 
-    export function buildLookaheadForOption(optionOccurrence:number, ruleGrammar:gast.Rule):() => boolean {
-        return buildLookAheadForGrammarProd(interp.NextInsideOptionWalker, optionOccurrence, ruleGrammar)
-    }
+export function buildLookaheadForOption(optionOccurrence:number, ruleGrammar:gast.Rule):() => boolean {
+    return buildLookAheadForGrammarProd(NextInsideOptionWalker, optionOccurrence, ruleGrammar)
+}
 
-    export function buildLookaheadForMany(manyOccurrence:number, ruleGrammar:gast.Rule):() => boolean {
-        return buildLookAheadForGrammarProd(interp.NextInsideManyWalker, manyOccurrence, ruleGrammar)
-    }
+export function buildLookaheadForMany(manyOccurrence:number, ruleGrammar:gast.Rule):() => boolean {
+    return buildLookAheadForGrammarProd(NextInsideManyWalker, manyOccurrence, ruleGrammar)
+}
 
-    export function buildLookaheadForManySep(manyOccurrence:number, ruleGrammar:gast.Rule):() => boolean {
-        return buildLookAheadForGrammarProd(interp.NextInsideManySepWalker, manyOccurrence, ruleGrammar)
-    }
+export function buildLookaheadForManySep(manyOccurrence:number, ruleGrammar:gast.Rule):() => boolean {
+    return buildLookAheadForGrammarProd(NextInsideManySepWalker, manyOccurrence, ruleGrammar)
+}
 
-    export function buildLookaheadForAtLeastOne(manyOccurrence:number, ruleGrammar:gast.Rule):() => boolean {
-        return buildLookAheadForGrammarProd(interp.NextInsideAtLeastOneWalker, manyOccurrence, ruleGrammar)
-    }
+export function buildLookaheadForAtLeastOne(manyOccurrence:number, ruleGrammar:gast.Rule):() => boolean {
+    return buildLookAheadForGrammarProd(NextInsideAtLeastOneWalker, manyOccurrence, ruleGrammar)
+}
 
-    export function buildLookaheadForAtLeastOneSep(manyOccurrence:number, ruleGrammar:gast.Rule):() => boolean {
-        return buildLookAheadForGrammarProd(interp.NextInsideAtLeastOneSepWalker, manyOccurrence, ruleGrammar)
-    }
+export function buildLookaheadForAtLeastOneSep(manyOccurrence:number, ruleGrammar:gast.Rule):() => boolean {
+    return buildLookAheadForGrammarProd(NextInsideAtLeastOneSepWalker, manyOccurrence, ruleGrammar)
+}
 
-    export function buildLookaheadForOr(orOccurrence:number, ruleGrammar:gast.Rule, ignoreAmbiguities:boolean = false):() => number {
+export function buildLookaheadForOr(orOccurrence:number, ruleGrammar:gast.Rule, ignoreAmbiguities:boolean = false):() => number {
 
-        let alternativesTokens = new interp.NextInsideOrWalker(ruleGrammar, orOccurrence).startWalking()
+    let alternativesTokens = new NextInsideOrWalker(ruleGrammar, orOccurrence).startWalking()
 
-        if (!ignoreAmbiguities) {
-            checkForOrAmbiguities(alternativesTokens, orOccurrence, ruleGrammar)
-        }
+    if (!ignoreAmbiguities) {
+        checkForOrAmbiguities(alternativesTokens, orOccurrence, ruleGrammar)
+    }
 
-        let hasLastAnEmptyAlt = utils.isEmpty(utils.last(alternativesTokens))
-        if (hasLastAnEmptyAlt) {
-            let lastIdx = alternativesTokens.length - 1
-            /**
-             * This will return the Index of the alternative to take or the <lastidx> if only the empty alternative matched
-             */
-            return function chooseAlternativeWithEmptyAlt():number {
-                let nextToken = this.NEXT_TOKEN()
-                // checking only until length - 1 because there is nothing to check in an empty alternative, it is always valid
-                for (let i = 0; i < lastIdx; i++) {
-                    let currAltTokens = alternativesTokens[i]
-                    // 'for' loop for performance reasons.
-                    for (let j = 0; j < (<any>currAltTokens).length; j++) {
-                        if (nextToken instanceof currAltTokens[j]) {
-                            return i
-                        }
+    let hasLastAnEmptyAlt = isEmpty(last(alternativesTokens))
+    if (hasLastAnEmptyAlt) {
+        let lastIdx = alternativesTokens.length - 1
+        /**
+         * This will return the Index of the alternative to take or the <lastidx> if only the empty alternative matched
+         */
+        return function chooseAlternativeWithEmptyAlt():number {
+            let nextToken = this.NEXT_TOKEN()
+            // checking only until length - 1 because there is nothing to check in an empty alternative, it is always valid
+            for (let i = 0; i < lastIdx; i++) {
+                let currAltTokens = alternativesTokens[i]
+                // 'for' loop for performance reasons.
+                for (let j = 0; j < (<any>currAltTokens).length; j++) {
+                    if (nextToken instanceof currAltTokens[j]) {
+                        return i
                     }
                 }
-                // an OR(alternation) with an empty alternative will always match
-                return lastIdx;
             }
+            // an OR(alternation) with an empty alternative will always match
+            return lastIdx
         }
-        else {
-            /**
-             * This will return the Index of the alternative to take or -1 if none of the alternatives match
-             */
-            return function chooseAlternative():number {
-                let nextToken = this.NEXT_TOKEN()
-                for (let i = 0; i < alternativesTokens.length; i++) {
-                    let currAltTokens = alternativesTokens[i]
-                    // 'for' loop for performance reasons.
-                    for (let j = 0; j < (<any>currAltTokens).length; j++) {
-                        if (nextToken instanceof currAltTokens[j]) {
-                            return i
-                        }
+    }
+    else {
+        /**
+         * This will return the Index of the alternative to take or -1 if none of the alternatives match
+         */
+        return function chooseAlternative():number {
+            let nextToken = this.NEXT_TOKEN()
+            for (let i = 0; i < alternativesTokens.length; i++) {
+                let currAltTokens = alternativesTokens[i]
+                // 'for' loop for performance reasons.
+                for (let j = 0; j < (<any>currAltTokens).length; j++) {
+                    if (nextToken instanceof currAltTokens[j]) {
+                        return i
                     }
                 }
-                return -1;
             }
+            return -1
         }
     }
+}
 
-    export function checkForOrAmbiguities(alternativesTokens:AlternativesFirstTokens,
-                                          orOccurrence:number,
-                                          ruleGrammar:gast.Rule):void {
-        let altsAmbiguityErrors = checkAlternativesAmbiguities(alternativesTokens)
-
-        if (!utils.isEmpty(altsAmbiguityErrors)) {
-            let errorMessages = utils.map(altsAmbiguityErrors, (currAmbiguity) => {
-                return `Ambiguous alternatives: <${currAmbiguity.alts.join(" ,")}> in <OR${orOccurrence}> inside <${ruleGrammar.name}> ` +
-                    `Rule, <${tokenName(currAmbiguity.token)}> may appears as the first Terminal in all these alternatives.\n`
-            })
+export function checkForOrAmbiguities(alternativesTokens:AlternativesFirstTokens,
+                                      orOccurrence:number,
+                                      ruleGrammar:gast.Rule):void {
+    let altsAmbiguityErrors = checkAlternativesAmbiguities(alternativesTokens)
 
-            throw new Error(errorMessages.join("\n ---------------- \n") +
-                "To Resolve this, either: \n" +
-                "1. refactor your grammar to be LL(1)\n" +
-                "2. provide explicit lookahead functions in the form {WHEN:laFunc, THEN_DO:...}\n" +
-                "3. Add ignore arg to this OR Production:\n" +
-                "OR([], 'msg', recognizer.IGNORE_AMBIGUITIES)\n" +
-                "In that case the parser will always pick the first alternative that" +
-                " matches and ignore all the others")
-        }
-    }
+    if (!isEmpty(altsAmbiguityErrors)) {
+        let errorMessages = map(altsAmbiguityErrors, (currAmbiguity) => {
+            return `Ambiguous alternatives: <${currAmbiguity.alts.join(" ,")}> in <OR${orOccurrence}> inside <${ruleGrammar.name}> ` +
+                `Rule, <${tokenName(currAmbiguity.token)}> may appears as the first Terminal in all these alternatives.\n`
+        })
 
-    export interface IAmbiguityDescriptor {
-        alts:number[]
-        token:Function
+        throw new Error(errorMessages.join("\n ---------------- \n") +
+            "To Resolve this, either: \n" +
+            "1. refactor your grammar to be LL(1)\n" +
+            "2. provide explicit lookahead functions in the form {WHEN:laFunc, THEN_DO:...}\n" +
+            "3. Add ignore arg to this OR Production:\n" +
+            "OR([], 'msg', recognizer.IGNORE_AMBIGUITIES)\n" +
+            "In that case the parser will always pick the first alternative that" +
+            " matches and ignore all the others")
     }
+}
 
-    export function checkAlternativesAmbiguities(alternativesTokens:Function[][]):IAmbiguityDescriptor[] {
+export interface IAmbiguityDescriptor {
+    alts:number[]
+    token:Function
+}
 
-        let allTokensFlat = utils.flatten(alternativesTokens)
-        let uniqueTokensFlat = utils.uniq(allTokensFlat)
+export function checkAlternativesAmbiguities(alternativesTokens:Function[][]):IAmbiguityDescriptor[] {
 
-        let tokensToAltsIndicesItAppearsIn = utils.map(uniqueTokensFlat, (seekToken) => {
-            let altsCurrTokenAppearsIn = utils.pick(alternativesTokens, (altToLookIn) => {
-                return <any> utils.find(altToLookIn, (currToken) => {
-                    return currToken === seekToken
-                })
-            })
+    let allTokensFlat = flatten(alternativesTokens)
+    let uniqueTokensFlat = uniq(allTokensFlat)
 
-            let altsIndicesTokenAppearsIn = utils.map(utils.keys(altsCurrTokenAppearsIn), (index) => {
-                return parseInt(index, 10) + 1
+    let tokensToAltsIndicesItAppearsIn = map(uniqueTokensFlat, (seekToken) => {
+        let altsCurrTokenAppearsIn = pick(alternativesTokens, (altToLookIn) => {
+            return <any> find(altToLookIn, (currToken) => {
+                return currToken === seekToken
             })
-
-            return {token: seekToken, alts: altsIndicesTokenAppearsIn}
         })
 
-        let tokensToAltsIndicesWithAmbiguity:any = utils.filter(tokensToAltsIndicesItAppearsIn, (tokAndAltsItAppearsIn) => {
-            return tokAndAltsItAppearsIn.alts.length > 1
+        let altsIndicesTokenAppearsIn = map(keys(altsCurrTokenAppearsIn), (index) => {
+            return parseInt(index, 10) + 1
         })
 
-        return tokensToAltsIndicesWithAmbiguity
-    }
+        return {token: seekToken, alts: altsIndicesTokenAppearsIn}
+    })
 
-    function buildLookAheadForGrammarProd(prodWalkerConstructor:any, ruleOccurrence:number,
-                                          ruleGrammar:gast.Rule):() => boolean {
-        let path:p.IRuleGrammarPath = {
-            ruleStack:       [ruleGrammar.name],
-            occurrenceStack: [1],
-            occurrence:      ruleOccurrence
-        }
+    let tokensToAltsIndicesWithAmbiguity:any = filter(tokensToAltsIndicesItAppearsIn, (tokAndAltsItAppearsIn) => {
+        return tokAndAltsItAppearsIn.alts.length > 1
+    })
 
-        let walker:interp.AbstractNextPossibleTokensWalker = new prodWalkerConstructor(ruleGrammar, path)
-        let possibleNextTokTypes = walker.startWalking()
+    return tokensToAltsIndicesWithAmbiguity
+}
 
-        return getSimpleLookahead(possibleNextTokTypes)
+function buildLookAheadForGrammarProd(prodWalkerConstructor:any, ruleOccurrence:number,
+                                      ruleGrammar:gast.Rule):() => boolean {
+    let path:IRuleGrammarPath = {
+        ruleStack:       [ruleGrammar.name],
+        occurrenceStack: [1],
+        occurrence:      ruleOccurrence
     }
 
-    function getSimpleLookahead(possibleNextTokTypes:Function[]):() => boolean {
-        return function ():boolean {
-            let nextToken = this.NEXT_TOKEN()
-            for (let j = 0; j < possibleNextTokTypes.length; j++) {
-                if (nextToken instanceof possibleNextTokTypes[j]) {
-                    return true
-                }
+    let walker:AbstractNextPossibleTokensWalker = new prodWalkerConstructor(ruleGrammar, path)
+    let possibleNextTokTypes = walker.startWalking()
+
+    return getSimpleLookahead(possibleNextTokTypes)
+}
+
+function getSimpleLookahead(possibleNextTokTypes:Function[]):() => boolean {
+    return function ():boolean {
+        let nextToken = this.NEXT_TOKEN()
+        for (let j = 0; j < possibleNextTokTypes.length; j++) {
+            if (nextToken instanceof possibleNextTokTypes[j]) {
+                return true
             }
-            return false
         }
+        return false
     }
 }
diff --git a/src/parse/grammar/path.ts b/src/parse/grammar/path.ts
index 5bf3a8874..ef4351ab1 100644
--- a/src/parse/grammar/path.ts
+++ b/src/parse/grammar/path.ts
@@ -1,22 +1,17 @@
+/**
+ * this interfaces defines the path the parser "took" to reach a certain position
+ * in the grammar.
+ */
+export interface IGrammarPath {
+    ruleStack:string[]
+    occurrenceStack:number[]
+}
 
-namespace chevrotain.path {
-
-    /**
-     * this interfaces defines the path the parser "took" to reach a certain position
-     * in the grammar.
-     */
-    export interface IGrammarPath {
-        ruleStack:string[]
-        occurrenceStack:number[]
-    }
-
-    export interface ITokenGrammarPath extends IGrammarPath {
-        lastTok:Function
-        lastTokOccurrence:number
-    }
-
-    export interface IRuleGrammarPath extends IGrammarPath {
-        occurrence:number
-    }
+export interface ITokenGrammarPath extends IGrammarPath {
+    lastTok:Function
+    lastTokOccurrence:number
+}
 
+export interface IRuleGrammarPath extends IGrammarPath {
+    occurrence:number
 }
diff --git a/src/parse/grammar/resolver.ts b/src/parse/grammar/resolver.ts
index d2b4d4121..5ba8b6490 100644
--- a/src/parse/grammar/resolver.ts
+++ b/src/parse/grammar/resolver.ts
@@ -1,43 +1,42 @@
-namespace chevrotain.resolver {
+import {HashTable} from "../../lang/lang_extensions"
+import {IParserDefinitionError, IParserUnresolvedRefDefinitionError, ParserDefinitionErrorType} from "../parser_public"
+import {gast} from "./gast_public"
+import {forEach} from "../../utils/utils"
+
+export function resolveGrammar(topLevels:HashTable<gast.Rule>):IParserDefinitionError[] {
+    let refResolver = new GastRefResolverVisitor(topLevels)
+    refResolver.resolveRefs()
+    return refResolver.errors
+}
 
-    import gast = chevrotain.gast
+export class GastRefResolverVisitor extends gast.GAstVisitor {
 
-    export function resolveGrammar(topLevels:lang.HashTable<gast.Rule>):IParserDefinitionError[] {
-        let refResolver = new GastRefResolverVisitor(topLevels)
-        refResolver.resolveRefs()
-        return refResolver.errors
-    }
+    public errors:IParserUnresolvedRefDefinitionError[] = []
+    private currTopLevel:gast.Rule
 
-    export class GastRefResolverVisitor extends gast.GAstVisitor {
+    constructor(private nameToTopRule:HashTable<gast.Rule>) { super() }
 
-        public errors:IParserUnresolvedRefDefinitionError[] = []
-        private currTopLevel:gast.Rule
+    public resolveRefs():void {
+        forEach(this.nameToTopRule.values(), (prod) => {
+            this.currTopLevel = prod
+            prod.accept(this)
+        })
+    }
 
-        constructor(private nameToTopRule:lang.HashTable<gast.Rule>) { super() }
+    public visitNonTerminal(node:gast.NonTerminal):void {
+        let ref = this.nameToTopRule.get(node.nonTerminalName)
 
-        public resolveRefs():void {
-            utils.forEach(this.nameToTopRule.values(), (prod) => {
-                this.currTopLevel = prod
-                prod.accept(this)
+        if (!ref) {
+            let msg = "Invalid grammar, reference to rule which is not defined --> " + node.nonTerminalName
+            this.errors.push({
+                message:           msg,
+                type:              ParserDefinitionErrorType.UNRESOLVED_SUBRULE_REF,
+                ruleName:          this.currTopLevel.name,
+                unresolvedRefName: node.nonTerminalName
             })
         }
-
-        public visitNonTerminal(node:gast.NonTerminal):void {
-            let ref = this.nameToTopRule.get(node.nonTerminalName)
-
-            if (!ref) {
-                let msg = "Invalid grammar, reference to rule which is not defined --> " + node.nonTerminalName
-                this.errors.push({
-                    message:msg,
-                    type:ParserDefinitionErrorType.UNRESOLVED_SUBRULE_REF,
-                    ruleName: this.currTopLevel.name,
-                    unresolvedRefName: node.nonTerminalName
-                })
-            }
-            else {
-                node.referencedRule = ref
-            }
+        else {
+            node.referencedRule = ref
         }
     }
-
 }
diff --git a/src/parse/grammar/rest.ts b/src/parse/grammar/rest.ts
index de3287b8a..f110e7b84 100644
--- a/src/parse/grammar/rest.ts
+++ b/src/parse/grammar/rest.ts
@@ -1,105 +1,104 @@
-namespace chevrotain.rest {
+import {gast} from "./gast_public"
+import {drop, forEach} from "../../utils/utils"
 
-    import g = chevrotain.gast
+/**
+ *  A Grammar Walker that computes the "remaining" grammar "after" a productions in the grammar.
+ */
+export abstract class RestWalker {
 
+    walk(prod:gast.AbstractProduction, prevRest:any[] = []):void {
+        forEach(prod.definition, (subProd:gast.IProduction, index) => {
+            let currRest = drop(prod.definition, index + 1)
 
-    /**
-     *  A Grammar Walker that computes the "remaining" grammar "after" a productions in the grammar.
-     */
-    export abstract class RestWalker {
-
-        walk(prod:g.AbstractProduction, prevRest:any[] = []):void {
-            utils.forEach(prod.definition, (subProd:gast.IProduction, index) => {
-                let currRest = utils.drop(prod.definition, index + 1)
-
-                if (subProd instanceof g.NonTerminal) {
-                    this.walkProdRef(subProd, currRest, prevRest)
-                }
-                else if (subProd instanceof g.Terminal) {
-                    this.walkTerminal(subProd, currRest, prevRest)
-                }
-                else if (subProd instanceof g.Flat) {
-                    this.walkFlat(subProd, currRest, prevRest)
-                }
-                else if (subProd instanceof g.Option) {
-                    this.walkOption(subProd, currRest, prevRest)
-                }
-                else if (subProd instanceof g.RepetitionMandatory) {
-                    this.walkAtLeastOne(subProd, currRest, prevRest)
-                }
-                else if (subProd instanceof g.RepetitionMandatoryWithSeparator) {
-                    this.walkAtLeastOneSep(subProd, currRest, prevRest)
-                }
-                else if (subProd instanceof g.RepetitionWithSeparator) {
-                    this.walkManySep(subProd, currRest, prevRest)
-                }
-                else if (subProd instanceof g.Repetition) {
-                    this.walkMany(subProd, currRest, prevRest)
-                }
-                else if (subProd instanceof g.Alternation) {
-                    this.walkOr(subProd, currRest, prevRest)
-                }
-                else {throw Error("non exhaustive match") }
-            })
-        }
-
-        walkTerminal(terminal:g.Terminal, currRest:g.IProduction[], prevRest:g.IProduction[]):void {}
+            if (subProd instanceof gast.NonTerminal) {
+                this.walkProdRef(subProd, currRest, prevRest)
+            }
+            else if (subProd instanceof gast.Terminal) {
+                this.walkTerminal(subProd, currRest, prevRest)
+            }
+            else if (subProd instanceof gast.Flat) {
+                this.walkFlat(subProd, currRest, prevRest)
+            }
+            else if (subProd instanceof gast.Option) {
+                this.walkOption(subProd, currRest, prevRest)
+            }
+            else if (subProd instanceof gast.RepetitionMandatory) {
+                this.walkAtLeastOne(subProd, currRest, prevRest)
+            }
+            else if (subProd instanceof gast.RepetitionMandatoryWithSeparator) {
+                this.walkAtLeastOneSep(subProd, currRest, prevRest)
+            }
+            else if (subProd instanceof gast.RepetitionWithSeparator) {
+                this.walkManySep(subProd, currRest, prevRest)
+            }
+            else if (subProd instanceof gast.Repetition) {
+                this.walkMany(subProd, currRest, prevRest)
+            }
+            else if (subProd instanceof gast.Alternation) {
+                this.walkOr(subProd, currRest, prevRest)
+            }
+            else {throw Error("non exhaustive match") }
+        })
+    }
 
-        walkProdRef(refProd:g.NonTerminal, currRest:g.IProduction[], prevRest:g.IProduction[]):void {}
+    walkTerminal(terminal:gast.Terminal, currRest:gast.IProduction[], prevRest:gast.IProduction[]):void {}
 
-        walkFlat(flatProd:g.Flat, currRest:g.IProduction[], prevRest:g.IProduction[]):void {
-            // ABCDEF => after the D the rest is EF
-            let fullOrRest = currRest.concat(prevRest)
-            this.walk(flatProd, <any>fullOrRest)
-        }
+    walkProdRef(refProd:gast.NonTerminal, currRest:gast.IProduction[], prevRest:gast.IProduction[]):void {}
 
-        walkOption(optionProd:g.Option, currRest:g.IProduction[], prevRest:g.IProduction[]):void {
-            // ABC(DE)?F => after the (DE)? the rest is F
-            let fullOrRest = currRest.concat(prevRest)
-            this.walk(optionProd, <any>fullOrRest)
-        }
+    walkFlat(flatProd:gast.Flat, currRest:gast.IProduction[], prevRest:gast.IProduction[]):void {
+        // ABCDEF => after the D the rest is EF
+        let fullOrRest = currRest.concat(prevRest)
+        this.walk(flatProd, <any>fullOrRest)
+    }
 
-        walkAtLeastOne(atLeastOneProd:g.RepetitionMandatory, currRest:g.IProduction[], prevRest:g.IProduction[]):void {
-            // ABC(DE)+F => after the (DE)+ the rest is (DE)?F
-            let fullAtLeastOneRest:g.IProduction[] = [new g.Option(atLeastOneProd.definition)].concat(<any>currRest, <any>prevRest)
-            this.walk(atLeastOneProd, fullAtLeastOneRest)
-        }
+    walkOption(optionProd:gast.Option, currRest:gast.IProduction[], prevRest:gast.IProduction[]):void {
+        // ABC(DE)?F => after the (DE)? the rest is F
+        let fullOrRest = currRest.concat(prevRest)
+        this.walk(optionProd, <any>fullOrRest)
+    }
 
-        walkAtLeastOneSep(atLeastOneSepProd:g.RepetitionMandatoryWithSeparator, currRest:g.IProduction[], prevRest:g.IProduction[]):void {
-            // ABC DE(,DE)* F => after the (,DE)+ the rest is (,DE)?F
-            let fullAtLeastOneSepRest = restForRepetitionWithSeparator(atLeastOneSepProd, currRest, prevRest)
-            this.walk(atLeastOneSepProd, fullAtLeastOneSepRest)
-        }
+    walkAtLeastOne(atLeastOneProd:gast.RepetitionMandatory, currRest:gast.IProduction[], prevRest:gast.IProduction[]):void {
+        // ABC(DE)+F => after the (DE)+ the rest is (DE)?F
+        let fullAtLeastOneRest:gast.IProduction[] = [new gast.Option(atLeastOneProd.definition)].concat(<any>currRest, <any>prevRest)
+        this.walk(atLeastOneProd, fullAtLeastOneRest)
+    }
 
-        walkMany(manyProd:g.Repetition, currRest:g.IProduction[], prevRest:g.IProduction[]):void {
-            // ABC(DE)*F => after the (DE)* the rest is (DE)?F
-            let fullManyRest:g.IProduction[] = [new g.Option(manyProd.definition)].concat(<any>currRest, <any>prevRest)
-            this.walk(manyProd, fullManyRest)
-        }
+    walkAtLeastOneSep(atLeastOneSepProd:gast.RepetitionMandatoryWithSeparator,
+                      currRest:gast.IProduction[],
+                      prevRest:gast.IProduction[]):void {
+        // ABC DE(,DE)* F => after the (,DE)+ the rest is (,DE)?F
+        let fullAtLeastOneSepRest = restForRepetitionWithSeparator(atLeastOneSepProd, currRest, prevRest)
+        this.walk(atLeastOneSepProd, fullAtLeastOneSepRest)
+    }
 
-        walkManySep(manySepProd:g.RepetitionWithSeparator, currRest:g.IProduction[], prevRest:g.IProduction[]):void {
-            // ABC (DE(,DE)*)? F => after the (,DE)* the rest is (,DE)?F
-            let fullManySepRest = restForRepetitionWithSeparator(manySepProd, currRest, prevRest)
-            this.walk(manySepProd, fullManySepRest)
-        }
+    walkMany(manyProd:gast.Repetition, currRest:gast.IProduction[], prevRest:gast.IProduction[]):void {
+        // ABC(DE)*F => after the (DE)* the rest is (DE)?F
+        let fullManyRest:gast.IProduction[] = [new gast.Option(manyProd.definition)].concat(<any>currRest, <any>prevRest)
+        this.walk(manyProd, fullManyRest)
+    }
 
-        walkOr(orProd:g.Alternation, currRest:g.IProduction[], prevRest:g.IProduction[]):void {
-            // ABC(D|E|F)G => when finding the (D|E|F) the rest is G
-            let fullOrRest = currRest.concat(prevRest)
-            // walk all different alternatives
-            utils.forEach(orProd.definition, (alt) => {
-                // wrapping each alternative in a single definition wrapper
-                // to avoid errors in computing the rest of that alternative in the invocation to computeInProdFollows
-                // (otherwise for OR([alt1,alt2]) alt2 will be considered in 'rest' of alt1
-                let prodWrapper = new gast.Flat([alt])
-                this.walk(prodWrapper, <any>fullOrRest)
-            })
-        }
+    walkManySep(manySepProd:gast.RepetitionWithSeparator, currRest:gast.IProduction[], prevRest:gast.IProduction[]):void {
+        // ABC (DE(,DE)*)? F => after the (,DE)* the rest is (,DE)?F
+        let fullManySepRest = restForRepetitionWithSeparator(manySepProd, currRest, prevRest)
+        this.walk(manySepProd, fullManySepRest)
     }
 
-    function restForRepetitionWithSeparator(repSepProd, currRest, prevRest) {
-        let repSepRest = [new g.Option([<any>new g.Terminal(repSepProd.separator)].concat(repSepProd.definition))]
-        let fullRepSepRest:g.IProduction[] = repSepRest.concat(<any>currRest, <any>prevRest)
-        return fullRepSepRest
+    walkOr(orProd:gast.Alternation, currRest:gast.IProduction[], prevRest:gast.IProduction[]):void {
+        // ABC(D|E|F)G => when finding the (D|E|F) the rest is G
+        let fullOrRest = currRest.concat(prevRest)
+        // walk all different alternatives
+        forEach(orProd.definition, (alt) => {
+            // wrapping each alternative in a single definition wrapper
+            // to avoid errors in computing the rest of that alternative in the invocation to computeInProdFollows
+            // (otherwise for OR([alt1,alt2]) alt2 will be considered in 'rest' of alt1
+            let prodWrapper = new gast.Flat([alt])
+            this.walk(prodWrapper, <any>fullOrRest)
+        })
     }
 }
+
+function restForRepetitionWithSeparator(repSepProd, currRest, prevRest) {
+    let repSepRest = [new gast.Option([<any>new gast.Terminal(repSepProd.separator)].concat(repSepProd.definition))]
+    let fullRepSepRest:gast.IProduction[] = repSepRest.concat(<any>currRest, <any>prevRest)
+    return fullRepSepRest
+}
diff --git a/src/parse/parse_tree.ts b/src/parse/parse_tree.ts
deleted file mode 100644
index e69de29bb..000000000
diff --git a/src/parse/parser_public.ts b/src/parse/parser_public.ts
index a02e52f4a..ea74a6696 100644
--- a/src/parse/parser_public.ts
+++ b/src/parse/parser_public.ts
@@ -1,1477 +1,1472 @@
-// using only root namespace name ('chevrotain') and not a longer name ('chevrotain.recognizer')
-// because the external and internal API must have the same names for d.ts definition files to be valid
-namespace chevrotain {
+import * as cache from "./cache"
+import {exceptions} from "./exceptions_public"
+import {classNameFromInstance, HashTable, functionName} from "../lang/lang_extensions"
+import {resolveGrammar} from "./grammar/resolver"
+import {validateGrammar, validateRuleName} from "./grammar/checks"
+import {
+    isEmpty,
+    map,
+    isArray,
+    reduce,
+    isObject,
+    cloneObj,
+    cloneArr,
+    first,
+    find,
+    contains,
+    flatten,
+    last,
+    isString
+} from "../utils/utils"
+import {computeAllProdsFollows} from "./grammar/follow"
+import {Token, tokenName, EOF} from "../scan/tokens_public"
+import {gast} from "./grammar/gast_public"
+import {
+    buildLookaheadForTopLevel,
+    buildLookaheadForOption,
+    buildLookaheadForOr,
+    buildLookaheadForMany,
+    buildLookaheadForManySep,
+    buildLookaheadForAtLeastOne,
+    buildLookaheadForAtLeastOneSep
+} from "./grammar/lookahead"
+import {TokenConstructor} from "../scan/lexer_public"
+import {buildTopProduction} from "./gast_builder"
+import {
+    NextAfterTokenWalker,
+    AbstractNextTerminalAfterProductionWalker,
+    NextTerminalAfterAtLeastOneWalker,
+    NextTerminalAfterAtLeastOneSepWalker,
+    NextTerminalAfterManyWalker,
+    NextTerminalAfterManySepWalker,
+    NextInsideOrWalker
+} from "./grammar/interpreter"
+import {IN} from "./constants"
+
+export enum ParserDefinitionErrorType {
+    INVALID_RULE_NAME,
+    DUPLICATE_RULE_NAME,
+    DUPLICATE_PRODUCTIONS,
+    UNRESOLVED_SUBRULE_REF,
+    LEFT_RECURSION,
+    NONE_LAST_EMPTY_ALT
+}
+
+export interface IParserDefinitionError {
+    message:string
+    type:ParserDefinitionErrorType
+    ruleName:string
+}
+
+export interface IParserDuplicatesDefinitionError extends IParserDefinitionError {
+    dslName:string
+    occurrence:number
+    parameter?:string
+}
+
+export interface IParserEmptyAlternativeDefinitionError extends IParserDefinitionError {
+    occurrence:number
+    alternative:number
+}
+
+export interface IParserUnresolvedRefDefinitionError extends IParserDefinitionError {
+    unresolvedRefName:string
+}
+
+// parameters needed to compute the key in the FOLLOW_SET map.
+export interface IFollowKey {
+    ruleName: string
+    idxInCallingRule: number
+    inRule:string
+}
+
+/**
+ * OR([
+ *  { WHEN:LA1, THEN_DO:XXX },
+ *  { WHEN:LA2, THEN_DO:YYY },
+ *  { WHEN:LA3, THEN_DO:ZZZ },
+ * ])
+ */
+export interface IOrAlt<T> {
+    WHEN:() => boolean
+    // TODO: change THEN_DO property to ALT (may need to modify gast builder)
+    THEN_DO:() => T
+}
 
-    import cache = chevrotain.cache
-    import gast = chevrotain.gast
-    import IN = chevrotain.constants.IN
-    import interp = chevrotain.interpreter
-    import lang = chevrotain.lang
-    import gastBuilder = chevrotain.gastBuilder
-    import follows = chevrotain.follow
-    import lookahead = chevrotain.lookahead
-    import checks = chevrotain.checks
-    import resolver = chevrotain.resolver
-    import exceptions = chevrotain.exceptions
-    import IRecognitionException = chevrotain.exceptions.IRecognitionException
+/**
+ * OR([
+ *  {ALT:XXX },
+ *  {ALT:YYY },
+ *  {ALT:ZZZ }
+ * ])
+ */
+export interface IOrAltImplicit<T> {
+    ALT:() => T
+}
 
+export interface IParserState {
+    errors: exceptions.IRecognitionException[]
+    inputIdx:number
+    RULE_STACK:string[]
+}
 
-    export enum ParserDefinitionErrorType {
-        INVALID_RULE_NAME,
-        DUPLICATE_RULE_NAME,
-        DUPLICATE_PRODUCTIONS,
-        UNRESOLVED_SUBRULE_REF,
-        LEFT_RECURSION,
-        NONE_LAST_EMPTY_ALT
+export type LookAheadFunc = () => boolean
+export type GrammarAction = () => void
+
+/**
+ * convenience used to express an empty alternative in an OR (alternation).
+ * can be used to more clearly describe the intent in a case of empty alternation.
+ *
+ * for example:
+ *
+ * 1. without using EMPTY_ALT:
+ *
+ *    this.OR([
+ *      {ALT: () => {
+ *        this.CONSUME1(OneTok)
+ *        return "1"
+ *      }},
+ *      {ALT: () => {
+ *        this.CONSUME1(TwoTok)
+ *        return "2"
+ *      }},
+ *      {ALT: () => { // implicitly empty because there are no invoked grammar rules (OR/MANY/CONSUME...) inside this alternative.
+ *        return "666"
+ *      }},
+ *    ])
+ *
+ *
+ * * 2. using EMPTY_ALT:
+ *
+ *    this.OR([
+ *      {ALT: () => {
+ *        this.CONSUME1(OneTok)
+ *        return "1"
+ *      }},
+ *      {ALT: () => {
+ *        this.CONSUME1(TwoTok)
+ *        return "2"
+ *      }},
+ *      {ALT: EMPTY_ALT("666")}, // explicitly empty, clearer intent
+ *    ])
+ *
+ */
+export function EMPTY_ALT<T>(value:T = undefined):() => T {
+    return function () {
+        return value
     }
+}
 
-    export interface IParserDefinitionError {
-        message:string
-        type:ParserDefinitionErrorType
-        ruleName:string
+let EOF_FOLLOW_KEY:any = {}
+
+/**
+ * A Recognizer capable of self analysis to determine it's grammar structure
+ * This is used for more advanced features requiring such information.
+ * for example: Error Recovery, Automatic lookahead calculation
+ */
+export class Parser {
+
+    static IGNORE_AMBIGUITIES:boolean = true
+    static NO_RESYNC:boolean = false
+    // Set this flag to true if you don't want the Parser to throw error when problems in it's definition are detected.
+    // (normally during the parser's constructor).
+    // This is a design time flag, it will not affect the runtime error handling of the parser, just design time errors,
+    // for example: duplicate rule names, referencing an unresolved subrule, ect...
+    // This flag should not be enabled during normal usage, it is used in special situations, for example when
+    // needing to display the parser definition errors in some GUI(online playground).
+    static DEFER_DEFINITION_ERRORS_HANDLING:boolean = false
+
+    protected static performSelfAnalysis(classInstance:Parser) {
+        let definitionErrors = []
+        let defErrorsMsgs
+
+        let className = classNameFromInstance(classInstance)
+        // this information should only be computed once
+        if (!cache.CLASS_TO_SELF_ANALYSIS_DONE.containsKey(className)) {
+            let grammarProductions = cache.getProductionsForClass(className)
+
+            // assumes this cache has been initialized (in the relevant parser's constructor)
+            // TODO: consider making the self analysis a member method to resolve this.
+            // that way it won't be callable before the constructor has been invoked...
+            definitionErrors = cache.CLASS_TO_DEFINITION_ERRORS.get(className)
+
+            let resolverErrors = resolveGrammar(grammarProductions)
+            definitionErrors.push.apply(definitionErrors, resolverErrors) // mutability for the win?
+            cache.CLASS_TO_SELF_ANALYSIS_DONE.put(className, true)
+            let validationErrors = validateGrammar(grammarProductions.values())
+            definitionErrors.push.apply(definitionErrors, validationErrors) // mutability for the win?
+            if (!isEmpty(definitionErrors) && !Parser.DEFER_DEFINITION_ERRORS_HANDLING) {
+                defErrorsMsgs = map(definitionErrors, defError => defError.message)
+                throw new Error(`Parser Definition Errors detected\n: ${defErrorsMsgs.join("\n-------------------------------\n")}`)
+            }
+            if (isEmpty(definitionErrors)) { // this analysis may fail if the grammar is not perfectly valid
+                let allFollows = computeAllProdsFollows(grammarProductions.values())
+                cache.setResyncFollowsForClass(className, allFollows)
+            }
+        }
+
+        // reThrow the validation errors each time an erroneous parser is instantiated
+        if (!isEmpty(cache.CLASS_TO_DEFINITION_ERRORS.get(className)) && !Parser.DEFER_DEFINITION_ERRORS_HANDLING) {
+            defErrorsMsgs = map(cache.CLASS_TO_DEFINITION_ERRORS.get(className), defError => defError.message)
+            throw new Error(`Parser Definition Errors detected\n: ${defErrorsMsgs.join("\n-------------------------------\n")}`)
+        }
     }
 
-    export interface IParserDuplicatesDefinitionError extends IParserDefinitionError {
-        dslName:string
-        occurrence:number
-        parameter?:string
+    public errors:exceptions.IRecognitionException[] = []
+
+    /**
+     * This flag enables or disables error recovery (fault tolerance) of the parser.
+     * If this flag is disabled the parser will halt on the first error.
+     */
+    public isErrorRecoveryEnabled
+
+    protected _input:Token[] = []
+    protected inputIdx = -1
+    protected isBackTrackingStack = []
+    protected className:string
+    protected RULE_STACK:string[] = []
+    protected RULE_OCCURRENCE_STACK:number[] = []
+    protected tokensMap:{ [fqn: string] : Function } = undefined
+
+    private firstAfterRepMap
+    private classLAFuncs
+    private definitionErrors:IParserDefinitionError[]
+    private orLookaheadKeys:HashTable<string>[]
+    private manyLookaheadKeys:HashTable<string>[]
+    private manySepLookaheadKeys:HashTable<string>[]
+    private atLeastOneSepLookaheadKeys:HashTable<string>[]
+    private atLeastOneLookaheadKeys:HashTable<string>[]
+    private optionLookaheadKeys:HashTable<string>[]
+    private definedRulesNames:string[] = []
+
+    constructor(input:Token[], tokensMapOrArr:{ [fqn: string] : Function; } | Function[], isErrorRecoveryEnabled = true) {
+        this._input = input
+        this.isErrorRecoveryEnabled = isErrorRecoveryEnabled
+        this.className = classNameFromInstance(this)
+        this.firstAfterRepMap = cache.getFirstAfterRepForClass(this.className)
+        this.classLAFuncs = cache.getLookaheadFuncsForClass(this.className)
+
+        if (!cache.CLASS_TO_DEFINITION_ERRORS.containsKey(this.className)) {
+            this.definitionErrors = []
+            cache.CLASS_TO_DEFINITION_ERRORS.put(this.className, this.definitionErrors)
+        }
+        else {
+            this.definitionErrors = cache.CLASS_TO_DEFINITION_ERRORS.get(this.className)
+        }
+
+        if (isArray(tokensMapOrArr)) {
+            this.tokensMap = <any>reduce(<any>tokensMapOrArr, (acc, tokenClazz:Function) => {
+                acc[tokenName(tokenClazz)] = tokenClazz
+                return acc
+            }, {})
+        }
+        else if (isObject(tokensMapOrArr)) {
+            this.tokensMap = cloneObj(tokensMapOrArr)
+        }
+        else {
+            throw new Error("'tokensMapOrArr' argument must be An Array of Token constructors or a Dictionary of Tokens.")
+        }
+
+        // always add EOF to the tokenNames -> constructors map. it is useful to assure all the input has been
+        // parsed with a clear error message ("expecting EOF but found ...")
+        this.tokensMap[tokenName(EOF)] = EOF
+
+        if (cache.CLASS_TO_OR_LA_CACHE[this.className] === undefined) {
+            cache.initLookAheadKeyCache(this.className)
+        }
+
+        this.orLookaheadKeys = cache.CLASS_TO_OR_LA_CACHE[this.className]
+        this.manyLookaheadKeys = cache.CLASS_TO_MANY_LA_CACHE[this.className]
+        this.manySepLookaheadKeys = cache.CLASS_TO_MANY_SEP_LA_CACHE[this.className]
+        this.atLeastOneLookaheadKeys = cache.CLASS_TO_AT_LEAST_ONE_LA_CACHE[this.className]
+        this.atLeastOneSepLookaheadKeys = cache.CLASS_TO_AT_LEAST_ONE_SEP_LA_CACHE[this.className]
+        this.optionLookaheadKeys = cache.CLASS_TO_OPTION_LA_CACHE[this.className]
     }
 
-    export interface IParserEmptyAlternativeDefinitionError extends IParserDefinitionError {
-        occurrence:number
-        alternative:number
+    public set input(newInput:Token[]) {
+        this.reset()
+        this._input = newInput
     }
 
-    export interface IParserUnresolvedRefDefinitionError extends IParserDefinitionError {
-        unresolvedRefName:string
+    public get input():Token[] {
+        return cloneArr(this._input)
     }
 
-    // parameters needed to compute the key in the FOLLOW_SET map.
-    export interface IFollowKey {
-        ruleName: string
-        idxInCallingRule: number
-        inRule:string
+    public reset():void {
+        this.isBackTrackingStack = []
+        this.errors = []
+        this._input = []
+        this.inputIdx = -1
+        this.RULE_STACK = []
+        this.RULE_OCCURRENCE_STACK = []
     }
 
-    /**
-     * OR([
-     *  { WHEN:LA1, THEN_DO:XXX },
-     *  { WHEN:LA2, THEN_DO:YYY },
-     *  { WHEN:LA3, THEN_DO:ZZZ },
-     * ])
-     */
-    export interface IOrAlt<T> {
-        WHEN:() => boolean
-        // TODO: change THEN_DO property to ALT (may need to modify gast builder)
-        THEN_DO:() => T
+    public isAtEndOfInput():boolean {
+        return this.LA(1) instanceof EOF
+    }
+
+    public getGAstProductions():HashTable<gast.Rule> {
+        return cache.getProductionsForClass(this.className)
+    }
+
+    protected isBackTracking():boolean {
+        return !(isEmpty(this.isBackTrackingStack))
+    }
+
+    protected SAVE_ERROR(error:exceptions.IRecognitionException):exceptions.IRecognitionException {
+        if (exceptions.isRecognitionException(error)) {
+            this.errors.push(error)
+            return error
+        }
+        else {
+            throw Error("trying to save an Error which is not a RecognitionException")
+        }
+    }
+
+    protected NEXT_TOKEN():Token {
+        return this.LA(1)
+    }
+
+    protected LA(howMuch:number):Token {
+        if (this._input.length <= this.inputIdx + howMuch) {
+            return new EOF()
+        }
+        else {
+            return this._input[this.inputIdx + howMuch]
+        }
+    }
+
+    protected isNextRule<T>(ruleName:string):boolean {
+        let classLAFuncs = cache.getLookaheadFuncsForClass(this.className)
+        let condition = <any>classLAFuncs.get(ruleName)
+        if (condition === undefined) {
+            let ruleGrammar = this.getGAstProductions().get(ruleName)
+            condition = buildLookaheadForTopLevel(ruleGrammar)
+            classLAFuncs.put(ruleName, condition)
+        }
+
+        return condition.call(this)
     }
 
     /**
-     * OR([
-     *  {ALT:XXX },
-     *  {ALT:YYY },
-     *  {ALT:ZZZ }
-     * ])
+     *
+     * @param grammarRule the rule to try and parse in backtracking mode
+     * @param isValid a predicate that given the result of the parse attempt will "decide" if the parse was successfully or not
+     * @return a lookahead function that will try to parse the given grammarRule and will return true if succeed
      */
-    export interface IOrAltImplicit<T> {
-        ALT:() => T
+    protected BACKTRACK<T>(grammarRule:(...args) => T, isValid:(T) => boolean):() => boolean {
+        return () => {
+            // save org state
+            this.isBackTrackingStack.push(1)
+            let orgState = this.saveRecogState()
+            try {
+                let ruleResult = grammarRule.call(this)
+                return isValid(ruleResult)
+            } catch (e) {
+                if (exceptions.isRecognitionException(e)) {
+                    return false
+                }
+                else {
+                    throw e
+                }
+            }
+            finally {
+                this.reloadRecogState(orgState)
+                this.isBackTrackingStack.pop()
+            }
+        }
     }
 
-    export interface IParserState {
-        errors: exceptions.IRecognitionException[]
-        inputIdx:number
-        RULE_STACK:string[]
+    // skips a token and returns the next token
+    protected SKIP_TOKEN():Token {
+        // example: assume 45 tokens in the input, if input index is 44 it means that NEXT_TOKEN will return
+        // input[45] which is the 46th item and no longer exists,
+        // so in this case the largest valid input index is 43 (input.length - 2 )
+        if (this.inputIdx <= this._input.length - 2) {
+            this.inputIdx++
+            return this.NEXT_TOKEN()
+        }
+        else {
+            return new EOF()
+        }
     }
 
-    export type LookAheadFunc = () => boolean
-    export type GrammarAction = () => void
+    // Parsing DSL
+
+    /**
+     * Convenience method equivalent to CONSUME1
+     * @see CONSUME1
+     */
+    protected CONSUME(tokClass:Function):Token {
+        return this.CONSUME1(tokClass)
+    }
 
     /**
-     * convenience used to express an empty alternative in an OR (alternation).
-     * can be used to more clearly describe the intent in a case of empty alternation.
-     *
-     * for example:
      *
-     * 1. without using EMPTY_ALT:
+     * A Parsing DSL method use to consume a single terminal Token.
+     * a Token will be consumed, IFF the next token in the token vector is an instanceof tokClass.
+     * otherwise the parser will attempt to perform error recovery.
      *
-     *    this.OR([
-     *      {ALT: () => {
-     *        this.CONSUME1(OneTok)
-     *        return "1"
-     *      }},
-     *      {ALT: () => {
-     *        this.CONSUME1(TwoTok)
-     *        return "2"
-     *      }},
-     *      {ALT: () => { // implicitly empty because there are no invoked grammar rules (OR/MANY/CONSUME...) inside this alternative.
-     *        return "666"
-     *      }},
-     *    ])
+     * The index in the method name indicates the unique occurrence of a terminal consumption
+     * inside a the top level rule. What this means is that if a terminal appears
+     * more than once in a single rule, each appearance must have a difference index.
      *
+     * for example:
      *
-     * * 2. using EMPTY_ALT:
+     * function parseQualifiedName() {
+     *    this.CONSUME1(Identifier);
+     *    this.MANY(()=> {
+     *       this.CONSUME1(Dot);
+     *       this.CONSUME2(Identifier); // <-- here we use CONSUME2 because the terminal
+     *    });                           //     'Identifier' has already appeared previously in the
+     *                                  //     the rule 'parseQualifiedName'
+     * }
      *
-     *    this.OR([
-     *      {ALT: () => {
-     *        this.CONSUME1(OneTok)
-     *        return "1"
-     *      }},
-     *      {ALT: () => {
-     *        this.CONSUME1(TwoTok)
-     *        return "2"
-     *      }},
-     *      {ALT: EMPTY_ALT("666")}, // explicitly empty, clearer intent
-     *    ])
+     * @param {Function} tokClass A constructor function specifying the type of token
+     *        to be consumed.
      *
+     * @returns {Token} The consumed token.
      */
-    export function EMPTY_ALT<T>(value:T = undefined):() => T {
-        return function () {
-            return value
-        }
+    protected CONSUME1(tokClass:Function):Token {
+        return this.consumeInternal(tokClass, 1)
     }
 
-    let EOF_FOLLOW_KEY:any = {}
+    /**
+     * @see CONSUME1
+     */
+    protected CONSUME2(tokClass:Function):Token {
+        return this.consumeInternal(tokClass, 2)
+    }
 
     /**
-     * A Recognizer capable of self analysis to determine it's grammar structure
-     * This is used for more advanced features requiring such information.
-     * for example: Error Recovery, Automatic lookahead calculation
+     * @see CONSUME1
      */
-    export class Parser {
-
-        static IGNORE_AMBIGUITIES:boolean = true
-        static NO_RESYNC:boolean = false
-        // Set this flag to true if you don't want the Parser to throw error when problems in it's definition are detected.
-        // (normally during the parser's constructor).
-        // This is a design time flag, it will not affect the runtime error handling of the parser, just design time errors,
-        // for example: duplicate rule names, referencing an unresolved subrule, ect...
-        // This flag should not be enabled during normal usage, it is used in special situations, for example when
-        // needing to display the parser definition errors in some GUI(online playground).
-        static DEFER_DEFINITION_ERRORS_HANDLING:boolean = false
-
-        protected static performSelfAnalysis(classInstance:Parser) {
-            let definitionErrors = []
-            let defErrorsMsgs
-
-            let className = lang.classNameFromInstance(classInstance)
-            // this information should only be computed once
-            if (!cache.CLASS_TO_SELF_ANALYSIS_DONE.containsKey(className)) {
-                let grammarProductions = cache.getProductionsForClass(className)
-
-                // assumes this cache has been initialized (in the relevant parser's constructor)
-                // TODO: consider making the self analysis a member method to resolve this.
-                // that way it won't be callable before the constructor has been invoked...
-                definitionErrors = cache.CLASS_TO_DEFINITION_ERRORS.get(className)
-
-                let resolverErrors = resolver.resolveGrammar(grammarProductions)
-                definitionErrors.push.apply(definitionErrors, resolverErrors) // mutability for the win?
-                cache.CLASS_TO_SELF_ANALYSIS_DONE.put(className, true)
-                let validationErrors = checks.validateGrammar(grammarProductions.values())
-                definitionErrors.push.apply(definitionErrors, validationErrors) // mutability for the win?
-                if (!utils.isEmpty(definitionErrors) && !Parser.DEFER_DEFINITION_ERRORS_HANDLING) {
-                    defErrorsMsgs = utils.map(definitionErrors, defError => defError.message)
-                    throw new Error(`Parser Definition Errors detected\n: ${defErrorsMsgs.join("\n-------------------------------\n")}`)
-                }
-                if (utils.isEmpty(definitionErrors)) { // this analysis may fail if the grammar is not perfectly valid
-                    let allFollows = follows.computeAllProdsFollows(grammarProductions.values())
-                    cache.setResyncFollowsForClass(className, allFollows)
-                }
-            }
+    protected CONSUME3(tokClass:Function):Token {
+        return this.consumeInternal(tokClass, 3)
+    }
 
-            // reThrow the validation errors each time an erroneous parser is instantiated
-            if (!utils.isEmpty(cache.CLASS_TO_DEFINITION_ERRORS.get(className)) && !Parser.DEFER_DEFINITION_ERRORS_HANDLING) {
-                defErrorsMsgs = utils.map(cache.CLASS_TO_DEFINITION_ERRORS.get(className), defError => defError.message)
-                throw new Error(`Parser Definition Errors detected\n: ${defErrorsMsgs.join("\n-------------------------------\n")}`)
-            }
-        }
+    /**
+     * @see CONSUME1
+     */
+    protected CONSUME4(tokClass:Function):Token {
+        return this.consumeInternal(tokClass, 4)
+    }
 
-        public errors:exceptions.IRecognitionException[] = []
-
-        /**
-         * This flag enables or disables error recovery (fault tolerance) of the parser.
-         * If this flag is disabled the parser will halt on the first error.
-         */
-        public isErrorRecoveryEnabled
-
-        protected _input:Token[] = []
-        protected inputIdx = -1
-        protected isBackTrackingStack = []
-        protected className:string
-        protected RULE_STACK:string[] = []
-        protected RULE_OCCURRENCE_STACK:number[] = []
-        protected tokensMap:{ [fqn: string] : Function; } = undefined
-
-        private firstAfterRepMap
-        private classLAFuncs
-        private definitionErrors:IParserDefinitionError[]
-        private orLookaheadKeys:lang.HashTable<string>[]
-        private manyLookaheadKeys:lang.HashTable<string>[]
-        private manySepLookaheadKeys:lang.HashTable<string>[]
-        private atLeastOneSepLookaheadKeys:lang.HashTable<string>[]
-        private atLeastOneLookaheadKeys:lang.HashTable<string>[]
-        private optionLookaheadKeys:lang.HashTable<string>[]
-        private definedRulesNames:string[] = []
-
-        constructor(input:Token[], tokensMapOrArr:{ [fqn: string] : Function; } | Function[], isErrorRecoveryEnabled = true) {
-            this._input = input
-            this.isErrorRecoveryEnabled = isErrorRecoveryEnabled
-            this.className = lang.classNameFromInstance(this)
-            this.firstAfterRepMap = cache.getFirstAfterRepForClass(this.className)
-            this.classLAFuncs = cache.getLookaheadFuncsForClass(this.className)
-
-            if (!cache.CLASS_TO_DEFINITION_ERRORS.containsKey(this.className)) {
-                this.definitionErrors = []
-                cache.CLASS_TO_DEFINITION_ERRORS.put(this.className, this.definitionErrors)
-            }
-            else {
-                this.definitionErrors = cache.CLASS_TO_DEFINITION_ERRORS.get(this.className)
-            }
+    /**
+     * @see CONSUME1
+     */
+    protected CONSUME5(tokClass:Function):Token {
+        return this.consumeInternal(tokClass, 5)
+    }
 
-            if (utils.isArray(tokensMapOrArr)) {
-                this.tokensMap = <any>utils.reduce(<any>tokensMapOrArr, (acc, tokenClazz:Function) => {
-                    acc[tokenName(tokenClazz)] = tokenClazz
-                    return acc
-                }, {})
-            }
-            else if (utils.isObject(tokensMapOrArr)) {
-                this.tokensMap = utils.cloneObj(tokensMapOrArr)
-            }
-            else {
-                throw new Error("'tokensMapOrArr' argument must be An Array of Token constructors or a Dictionary of Tokens.")
-            }
+    /**
+     * Convenience method equivalent to SUBRULE1
+     * @see SUBRULE1
+     */
+    protected SUBRULE<T>(ruleToCall:(number) => T, args:any[] = []):T {
+        return this.SUBRULE1(ruleToCall, args)
+    }
 
-            // always add EOF to the tokenNames -> constructors map. it is useful to assure all the input has been
-            // parsed with a clear error message ("expecting EOF but found ...")
-            this.tokensMap[tokenName(EOF)] = EOF
+    /**
+     * The Parsing DSL Method is used by one rule to call another.
+     *
+     * This may seem redundant as it does not actually do much.
+     * However using it is mandatory for all sub rule invocations.
+     * calling another rule without wrapping in SUBRULE(...)
+     * will cause errors/mistakes in the Recognizer's self analysis
+     * which will lead to errors in error recovery/automatic lookahead calculation
+     * and any other functionality relying on the Recognizer's self analysis
+     * output.
+     *
+     * As in CONSUME the index in the method name indicates the occurrence
+     * of the sub rule invocation in its rule.
+     *
+     * @param {Function} ruleToCall the rule to invoke
+     * @param {*[]} args the arguments to pass to the invoked subrule
+     * @returns {*} the result of invoking ruleToCall
+     */
+    protected SUBRULE1<T>(ruleToCall:(number) => T, args:any[] = []):T {
+        return ruleToCall.call(this, 1, args)
+    }
 
-            if (cache.CLASS_TO_OR_LA_CACHE[this.className] === undefined) {
-                cache.initLookAheadKeyCache(this.className)
-            }
+    /**
+     * @see SUBRULE1
+     */
+    protected SUBRULE2<T>(ruleToCall:(number) => T, args:any[] = []):T {
+        return ruleToCall.call(this, 2, args)
+    }
 
-            this.orLookaheadKeys = cache.CLASS_TO_OR_LA_CACHE[this.className]
-            this.manyLookaheadKeys = cache.CLASS_TO_MANY_LA_CACHE[this.className]
-            this.manySepLookaheadKeys = cache.CLASS_TO_MANY_SEP_LA_CACHE[this.className]
-            this.atLeastOneLookaheadKeys = cache.CLASS_TO_AT_LEAST_ONE_LA_CACHE[this.className]
-            this.atLeastOneSepLookaheadKeys = cache.CLASS_TO_AT_LEAST_ONE_SEP_LA_CACHE[this.className]
-            this.optionLookaheadKeys = cache.CLASS_TO_OPTION_LA_CACHE[this.className]
-        }
+    /**
+     * @see SUBRULE1
+     */
+    protected SUBRULE3<T>(ruleToCall:(number) => T, args:any[] = []):T {
+        return ruleToCall.call(this, 3, args)
+    }
 
-        public set input(newInput:Token[]) {
-            this.reset()
-            this._input = newInput
-        }
+    /**
+     * @see SUBRULE1
+     */
+    protected SUBRULE4<T>(ruleToCall:(number) => T, args:any[] = []):T {
+        return ruleToCall.call(this, 4, args)
+    }
 
-        public get input():Token[] {
-            return utils.cloneArr(this._input)
-        }
+    /**
+     * @see SUBRULE1
+     */
+    protected SUBRULE5<T>(ruleToCall:(number) => T, args:any[] = []):T {
+        return ruleToCall.call(this, 5, args)
+    }
 
-        public reset():void {
-            this.isBackTrackingStack = []
-            this.errors = []
-            this._input = []
-            this.inputIdx = -1
-            this.RULE_STACK = []
-            this.RULE_OCCURRENCE_STACK = []
-        }
+    /**
+     * Convenience method equivalent to OPTION1
+     * @see OPTION1
+     */
+    protected OPTION(laFuncOrAction:LookAheadFunc | GrammarAction,
+                     action?:GrammarAction):boolean {
+        return this.OPTION1.call(this, laFuncOrAction, action)
+    }
 
-        public isAtEndOfInput():boolean {
-            return this.LA(1) instanceof EOF
+    /**
+     * Parsing DSL Method that Indicates an Optional production
+     * in EBNF notation: [...]
+     *
+     * note that the 'action' param is optional. so both of the following forms are valid:
+     *
+     * short: this.OPTION(()=>{ this.CONSUME(Digit});
+     * long: this.OPTION(isDigit, ()=>{ this.CONSUME(Digit});
+     *
+     * using the short form is recommended as it will compute the lookahead function
+     * automatically. however this currently has one limitation:
+     * It only works if the lookahead for the grammar is one.
+     *
+     * As in CONSUME the index in the method name indicates the occurrence
+     * of the optional production in it's top rule.
+     *
+     * @param {Function} laFuncOrAction The lookahead function that 'decides'
+     *                                  whether or not the OPTION's action will be
+     *                                  invoked or the action to optionally invoke
+     * @param {Function} [action] The action to optionally invoke.
+     *
+     * @returns {boolean} true iff the OPTION's action has been invoked
+     */
+    protected OPTION1(laFuncOrAction:LookAheadFunc | GrammarAction,
+                      action?:GrammarAction):boolean {
+        if (action === undefined) {
+            action = <any>laFuncOrAction
+            laFuncOrAction = this.getLookaheadFuncForOption(1)
         }
+        return this.optionInternal(<any>laFuncOrAction, <any>action)
+    }
 
-        public getGAstProductions():lang.HashTable<gast.Rule> {
-            return cache.getProductionsForClass(this.className)
+    /**
+     * @see OPTION1
+     */
+    protected OPTION2(laFuncOrAction:LookAheadFunc | GrammarAction,
+                      action?:GrammarAction):boolean {
+        if (action === undefined) {
+            action = <any>laFuncOrAction
+            laFuncOrAction = this.getLookaheadFuncForOption(2)
         }
+        return this.optionInternal(<any>laFuncOrAction, <any>action)
+    }
 
-        protected isBackTracking():boolean {
-            return !(utils.isEmpty(this.isBackTrackingStack))
+    /**
+     * @see OPTION1
+     */
+    protected OPTION3(laFuncOrAction:LookAheadFunc | GrammarAction,
+                      action?:GrammarAction):boolean {
+        if (action === undefined) {
+            action = <any>laFuncOrAction
+            laFuncOrAction = this.getLookaheadFuncForOption(3)
         }
+        return this.optionInternal(<any>laFuncOrAction, <any>action)
+    }
 
-        protected SAVE_ERROR(error:exceptions.IRecognitionException):IRecognitionException {
-            if (exceptions.isRecognitionException(error)) {
-                this.errors.push(error)
-                return error
-            }
-            else {
-                throw Error("trying to save an Error which is not a RecognitionException")
-            }
+    /**
+     * @see OPTION1
+     */
+    protected OPTION4(laFuncOrAction:LookAheadFunc | GrammarAction,
+                      action?:GrammarAction):boolean {
+        if (action === undefined) {
+            action = <any>laFuncOrAction
+            laFuncOrAction = this.getLookaheadFuncForOption(4)
         }
+        return this.optionInternal(<any>laFuncOrAction, <any>action)
+    }
 
-        protected NEXT_TOKEN():Token {
-            return this.LA(1)
+    /**
+     * @see OPTION1
+     */
+    protected OPTION5(laFuncOrAction:LookAheadFunc | GrammarAction,
+                      action?:GrammarAction):boolean {
+        if (action === undefined) {
+            action = <any>laFuncOrAction
+            laFuncOrAction = this.getLookaheadFuncForOption(5)
         }
+        return this.optionInternal(<any>laFuncOrAction, <any>action)
+    }
 
-        protected LA(howMuch:number):Token {
-            if (this._input.length <= this.inputIdx + howMuch) {
-                return new EOF()
-            }
-            else {
-                return this._input[this.inputIdx + howMuch]
-            }
-        }
+    /**
+     * Convenience method equivalent to OR1
+     * @see OR1
+     */
+    protected OR<T>(alts:IOrAlt<T>[] | IOrAltImplicit<T>[], errMsgTypes?:string, ignoreAmbiguities:boolean = false):T {
+        return this.OR1(alts, errMsgTypes, ignoreAmbiguities)
+    }
 
-        protected isNextRule<T>(ruleName:string):boolean {
-            let classLAFuncs = cache.getLookaheadFuncsForClass(this.className)
-            let condition = <any>classLAFuncs.get(ruleName)
-            if (condition === undefined) {
-                let ruleGrammar = this.getGAstProductions().get(ruleName)
-                condition = lookahead.buildLookaheadForTopLevel(ruleGrammar)
-                classLAFuncs.put(ruleName, condition)
-            }
+    /**
+     * Parsing DSL method that indicates a choice between a set of alternatives must be made.
+     * This is equivalent to EBNF alternation (A | B | C | D ...)
+     *
+     * There are two forms:
+     *
+     * short: this.OR([
+     *           {ALT:()=>{this.CONSUME(One)}},
+     *           {ALT:()=>{this.CONSUME(Two)}},
+     *           {ALT:()=>{this.CONSUME(Three)}},
+     *        ], "a number")
+     *
+     * long: this.OR([
+     *           {WHEN: isOne, THEN_DO:()=>{this.CONSUME(One)}},
+     *           {WHEN: isTwo, THEN_DO:()=>{this.CONSUME(Two)}},
+     *           {WHEN: isThree, THEN_DO:()=>{this.CONSUME(Three)}},
+     *        ], "a number")
+     *
+     * using the short form is recommended as it will compute the lookahead function
+     * automatically. however this currently has one limitation:
+     * It only works if the lookahead for the grammar is one LL(1).
+     *
+     * As in CONSUME the index in the method name indicates the occurrence
+     * of the alternation production in it's top rule.
+     *
+     * @param {{ALT:Function}[] | {WHEN:Function, THEN_DO:Function}[]} alts - An array of alternatives
+     *
+     * @param {string} [errMsgTypes] - A description for the alternatives used in error messages
+     *                                 If none is provided, the error message will include the names of the expected
+     *                                 Tokens which may start each alternative.
+     *
+     * @param {boolean} [ignoreAmbiguities] - if true this will ignore ambiguities caused when two alternatives can not
+     *        be distinguished by a lookahead of one. enabling this means the first alternative
+     *        that matches will be taken. This is sometimes the grammar's intent.
+     *        * only enable this if you know what you are doing!
+     *
+     * @returns {*} The result of invoking the chosen alternative
 
-            return condition.call(this)
-        }
+     */
+    protected OR1<T>(alts:IOrAlt<T>[] | IOrAltImplicit<T>[], errMsgTypes?:string, ignoreAmbiguities:boolean = false):T {
+        return this.orInternal(alts, errMsgTypes, 1, ignoreAmbiguities)
+    }
 
-        /**
-         *
-         * @param grammarRule the rule to try and parse in backtracking mode
-         * @param isValid a predicate that given the result of the parse attempt will "decide" if the parse was successfully or not
-         * @return a lookahead function that will try to parse the given grammarRule and will return true if succeed
-         */
-        protected BACKTRACK<T>(grammarRule:(...args) => T, isValid:(T) => boolean):() => boolean {
-            return () => {
-                // save org state
-                this.isBackTrackingStack.push(1)
-                let orgState = this.saveRecogState()
-                try {
-                    let ruleResult = grammarRule.call(this)
-                    return isValid(ruleResult)
-                } catch (e) {
-                    if (exceptions.isRecognitionException(e)) {
-                        return false
-                    }
-                    else {
-                        throw e
-                    }
-                }
-                finally {
-                    this.reloadRecogState(orgState)
-                    this.isBackTrackingStack.pop()
-                }
-            }
-        }
+    /**
+     * @see OR1
+     */
+    protected OR2<T>(alts:IOrAlt<T>[] | IOrAltImplicit<T>[], errMsgTypes?:string, ignoreAmbiguities:boolean = false):T {
+        return this.orInternal(alts, errMsgTypes, 2, ignoreAmbiguities)
+    }
 
-        // skips a token and returns the next token
-        protected SKIP_TOKEN():Token {
-            // example: assume 45 tokens in the input, if input index is 44 it means that NEXT_TOKEN will return
-            // input[45] which is the 46th item and no longer exists,
-            // so in this case the largest valid input index is 43 (input.length - 2 )
-            if (this.inputIdx <= this._input.length - 2) {
-                this.inputIdx++
-                return this.NEXT_TOKEN()
-            }
-            else {
-                return new EOF()
-            }
-        }
+    /**
+     * @see OR1
+     */
+    protected OR3<T>(alts:IOrAlt<T>[] | IOrAltImplicit<T>[], errMsgTypes?:string, ignoreAmbiguities:boolean = false):T {
+        return this.orInternal(alts, errMsgTypes, 3, ignoreAmbiguities)
+    }
 
-        // Parsing DSL
-
-        /**
-         * Convenience method equivalent to CONSUME1
-         * @see CONSUME1
-         */
-        protected CONSUME(tokClass:Function):Token {
-            return this.CONSUME1(tokClass)
-        }
-
-        /**
-         *
-         * A Parsing DSL method use to consume a single terminal Token.
-         * a Token will be consumed, IFF the next token in the token vector is an instanceof tokClass.
-         * otherwise the parser will attempt to perform error recovery.
-         *
-         * The index in the method name indicates the unique occurrence of a terminal consumption
-         * inside a the top level rule. What this means is that if a terminal appears
-         * more than once in a single rule, each appearance must have a difference index.
-         *
-         * for example:
-         *
-         * function parseQualifiedName() {
-         *    this.CONSUME1(Identifier);
-         *    this.MANY(()=> {
-         *       this.CONSUME1(Dot);
-         *       this.CONSUME2(Identifier); // <-- here we use CONSUME2 because the terminal
-         *    });                           //     'Identifier' has already appeared previously in the
-         *                                  //     the rule 'parseQualifiedName'
-         * }
-         *
-         * @param {Function} tokClass A constructor function specifying the type of token
-         *        to be consumed.
-         *
-         * @returns {chevrotain.tokens.Token} The consumed token.
-         */
-        protected CONSUME1(tokClass:Function):Token {
-            return this.consumeInternal(tokClass, 1)
-        }
-
-        /**
-         * @see CONSUME1
-         */
-        protected CONSUME2(tokClass:Function):Token {
-            return this.consumeInternal(tokClass, 2)
-        }
-
-        /**
-         * @see CONSUME1
-         */
-        protected CONSUME3(tokClass:Function):Token {
-            return this.consumeInternal(tokClass, 3)
-        }
-
-        /**
-         * @see CONSUME1
-         */
-        protected CONSUME4(tokClass:Function):Token {
-            return this.consumeInternal(tokClass, 4)
-        }
-
-        /**
-         * @see CONSUME1
-         */
-        protected CONSUME5(tokClass:Function):Token {
-            return this.consumeInternal(tokClass, 5)
-        }
-
-        /**
-         * Convenience method equivalent to SUBRULE1
-         * @see SUBRULE1
-         */
-        protected SUBRULE<T>(ruleToCall:(number) => T, args:any[] = []):T {
-            return this.SUBRULE1(ruleToCall, args)
-        }
-
-        /**
-         * The Parsing DSL Method is used by one rule to call another.
-         *
-         * This may seem redundant as it does not actually do much.
-         * However using it is mandatory for all sub rule invocations.
-         * calling another rule without wrapping in SUBRULE(...)
-         * will cause errors/mistakes in the Recognizer's self analysis
-         * which will lead to errors in error recovery/automatic lookahead calculation
-         * and any other functionality relying on the Recognizer's self analysis
-         * output.
-         *
-         * As in CONSUME the index in the method name indicates the occurrence
-         * of the sub rule invocation in its rule.
-         *
-         * @param {Function} ruleToCall the rule to invoke
-         * @param {*[]} args the arguments to pass to the invoked subrule
-         * @returns {*} the result of invoking ruleToCall
-         */
-        protected SUBRULE1<T>(ruleToCall:(number) => T, args:any[] = []):T {
-            return ruleToCall.call(this, 1, args)
-        }
-
-        /**
-         * @see SUBRULE1
-         */
-        protected SUBRULE2<T>(ruleToCall:(number) => T, args:any[] = []):T {
-            return ruleToCall.call(this, 2, args)
-        }
-
-        /**
-         * @see SUBRULE1
-         */
-        protected SUBRULE3<T>(ruleToCall:(number) => T, args:any[] = []):T {
-            return ruleToCall.call(this, 3, args)
-        }
-
-        /**
-         * @see SUBRULE1
-         */
-        protected SUBRULE4<T>(ruleToCall:(number) => T, args:any[] = []):T {
-            return ruleToCall.call(this, 4, args)
-        }
-
-        /**
-         * @see SUBRULE1
-         */
-        protected SUBRULE5<T>(ruleToCall:(number) => T, args:any[] = []):T {
-            return ruleToCall.call(this, 5, args)
-        }
-
-        /**
-         * Convenience method equivalent to OPTION1
-         * @see OPTION1
-         */
-        protected OPTION(laFuncOrAction:LookAheadFunc | GrammarAction,
-                         action?:GrammarAction):boolean {
-            return this.OPTION1.call(this, laFuncOrAction, action)
-        }
-
-        /**
-         * Parsing DSL Method that Indicates an Optional production
-         * in EBNF notation: [...]
-         *
-         * note that the 'action' param is optional. so both of the following forms are valid:
-         *
-         * short: this.OPTION(()=>{ this.CONSUME(Digit});
-         * long: this.OPTION(isDigit, ()=>{ this.CONSUME(Digit});
-         *
-         * using the short form is recommended as it will compute the lookahead function
-         * automatically. however this currently has one limitation:
-         * It only works if the lookahead for the grammar is one.
-         *
-         * As in CONSUME the index in the method name indicates the occurrence
-         * of the optional production in it's top rule.
-         *
-         * @param {Function} laFuncOrAction The lookahead function that 'decides'
-         *                                  whether or not the OPTION's action will be
-         *                                  invoked or the action to optionally invoke
-         * @param {Function} [action] The action to optionally invoke.
-         *
-         * @returns {boolean} true iff the OPTION's action has been invoked
-         */
-        protected OPTION1(laFuncOrAction:LookAheadFunc | GrammarAction,
-                          action?:GrammarAction):boolean {
-            if (action === undefined) {
-                action = <any>laFuncOrAction
-                laFuncOrAction = this.getLookaheadFuncForOption(1)
-            }
-            return this.optionInternal(<any>laFuncOrAction, <any>action)
-        }
+    /**
+     * @see OR1
+     */
+    protected OR4<T>(alts:IOrAlt<T>[] | IOrAltImplicit<T>[], errMsgTypes?:string, ignoreAmbiguities:boolean = false):T {
+        return this.orInternal(alts, errMsgTypes, 4, ignoreAmbiguities)
+    }
 
-        /**
-         * @see OPTION1
-         */
-        protected OPTION2(laFuncOrAction:LookAheadFunc | GrammarAction,
-                          action?:GrammarAction):boolean {
-            if (action === undefined) {
-                action = <any>laFuncOrAction
-                laFuncOrAction = this.getLookaheadFuncForOption(2)
-            }
-            return this.optionInternal(<any>laFuncOrAction, <any>action)
-        }
+    /**
+     * @see OR1
+     */
+    protected OR5<T>(alts:IOrAlt<T>[] | IOrAltImplicit<T>[], errMsgTypes?:string, ignoreAmbiguities:boolean = false):T {
+        return this.orInternal(alts, errMsgTypes, 5, ignoreAmbiguities)
+    }
 
-        /**
-         * @see OPTION1
-         */
-        protected OPTION3(laFuncOrAction:LookAheadFunc | GrammarAction,
-                          action?:GrammarAction):boolean {
-            if (action === undefined) {
-                action = <any>laFuncOrAction
-                laFuncOrAction = this.getLookaheadFuncForOption(3)
-            }
-            return this.optionInternal(<any>laFuncOrAction, <any>action)
-        }
+    /**
+     * Convenience method equivalent to MANY1
+     * @see MANY1
+     */
+    protected MANY(laFuncOrAction:LookAheadFunc | GrammarAction,
+                   action?:GrammarAction):void {
+        return this.MANY1.call(this, laFuncOrAction, action)
+    }
 
-        /**
-         * @see OPTION1
-         */
-        protected OPTION4(laFuncOrAction:LookAheadFunc | GrammarAction,
-                          action?:GrammarAction):boolean {
-            if (action === undefined) {
-                action = <any>laFuncOrAction
-                laFuncOrAction = this.getLookaheadFuncForOption(4)
-            }
-            return this.optionInternal(<any>laFuncOrAction, <any>action)
-        }
+    /**
+     * Parsing DSL method, that indicates a repetition of zero or more.
+     * This is equivalent to EBNF repetition {...}
+     *
+     * note that the 'action' param is optional. so both of the following forms are valid:
+     *
+     * short: this.MANY(()=>{
+     *                       this.CONSUME(Comma};
+     *                       this.CONSUME(Digit});
+     * long: this.MANY(isComma, ()=>{
+     *                       this.CONSUME(Comma};
+     *                       this.CONSUME(Digit});
+     *
+     * using the short form is recommended as it will compute the lookahead function
+     * automatically. however this currently has one limitation:
+     * It only works if the lookahead for the grammar is one.
+     *
+     * As in CONSUME the index in the method name indicates the occurrence
+     * of the repetition production in it's top rule.
+     *
+     * @param {Function} laFuncOrAction The lookahead function that 'decides'
+     *                                  whether or not the MANY's action will be
+     *                                  invoked or the action to optionally invoke
+     * @param {Function} [action] The action to optionally invoke.
+     */
+    protected MANY1(laFuncOrAction:LookAheadFunc | GrammarAction,
+                    action?:GrammarAction):void {
+        this.manyInternal(this.MANY1, "MANY1", 1, laFuncOrAction, action)
+    }
 
-        /**
-         * @see OPTION1
-         */
-        protected OPTION5(laFuncOrAction:LookAheadFunc | GrammarAction,
-                          action?:GrammarAction):boolean {
-            if (action === undefined) {
-                action = <any>laFuncOrAction
-                laFuncOrAction = this.getLookaheadFuncForOption(5)
-            }
-            return this.optionInternal(<any>laFuncOrAction, <any>action)
-        }
-
-        /**
-         * Convenience method equivalent to OR1
-         * @see OR1
-         */
-        protected OR<T>(alts:IOrAlt<T>[] | IOrAltImplicit<T>[], errMsgTypes?:string, ignoreAmbiguities:boolean = false):T {
-            return this.OR1(alts, errMsgTypes, ignoreAmbiguities)
-        }
-
-        /**
-         * Parsing DSL method that indicates a choice between a set of alternatives must be made.
-         * This is equivalent to EBNF alternation (A | B | C | D ...)
-         *
-         * There are two forms:
-         *
-         * short: this.OR([
-         *           {ALT:()=>{this.CONSUME(One)}},
-         *           {ALT:()=>{this.CONSUME(Two)}},
-         *           {ALT:()=>{this.CONSUME(Three)}},
-         *        ], "a number")
-         *
-         * long: this.OR([
-         *           {WHEN: isOne, THEN_DO:()=>{this.CONSUME(One)}},
-         *           {WHEN: isTwo, THEN_DO:()=>{this.CONSUME(Two)}},
-         *           {WHEN: isThree, THEN_DO:()=>{this.CONSUME(Three)}},
-         *        ], "a number")
-         *
-         * using the short form is recommended as it will compute the lookahead function
-         * automatically. however this currently has one limitation:
-         * It only works if the lookahead for the grammar is one LL(1).
-         *
-         * As in CONSUME the index in the method name indicates the occurrence
-         * of the alternation production in it's top rule.
-         *
-         * @param {{ALT:Function}[] | {WHEN:Function, THEN_DO:Function}[]} alts - An array of alternatives
-         *
-         * @param {string} [errMsgTypes] - A description for the alternatives used in error messages
-         *                                 If none is provided, the error message will include the names of the expected
-         *                                 Tokens which may start each alternative.
-         *
-         * @param {boolean} [ignoreAmbiguities] - if true this will ignore ambiguities caused when two alternatives can not
-         *        be distinguished by a lookahead of one. enabling this means the first alternative
-         *        that matches will be taken. This is sometimes the grammar's intent.
-         *        * only enable this if you know what you are doing!
-         *
-         * @returns {*} The result of invoking the chosen alternative
-
-         */
-        protected OR1<T>(alts:IOrAlt<T>[] | IOrAltImplicit<T>[], errMsgTypes?:string, ignoreAmbiguities:boolean = false):T {
-            return this.orInternal(alts, errMsgTypes, 1, ignoreAmbiguities)
-        }
-
-        /**
-         * @see OR1
-         */
-        protected OR2<T>(alts:IOrAlt<T>[] | IOrAltImplicit<T>[], errMsgTypes?:string, ignoreAmbiguities:boolean = false):T {
-            return this.orInternal(alts, errMsgTypes, 2, ignoreAmbiguities)
-        }
-
-        /**
-         * @see OR1
-         */
-        protected OR3<T>(alts:IOrAlt<T>[] | IOrAltImplicit<T>[], errMsgTypes?:string, ignoreAmbiguities:boolean = false):T {
-            return this.orInternal(alts, errMsgTypes, 3, ignoreAmbiguities)
-        }
-
-        /**
-         * @see OR1
-         */
-        protected OR4<T>(alts:IOrAlt<T>[] | IOrAltImplicit<T>[], errMsgTypes?:string, ignoreAmbiguities:boolean = false):T {
-            return this.orInternal(alts, errMsgTypes, 4, ignoreAmbiguities)
-        }
-
-        /**
-         * @see OR1
-         */
-        protected OR5<T>(alts:IOrAlt<T>[] | IOrAltImplicit<T>[], errMsgTypes?:string, ignoreAmbiguities:boolean = false):T {
-            return this.orInternal(alts, errMsgTypes, 5, ignoreAmbiguities)
-        }
-
-        /**
-         * Convenience method equivalent to MANY1
-         * @see MANY1
-         */
-        protected MANY(laFuncOrAction:LookAheadFunc | GrammarAction,
-                       action?:GrammarAction):void {
-            return this.MANY1.call(this, laFuncOrAction, action)
-        }
-
-        /**
-         * Parsing DSL method, that indicates a repetition of zero or more.
-         * This is equivalent to EBNF repetition {...}
-         *
-         * note that the 'action' param is optional. so both of the following forms are valid:
-         *
-         * short: this.MANY(()=>{
-         *                       this.CONSUME(Comma};
-         *                       this.CONSUME(Digit});
-         * long: this.MANY(isComma, ()=>{
-         *                       this.CONSUME(Comma};
-         *                       this.CONSUME(Digit});
-         *
-         * using the short form is recommended as it will compute the lookahead function
-         * automatically. however this currently has one limitation:
-         * It only works if the lookahead for the grammar is one.
-         *
-         * As in CONSUME the index in the method name indicates the occurrence
-         * of the repetition production in it's top rule.
-         *
-         * @param {Function} laFuncOrAction The lookahead function that 'decides'
-         *                                  whether or not the MANY's action will be
-         *                                  invoked or the action to optionally invoke
-         * @param {Function} [action] The action to optionally invoke.
-         */
-        protected MANY1(laFuncOrAction:LookAheadFunc | GrammarAction,
-                        action?:GrammarAction):void {
-            this.manyInternal(this.MANY1, "MANY1", 1, laFuncOrAction, action)
-        }
-
-        /**
-         * @see MANY1
-         */
-        protected MANY2(laFuncOrAction:LookAheadFunc | GrammarAction,
-                        action?:GrammarAction):void {
-            this.manyInternal(this.MANY2, "MANY2", 2, laFuncOrAction, action)
-        }
-
-        /**
-         * @see MANY1
-         */
-        protected MANY3(laFuncOrAction:LookAheadFunc | GrammarAction,
-                        action?:GrammarAction):void {
-            this.manyInternal(this.MANY3, "MANY3", 3, laFuncOrAction, action)
-        }
-
-        /**
-         * @see MANY1
-         */
-        protected MANY4(laFuncOrAction:LookAheadFunc | GrammarAction,
-                        action?:GrammarAction):void {
-            this.manyInternal(this.MANY4, "MANY4", 4, laFuncOrAction, action)
-        }
-
-        /**
-         * @see MANY1
-         */
-        protected MANY5(laFuncOrAction:LookAheadFunc | GrammarAction,
-                        action?:GrammarAction):void {
-            this.manyInternal(this.MANY5, "MANY5", 5, laFuncOrAction, action)
-        }
-
-        /**
-         * Convenience method equivalent to MANY_SEP1
-         * @see MANY_SEP1
-         */
-        protected MANY_SEP(separator:TokenConstructor, laFuncOrAction:LookAheadFunc | GrammarAction,
-                           action?:GrammarAction):Token[] {
-            return this.MANY_SEP1.call(this, separator, laFuncOrAction, action)
-        }
-
-        /**
-         * Parsing DSL method, that indicates a repetition of zero or more with a separator
-         * Token between the repetitions.
-         *
-         * note that the 'action' param is optional. so both of the following forms are valid:
-         *
-         * short: this.MANY_SEP(Comma, ()=>{
-         *                       this.CONSUME(Number};
-         *                       ...
-         *                       );
-         *
-         * long: this.MANY(Comma, isNumber, ()=>{
-         *                       this.CONSUME(Number}
-         *                       ...
-         *                       );
-         *
-         * using the short form is recommended as it will compute the lookahead function
-         * (for the first iteration) automatically. however this currently has one limitation:
-         * It only works if the lookahead for the grammar is one.
-         *
-         * As in CONSUME the index in the method name indicates the occurrence
-         * of the repetition production in it's top rule.
-         *
-         * @param separator - The Token to use as a separator between repetitions.
-         * @param {Function} laFuncOrAction - The lookahead function that 'decides'
-         *                                  whether or not the MANY_SEP's action will be
-         *                                  invoked or the action to optionally invoke
-         * @param {Function} [action] - The action to optionally invoke.
-         *
-         * @return {Token[]} - The consumed separator Tokens.
-         */
-        protected MANY_SEP1(separator:TokenConstructor, laFuncOrAction:LookAheadFunc | GrammarAction,
-                            action?:GrammarAction):Token[] {
-            return this.manySepFirstInternal(this.MANY_SEP1, "MANY_SEP1", 1, separator, laFuncOrAction, action)
-        }
-
-        /**
-         * @see MANY_SEP1
-         */
-        protected MANY_SEP2(separator:TokenConstructor, laFuncOrAction:LookAheadFunc | GrammarAction,
-                            action?:GrammarAction):Token[] {
-            return this.manySepFirstInternal(this.MANY_SEP2, "MANY_SEP2", 2, separator, laFuncOrAction, action)
-        }
-
-        /**
-         * @see MANY_SEP1
-         */
-        protected MANY_SEP3(separator:TokenConstructor, laFuncOrAction:LookAheadFunc | GrammarAction,
-                            action?:GrammarAction):Token[] {
-            return this.manySepFirstInternal(this.MANY_SEP3, "MANY_SEP3", 3, separator, laFuncOrAction, action)
-        }
-
-        /**
-         * @see MANY_SEP1
-         */
-        protected MANY_SEP4(separator:TokenConstructor, laFuncOrAction:LookAheadFunc | GrammarAction,
-                            action?:GrammarAction):Token[] {
-            return this.manySepFirstInternal(this.MANY_SEP4, "MANY_SEP4", 4, separator, laFuncOrAction, action)
-        }
-
-        /**
-         * @see MANY_SEP1
-         */
-        protected MANY_SEP5(separator:TokenConstructor, laFuncOrAction:LookAheadFunc | GrammarAction,
-                            action?:GrammarAction):Token[] {
-            return this.manySepFirstInternal(this.MANY_SEP5, "MANY_SEP5", 5, separator, laFuncOrAction, action)
-        }
-
-        /**
-         * Convenience method equivalent to AT_LEAST_ONE1
-         * @see AT_LEAST_ONE1
-         */
-        protected AT_LEAST_ONE(laFuncOrAction:LookAheadFunc | GrammarAction,
+    /**
+     * @see MANY1
+     */
+    protected MANY2(laFuncOrAction:LookAheadFunc | GrammarAction,
+                    action?:GrammarAction):void {
+        this.manyInternal(this.MANY2, "MANY2", 2, laFuncOrAction, action)
+    }
+
+    /**
+     * @see MANY1
+     */
+    protected MANY3(laFuncOrAction:LookAheadFunc | GrammarAction,
+                    action?:GrammarAction):void {
+        this.manyInternal(this.MANY3, "MANY3", 3, laFuncOrAction, action)
+    }
+
+    /**
+     * @see MANY1
+     */
+    protected MANY4(laFuncOrAction:LookAheadFunc | GrammarAction,
+                    action?:GrammarAction):void {
+        this.manyInternal(this.MANY4, "MANY4", 4, laFuncOrAction, action)
+    }
+
+    /**
+     * @see MANY1
+     */
+    protected MANY5(laFuncOrAction:LookAheadFunc | GrammarAction,
+                    action?:GrammarAction):void {
+        this.manyInternal(this.MANY5, "MANY5", 5, laFuncOrAction, action)
+    }
+
+    /**
+     * Convenience method equivalent to MANY_SEP1
+     * @see MANY_SEP1
+     */
+    protected MANY_SEP(separator:TokenConstructor, laFuncOrAction:LookAheadFunc | GrammarAction,
+                       action?:GrammarAction):Token[] {
+        return this.MANY_SEP1.call(this, separator, laFuncOrAction, action)
+    }
+
+    /**
+     * Parsing DSL method, that indicates a repetition of zero or more with a separator
+     * Token between the repetitions.
+     *
+     * note that the 'action' param is optional. so both of the following forms are valid:
+     *
+     * short: this.MANY_SEP(Comma, ()=>{
+     *                          this.CONSUME(Number};
+     *                       ...
+     *                       );
+     *
+     * long: this.MANY(Comma, isNumber, ()=>{
+     *                           this.CONSUME(Number}
+     *                       ...
+     *                       );
+     *
+     * using the short form is recommended as it will compute the lookahead function
+     * (for the first iteration) automatically. however this currently has one limitation:
+     * It only works if the lookahead for the grammar is one.
+     *
+     * As in CONSUME the index in the method name indicates the occurrence
+     * of the repetition production in it's top rule.
+     *
+     * @param separator - The Token to use as a separator between repetitions.
+     * @param {Function} laFuncOrAction - The lookahead function that 'decides'
+     *                                  whether or not the MANY_SEP's action will be
+     *                                  invoked or the action to optionally invoke
+     * @param {Function} [action] - The action to optionally invoke.
+     *
+     * @return {Token[]} - The consumed separator Tokens.
+     */
+    protected MANY_SEP1(separator:TokenConstructor, laFuncOrAction:LookAheadFunc | GrammarAction,
+                        action?:GrammarAction):Token[] {
+        return this.manySepFirstInternal(this.MANY_SEP1, "MANY_SEP1", 1, separator, laFuncOrAction, action)
+    }
+
+    /**
+     * @see MANY_SEP1
+     */
+    protected MANY_SEP2(separator:TokenConstructor, laFuncOrAction:LookAheadFunc | GrammarAction,
+                        action?:GrammarAction):Token[] {
+        return this.manySepFirstInternal(this.MANY_SEP2, "MANY_SEP2", 2, separator, laFuncOrAction, action)
+    }
+
+    /**
+     * @see MANY_SEP1
+     */
+    protected MANY_SEP3(separator:TokenConstructor, laFuncOrAction:LookAheadFunc | GrammarAction,
+                        action?:GrammarAction):Token[] {
+        return this.manySepFirstInternal(this.MANY_SEP3, "MANY_SEP3", 3, separator, laFuncOrAction, action)
+    }
+
+    /**
+     * @see MANY_SEP1
+     */
+    protected MANY_SEP4(separator:TokenConstructor, laFuncOrAction:LookAheadFunc | GrammarAction,
+                        action?:GrammarAction):Token[] {
+        return this.manySepFirstInternal(this.MANY_SEP4, "MANY_SEP4", 4, separator, laFuncOrAction, action)
+    }
+
+    /**
+     * @see MANY_SEP1
+     */
+    protected MANY_SEP5(separator:TokenConstructor, laFuncOrAction:LookAheadFunc | GrammarAction,
+                        action?:GrammarAction):Token[] {
+        return this.manySepFirstInternal(this.MANY_SEP5, "MANY_SEP5", 5, separator, laFuncOrAction, action)
+    }
+
+    /**
+     * Convenience method equivalent to AT_LEAST_ONE1
+     * @see AT_LEAST_ONE1
+     */
+    protected AT_LEAST_ONE(laFuncOrAction:LookAheadFunc | GrammarAction,
+                           action:GrammarAction | string,
+                           errMsg?:string):void {
+        return this.AT_LEAST_ONE1.call(this, laFuncOrAction, action, errMsg)
+    }
+
+    /**
+     *
+     * convenience method, same as MANY but the repetition is of one or more.
+     * failing to match at least one repetition will result in a parsing error and
+     * cause the parser to attempt error recovery.
+     *
+     * @see MANY1
+     *
+     * @param {Function} laFuncOrAction The lookahead function that 'decides'
+     *                                  whether or not the AT_LEAST_ONE's action will be
+     *                                  invoked or the action to optionally invoke
+     * @param {Function} [action] The action to optionally invoke.
+     * @param {string} [errMsg] short title/classification to what is being matched
+     */
+    protected AT_LEAST_ONE1(laFuncOrAction:LookAheadFunc | GrammarAction,
+                            action:GrammarAction | string,
+                            errMsg?:string):void {
+        this.atLeastOneInternal(this.AT_LEAST_ONE1, "AT_LEAST_ONE1", 1, laFuncOrAction, action, errMsg)
+    }
+
+    /**
+     * @see AT_LEAST_ONE1
+     */
+    protected AT_LEAST_ONE2(laFuncOrAction:LookAheadFunc | GrammarAction,
+                            action:GrammarAction | string,
+                            errMsg?:string):void {
+        this.atLeastOneInternal(this.AT_LEAST_ONE2, "AT_LEAST_ONE2", 2, laFuncOrAction, action, errMsg)
+    }
+
+    /**
+     * @see AT_LEAST_ONE1
+     */
+    protected AT_LEAST_ONE3(laFuncOrAction:LookAheadFunc | GrammarAction,
+                            action:GrammarAction | string,
+                            errMsg?:string):void {
+        this.atLeastOneInternal(this.AT_LEAST_ONE3, "AT_LEAST_ONE3", 3, laFuncOrAction, action, errMsg)
+    }
+
+    /**
+     * @see AT_LEAST_ONE1
+     */
+    protected AT_LEAST_ONE4(laFuncOrAction:LookAheadFunc | GrammarAction,
+                            action:GrammarAction | string,
+                            errMsg?:string):void {
+        this.atLeastOneInternal(this.AT_LEAST_ONE4, "AT_LEAST_ONE4", 4, laFuncOrAction, action, errMsg)
+    }
+
+    /**
+     * @see AT_LEAST_ONE1
+     */
+    protected AT_LEAST_ONE5(laFuncOrAction:LookAheadFunc | GrammarAction,
+                            action:GrammarAction | string,
+                            errMsg?:string):void {
+        this.atLeastOneInternal(this.AT_LEAST_ONE5, "AT_LEAST_ONE5", 5, laFuncOrAction, action, errMsg)
+    }
+
+    /**
+     * Convenience method equivalent to AT_LEAST_ONE_SEP1
+     * @see AT_LEAST_ONE1
+     */
+    protected AT_LEAST_ONE_SEP(separator:TokenConstructor,
+                               laFuncOrAction:LookAheadFunc | GrammarAction,
                                action:GrammarAction | string,
-                               errMsg?:string):void {
-            return this.AT_LEAST_ONE1.call(this, laFuncOrAction, action, errMsg)
-        }
-
-        /**
-         *
-         * convenience method, same as MANY but the repetition is of one or more.
-         * failing to match at least one repetition will result in a parsing error and
-         * cause the parser to attempt error recovery.
-         *
-         * @see MANY1
-         *
-         * @param {Function} laFuncOrAction The lookahead function that 'decides'
-         *                                  whether or not the AT_LEAST_ONE's action will be
-         *                                  invoked or the action to optionally invoke
-         * @param {Function} [action] The action to optionally invoke.
-         * @param {string} [errMsg] short title/classification to what is being matched
-         */
-        protected AT_LEAST_ONE1(laFuncOrAction:LookAheadFunc | GrammarAction,
+                               errMsg?:string):Token[] {
+        return this.AT_LEAST_ONE_SEP1.call(this, separator, laFuncOrAction, action, errMsg)
+    }
+
+    /**
+     *
+     * convenience method, same as MANY_SEP but the repetition is of one or more.
+     * failing to match at least one repetition will result in a parsing error and
+     * cause the parser to attempt error recovery.
+     *
+     * @see MANY_SEP1
+     *
+     * @param separator {Token}
+     * @param {Function} laFuncOrAction The lookahead function that 'decides'
+     *                                  whether or not the AT_LEAST_ONE's action will be
+     *                                  invoked or the action to optionally invoke
+     * @param {Function} [action] The action to optionally invoke.
+     * @param {string} [errMsg] short title/classification to what is being matched
+     */
+    protected AT_LEAST_ONE_SEP1(separator:TokenConstructor,
+                                laFuncOrAction:LookAheadFunc | GrammarAction,
                                 action:GrammarAction | string,
-                                errMsg?:string):void {
-            this.atLeastOneInternal(this.AT_LEAST_ONE1, "AT_LEAST_ONE1", 1, laFuncOrAction, action, errMsg)
-        }
+                                errMsg?:string):Token[] {
+        return this.atLeastOneSepFirstInternal(this.atLeastOneSepFirstInternal, "AT_LEAST_ONE_SEP1", 1, separator,
+            laFuncOrAction, action, errMsg)
+    }
 
-        /**
-         * @see AT_LEAST_ONE1
-         */
-        protected AT_LEAST_ONE2(laFuncOrAction:LookAheadFunc | GrammarAction,
+    /**
+     * @see AT_LEAST_ONE_SEP1
+     */
+    protected AT_LEAST_ONE_SEP2(separator:TokenConstructor,
+                                laFuncOrAction:LookAheadFunc | GrammarAction,
                                 action:GrammarAction | string,
-                                errMsg?:string):void {
-            this.atLeastOneInternal(this.AT_LEAST_ONE2, "AT_LEAST_ONE2", 2, laFuncOrAction, action, errMsg)
-        }
+                                errMsg?:string):Token[] {
+        return this.atLeastOneSepFirstInternal(this.atLeastOneSepFirstInternal, "AT_LEAST_ONE_SEP2", 2, separator,
+            laFuncOrAction, action, errMsg)
+    }
 
-        /**
-         * @see AT_LEAST_ONE1
-         */
-        protected AT_LEAST_ONE3(laFuncOrAction:LookAheadFunc | GrammarAction,
+    /**
+     * @see AT_LEAST_ONE_SEP1
+     */
+    protected AT_LEAST_ONE_SEP3(separator:TokenConstructor,
+                                laFuncOrAction:LookAheadFunc | GrammarAction,
                                 action:GrammarAction | string,
-                                errMsg?:string):void {
-            this.atLeastOneInternal(this.AT_LEAST_ONE3, "AT_LEAST_ONE3", 3, laFuncOrAction, action, errMsg)
-        }
+                                errMsg?:string):Token[] {
+        return this.atLeastOneSepFirstInternal(this.atLeastOneSepFirstInternal, "AT_LEAST_ONE_SEP3", 3, separator,
+            laFuncOrAction, action, errMsg)
+    }
 
-        /**
-         * @see AT_LEAST_ONE1
-         */
-        protected AT_LEAST_ONE4(laFuncOrAction:LookAheadFunc | GrammarAction,
+    /**
+     * @see AT_LEAST_ONE_SEP1
+     */
+    protected AT_LEAST_ONE_SEP4(separator:TokenConstructor,
+                                laFuncOrAction:LookAheadFunc | GrammarAction,
                                 action:GrammarAction | string,
-                                errMsg?:string):void {
-            this.atLeastOneInternal(this.AT_LEAST_ONE4, "AT_LEAST_ONE4", 4, laFuncOrAction, action, errMsg)
-        }
+                                errMsg?:string):Token[] {
+        return this.atLeastOneSepFirstInternal(this.atLeastOneSepFirstInternal, "AT_LEAST_ONE_SEP4", 4, separator,
+            laFuncOrAction, action, errMsg)
+    }
 
-        /**
-         * @see AT_LEAST_ONE1
-         */
-        protected AT_LEAST_ONE5(laFuncOrAction:LookAheadFunc | GrammarAction,
+    /**
+     * @see AT_LEAST_ONE_SEP1
+     */
+    protected AT_LEAST_ONE_SEP5(separator:TokenConstructor,
+                                laFuncOrAction:LookAheadFunc | GrammarAction,
                                 action:GrammarAction | string,
-                                errMsg?:string):void {
-            this.atLeastOneInternal(this.AT_LEAST_ONE5, "AT_LEAST_ONE5", 5, laFuncOrAction, action, errMsg)
-        }
-
-        /**
-         * Convenience method equivalent to AT_LEAST_ONE_SEP1
-         * @see AT_LEAST_ONE1
-         */
-        protected AT_LEAST_ONE_SEP(separator:TokenConstructor,
-                                   laFuncOrAction:LookAheadFunc | GrammarAction,
-                                   action:GrammarAction | string,
-                                   errMsg?:string):Token[] {
-            return this.AT_LEAST_ONE_SEP1.call(this, separator, laFuncOrAction, action, errMsg)
-        }
-
-        /**
-         *
-         * convenience method, same as MANY_SEP but the repetition is of one or more.
-         * failing to match at least one repetition will result in a parsing error and
-         * cause the parser to attempt error recovery.
-         *
-         * @see MANY_SEP1
-         *
-         * @param separator {Token}
-         * @param {Function} laFuncOrAction The lookahead function that 'decides'
-         *                                  whether or not the AT_LEAST_ONE's action will be
-         *                                  invoked or the action to optionally invoke
-         * @param {Function} [action] The action to optionally invoke.
-         * @param {string} [errMsg] short title/classification to what is being matched
-         */
-        protected AT_LEAST_ONE_SEP1(separator:TokenConstructor,
-                                    laFuncOrAction:LookAheadFunc | GrammarAction,
-                                    action:GrammarAction | string,
-                                    errMsg?:string):Token[] {
-            return this.atLeastOneSepFirstInternal(this.atLeastOneSepFirstInternal, "AT_LEAST_ONE_SEP1", 1, separator,
-                laFuncOrAction, action, errMsg)
-        }
-
-        /**
-         * @see AT_LEAST_ONE_SEP1
-         */
-        protected AT_LEAST_ONE_SEP2(separator:TokenConstructor,
-                                    laFuncOrAction:LookAheadFunc | GrammarAction,
-                                    action:GrammarAction | string,
-                                    errMsg?:string):Token[] {
-            return this.atLeastOneSepFirstInternal(this.atLeastOneSepFirstInternal, "AT_LEAST_ONE_SEP2", 2, separator,
-                laFuncOrAction, action, errMsg)
-        }
-
-        /**
-         * @see AT_LEAST_ONE_SEP1
-         */
-        protected AT_LEAST_ONE_SEP3(separator:TokenConstructor,
-                                    laFuncOrAction:LookAheadFunc | GrammarAction,
-                                    action:GrammarAction | string,
-                                    errMsg?:string):Token[] {
-            return this.atLeastOneSepFirstInternal(this.atLeastOneSepFirstInternal, "AT_LEAST_ONE_SEP3", 3, separator,
-                laFuncOrAction, action, errMsg)
-        }
-
-        /**
-         * @see AT_LEAST_ONE_SEP1
-         */
-        protected AT_LEAST_ONE_SEP4(separator:TokenConstructor,
-                                    laFuncOrAction:LookAheadFunc | GrammarAction,
-                                    action:GrammarAction | string,
-                                    errMsg?:string):Token[] {
-            return this.atLeastOneSepFirstInternal(this.atLeastOneSepFirstInternal, "AT_LEAST_ONE_SEP4", 4, separator,
-                laFuncOrAction, action, errMsg)
-        }
-
-        /**
-         * @see AT_LEAST_ONE_SEP1
-         */
-        protected AT_LEAST_ONE_SEP5(separator:TokenConstructor,
-                                    laFuncOrAction:LookAheadFunc | GrammarAction,
-                                    action:GrammarAction | string,
-                                    errMsg?:string):Token[] {
-            return this.atLeastOneSepFirstInternal(this.atLeastOneSepFirstInternal, "AT_LEAST_ONE_SEP5", 5, separator,
-                laFuncOrAction, action, errMsg)
-        }
-
-        /**
-         * Convenience method, same as RULE with doReSync=false
-         * @see RULE
-         */
-        protected RULE_NO_RESYNC<T>(ruleName:string,
-                                    impl:() => T,
-                                    invalidRet:() => T):(idxInCallingRule:number,
-                                                         isEntryPoint?:boolean) => T {
-            return this.RULE(ruleName, impl, invalidRet, false)
-        }
-
-        /**
-         *
-         * @param {string} ruleName The name of the Rule. must match the let it is assigned to.
-         * @param {Function} impl The implementation of the Rule
-         * @param {Function} [invalidRet] A function that will return the chosen invalid value for the rule in case of
-         *                   re-sync recovery.
-         * @param {boolean} [doReSync] enable or disable re-sync recovery for this rule. defaults to true
-         * @returns {Function} The parsing rule which is the impl Function wrapped with the parsing logic that handles
-         *                     Parser state / error recovery / ...
-         */
-        protected RULE<T>(ruleName:string,
-                          impl:(...implArgs:any[]) => T,
-                          invalidRet:() => T = this.defaultInvalidReturn,
-                          doReSync = true):(idxInCallingRule?:number, ...args:any[]) => T {
-            // TODO: isEntryPoint by default true? SUBRULE explicitly pass false?
-            let ruleNameErrors = checks.validateRuleName(ruleName, this.definedRulesNames, this.className)
-            this.definedRulesNames.push(ruleName)
-            this.definitionErrors.push.apply(this.definitionErrors, ruleNameErrors) // mutability for the win
-            let parserClassProductions = cache.getProductionsForClass(this.className)
-            // only build the gast representation once
-            if (!(parserClassProductions.containsKey(ruleName))) {
-                let gastProduction = gastBuilder.buildTopProduction(impl.toString(), ruleName, this.tokensMap)
-                parserClassProductions.put(ruleName, gastProduction)
-            }
+                                errMsg?:string):Token[] {
+        return this.atLeastOneSepFirstInternal(this.atLeastOneSepFirstInternal, "AT_LEAST_ONE_SEP5", 5, separator,
+            laFuncOrAction, action, errMsg)
+    }
 
-            let wrappedGrammarRule = function (idxInCallingRule:number = 1, args:any[] = []) {
-                this.ruleInvocationStateUpdate(ruleName, idxInCallingRule)
+    /**
+     * Convenience method, same as RULE with doReSync=false
+     * @see RULE
+     */
+    protected RULE_NO_RESYNC<T>(ruleName:string,
+                                impl:() => T,
+                                invalidRet:() => T):(idxInCallingRule:number,
+                                                     isEntryPoint?:boolean) => T {
+        return this.RULE(ruleName, impl, invalidRet, false)
+    }
 
-                try {
-                    // actual parsing happens here
-                    return impl.apply(this, args)
-                } catch (e) {
-                    let isFirstInvokedRule = (this.RULE_STACK.length === 1)
-                    // note the reSync is always enabled for the first rule invocation, because we must always be able to
-                    // reSync with EOF and just output some INVALID ParseTree
-                    // during backtracking reSync recovery is disabled, otherwise we can't be certain the backtracking
-                    // path is really the most valid one
-                    let reSyncEnabled = isFirstInvokedRule || (
-                        doReSync
-                        && !this.isBackTracking()
-                            // if errorRecovery is disabled, the exception will be rethrown to the top rule
-                            // (isFirstInvokedRule) and there will resync to EOF and terminate.
-                        && this.isErrorRecoveryEnabled)
-
-                    if (reSyncEnabled && exceptions.isRecognitionException(e)) {
-                        let reSyncTokType = this.findReSyncTokenType()
-                        if (this.isInCurrentRuleReSyncSet(reSyncTokType)) {
-                            this.reSyncTo(reSyncTokType)
-                            return invalidRet()
-                        }
-                        else {
-                            // to be handled farther up the call stack
-                            throw e
-                        }
+    /**
+     *
+     * @param {string} ruleName The name of the Rule. must match the let it is assigned to.
+     * @param {Function} impl The implementation of the Rule
+     * @param {Function} [invalidRet] A function that will return the chosen invalid value for the rule in case of
+     *                   re-sync recovery.
+     * @param {boolean} [doReSync] enable or disable re-sync recovery for this rule. defaults to true
+     * @returns {Function} The parsing rule which is the impl Function wrapped with the parsing logic that handles
+     *                     Parser state / error recovery / ...
+     */
+    protected RULE<T>(ruleName:string,
+                      impl:(...implArgs:any[]) => T,
+                      invalidRet:() => T = this.defaultInvalidReturn,
+                      doReSync = true):(idxInCallingRule?:number, ...args:any[]) => T {
+        // TODO: isEntryPoint by default true? SUBRULE explicitly pass false?
+        let ruleNameErrors = validateRuleName(ruleName, this.definedRulesNames, this.className)
+        this.definedRulesNames.push(ruleName)
+        this.definitionErrors.push.apply(this.definitionErrors, ruleNameErrors) // mutability for the win
+        let parserClassProductions = cache.getProductionsForClass(this.className)
+        // only build the gast representation once
+        if (!(parserClassProductions.containsKey(ruleName))) {
+            let gastProduction = buildTopProduction(impl.toString(), ruleName, this.tokensMap)
+            parserClassProductions.put(ruleName, gastProduction)
+        }
+
+        let wrappedGrammarRule = function (idxInCallingRule:number = 1, args:any[] = []) {
+            this.ruleInvocationStateUpdate(ruleName, idxInCallingRule)
+
+            try {
+                // actual parsing happens here
+                return impl.apply(this, args)
+            } catch (e) {
+                let isFirstInvokedRule = (this.RULE_STACK.length === 1)
+                // note the reSync is always enabled for the first rule invocation, because we must always be able to
+                // reSync with EOF and just output some INVALID ParseTree
+                // during backtracking reSync recovery is disabled, otherwise we can't be certain the backtracking
+                // path is really the most valid one
+                let reSyncEnabled = isFirstInvokedRule || (
+                    doReSync
+                    && !this.isBackTracking()
+                        // if errorRecovery is disabled, the exception will be rethrown to the top rule
+                        // (isFirstInvokedRule) and there will resync to EOF and terminate.
+                    && this.isErrorRecoveryEnabled)
+
+                if (reSyncEnabled && exceptions.isRecognitionException(e)) {
+                    let reSyncTokType = this.findReSyncTokenType()
+                    if (this.isInCurrentRuleReSyncSet(reSyncTokType)) {
+                        this.reSyncTo(reSyncTokType)
+                        return invalidRet()
                     }
                     else {
-                        // some other Error type which we don't know how to handle (for example a built in JavaScript Error)
+                        // to be handled farther up the call stack
                         throw e
                     }
                 }
-                finally {
-                    this.ruleFinallyStateUpdate()
+                else {
+                    // some other Error type which we don't know how to handle (for example a built in JavaScript Error)
+                    throw e
                 }
             }
-            let ruleNamePropName = "ruleName"
-            wrappedGrammarRule[ruleNamePropName] = ruleName
-            return wrappedGrammarRule
+            finally {
+                this.ruleFinallyStateUpdate()
+            }
         }
+        let ruleNamePropName = "ruleName"
+        wrappedGrammarRule[ruleNamePropName] = ruleName
+        return wrappedGrammarRule
+    }
+
+    protected ruleInvocationStateUpdate(ruleName:string, idxInCallingRule:number):void {
+        this.RULE_OCCURRENCE_STACK.push(idxInCallingRule)
+        this.RULE_STACK.push(ruleName)
+    }
 
-        protected ruleInvocationStateUpdate(ruleName:string, idxInCallingRule:number):void {
-            this.RULE_OCCURRENCE_STACK.push(idxInCallingRule)
-            this.RULE_STACK.push(ruleName)
+    protected ruleFinallyStateUpdate():void {
+        this.RULE_STACK.pop()
+        this.RULE_OCCURRENCE_STACK.pop()
+
+        let maxInputIdx = this._input.length - 1
+        if ((this.RULE_STACK.length === 0) && this.inputIdx < maxInputIdx) {
+            let firstRedundantTok:Token = this.NEXT_TOKEN()
+            this.SAVE_ERROR(new exceptions.NotAllInputParsedException(
+                "Redundant input, expecting EOF but found: " + firstRedundantTok.image, firstRedundantTok))
         }
+    }
 
-        protected ruleFinallyStateUpdate():void {
-            this.RULE_STACK.pop()
-            this.RULE_OCCURRENCE_STACK.pop()
+    /*
+     * Returns an "imaginary" Token to insert when Single Token Insertion is done
+     * Override this if you require special behavior in your grammar
+     * for example if an IntegerToken is required provide one with the image '0' so it would be valid syntactically
+     */
+    protected getTokenToInsert(tokClass:Function):Token {
+        return new (<any>tokClass)(-1, -1)
+    }
 
-            let maxInputIdx = this._input.length - 1
-            if ((this.RULE_STACK.length === 0) && this.inputIdx < maxInputIdx) {
-                let firstRedundantTok:Token = this.NEXT_TOKEN()
-                this.SAVE_ERROR(new exceptions.NotAllInputParsedException(
-                    "Redundant input, expecting EOF but found: " + firstRedundantTok.image, firstRedundantTok))
+    /*
+     * By default all tokens type may be inserted. This behavior may be overridden in inheriting Recognizers
+     * for example: One may decide that only punctuation tokens may be inserted automatically as they have no additional
+     * semantic value. (A mandatory semicolon has no additional semantic meaning, but an Integer may have additional meaning
+     * depending on its int value and context (Inserting an integer 0 in cardinality: "[1..]" will cause semantic issues
+     * as the max of the cardinality will be greater than the min value. (and this is a false error!)
+     */
+    protected canTokenTypeBeInsertedInRecovery(tokClass:Function) {
+        return true
+    }
+
+    private defaultInvalidReturn():any { return undefined }
+
+    private tryInRepetitionRecovery(grammarRule:Function,
+                                    grammarRuleArgs:any[],
+                                    lookAheadFunc:() => boolean,
+                                    expectedTokType:Function):void {
+        // TODO: can the resyncTokenType be cached?
+        let reSyncTokType = this.findReSyncTokenType()
+        let orgInputIdx = this.inputIdx
+        let nextTokenWithoutResync = this.NEXT_TOKEN()
+        let currToken = this.NEXT_TOKEN()
+        let passedResyncPoint = false
+        while (!passedResyncPoint) {
+            // we skipped enough tokens so we can resync right back into another iteration of the repetition grammar rule
+            if (lookAheadFunc.call(this)) {
+                // we are preemptively re-syncing before an error has been detected, therefor we must reproduce
+                // the error that would have been thrown
+                let expectedTokName = tokenName(expectedTokType)
+                let msg = "Expecting token of type -->" + expectedTokName +
+                    "<-- but found -->'" + nextTokenWithoutResync.image + "'<--"
+                this.SAVE_ERROR(new exceptions.MismatchedTokenException(msg, nextTokenWithoutResync))
+
+                // recursive invocation in other to support multiple re-syncs in the same top level repetition grammar rule
+                grammarRule.apply(this, grammarRuleArgs)
+                return // must return here to avoid reverting the inputIdx
+            }
+            if (currToken instanceof reSyncTokType) {
+                passedResyncPoint = true
             }
+            currToken = this.SKIP_TOKEN()
         }
 
-        /*
-         * Returns an "imaginary" Token to insert when Single Token Insertion is done
-         * Override this if you require special behavior in your grammar
-         * for example if an IntegerToken is required provide one with the image '0' so it would be valid syntactically
-         */
-        protected getTokenToInsert(tokClass:Function):Token {
-            return new (<any>tokClass)(-1, -1)
-        }
+        // we were unable to find a CLOSER point to resync inside the MANY, reset the state and
+        // rethrow the exception for farther recovery attempts into rules deeper in the rules stack
+        this.inputIdx = orgInputIdx
+    }
 
-        /*
-         * By default all tokens type may be inserted. This behavior may be overridden in inheriting Recognizers
-         * for example: One may decide that only punctuation tokens may be inserted automatically as they have no additional
-         * semantic value. (A mandatory semicolon has no additional semantic meaning, but an Integer may have additional meaning
-         * depending on its int value and context (Inserting an integer 0 in cardinality: "[1..]" will cause semantic issues
-         * as the max of the cardinality will be greater than the min value. (and this is a false error!)
-         */
-        protected canTokenTypeBeInsertedInRecovery(tokClass:Function) {
-            return true
+    private shouldInRepetitionRecoveryBeTried(expectTokAfterLastMatch?:Function, nextTokIdx?:number):boolean {
+        // arguments to try and perform resync into the next iteration of the many are missing
+        if (expectTokAfterLastMatch === undefined || nextTokIdx === undefined) {
+            return false
         }
 
-        private defaultInvalidReturn():any { return undefined }
-
-        private tryInRepetitionRecovery(grammarRule:Function,
-                                        grammarRuleArgs:any[],
-                                        lookAheadFunc:() => boolean,
-                                        expectedTokType:Function):void {
-            // TODO: can the resyncTokenType be cached?
-            let reSyncTokType = this.findReSyncTokenType()
-            let orgInputIdx = this.inputIdx
-            let nextTokenWithoutResync = this.NEXT_TOKEN()
-            let currToken = this.NEXT_TOKEN()
-            let passedResyncPoint = false
-            while (!passedResyncPoint) {
-                // we skipped enough tokens so we can resync right back into another iteration of the repetition grammar rule
-                if (lookAheadFunc.call(this)) {
-                    // we are preemptively re-syncing before an error has been detected, therefor we must reproduce
-                    // the error that would have been thrown
-                    let expectedTokName = tokenName(expectedTokType)
-                    let msg = "Expecting token of type -->" + expectedTokName +
-                        "<-- but found -->'" + nextTokenWithoutResync.image + "'<--"
-                    this.SAVE_ERROR(new exceptions.MismatchedTokenException(msg, nextTokenWithoutResync))
-
-                    // recursive invocation in other to support multiple re-syncs in the same top level repetition grammar rule
-                    grammarRule.apply(this, grammarRuleArgs)
-                    return // must return here to avoid reverting the inputIdx
-                }
-                if (currToken instanceof reSyncTokType) {
-                    passedResyncPoint = true
-                }
-                currToken = this.SKIP_TOKEN()
-            }
+        // no need to recover, next token is what we expect...
+        if (this.NEXT_TOKEN() instanceof expectTokAfterLastMatch) {
+            return false
+        }
 
-            // we were unable to find a CLOSER point to resync inside the MANY, reset the state and
-            // rethrow the exception for farther recovery attempts into rules deeper in the rules stack
-            this.inputIdx = orgInputIdx
+        // error recovery is disabled during backtracking as it can make the parser ignore a valid grammar path
+        // and prefer some backtracking path that includes recovered errors.
+        if (this.isBackTracking()) {
+            return false
         }
 
-        private shouldInRepetitionRecoveryBeTried(expectTokAfterLastMatch?:Function, nextTokIdx?:number):boolean {
-            // arguments to try and perform resync into the next iteration of the many are missing
-            if (expectTokAfterLastMatch === undefined || nextTokIdx === undefined) {
-                return false
-            }
+        // if we can perform inRule recovery (single token insertion or deletion) we always prefer that recovery algorithm
+        // because if it works, it makes the least amount of changes to the input stream (greedy algorithm)
+        //noinspection RedundantIfStatementJS
+        if (this.canPerformInRuleRecovery(expectTokAfterLastMatch,
+                this.getFollowsForInRuleRecovery(expectTokAfterLastMatch, nextTokIdx))) {
+            return false
+        }
 
-            // no need to recover, next token is what we expect...
-            if (this.NEXT_TOKEN() instanceof expectTokAfterLastMatch) {
-                return false
-            }
+        return true
+    }
 
-            // error recovery is disabled during backtracking as it can make the parser ignore a valid grammar path
-            // and prefer some backtracking path that includes recovered errors.
-            if (this.isBackTracking()) {
-                return false
-            }
+    // Error Recovery functionality
+    private getFollowsForInRuleRecovery(tokClass:Function, tokIdxInRule):Function[] {
+        let pathRuleStack:string[] = cloneArr(this.RULE_STACK)
+        let pathOccurrenceStack:number[] = cloneArr(this.RULE_OCCURRENCE_STACK)
+        let grammarPath:any = {
+            ruleStack:         pathRuleStack,
+            occurrenceStack:   pathOccurrenceStack,
+            lastTok:           tokClass,
+            lastTokOccurrence: tokIdxInRule
+        }
+
+        let topRuleName = first(pathRuleStack)
+        let gastProductions = this.getGAstProductions()
+        let topProduction = gastProductions.get(topRuleName)
+        let follows = new NextAfterTokenWalker(topProduction, grammarPath).startWalking()
+        return follows
+    }
 
-            // if we can perform inRule recovery (single token insertion or deletion) we always prefer that recovery algorithm
-            // because if it works, it makes the least amount of changes to the input stream (greedy algorithm)
-            //noinspection RedundantIfStatementJS
-            if (this.canPerformInRuleRecovery(expectTokAfterLastMatch,
-                    this.getFollowsForInRuleRecovery(expectTokAfterLastMatch, nextTokIdx))) {
-                return false
-            }
+    private tryInRuleRecovery(expectedTokType:Function, follows:Function[]):Token {
+        if (this.canRecoverWithSingleTokenInsertion(expectedTokType, follows)) {
+            let tokToInsert = this.getTokenToInsert(expectedTokType)
+            tokToInsert.isInsertedInRecovery = true
+            return tokToInsert
 
-            return true
         }
 
-        // Error Recovery functionality
-        private getFollowsForInRuleRecovery(tokClass:Function, tokIdxInRule):Function[] {
-            let pathRuleStack:string[] = utils.cloneArr(this.RULE_STACK)
-            let pathOccurrenceStack:number[] = utils.cloneArr(this.RULE_OCCURRENCE_STACK)
-            let grammarPath:any = {
-                ruleStack:         pathRuleStack,
-                occurrenceStack:   pathOccurrenceStack,
-                lastTok:           tokClass,
-                lastTokOccurrence: tokIdxInRule
-            }
-
-            let topRuleName = utils.first(pathRuleStack)
-            let gastProductions = this.getGAstProductions()
-            let topProduction = gastProductions.get(topRuleName)
-            let follows = new interp.NextAfterTokenWalker(topProduction, grammarPath).startWalking()
-            return follows
+        if (this.canRecoverWithSingleTokenDeletion(expectedTokType)) {
+            let nextTok = this.SKIP_TOKEN()
+            this.inputIdx++
+            return nextTok
         }
 
-        private tryInRuleRecovery(expectedTokType:Function, follows:Function[]):Token {
-            if (this.canRecoverWithSingleTokenInsertion(expectedTokType, follows)) {
-                let tokToInsert = this.getTokenToInsert(expectedTokType)
-                tokToInsert.isInsertedInRecovery = true
-                return tokToInsert
-
-            }
+        throw new InRuleRecoveryException("sad sad panda")
+    }
 
-            if (this.canRecoverWithSingleTokenDeletion(expectedTokType)) {
-                let nextTok = this.SKIP_TOKEN()
-                this.inputIdx++
-                return nextTok
-            }
+    private canPerformInRuleRecovery(expectedToken:Function, follows:Function[]):boolean {
+        return this.canRecoverWithSingleTokenInsertion(expectedToken, follows) ||
+            this.canRecoverWithSingleTokenDeletion(expectedToken)
+    }
 
-            throw new InRuleRecoveryException("sad sad panda")
+    private canRecoverWithSingleTokenInsertion(expectedTokType:Function, follows:Function[]):boolean {
+        if (!this.canTokenTypeBeInsertedInRecovery(expectedTokType)) {
+            return false
         }
 
-        private canPerformInRuleRecovery(expectedToken:Function, follows:Function[]):boolean {
-            return this.canRecoverWithSingleTokenInsertion(expectedToken, follows) ||
-                this.canRecoverWithSingleTokenDeletion(expectedToken)
+        // must know the possible following tokens to perform single token insertion
+        if (isEmpty(follows)) {
+            return false
         }
 
-        private canRecoverWithSingleTokenInsertion(expectedTokType:Function, follows:Function[]):boolean {
-            if (!this.canTokenTypeBeInsertedInRecovery(expectedTokType)) {
-                return false
-            }
+        let mismatchedTok = this.NEXT_TOKEN()
+        let isMisMatchedTokInFollows = find(follows, (possibleFollowsTokType:Function) => {
+                return mismatchedTok instanceof possibleFollowsTokType
+            }) !== undefined
 
-            // must know the possible following tokens to perform single token insertion
-            if (utils.isEmpty(follows)) {
-                return false
-            }
+        return isMisMatchedTokInFollows
+    }
 
-            let mismatchedTok = this.NEXT_TOKEN()
-            let isMisMatchedTokInFollows = utils.find(follows, (possibleFollowsTokType:Function) => {
-                    return mismatchedTok instanceof possibleFollowsTokType
-                }) !== undefined
+    private canRecoverWithSingleTokenDeletion(expectedTokType:Function):boolean {
+        let isNextTokenWhatIsExpected = this.LA(2) instanceof expectedTokType
+        return isNextTokenWhatIsExpected
+    }
 
-            return isMisMatchedTokInFollows
-        }
+    private isInCurrentRuleReSyncSet(token:Function):boolean {
+        let followKey = this.getCurrFollowKey()
+        let currentRuleReSyncSet = this.getFollowSetFromFollowKey(followKey)
+        return contains(currentRuleReSyncSet, token)
+    }
 
-        private canRecoverWithSingleTokenDeletion(expectedTokType:Function):boolean {
-            let isNextTokenWhatIsExpected = this.LA(2) instanceof expectedTokType
-            return isNextTokenWhatIsExpected
+    private findReSyncTokenType():Function {
+        let allPossibleReSyncTokTypes = this.flattenFollowSet()
+        // this loop will always terminate as EOF is always in the follow stack and also always (virtually) in the input
+        let nextToken = this.NEXT_TOKEN()
+        let k = 2
+        while (true) {
+            let nextTokenType:any = (<any>nextToken).constructor
+            if (contains(allPossibleReSyncTokTypes, nextTokenType)) {
+                return nextTokenType
+            }
+            nextToken = this.LA(k)
+            k++
         }
+    }
 
-        private isInCurrentRuleReSyncSet(token:Function):boolean {
-            let followKey = this.getCurrFollowKey()
-            let currentRuleReSyncSet = this.getFollowSetFromFollowKey(followKey)
-            return utils.contains(currentRuleReSyncSet, token)
+    private getCurrFollowKey():IFollowKey {
+        // the length is at least one as we always add the ruleName to the stack before invoking the rule.
+        if (this.RULE_STACK.length === 1) {
+            return EOF_FOLLOW_KEY
         }
+        let currRuleIdx = this.RULE_STACK.length - 1
+        let currRuleOccIdx = currRuleIdx
+        let prevRuleIdx = currRuleIdx - 1
 
-        private findReSyncTokenType():Function {
-            let allPossibleReSyncTokTypes = this.flattenFollowSet()
-            // this loop will always terminate as EOF is always in the follow stack and also always (virtually) in the input
-            let nextToken = this.NEXT_TOKEN()
-            let k = 2
-            while (true) {
-                let nextTokenType:any = (<any>nextToken).constructor
-                if (utils.contains(allPossibleReSyncTokTypes, nextTokenType)) {
-                    return nextTokenType
-                }
-                nextToken = this.LA(k)
-                k++
-            }
+        return {
+            ruleName:         this.RULE_STACK[currRuleIdx],
+            idxInCallingRule: this.RULE_OCCURRENCE_STACK[currRuleOccIdx],
+            inRule:           this.RULE_STACK[prevRuleIdx]
         }
+    }
 
-        private getCurrFollowKey():IFollowKey {
-            // the length is at least one as we always add the ruleName to the stack before invoking the rule.
-            if (this.RULE_STACK.length === 1) {
+    private buildFullFollowKeyStack():IFollowKey[] {
+        return map(this.RULE_STACK, (ruleName, idx) => {
+            if (idx === 0) {
                 return EOF_FOLLOW_KEY
             }
-            let currRuleIdx = this.RULE_STACK.length - 1
-            let currRuleOccIdx = currRuleIdx
-            let prevRuleIdx = currRuleIdx - 1
-
             return {
-                ruleName:         this.RULE_STACK[currRuleIdx],
-                idxInCallingRule: this.RULE_OCCURRENCE_STACK[currRuleOccIdx],
-                inRule:           this.RULE_STACK[prevRuleIdx]
+                ruleName:         ruleName,
+                idxInCallingRule: this.RULE_OCCURRENCE_STACK[idx],
+                inRule:           this.RULE_STACK[idx - 1]
             }
-        }
+        })
+    }
 
-        private buildFullFollowKeyStack():IFollowKey[] {
-            return utils.map(this.RULE_STACK, (ruleName, idx) => {
-                if (idx === 0) {
-                    return EOF_FOLLOW_KEY
-                }
-                return {
-                    ruleName:         ruleName,
-                    idxInCallingRule: this.RULE_OCCURRENCE_STACK[idx],
-                    inRule:           this.RULE_STACK[idx - 1]
-                }
-            })
-        }
+    private flattenFollowSet():Function[] {
+        let followStack = map(this.buildFullFollowKeyStack(), (currKey) => {
+            return this.getFollowSetFromFollowKey(currKey)
+        })
+        return <any>flatten(followStack)
+    }
 
-        private flattenFollowSet():Function[] {
-            let followStack = utils.map(this.buildFullFollowKeyStack(), (currKey) => {
-                return this.getFollowSetFromFollowKey(currKey)
-            })
-            return <any>utils.flatten(followStack)
+    private getFollowSetFromFollowKey(followKey:IFollowKey):Function[] {
+        if (followKey === EOF_FOLLOW_KEY) {
+            return [EOF]
         }
 
-        private getFollowSetFromFollowKey(followKey:IFollowKey):Function[] {
-            if (followKey === EOF_FOLLOW_KEY) {
-                return [EOF]
-            }
+        let followName = followKey.ruleName + followKey.idxInCallingRule + IN + followKey.inRule
+        return cache.getResyncFollowsForClass(this.className).get(followName)
+    }
 
-            let followName = followKey.ruleName + followKey.idxInCallingRule + IN + followKey.inRule
-            return cache.getResyncFollowsForClass(this.className).get(followName)
+    private reSyncTo(tokClass:Function):void {
+        let nextTok = this.NEXT_TOKEN()
+        while ((nextTok instanceof tokClass) === false) {
+            nextTok = this.SKIP_TOKEN()
         }
+    }
 
-        private reSyncTo(tokClass:Function):void {
-            let nextTok = this.NEXT_TOKEN()
-            while ((nextTok instanceof tokClass) === false) {
-                nextTok = this.SKIP_TOKEN()
-            }
+    private attemptInRepetitionRecovery(prodFunc:Function,
+                                        args:any[],
+                                        lookaheadFunc:() => boolean,
+                                        prodName:string,
+                                        prodOccurrence:number,
+                                        nextToksWalker:typeof AbstractNextTerminalAfterProductionWalker,
+                                        prodKeys:HashTable<string>[]) {
+
+        let key = this.getKeyForAutomaticLookahead(prodName, prodKeys, prodOccurrence)
+        let firstAfterRepInfo = this.firstAfterRepMap.get(key)
+        if (firstAfterRepInfo === undefined) {
+            let currRuleName = last(this.RULE_STACK)
+            let ruleGrammar = this.getGAstProductions().get(currRuleName)
+            let walker:AbstractNextTerminalAfterProductionWalker = new nextToksWalker(ruleGrammar, prodOccurrence)
+            firstAfterRepInfo = walker.startWalking()
+            this.firstAfterRepMap.put(key, firstAfterRepInfo)
+        }
+
+        let expectTokAfterLastMatch = firstAfterRepInfo.token
+        let nextTokIdx = firstAfterRepInfo.occurrence
+        let isEndOfRule = firstAfterRepInfo.isEndOfRule
+
+        // special edge case of a TOP most repetition after which the input should END.
+        // this will force an attempt for inRule recovery in that scenario.
+        if (this.RULE_STACK.length === 1 &&
+            isEndOfRule &&
+            expectTokAfterLastMatch === undefined) {
+            expectTokAfterLastMatch = EOF
+            nextTokIdx = 1
+        }
+
+        if (this.shouldInRepetitionRecoveryBeTried(expectTokAfterLastMatch, nextTokIdx)) {
+            // TODO: performance optimization: instead of passing the original args here, we modify
+            // the args param (or create a new one) and make sure the lookahead func is explicitly provided
+            // to avoid searching the cache for it once more.
+            this.tryInRepetitionRecovery(prodFunc, args, lookaheadFunc, expectTokAfterLastMatch)
         }
+    }
 
-        private attemptInRepetitionRecovery(prodFunc:Function,
-                                            args:any[],
-                                            lookaheadFunc:() => boolean,
-                                            prodName:string,
-                                            prodOccurrence:number,
-                                            nextToksWalker:typeof interp.AbstractNextTerminalAfterProductionWalker,
-                                            prodKeys:lang.HashTable<string>[]) {
-
-            let key = this.getKeyForAutomaticLookahead(prodName, prodKeys, prodOccurrence)
-            let firstAfterRepInfo = this.firstAfterRepMap.get(key)
-            if (firstAfterRepInfo === undefined) {
-                let currRuleName = utils.last(this.RULE_STACK)
-                let ruleGrammar = this.getGAstProductions().get(currRuleName)
-                let walker:interp.AbstractNextTerminalAfterProductionWalker = new nextToksWalker(ruleGrammar, prodOccurrence)
-                firstAfterRepInfo = walker.startWalking()
-                this.firstAfterRepMap.put(key, firstAfterRepInfo)
-            }
-
-            let expectTokAfterLastMatch = firstAfterRepInfo.token
-            let nextTokIdx = firstAfterRepInfo.occurrence
-            let isEndOfRule = firstAfterRepInfo.isEndOfRule
-
-            // special edge case of a TOP most repetition after which the input should END.
-            // this will force an attempt for inRule recovery in that scenario.
-            if (this.RULE_STACK.length === 1 &&
-                isEndOfRule &&
-                expectTokAfterLastMatch === undefined) {
-                expectTokAfterLastMatch = EOF
-                nextTokIdx = 1
-            }
-
-            if (this.shouldInRepetitionRecoveryBeTried(expectTokAfterLastMatch, nextTokIdx)) {
-                // TODO: performance optimization: instead of passing the original args here, we modify
-                // the args param (or create a new one) and make sure the lookahead func is explicitly provided
-                // to avoid searching the cache for it once more.
-                this.tryInRepetitionRecovery(prodFunc, args, lookaheadFunc, expectTokAfterLastMatch)
-            }
+    // Implementation of parsing DSL
+    private optionInternal(condition:LookAheadFunc, action:GrammarAction):boolean {
+        if (condition.call(this)) {
+            action.call(this)
+            return true
         }
+        return false
+    }
 
-        // Implementation of parsing DSL
-        private optionInternal(condition:LookAheadFunc, action:GrammarAction):boolean {
-            if (condition.call(this)) {
-                action.call(this)
-                return true
-            }
-            return false
+    private atLeastOneInternal(prodFunc:Function,
+                               prodName:string,
+                               prodOccurrence:number,
+                               lookAheadFunc:LookAheadFunc | GrammarAction,
+                               action:GrammarAction | string,
+                               errMsg?:string):void {
+        if (isString(action)) {
+            errMsg = <any>action
+            action = <any>lookAheadFunc
+            lookAheadFunc = this.getLookaheadFuncForAtLeastOne(prodOccurrence)
         }
 
-        private atLeastOneInternal(prodFunc:Function,
-                                   prodName:string,
-                                   prodOccurrence:number,
-                                   lookAheadFunc:LookAheadFunc | GrammarAction,
-                                   action:GrammarAction | string,
-                                   errMsg?:string):void {
-            if (utils.isString(action)) {
-                errMsg = <any>action
-                action = <any>lookAheadFunc
-                lookAheadFunc = this.getLookaheadFuncForAtLeastOne(prodOccurrence)
-            }
-
-            if (lookAheadFunc.call(this)) {
+        if (lookAheadFunc.call(this)) {
+            (<any>action).call(this)
+            while (lookAheadFunc.call(this)) {
                 (<any>action).call(this)
-                while (lookAheadFunc.call(this)) {
-                    (<any>action).call(this)
-                }
-            }
-            else {
-                throw this.SAVE_ERROR(new exceptions.EarlyExitException("expecting at least one: " + errMsg, this.NEXT_TOKEN()))
-            }
-
-            // note that while it may seem that this can cause an error because by using a recursive call to
-            // AT_LEAST_ONE we change the grammar to AT_LEAST_TWO, AT_LEAST_THREE ... , the possible recursive call
-            // from the tryInRepetitionRecovery(...) will only happen IFF there really are TWO/THREE/.... items.
-            if (this.isErrorRecoveryEnabled) {
-                this.attemptInRepetitionRecovery(prodFunc, [lookAheadFunc, action, errMsg],
-                    <any>lookAheadFunc, prodName, prodOccurrence, interp.NextTerminalAfterAtLeastOneWalker, this.atLeastOneLookaheadKeys)
             }
         }
+        else {
+            throw this.SAVE_ERROR(new exceptions.EarlyExitException("expecting at least one: " + errMsg, this.NEXT_TOKEN()))
+        }
 
-        private atLeastOneSepFirstInternal(prodFunc:Function,
-                                           prodName:string,
-                                           prodOccurrence:number,
-                                           separator:TokenConstructor,
-                                           firstIterationLookAheadFunc:LookAheadFunc | GrammarAction,
-                                           action:GrammarAction | string,
-                                           errMsg?:string):Token[] {
-
-            let separatorsResult = []
-
-            if (utils.isString(action)) {
-                errMsg = <any>action
-                action = <any>firstIterationLookAheadFunc
-                firstIterationLookAheadFunc = this.getLookaheadFuncForAtLeastOneSep(prodOccurrence)
-            }
-
-            // 1st iteration
-            if (firstIterationLookAheadFunc.call(this)) {
-                (<GrammarAction>action).call(this)
+        // note that while it may seem that this can cause an error because by using a recursive call to
+        // AT_LEAST_ONE we change the grammar to AT_LEAST_TWO, AT_LEAST_THREE ... , the possible recursive call
+        // from the tryInRepetitionRecovery(...) will only happen IFF there really are TWO/THREE/.... items.
+        if (this.isErrorRecoveryEnabled) {
+            this.attemptInRepetitionRecovery(prodFunc, [lookAheadFunc, action, errMsg],
+                <any>lookAheadFunc, prodName, prodOccurrence, NextTerminalAfterAtLeastOneWalker, this.atLeastOneLookaheadKeys)
+        }
+    }
 
-                let separatorLookAheadFunc = () => {return this.NEXT_TOKEN() instanceof separator}
-                // 2nd..nth iterations
-                while (separatorLookAheadFunc()) {
-                    // note that this CONSUME will never enter recovery because
-                    // the separatorLookAheadFunc checks that the separator really does exist.
-                    separatorsResult.push(this.CONSUME(separator));
-                    (<GrammarAction>action).call(this)
-                }
+    private atLeastOneSepFirstInternal(prodFunc:Function,
+                                       prodName:string,
+                                       prodOccurrence:number,
+                                       separator:TokenConstructor,
+                                       firstIterationLookAheadFunc:LookAheadFunc | GrammarAction,
+                                       action:GrammarAction | string,
+                                       errMsg?:string):Token[] {
 
-                if (this.isErrorRecoveryEnabled) {
-                    this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal,
-                        [prodName, prodOccurrence, separator, separatorLookAheadFunc, action, separatorsResult,
-                            this.atLeastOneSepLookaheadKeys, interp.NextTerminalAfterAtLeastOneSepWalker],
-                        separatorLookAheadFunc,
-                        prodName,
-                        prodOccurrence,
-                        interp.NextTerminalAfterAtLeastOneSepWalker,
-                        this.atLeastOneSepLookaheadKeys)
-                }
-            }
-            else {
-                throw this.SAVE_ERROR(new exceptions.EarlyExitException("expecting at least one: " + errMsg, this.NEXT_TOKEN()))
-            }
+        let separatorsResult = []
 
-            return separatorsResult
+        if (isString(action)) {
+            errMsg = <any>action
+            action = <any>firstIterationLookAheadFunc
+            firstIterationLookAheadFunc = this.getLookaheadFuncForAtLeastOneSep(prodOccurrence)
         }
 
-        private manyInternal(prodFunc:Function,
-                             prodName:string,
-                             prodOccurrence:number,
-                             lookAheadFunc:LookAheadFunc | GrammarAction,
-                             action?:GrammarAction):void {
+        // 1st iteration
+        if (firstIterationLookAheadFunc.call(this)) {
+            (<GrammarAction>action).call(this)
 
-            if (action === undefined) {
-                action = <any>lookAheadFunc
-                lookAheadFunc = this.getLookaheadFuncForMany(prodOccurrence)
-            }
-
-            while (lookAheadFunc.call(this)) {
-                action.call(this)
+            let separatorLookAheadFunc = () => {return this.NEXT_TOKEN() instanceof separator}
+            // 2nd..nth iterations
+            while (separatorLookAheadFunc()) {
+                // note that this CONSUME will never enter recovery because
+                // the separatorLookAheadFunc checks that the separator really does exist.
+                separatorsResult.push(this.CONSUME(separator));
+                (<GrammarAction>action).call(this)
             }
 
             if (this.isErrorRecoveryEnabled) {
-                this.attemptInRepetitionRecovery(prodFunc,
-                    [lookAheadFunc, action],
-                    <any>lookAheadFunc
-                    , prodName,
+                this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal,
+                    [prodName, prodOccurrence, separator, separatorLookAheadFunc, action, separatorsResult,
+                        this.atLeastOneSepLookaheadKeys, NextTerminalAfterAtLeastOneSepWalker],
+                    separatorLookAheadFunc,
+                    prodName,
                     prodOccurrence,
-                    interp.NextTerminalAfterManyWalker,
-                    this.manyLookaheadKeys)
+                    NextTerminalAfterAtLeastOneSepWalker,
+                    this.atLeastOneSepLookaheadKeys)
             }
         }
+        else {
+            throw this.SAVE_ERROR(new exceptions.EarlyExitException("expecting at least one: " + errMsg, this.NEXT_TOKEN()))
+        }
 
-        private manySepFirstInternal(prodFunc:Function,
-                                     prodName:string,
-                                     prodOccurrence:number,
-                                     separator:TokenConstructor,
-                                     firstIterationLookAheadFunc:LookAheadFunc | GrammarAction,
-                                     action?:GrammarAction):Token[] {
+        return separatorsResult
+    }
 
-            let separatorsResult = []
+    private manyInternal(prodFunc:Function,
+                         prodName:string,
+                         prodOccurrence:number,
+                         lookAheadFunc:LookAheadFunc | GrammarAction,
+                         action?:GrammarAction):void {
 
-            if (action === undefined) {
-                action = <any>firstIterationLookAheadFunc
-                firstIterationLookAheadFunc = this.getLookaheadFuncForManySep(prodOccurrence)
-            }
+        if (action === undefined) {
+            action = <any>lookAheadFunc
+            lookAheadFunc = this.getLookaheadFuncForMany(prodOccurrence)
+        }
 
-            // 1st iteration
-            if (firstIterationLookAheadFunc.call(this)) {
-                action.call(this)
+        while (lookAheadFunc.call(this)) {
+            action.call(this)
+        }
 
-                let separatorLookAheadFunc = () => {return this.NEXT_TOKEN() instanceof separator}
-                // 2nd..nth iterations
-                while (separatorLookAheadFunc()) {
-                    // note that this CONSUME will never enter recovery because
-                    // the separatorLookAheadFunc checks that the separator really does exist.
-                    separatorsResult.push(this.CONSUME(separator))
-                    action.call(this)
-                }
+        if (this.isErrorRecoveryEnabled) {
+            this.attemptInRepetitionRecovery(prodFunc,
+                [lookAheadFunc, action],
+                <any>lookAheadFunc
+                , prodName,
+                prodOccurrence,
+                NextTerminalAfterManyWalker,
+                this.manyLookaheadKeys)
+        }
+    }
 
-                if (this.isErrorRecoveryEnabled) {
-                    this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal,
-                        [prodName, prodOccurrence, separator, separatorLookAheadFunc, action, separatorsResult,
-                            this.manySepLookaheadKeys, interp.NextTerminalAfterManySepWalker],
-                        separatorLookAheadFunc,
-                        prodName,
-                        prodOccurrence,
-                        interp.NextTerminalAfterManySepWalker,
-                        this.manySepLookaheadKeys)
-                }
-            }
+    private manySepFirstInternal(prodFunc:Function,
+                                 prodName:string,
+                                 prodOccurrence:number,
+                                 separator:TokenConstructor,
+                                 firstIterationLookAheadFunc:LookAheadFunc | GrammarAction,
+                                 action?:GrammarAction):Token[] {
 
-            return separatorsResult
-        }
+        let separatorsResult = []
 
-        private repetitionSepSecondInternal(prodName:string,
-                                            prodOccurrence:number,
-                                            separator:TokenConstructor,
-                                            separatorLookAheadFunc:() => boolean,
-                                            action:GrammarAction,
-                                            separatorsResult:Token[],
-                                            laKeys:lang.HashTable<string>[],
-                                            nextTerminalAfterWalker:typeof interp.AbstractNextTerminalAfterProductionWalker):void {
+        if (action === undefined) {
+            action = <any>firstIterationLookAheadFunc
+            firstIterationLookAheadFunc = this.getLookaheadFuncForManySep(prodOccurrence)
+        }
 
+        // 1st iteration
+        if (firstIterationLookAheadFunc.call(this)) {
+            action.call(this)
 
+            let separatorLookAheadFunc = () => {return this.NEXT_TOKEN() instanceof separator}
+            // 2nd..nth iterations
             while (separatorLookAheadFunc()) {
                 // note that this CONSUME will never enter recovery because
                 // the separatorLookAheadFunc checks that the separator really does exist.
@@ -1479,202 +1474,233 @@ namespace chevrotain {
                 action.call(this)
             }
 
-            // we can only arrive to this function after an error
-            // has occurred (hence the name 'second') so the following
-            // IF will always be entered, its possible to remove it...
-            // however it is kept to avoid confusion and be consistent.
-            /* istanbul ignore else */
             if (this.isErrorRecoveryEnabled) {
                 this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal,
-                    [prodName, prodOccurrence, separator, separatorLookAheadFunc,
-                        action, separatorsResult, laKeys, nextTerminalAfterWalker],
+                    [prodName, prodOccurrence, separator, separatorLookAheadFunc, action, separatorsResult,
+                        this.manySepLookaheadKeys, NextTerminalAfterManySepWalker],
                     separatorLookAheadFunc,
                     prodName,
                     prodOccurrence,
-                    nextTerminalAfterWalker,
-                    laKeys)
+                    NextTerminalAfterManySepWalker,
+                    this.manySepLookaheadKeys)
             }
         }
 
-        private orInternal<T>(alts:IOrAlt<T>[] | IOrAltImplicit<T>[],
-                              errMsgTypes:string,
-                              occurrence:number,
-                              ignoreAmbiguities:boolean):T {
-            // explicit alternatives look ahead
-            if ((<any>alts[0]).WHEN !== undefined) {
-                for (let i = 0; i < alts.length; i++) {
-                    if ((<any>alts[i]).WHEN.call(this)) {
-                        let res = (<any>alts[i]).THEN_DO()
-                        return res
-                    }
-                }
-                this.raiseNoAltException(occurrence, errMsgTypes)
-            }
-
-            // else implicit lookahead
-            let laFunc = this.getLookaheadFuncForOr(occurrence, ignoreAmbiguities)
-            let altToTake = laFunc.call(this)
-            if (altToTake !== -1) {
-                return (<any>alts[altToTake]).ALT.call(this)
-            }
+        return separatorsResult
+    }
 
-            this.raiseNoAltException(occurrence, errMsgTypes)
+    private repetitionSepSecondInternal(prodName:string,
+                                        prodOccurrence:number,
+                                        separator:TokenConstructor,
+                                        separatorLookAheadFunc:() => boolean,
+                                        action:GrammarAction,
+                                        separatorsResult:Token[],
+                                        laKeys:HashTable<string>[],
+                                        nextTerminalAfterWalker:typeof AbstractNextTerminalAfterProductionWalker):void {
+
+
+        while (separatorLookAheadFunc()) {
+            // note that this CONSUME will never enter recovery because
+            // the separatorLookAheadFunc checks that the separator really does exist.
+            separatorsResult.push(this.CONSUME(separator))
+            action.call(this)
+        }
+
+        // we can only arrive to this function after an error
+        // has occurred (hence the name 'second') so the following
+        // IF will always be entered, its possible to remove it...
+        // however it is kept to avoid confusion and be consistent.
+        /* istanbul ignore else */
+        if (this.isErrorRecoveryEnabled) {
+            this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal,
+                [prodName, prodOccurrence, separator, separatorLookAheadFunc,
+                    action, separatorsResult, laKeys, nextTerminalAfterWalker],
+                separatorLookAheadFunc,
+                prodName,
+                prodOccurrence,
+                nextTerminalAfterWalker,
+                laKeys)
         }
+    }
 
-        /**
-         * @param tokClass The Type of Token we wish to consume (Reference to its constructor function)
-         * @param idx occurrence index of consumed token in the invoking parser rule text
-         *         for example:
-         *         IDENT (DOT IDENT)*
-         *         the first ident will have idx 1 and the second one idx 2
-         *         * note that for the second ident the idx is always 2 even if its invoked 30 times in the same rule
-         *           the idx is about the position in grammar (source code) and has nothing to do with a specific invocation
-         *           details
-         *
-         * @returns the consumed Token
-         */
-        private consumeInternal(tokClass:Function, idx:number):Token {
-            try {
-                return this.consumeInternalOptimized(tokClass)
-            } catch (eFromConsumption) {
-                // no recovery allowed during backtracking, otherwise backtracking may recover invalid syntax and accept it
-                // but the original syntax could have been parsed successfully without any backtracking + recovery
-                if (this.isErrorRecoveryEnabled &&
-                    eFromConsumption instanceof exceptions.MismatchedTokenException && !this.isBackTracking()) {
-
-                    let follows = this.getFollowsForInRuleRecovery(tokClass, idx)
-                    try {
-                        return this.tryInRuleRecovery(tokClass, follows)
-                    } catch (eFromInRuleRecovery) {
-                        /* istanbul ignore next */ // TODO: try removing this istanbul ignore with tsc 1.5.
-                        // it is only needed for the else branch but in tsc 1.4.1 comments
-                        // between if and else seem to get swallowed and disappear.
-                        if (eFromConsumption instanceof InRuleRecoveryException) {
-                            // throw the original error in order to trigger reSync error recovery
-                            throw eFromConsumption
-                        }
-                        // this is not part of the contract, just a workaround javascript weak error handling
-                        // for a test to reach this code one would have to extend the BaseErrorRecoveryParser
-                        // and override some of the recovery code to be faulty (example: throw undefined is not a function error)
-                        // this is not a useful use case that needs to be tested...
-                        /* istanbul ignore next */
-                        else {
-                            // some other error Type (built in JS error) this needs to be rethrown, we don't want to swallow it
-                            throw eFromInRuleRecovery
-                        }
-                    }
-                }
-                else {
-                    throw eFromConsumption
+    private orInternal<T>(alts:IOrAlt<T>[] | IOrAltImplicit<T>[],
+                          errMsgTypes:string,
+                          occurrence:number,
+                          ignoreAmbiguities:boolean):T {
+        // explicit alternatives look ahead
+        if ((<any>alts[0]).WHEN !== undefined) {
+            for (let i = 0; i < alts.length; i++) {
+                if ((<any>alts[i]).WHEN.call(this)) {
+                    let res = (<any>alts[i]).THEN_DO()
+                    return res
                 }
             }
+            this.raiseNoAltException(occurrence, errMsgTypes)
+        }
+
+        // else implicit lookahead
+        let laFunc = this.getLookaheadFuncForOr(occurrence, ignoreAmbiguities)
+        let altToTake = laFunc.call(this)
+        if (altToTake !== -1) {
+            return (<any>alts[altToTake]).ALT.call(this)
         }
 
-        // to enable optimizations this logic has been extract to a method as its invoker contains try/catch
-        private consumeInternalOptimized(tokClass:Function):Token {
-            let nextToken = this.NEXT_TOKEN()
-            if (this.NEXT_TOKEN() instanceof tokClass) {
-                this.inputIdx++
-                return nextToken
+        this.raiseNoAltException(occurrence, errMsgTypes)
+    }
+
+    /**
+     * @param tokClass The Type of Token we wish to consume (Reference to its constructor function)
+     * @param idx occurrence index of consumed token in the invoking parser rule text
+     *         for example:
+     *         IDENT (DOT IDENT)*
+     *         the first ident will have idx 1 and the second one idx 2
+     *         * note that for the second ident the idx is always 2 even if its invoked 30 times in the same rule
+     *           the idx is about the position in grammar (source code) and has nothing to do with a specific invocation
+     *           details
+     *
+     * @returns the consumed Token
+     */
+    private consumeInternal(tokClass:Function, idx:number):Token {
+        try {
+            return this.consumeInternalOptimized(tokClass)
+        } catch (eFromConsumption) {
+            // no recovery allowed during backtracking, otherwise backtracking may recover invalid syntax and accept it
+            // but the original syntax could have been parsed successfully without any backtracking + recovery
+            if (this.isErrorRecoveryEnabled &&
+                eFromConsumption instanceof exceptions.MismatchedTokenException && !this.isBackTracking()) {
+
+                let follows = this.getFollowsForInRuleRecovery(tokClass, idx)
+                try {
+                    return this.tryInRuleRecovery(tokClass, follows)
+                } catch (eFromInRuleRecovery) {
+                    /* istanbul ignore next */ // TODO: try removing this istanbul ignore with tsc 1.5.
+                    // it is only needed for the else branch but in tsc 1.4.1 comments
+                    // between if and else seem to get swallowed and disappear.
+                    if (eFromConsumption instanceof InRuleRecoveryException) {
+                        // throw the original error in order to trigger reSync error recovery
+                        throw eFromConsumption
+                    }
+                    // this is not part of the contract, just a workaround javascript weak error handling
+                    // for a test to reach this code one would have to extend the BaseErrorRecoveryParser
+                    // and override some of the recovery code to be faulty (example: throw undefined is not a function error)
+                    // this is not a useful use case that needs to be tested...
+                    /* istanbul ignore next */
+                    else {
+                        // some other error Type (built in JS error) this needs to be rethrown, we don't want to swallow it
+                        throw eFromInRuleRecovery
+                    }
+                }
             }
             else {
-                let expectedTokType = tokenName(tokClass)
-                let msg = "Expecting token of type -->" + expectedTokType + "<-- but found -->'" + nextToken.image + "'<--"
-                throw this.SAVE_ERROR(new exceptions.MismatchedTokenException(msg, nextToken))
+                throw eFromConsumption
             }
         }
+    }
 
-        private getKeyForAutomaticLookahead(prodName:string, prodKeys:lang.HashTable<string>[], occurrence:number):string {
-            let occuMap = prodKeys[occurrence - 1]
-            let currRule = utils.last(this.RULE_STACK)
-            let key = occuMap[currRule]
-            if (key === undefined) {
-                key = prodName + occurrence + IN + currRule
-                occuMap[currRule] = key
-            }
-            return key
+    // to enable optimizations this logic has been extract to a method as its invoker contains try/catch
+    private consumeInternalOptimized(tokClass:Function):Token {
+        let nextToken = this.NEXT_TOKEN()
+        if (this.NEXT_TOKEN() instanceof tokClass) {
+            this.inputIdx++
+            return nextToken
         }
-
-        // Automatic lookahead calculation
-        private getLookaheadFuncForOption(occurence:number):() => boolean {
-            let key = this.getKeyForAutomaticLookahead("OPTION", this.optionLookaheadKeys, occurence)
-            return this.getLookaheadFuncFor(key, occurence, lookahead.buildLookaheadForOption)
+        else {
+            let expectedTokType = tokenName(tokClass)
+            let msg = "Expecting token of type -->" + expectedTokType + "<-- but found -->'" + nextToken.image + "'<--"
+            throw this.SAVE_ERROR(new exceptions.MismatchedTokenException(msg, nextToken))
         }
+    }
 
-        private getLookaheadFuncForOr(occurence:number, ignoreErrors:boolean):() => number {
-            let key = this.getKeyForAutomaticLookahead("OR", this.orLookaheadKeys, occurence)
-            return this.getLookaheadFuncFor(key, occurence, lookahead.buildLookaheadForOr, [ignoreErrors])
+    private getKeyForAutomaticLookahead(prodName:string, prodKeys:HashTable<string>[], occurrence:number):string {
+        let occuMap = prodKeys[occurrence - 1]
+        let currRule = last(this.RULE_STACK)
+        let key = occuMap[currRule]
+        if (key === undefined) {
+            key = prodName + occurrence + IN + currRule
+            occuMap[currRule] = key
         }
+        return key
+    }
 
-        private getLookaheadFuncForMany(occurence:number):() => boolean {
-            let key = this.getKeyForAutomaticLookahead("MANY", this.manyLookaheadKeys, occurence)
-            return this.getLookaheadFuncFor(key, occurence, lookahead.buildLookaheadForMany)
-        }
+    // Automatic lookahead calculation
+    private getLookaheadFuncForOption(occurence:number):() => boolean {
+        let key = this.getKeyForAutomaticLookahead("OPTION", this.optionLookaheadKeys, occurence)
+        return this.getLookaheadFuncFor(key, occurence, buildLookaheadForOption)
+    }
 
-        private getLookaheadFuncForManySep(occurence:number):() => boolean {
-            let key = this.getKeyForAutomaticLookahead("MANY_SEP", this.manySepLookaheadKeys, occurence)
-            return this.getLookaheadFuncFor(key, occurence, lookahead.buildLookaheadForManySep)
-        }
+    private getLookaheadFuncForOr(occurence:number, ignoreErrors:boolean):() => number {
+        let key = this.getKeyForAutomaticLookahead("OR", this.orLookaheadKeys, occurence)
+        return this.getLookaheadFuncFor(key, occurence, buildLookaheadForOr, [ignoreErrors])
+    }
 
-        private getLookaheadFuncForAtLeastOne(occurence:number):() => boolean {
-            let key = this.getKeyForAutomaticLookahead("AT_LEAST_ONE", this.atLeastOneLookaheadKeys, occurence)
-            return this.getLookaheadFuncFor(key, occurence, lookahead.buildLookaheadForAtLeastOne)
-        }
+    private getLookaheadFuncForMany(occurence:number):() => boolean {
+        let key = this.getKeyForAutomaticLookahead("MANY", this.manyLookaheadKeys, occurence)
+        return this.getLookaheadFuncFor(key, occurence, buildLookaheadForMany)
+    }
 
-        private getLookaheadFuncForAtLeastOneSep(occurence:number):() => boolean {
-            let key = this.getKeyForAutomaticLookahead("AT_LEAST_ONE_SEP", this.atLeastOneSepLookaheadKeys, occurence)
-            return this.getLookaheadFuncFor(key, occurence, lookahead.buildLookaheadForAtLeastOneSep)
-        }
+    private getLookaheadFuncForManySep(occurence:number):() => boolean {
+        let key = this.getKeyForAutomaticLookahead("MANY_SEP", this.manySepLookaheadKeys, occurence)
+        return this.getLookaheadFuncFor(key, occurence, buildLookaheadForManySep)
+    }
 
-        private getLookaheadFuncFor<T>(key:string,
-                                       occurrence:number,
-                                       laFuncBuilder:(number, any) => () => T,
-                                       extraArgs:any[] = []):() => T {
-            let ruleName = utils.last(this.RULE_STACK)
-            let condition = <any>this.classLAFuncs.get(key)
-            if (condition === undefined) {
-                let ruleGrammar = this.getGAstProductions().get(ruleName)
-                condition = laFuncBuilder.apply(null, [occurrence, ruleGrammar].concat(extraArgs))
-                this.classLAFuncs.put(key, condition)
-            }
-            return condition
-        }
+    private getLookaheadFuncForAtLeastOne(occurence:number):() => boolean {
+        let key = this.getKeyForAutomaticLookahead("AT_LEAST_ONE", this.atLeastOneLookaheadKeys, occurence)
+        return this.getLookaheadFuncFor(key, occurence, buildLookaheadForAtLeastOne)
+    }
 
-        // other functionality
-        private saveRecogState():IParserState {
-            let savedErrors = utils.cloneArr(this.errors)
-            let savedRuleStack = utils.cloneArr(this.RULE_STACK)
-            return {
-                errors:     savedErrors,
-                inputIdx:   this.inputIdx,
-                RULE_STACK: savedRuleStack
-            }
-        }
+    private getLookaheadFuncForAtLeastOneSep(occurence:number):() => boolean {
+        let key = this.getKeyForAutomaticLookahead("AT_LEAST_ONE_SEP", this.atLeastOneSepLookaheadKeys, occurence)
+        return this.getLookaheadFuncFor(key, occurence, buildLookaheadForAtLeastOneSep)
+    }
 
-        private reloadRecogState(newState:IParserState) {
-            this.errors = newState.errors
-            this.inputIdx = newState.inputIdx
-            this.RULE_STACK = newState.RULE_STACK
-        }
+    private getLookaheadFuncFor<T>(key:string,
+                                   occurrence:number,
+                                   laFuncBuilder:(number, any) => () => T,
+                                   extraArgs:any[] = []):() => T {
+        let ruleName = last(this.RULE_STACK)
+        let condition = <any>this.classLAFuncs.get(key)
+        if (condition === undefined) {
+            let ruleGrammar = this.getGAstProductions().get(ruleName)
+            condition = laFuncBuilder.apply(null, [occurrence, ruleGrammar].concat(extraArgs))
+            this.classLAFuncs.put(key, condition)
+        }
+        return condition
+    }
 
-        private raiseNoAltException(occurrence:number, errMsgTypes:string):void {
-            let errSuffix = " but found: '" + this.NEXT_TOKEN().image + "'"
-            if (errMsgTypes === undefined) {
-                let ruleName = utils.last(this.RULE_STACK)
-                let ruleGrammar = this.getGAstProductions().get(ruleName)
-                let nextTokens = new interp.NextInsideOrWalker(ruleGrammar, occurrence).startWalking()
-                let nextTokensFlat = utils.flatten(nextTokens)
-                let nextTokensNames = utils.map(nextTokensFlat, (currTokenClass:Function) => tokenName(currTokenClass))
-                errMsgTypes = `one of: <${nextTokensNames.join(" ,")}>`
-            }
-            throw this.SAVE_ERROR(new exceptions.NoViableAltException(`expecting: ${errMsgTypes} ${errSuffix}`, this.NEXT_TOKEN()))
+    // other functionality
+    private saveRecogState():IParserState {
+        let savedErrors = cloneArr(this.errors)
+        let savedRuleStack = cloneArr(this.RULE_STACK)
+        return {
+            errors:     savedErrors,
+            inputIdx:   this.inputIdx,
+            RULE_STACK: savedRuleStack
         }
     }
 
-    function InRuleRecoveryException(message:string) {
-        this.name = lang.functionName(InRuleRecoveryException)
-        this.message = message
+    private reloadRecogState(newState:IParserState) {
+        this.errors = newState.errors
+        this.inputIdx = newState.inputIdx
+        this.RULE_STACK = newState.RULE_STACK
     }
 
-    InRuleRecoveryException.prototype = Error.prototype
+    private raiseNoAltException(occurrence:number, errMsgTypes:string):void {
+        let errSuffix = " but found: '" + this.NEXT_TOKEN().image + "'"
+        if (errMsgTypes === undefined) {
+            let ruleName = last(this.RULE_STACK)
+            let ruleGrammar = this.getGAstProductions().get(ruleName)
+            let nextTokens = new NextInsideOrWalker(ruleGrammar, occurrence).startWalking()
+            let nextTokensFlat = flatten(nextTokens)
+            let nextTokensNames = map(nextTokensFlat, (currTokenClass:Function) => tokenName(currTokenClass))
+            errMsgTypes = `one of: <${nextTokensNames.join(" ,")}>`
+        }
+        throw this.SAVE_ERROR(new exceptions.NoViableAltException(`expecting: ${errMsgTypes} ${errSuffix}`, this.NEXT_TOKEN()))
+    }
 }
+
+function InRuleRecoveryException(message:string) {
+    this.name = functionName(InRuleRecoveryException)
+    this.message = message
+}
+
+InRuleRecoveryException.prototype = Error.prototype
diff --git a/src/scan/lexer.ts b/src/scan/lexer.ts
index b0d9fd55e..c11bd270b 100644
--- a/src/scan/lexer.ts
+++ b/src/scan/lexer.ts
@@ -1,271 +1,282 @@
-// using only root namespace name ('chevrotain') and not a longer name ('chevrotain.lexer')
-// because the external and internal API must have the same names for d.ts definition files to be valid
-namespace chevrotain {
-
-    import lang = chevrotain.lang
-
-    let PATTERN = "PATTERN"
+import {Token, tokenName} from "./tokens_public"
+import {TokenConstructor, ILexerDefinitionError, LexerDefinitionErrorType, Lexer} from "./lexer_public"
+import {
+    reject,
+    indexOf,
+    map,
+    zipObject,
+    isString,
+    isUndefined,
+    reduce,
+    has,
+    filter,
+    difference,
+    isRegExp,
+    compact,
+    contains,
+    first
+} from "../utils/utils"
+
+let PATTERN = "PATTERN"
+
+export interface IAnalyzeResult {
+    allPatterns: RegExp[]
+    patternIdxToClass: Function[]
+    patternIdxToGroup : any[]
+    patternIdxToLongerAltIdx : number[]
+    patternIdxToCanLineTerminator: boolean[]
+    emptyGroups: { [groupName: string] : Token }
+}
 
-    export interface IAnalyzeResult {
-        allPatterns: RegExp[]
-        patternIdxToClass: Function[]
-        patternIdxToGroup : any[]
-        patternIdxToLongerAltIdx : number[]
-        patternIdxToCanLineTerminator: boolean[]
-        emptyGroups: { [groupName: string] : Token }
-    }
+export function analyzeTokenClasses(tokenClasses:TokenConstructor[]):IAnalyzeResult {
 
-    export function analyzeTokenClasses(tokenClasses:TokenConstructor[]):IAnalyzeResult {
+    let onlyRelevantClasses = reject(tokenClasses, (currClass) => {
+        return currClass[PATTERN] === Lexer.NA
+    })
 
-        let onlyRelevantClasses = utils.reject(tokenClasses, (currClass) => {
-            return currClass[PATTERN] === Lexer.NA
-        })
+    let allTransformedPatterns = map(onlyRelevantClasses, (currClass) => {
+        return addStartOfInput(currClass[PATTERN])
+    })
 
-        let allTransformedPatterns = utils.map(onlyRelevantClasses, (currClass) => {
-            return addStartOfInput(currClass[PATTERN])
-        })
+    let allPatternsToClass = zipObject(<any>allTransformedPatterns, onlyRelevantClasses)
 
-        let allPatternsToClass = utils.zipObject(<any>allTransformedPatterns, onlyRelevantClasses)
+    let patternIdxToClass:any = map(allTransformedPatterns, (pattern) => {
+        return allPatternsToClass[pattern.toString()]
+    })
 
-        let patternIdxToClass:any = utils.map(allTransformedPatterns, (pattern) => {
-            return allPatternsToClass[pattern.toString()]
-        })
-
-        let patternIdxToGroup = utils.map(onlyRelevantClasses, (clazz:any) => {
-            let groupName = clazz.GROUP
-            if (groupName === Lexer.SKIPPED) {
-                return undefined
-            }
-            else if (utils.isString(groupName)) {
-                return groupName
-            }
-            else if (utils.isUndefined(groupName)) {
-                return "default"
-            }
-            else {
-                throw Error("non exhaustive match")
-            }
-        })
-
-        let patternIdxToLongerAltIdx:any = utils.map(onlyRelevantClasses, (clazz:any) => {
-            let longerAltClass = clazz.LONGER_ALT
+    let patternIdxToGroup = map(onlyRelevantClasses, (clazz:any) => {
+        let groupName = clazz.GROUP
+        if (groupName === Lexer.SKIPPED) {
+            return undefined
+        }
+        else if (isString(groupName)) {
+            return groupName
+        }
+        else if (isUndefined(groupName)) {
+            return "default"
+        }
+        else {
+            throw Error("non exhaustive match")
+        }
+    })
 
-            if (longerAltClass) {
-                let longerAltIdx = utils.indexOf(onlyRelevantClasses, longerAltClass)
-                return longerAltIdx
-            }
-        })
+    let patternIdxToLongerAltIdx:any = map(onlyRelevantClasses, (clazz:any) => {
+        let longerAltClass = clazz.LONGER_ALT
 
-        let patternIdxToCanLineTerminator = utils.map(allTransformedPatterns, (pattern:RegExp) => {
-            // TODO: unicode escapes of line terminators too?
-            return /\\n|\\r|\\s/g.test(pattern.source)
-        })
+        if (longerAltClass) {
+            let longerAltIdx = indexOf(onlyRelevantClasses, longerAltClass)
+            return longerAltIdx
+        }
+    })
 
-        let emptyGroups = utils.reduce(onlyRelevantClasses, (acc, clazz:any) => {
-            let groupName = clazz.GROUP
-            if (utils.isString(groupName)) {
-                acc[groupName] = []
-            }
-            return acc
-        }, {})
+    let patternIdxToCanLineTerminator = map(allTransformedPatterns, (pattern:RegExp) => {
+        // TODO: unicode escapes of line terminators too?
+        return /\\n|\\r|\\s/g.test(pattern.source)
+    })
 
-        return {
-            allPatterns:                   allTransformedPatterns,
-            patternIdxToClass:             patternIdxToClass,
-            patternIdxToGroup:             patternIdxToGroup,
-            patternIdxToLongerAltIdx:      patternIdxToLongerAltIdx,
-            patternIdxToCanLineTerminator: patternIdxToCanLineTerminator,
-            emptyGroups:                   emptyGroups
+    let emptyGroups = reduce(onlyRelevantClasses, (acc, clazz:any) => {
+        let groupName = clazz.GROUP
+        if (isString(groupName)) {
+            acc[groupName] = []
         }
+        return acc
+    }, {})
+
+    return {
+        allPatterns:                   allTransformedPatterns,
+        patternIdxToClass:             patternIdxToClass,
+        patternIdxToGroup:             patternIdxToGroup,
+        patternIdxToLongerAltIdx:      patternIdxToLongerAltIdx,
+        patternIdxToCanLineTerminator: patternIdxToCanLineTerminator,
+        emptyGroups:                   emptyGroups
     }
+}
 
-    export function validatePatterns(tokenClasses:TokenConstructor[]):ILexerDefinitionError[] {
-        let errors = []
+export function validatePatterns(tokenClasses:TokenConstructor[]):ILexerDefinitionError[] {
+    let errors = []
 
-        let missingResult = findMissingPatterns(tokenClasses)
-        let validTokenClasses = missingResult.validTokenClasses
-        errors = errors.concat(missingResult.errors)
+    let missingResult = findMissingPatterns(tokenClasses)
+    let validTokenClasses = missingResult.validTokenClasses
+    errors = errors.concat(missingResult.errors)
 
-        let invalidResult = findInvalidPatterns(validTokenClasses)
-        validTokenClasses = invalidResult.validTokenClasses
-        errors = errors.concat(invalidResult.errors)
+    let invalidResult = findInvalidPatterns(validTokenClasses)
+    validTokenClasses = invalidResult.validTokenClasses
+    errors = errors.concat(invalidResult.errors)
 
-        errors = errors.concat(findEndOfInputAnchor(validTokenClasses))
+    errors = errors.concat(findEndOfInputAnchor(validTokenClasses))
 
-        errors = errors.concat(findUnsupportedFlags(validTokenClasses))
+    errors = errors.concat(findUnsupportedFlags(validTokenClasses))
 
-        errors = errors.concat(findDuplicatePatterns(validTokenClasses))
+    errors = errors.concat(findDuplicatePatterns(validTokenClasses))
 
-        errors = errors.concat(findInvalidGroupType(validTokenClasses))
+    errors = errors.concat(findInvalidGroupType(validTokenClasses))
 
-        return errors
-    }
+    return errors
+}
 
-    export function findMissingPatterns(tokenClasses:TokenConstructor[]) {
-        let tokenClassesWithMissingPattern = utils.filter(tokenClasses, (currClass) => {
-            return !utils.has(currClass, PATTERN)
-        })
+export function findMissingPatterns(tokenClasses:TokenConstructor[]) {
+    let tokenClassesWithMissingPattern = filter(tokenClasses, (currClass) => {
+        return !has(currClass, PATTERN)
+    })
 
-        let errors = utils.map(tokenClassesWithMissingPattern, (currClass) => {
-            return {
-                message:      "Token class: ->" + tokenName(currClass) + "<- missing static 'PATTERN' property",
-                type:         LexerDefinitionErrorType.MISSING_PATTERN,
-                tokenClasses: [currClass]
-            }
-        })
+    let errors = map(tokenClassesWithMissingPattern, (currClass) => {
+        return {
+            message:      "Token class: ->" + tokenName(currClass) + "<- missing static 'PATTERN' property",
+            type:         LexerDefinitionErrorType.MISSING_PATTERN,
+            tokenClasses: [currClass]
+        }
+    })
 
-        let validTokenClasses = utils.difference(tokenClasses, tokenClassesWithMissingPattern)
-        return {errors: errors, validTokenClasses}
-    }
+    let validTokenClasses = difference(tokenClasses, tokenClassesWithMissingPattern)
+    return {errors: errors, validTokenClasses}
+}
 
-    export function findInvalidPatterns(tokenClasses:TokenConstructor[]) {
-        let tokenClassesWithInvalidPattern = utils.filter(tokenClasses, (currClass) => {
-            let pattern = currClass[PATTERN]
-            return !utils.isRegExp(pattern)
-        })
+export function findInvalidPatterns(tokenClasses:TokenConstructor[]) {
+    let tokenClassesWithInvalidPattern = filter(tokenClasses, (currClass) => {
+        let pattern = currClass[PATTERN]
+        return !isRegExp(pattern)
+    })
 
-        let errors = utils.map(tokenClassesWithInvalidPattern, (currClass) => {
-            return {
-                message:      "Token class: ->" + tokenName(currClass) + "<- static 'PATTERN' can only be a RegExp",
-                type:         LexerDefinitionErrorType.INVALID_PATTERN,
-                tokenClasses: [currClass]
-            }
-        })
+    let errors = map(tokenClassesWithInvalidPattern, (currClass) => {
+        return {
+            message:      "Token class: ->" + tokenName(currClass) + "<- static 'PATTERN' can only be a RegExp",
+            type:         LexerDefinitionErrorType.INVALID_PATTERN,
+            tokenClasses: [currClass]
+        }
+    })
 
-        let validTokenClasses = utils.difference(tokenClasses, tokenClassesWithInvalidPattern)
-        return {errors: errors, validTokenClasses}
-    }
+    let validTokenClasses = difference(tokenClasses, tokenClassesWithInvalidPattern)
+    return {errors: errors, validTokenClasses}
+}
 
-    let end_of_input = /[^\\][\$]/
+let end_of_input = /[^\\][\$]/
 
-    export function findEndOfInputAnchor(tokenClasses:TokenConstructor[]):ILexerDefinitionError[] {
-        let invalidRegex = utils.filter(tokenClasses, (currClass) => {
-            let pattern = currClass[PATTERN]
-            return end_of_input.test(pattern.source)
-        })
+export function findEndOfInputAnchor(tokenClasses:TokenConstructor[]):ILexerDefinitionError[] {
+    let invalidRegex = filter(tokenClasses, (currClass) => {
+        let pattern = currClass[PATTERN]
+        return end_of_input.test(pattern.source)
+    })
 
-        let errors = utils.map(invalidRegex, (currClass) => {
-            return {
-                message:      "Token class: ->" + tokenName(currClass) + "<- static 'PATTERN' cannot contain end of input anchor '$'",
-                type:         LexerDefinitionErrorType.EOI_ANCHOR_FOUND,
-                tokenClasses: [currClass]
-            }
-        })
+    let errors = map(invalidRegex, (currClass) => {
+        return {
+            message:      "Token class: ->" + tokenName(currClass) + "<- static 'PATTERN' cannot contain end of input anchor '$'",
+            type:         LexerDefinitionErrorType.EOI_ANCHOR_FOUND,
+            tokenClasses: [currClass]
+        }
+    })
 
-        return errors
-    }
+    return errors
+}
 
-    export function findUnsupportedFlags(tokenClasses:TokenConstructor[]):ILexerDefinitionError[] {
-        let invalidFlags = utils.filter(tokenClasses, (currClass) => {
-            let pattern = currClass[PATTERN]
-            return pattern instanceof RegExp && (pattern.multiline || pattern.global)
-        })
+export function findUnsupportedFlags(tokenClasses:TokenConstructor[]):ILexerDefinitionError[] {
+    let invalidFlags = filter(tokenClasses, (currClass) => {
+        let pattern = currClass[PATTERN]
+        return pattern instanceof RegExp && (pattern.multiline || pattern.global)
+    })
 
-        let errors = utils.map(invalidFlags, (currClass) => {
-            return {
-                message:      "Token class: ->" + tokenName(currClass) +
-                              "<- static 'PATTERN' may NOT contain global('g') or multiline('m')",
-                type:         LexerDefinitionErrorType.UNSUPPORTED_FLAGS_FOUND,
-                tokenClasses: [currClass]
-            }
-        })
+    let errors = map(invalidFlags, (currClass) => {
+        return {
+            message:      "Token class: ->" + tokenName(currClass) +
+                          "<- static 'PATTERN' may NOT contain global('g') or multiline('m')",
+            type:         LexerDefinitionErrorType.UNSUPPORTED_FLAGS_FOUND,
+            tokenClasses: [currClass]
+        }
+    })
 
-        return errors
-    }
+    return errors
+}
 
-    // This can only test for identical duplicate RegExps, not semantically equivalent ones.
-    export function findDuplicatePatterns(tokenClasses:TokenConstructor[]):ILexerDefinitionError[] {
-
-        let found = []
-        let identicalPatterns = utils.map(tokenClasses, (outerClass:any) => {
-            return utils.reduce(tokenClasses, (result, innerClass:any) => {
-                if ((outerClass.PATTERN.source === innerClass.PATTERN.source) &&
-                    !utils.contains(found, innerClass) &&
-                    innerClass.PATTERN !== Lexer.NA) {
-                    // this avoids duplicates in the result, each class may only appear in one "set"
-                    // in essence we are creating Equivalence classes on equality relation.
-                    found.push(innerClass)
-                    result.push(innerClass)
-                    return result
-                }
+// This can only test for identical duplicate RegExps, not semantically equivalent ones.
+export function findDuplicatePatterns(tokenClasses:TokenConstructor[]):ILexerDefinitionError[] {
+
+    let found = []
+    let identicalPatterns = map(tokenClasses, (outerClass:any) => {
+        return reduce(tokenClasses, (result, innerClass:any) => {
+            if ((outerClass.PATTERN.source === innerClass.PATTERN.source) && !contains(found, innerClass) &&
+                innerClass.PATTERN !== Lexer.NA) {
+                // this avoids duplicates in the result, each class may only appear in one "set"
+                // in essence we are creating Equivalence classes on equality relation.
+                found.push(innerClass)
+                result.push(innerClass)
                 return result
-            }, [])
-        })
+            }
+            return result
+        }, [])
+    })
 
-        identicalPatterns = utils.compact(identicalPatterns)
+    identicalPatterns = compact(identicalPatterns)
 
-        let duplicatePatterns = utils.filter(identicalPatterns, (currIdenticalSet) => {
-            return currIdenticalSet.length > 1
-        })
+    let duplicatePatterns = filter(identicalPatterns, (currIdenticalSet) => {
+        return currIdenticalSet.length > 1
+    })
 
-        let errors = utils.map(duplicatePatterns, (setOfIdentical:any) => {
-            let classNames = utils.map(setOfIdentical, (currClass:any) => {
-                return tokenName(currClass)
-            })
-
-            let dupPatternSrc = (<any>utils.first(setOfIdentical)).PATTERN
-            return {
-                message:      `The same RegExp pattern ->${dupPatternSrc}<-` +
-                              `has been used in all the following classes: ${classNames.join(", ")} <-`,
-                type:         LexerDefinitionErrorType.DUPLICATE_PATTERNS_FOUND,
-                tokenClasses: setOfIdentical
-            }
+    let errors = map(duplicatePatterns, (setOfIdentical:any) => {
+        let classNames = map(setOfIdentical, (currClass:any) => {
+            return tokenName(currClass)
         })
 
-        return errors
-    }
+        let dupPatternSrc = (<any>first(setOfIdentical)).PATTERN
+        return {
+            message:      `The same RegExp pattern ->${dupPatternSrc}<-` +
+                          `has been used in all the following classes: ${classNames.join(", ")} <-`,
+            type:         LexerDefinitionErrorType.DUPLICATE_PATTERNS_FOUND,
+            tokenClasses: setOfIdentical
+        }
+    })
 
-    export function findInvalidGroupType(tokenClasses:TokenConstructor[]):ILexerDefinitionError[] {
-        let invalidTypes = utils.filter(tokenClasses, (clazz:any) => {
-            if (!utils.has(clazz, "GROUP")) {
-                return false
-            }
-            let group = clazz.GROUP
+    return errors
+}
 
-            return group !== Lexer.SKIPPED &&
-                group !== Lexer.NA && !utils.isString(group)
-        })
+export function findInvalidGroupType(tokenClasses:TokenConstructor[]):ILexerDefinitionError[] {
+    let invalidTypes = filter(tokenClasses, (clazz:any) => {
+        if (!has(clazz, "GROUP")) {
+            return false
+        }
+        let group = clazz.GROUP
 
-        let errors = utils.map(invalidTypes, (currClass) => {
-            return {
-                message:      "Token class: ->" + tokenName(currClass) + "<- static 'GROUP' can only be Lexer.SKIPPED/Lexer.NA/A String",
-                type:         LexerDefinitionErrorType.INVALID_GROUP_TYPE_FOUND,
-                tokenClasses: [currClass]
-            }
-        })
+        return group !== Lexer.SKIPPED &&
+            group !== Lexer.NA && !isString(group)
+    })
 
-        return errors
-    }
+    let errors = map(invalidTypes, (currClass) => {
+        return {
+            message:      "Token class: ->" + tokenName(currClass) + "<- static 'GROUP' can only be Lexer.SKIPPED/Lexer.NA/A String",
+            type:         LexerDefinitionErrorType.INVALID_GROUP_TYPE_FOUND,
+            tokenClasses: [currClass]
+        }
+    })
 
-    export function addStartOfInput(pattern:RegExp):RegExp {
-        let flags = pattern.ignoreCase ? "i" : ""
-        // always wrapping in a none capturing group preceded by '^' to make sure matching can only work on start of input.
-        // duplicate/redundant start of input markers have no meaning (/^^^^A/ === /^A/)
-        return new RegExp(`^(?:${pattern.source})`, flags)
-    }
+    return errors
+}
 
-    export function countLineTerminators(text:string):number {
-        let lineTerminators = 0
-        let currOffset = 0
+export function addStartOfInput(pattern:RegExp):RegExp {
+    let flags = pattern.ignoreCase ? "i" : ""
+    // always wrapping in a none capturing group preceded by '^' to make sure matching can only work on start of input.
+    // duplicate/redundant start of input markers have no meaning (/^^^^A/ === /^A/)
+    return new RegExp(`^(?:${pattern.source})`, flags)
+}
 
-        while (currOffset < text.length) {
-            let c = text.charCodeAt(currOffset)
-            if (c === 10) { // "\n"
-                lineTerminators++
+export function countLineTerminators(text:string):number {
+    let lineTerminators = 0
+    let currOffset = 0
+
+    while (currOffset < text.length) {
+        let c = text.charCodeAt(currOffset)
+        if (c === 10) { // "\n"
+            lineTerminators++
+        }
+        else if (c === 13) { // \r
+            if (currOffset !== text.length - 1 &&
+                text.charCodeAt(currOffset + 1) === 10) { // "\n"
             }
-            else if (c === 13) { // \r
-                if (currOffset !== text.length - 1 &&
-                    text.charCodeAt(currOffset + 1) === 10) { // "\n"
-                }
-                else {
-                    lineTerminators++
-                }
+            else {
+                lineTerminators++
             }
-
-            currOffset++
         }
 
-        return lineTerminators
+        currOffset++
     }
+
+    return lineTerminators
 }
 
diff --git a/src/scan/lexer_public.ts b/src/scan/lexer_public.ts
index c6dbb7548..4200b45f2 100644
--- a/src/scan/lexer_public.ts
+++ b/src/scan/lexer_public.ts
@@ -1,270 +1,266 @@
-// using only root namespace name ('chevrotain') and not a longer name ('chevrotain.lexer')
-// because the external and internal API must have the same names for d.ts definition files to be valid
-namespace chevrotain {
+import {Token} from "./tokens_public"
+import {validatePatterns, analyzeTokenClasses, countLineTerminators} from "./lexer"
+import {cloneObj, isEmpty, map} from "../utils/utils"
 
-    import lang = chevrotain.lang
+export type TokenConstructor = Function
 
-    export type TokenConstructor = Function
-
-    export interface ILexingResult {
-        tokens:Token[]
-        groups:{ [groupName: string] : Token }
-        errors:ILexingError[]
-    }
+export interface ILexingResult {
+    tokens:Token[]
+    groups:{ [groupName: string] : Token }
+    errors:ILexingError[]
+}
 
-    export enum LexerDefinitionErrorType {
-        MISSING_PATTERN,
-        INVALID_PATTERN,
-        EOI_ANCHOR_FOUND,
-        UNSUPPORTED_FLAGS_FOUND,
-        DUPLICATE_PATTERNS_FOUND,
-        INVALID_GROUP_TYPE_FOUND
-    }
+export enum LexerDefinitionErrorType {
+    MISSING_PATTERN,
+    INVALID_PATTERN,
+    EOI_ANCHOR_FOUND,
+    UNSUPPORTED_FLAGS_FOUND,
+    DUPLICATE_PATTERNS_FOUND,
+    INVALID_GROUP_TYPE_FOUND
+}
 
-    export interface ILexerDefinitionError {
-        message:string
-        type:LexerDefinitionErrorType
-        tokenClasses:Function[]
-    }
+export interface ILexerDefinitionError {
+    message:string
+    type:LexerDefinitionErrorType
+    tokenClasses:Function[]
+}
 
-    export interface ILexingError {
-        line:number
-        column:number
-        length:number
-        message:string
-    }
+export interface ILexingError {
+    line:number
+    column:number
+    length:number
+    message:string
+}
 
-    export class Lexer {
+export class Lexer {
 
-        public static SKIPPED = {
-            description: "This marks a skipped Token pattern, this means each token identified by it will" +
-                         "be consumed and then throw into oblivion, this can be used to for example: skip whitespace."
-        }
+    public static SKIPPED = {
+        description: "This marks a skipped Token pattern, this means each token identified by it will" +
+                     "be consumed and then throw into oblivion, this can be used to for example: skip whitespace."
+    }
 
-        public static NA = /NOT_APPLICABLE/
-        public lexerDefinitionErrors = []
+    public static NA = /NOT_APPLICABLE/
+    public lexerDefinitionErrors = []
 
-        protected allPatterns:RegExp[]
-        protected patternIdxToClass:Function[]
-        protected patternIdxToGroup:boolean[]
-        protected patternIdxToLongerAltIdx:number[]
-        protected patternIdxToCanLineTerminator:boolean[]
-        protected emptyGroups:{ [groupName: string] : Token }
+    protected allPatterns:RegExp[]
+    protected patternIdxToClass:Function[]
+    protected patternIdxToGroup:boolean[]
+    protected patternIdxToLongerAltIdx:number[]
+    protected patternIdxToCanLineTerminator:boolean[]
+    protected emptyGroups:{ [groupName: string] : Token }
 
-        /**
-         * @param {Function[]} tokenClasses constructor functions for the Tokens types this scanner will support
-         *                     These constructors must be in one of THESE forms:
-         *
-         *  1. With a PATTERN property that has a RegExp value for tokens to match:
-         *     example: -->class Integer extends Token { static PATTERN = /[1-9]\d }<--
-         *
-         *  2. With a PATTERN property that has the value of the var Lexer.NA defined above.
-         *     This is a convenience form used to avoid matching Token classes that only act as categories.
-         *     example: -->class Keyword extends Token { static PATTERN = NA }<--
-         *
-         *
-         *   The following RegExp patterns are not supported:
-         *   a. '$' for match at end of input
-         *   b. /b global flag
-         *   c. /m multi-line flag
-         *
-         *   The Lexer will identify the first pattern the matches, Therefor the order of Token Constructors passed
-         *   To the SimpleLexer's constructor is meaningful. If two patterns may match the same string, the longer one
-         *   should be before the shorter one.
-         *
-         *   Note that there are situations in which we may wish to place the longer pattern after the shorter one.
-         *   For example: keywords vs Identifiers.
-         *   'do'(/do/) and 'done'(/w+)
-         *
-         *   * If the Identifier pattern appears before the 'do' pattern both 'do' and 'done'
-         *     will be lexed as an Identifier.
-         *
-         *   * If the 'do' pattern appears before the Identifier pattern 'do' will be lexed correctly as a keyword.
-         *     however 'done' will be lexed as TWO tokens keyword 'do' and identifier 'ne'.
-         *
-         *   To resolve this problem, add a static property on the keyword's Tokens constructor named: LONGER_ALT
-         *   example:
-         *
-         *       export class Identifier extends Keyword { static PATTERN = /[_a-zA-Z][_a-zA-Z0-9]/ }
-         *       export class Keyword extends Token {
-         *          static PATTERN = lex.NA
-         *          static LONGER_ALT = Identifier
-         *       }
-         *       export class Do extends Keyword { static PATTERN = /do/ }
-         *       export class While extends Keyword { static PATTERN = /while/ }
-         *       export class Return extends Keyword { static PATTERN = /return/ }
-         *
-         *   The lexer will then also attempt to match a (longer) Identifier each time a keyword is matched
-         *
-         *
-         * @param {boolean} [deferDefinitionErrorsHandling=false]
-         *                  an optional flag indicating that lexer definition errors
-         *                  should not automatically cause an error to be raised.
-         *                  This can be useful when wishing to indicate lexer errors in another manner
-         *                  than simply throwing an error (for example in an online playground).
-         */
-        constructor(protected tokenClasses:TokenConstructor[], deferDefinitionErrorsHandling:boolean = false) {
-            this.lexerDefinitionErrors = validatePatterns(tokenClasses)
-            if (!utils.isEmpty(this.lexerDefinitionErrors) && !deferDefinitionErrorsHandling) {
-                let allErrMessages = utils.map(this.lexerDefinitionErrors, (error) => {
-                    return error.message
-                })
-                let allErrMessagesString = allErrMessages.join("-----------------------\n")
-                throw new Error("Errors detected in definition of Lexer:\n" + allErrMessagesString)
-            }
+    /**
+     * @param {Function[]} tokenClasses constructor functions for the Tokens types this scanner will support
+     *                     These constructors must be in one of THESE forms:
+     *
+     *  1. With a PATTERN property that has a RegExp value for tokens to match:
+     *     example: -->class Integer extends Token { static PATTERN = /[1-9]\d }<--
+     *
+     *  2. With a PATTERN property that has the value of the var Lexer.NA defined above.
+     *     This is a convenience form used to avoid matching Token classes that only act as categories.
+     *     example: -->class Keyword extends Token { static PATTERN = NA }<--
+     *
+     *
+     *   The following RegExp patterns are not supported:
+     *   a. '$' for match at end of input
+     *   b. /b global flag
+     *   c. /m multi-line flag
+     *
+     *   The Lexer will identify the first pattern the matches, Therefor the order of Token Constructors passed
+     *   To the SimpleLexer's constructor is meaningful. If two patterns may match the same string, the longer one
+     *   should be before the shorter one.
+     *
+     *   Note that there are situations in which we may wish to place the longer pattern after the shorter one.
+     *   For example: keywords vs Identifiers.
+     *   'do'(/do/) and 'done'(/w+)
+     *
+     *   * If the Identifier pattern appears before the 'do' pattern both 'do' and 'done'
+     *     will be lexed as an Identifier.
+     *
+     *   * If the 'do' pattern appears before the Identifier pattern 'do' will be lexed correctly as a keyword.
+     *     however 'done' will be lexed as TWO tokens keyword 'do' and identifier 'ne'.
+     *
+     *   To resolve this problem, add a static property on the keyword's Tokens constructor named: LONGER_ALT
+     *   example:
+     *
+     *       export class Identifier extends Keyword { static PATTERN = /[_a-zA-Z][_a-zA-Z0-9]/ }
+     *       export class Keyword extends Token {
+     *          static PATTERN = lex.NA
+     *          static LONGER_ALT = Identifier
+     *       }
+     *       export class Do extends Keyword { static PATTERN = /do/ }
+     *       export class While extends Keyword { static PATTERN = /while/ }
+     *       export class Return extends Keyword { static PATTERN = /return/ }
+     *
+     *   The lexer will then also attempt to match a (longer) Identifier each time a keyword is matched
+     *
+     *
+     * @param {boolean} [deferDefinitionErrorsHandling=false]
+     *                  an optional flag indicating that lexer definition errors
+     *                  should not automatically cause an error to be raised.
+     *                  This can be useful when wishing to indicate lexer errors in another manner
+     *                  than simply throwing an error (for example in an online playground).
+     */
+    constructor(protected tokenClasses:TokenConstructor[], deferDefinitionErrorsHandling:boolean = false) {
+        this.lexerDefinitionErrors = validatePatterns(tokenClasses)
+        if (!isEmpty(this.lexerDefinitionErrors) && !deferDefinitionErrorsHandling) {
+            let allErrMessages = map(this.lexerDefinitionErrors, (error) => {
+                return error.message
+            })
+            let allErrMessagesString = allErrMessages.join("-----------------------\n")
+            throw new Error("Errors detected in definition of Lexer:\n" + allErrMessagesString)
+        }
 
-            // If definition errors were encountered, the analysis phase may fail unexpectedly/
-            // Considering a lexer with definition errors may never be used, there is no point
-            // to performing the analysis anyhow...
-            if (utils.isEmpty(this.lexerDefinitionErrors)) {
-                let analyzeResult = analyzeTokenClasses(tokenClasses)
-                this.allPatterns = analyzeResult.allPatterns
-                this.patternIdxToClass = analyzeResult.patternIdxToClass
-                this.patternIdxToGroup = analyzeResult.patternIdxToGroup
-                this.patternIdxToLongerAltIdx = analyzeResult.patternIdxToLongerAltIdx
-                this.patternIdxToCanLineTerminator = analyzeResult.patternIdxToCanLineTerminator
-                this.emptyGroups = analyzeResult.emptyGroups
-            }
+        // If definition errors were encountered, the analysis phase may fail unexpectedly/
+        // Considering a lexer with definition errors may never be used, there is no point
+        // to performing the analysis anyhow...
+        if (isEmpty(this.lexerDefinitionErrors)) {
+            let analyzeResult = analyzeTokenClasses(tokenClasses)
+            this.allPatterns = analyzeResult.allPatterns
+            this.patternIdxToClass = analyzeResult.patternIdxToClass
+            this.patternIdxToGroup = analyzeResult.patternIdxToGroup
+            this.patternIdxToLongerAltIdx = analyzeResult.patternIdxToLongerAltIdx
+            this.patternIdxToCanLineTerminator = analyzeResult.patternIdxToCanLineTerminator
+            this.emptyGroups = analyzeResult.emptyGroups
         }
+    }
 
-        /**
-         * Will lex(Tokenize) a string.
-         * Note that this can be called repeatedly on different strings as this method
-         * does not modify the state of the Lexer.
-         *
-         * @param {string} text the string to lex
-         * @returns {{tokens: {Token}[], errors: string[]}}
-         */
-        public tokenize(text:string):ILexingResult {
-            let match, i, j, matchAlt, longerAltIdx, matchedImage, imageLength, group, tokClass, newToken, errLength,
-                canMatchedContainLineTerminator, fixForEndingInLT, c, droppedChar, lastLTIdx, errorMessage, lastCharIsLT
-            let orgInput = text
-            let offset = 0
-            let matchedTokens = []
-            let errors:ILexingError[] = []
-            let line = 1
-            let column = 1
-            let groups:any = utils.cloneObj(this.emptyGroups)
+    /**
+     * Will lex(Tokenize) a string.
+     * Note that this can be called repeatedly on different strings as this method
+     * does not modify the state of the Lexer.
+     *
+     * @param {string} text the string to lex
+     * @returns {{tokens: {Token}[], errors: string[]}}
+     */
+    public tokenize(text:string):ILexingResult {
+        let match, i, j, matchAlt, longerAltIdx, matchedImage, imageLength, group, tokClass, newToken, errLength,
+            canMatchedContainLineTerminator, fixForEndingInLT, c, droppedChar, lastLTIdx, errorMessage, lastCharIsLT
+        let orgInput = text
+        let offset = 0
+        let matchedTokens = []
+        let errors:ILexingError[] = []
+        let line = 1
+        let column = 1
+        let groups:any = cloneObj(this.emptyGroups)
 
-            if (!utils.isEmpty(this.lexerDefinitionErrors)) {
-                let allErrMessages = utils.map(this.lexerDefinitionErrors, (error) => {
-                    return error.message
-                })
-                let allErrMessagesString = allErrMessages.join("-----------------------\n")
-                throw new Error("Unable to Tokenize because Errors detected in definition of Lexer:\n" + allErrMessagesString)
-            }
+        if (!isEmpty(this.lexerDefinitionErrors)) {
+            let allErrMessages = map(this.lexerDefinitionErrors, (error) => {
+                return error.message
+            })
+            let allErrMessagesString = allErrMessages.join("-----------------------\n")
+            throw new Error("Unable to Tokenize because Errors detected in definition of Lexer:\n" + allErrMessagesString)
+        }
 
-            while (text.length > 0) {
+        while (text.length > 0) {
 
-                match = null
-                for (i = 0; i < this.allPatterns.length; i++) {
-                    match = this.allPatterns[i].exec(text)
-                    if (match !== null) {
-                        // even though this pattern matched we must try a another longer alternative.
-                        // this can be used to prioritize keywords over identifers
-                        longerAltIdx = this.patternIdxToLongerAltIdx[i]
-                        if (longerAltIdx) {
-                            matchAlt = this.allPatterns[longerAltIdx].exec(text)
-                            if (matchAlt && matchAlt[0].length > match[0].length) {
-                                match = matchAlt
-                                i = longerAltIdx
-                            }
+            match = null
+            for (i = 0; i < this.allPatterns.length; i++) {
+                match = this.allPatterns[i].exec(text)
+                if (match !== null) {
+                    // even though this pattern matched we must try a another longer alternative.
+                    // this can be used to prioritize keywords over identifers
+                    longerAltIdx = this.patternIdxToLongerAltIdx[i]
+                    if (longerAltIdx) {
+                        matchAlt = this.allPatterns[longerAltIdx].exec(text)
+                        if (matchAlt && matchAlt[0].length > match[0].length) {
+                            match = matchAlt
+                            i = longerAltIdx
                         }
-                        break
                     }
+                    break
                 }
-                if (match !== null) {
-                    matchedImage = match[0]
-                    imageLength = matchedImage.length
-                    group = this.patternIdxToGroup[i]
-                    if (group !== undefined) {
-                        tokClass = this.patternIdxToClass[i]
-                        newToken = new tokClass(matchedImage, offset, line, column);
-                        if (group === "default") {
-                            matchedTokens.push(newToken)
-                        }
-                        else {
-                            groups[group].push(newToken)
-                        }
+            }
+            if (match !== null) {
+                matchedImage = match[0]
+                imageLength = matchedImage.length
+                group = this.patternIdxToGroup[i]
+                if (group !== undefined) {
+                    tokClass = this.patternIdxToClass[i]
+                    newToken = new tokClass(matchedImage, offset, line, column)
+                    if (group === "default") {
+                        matchedTokens.push(newToken)
+                    }
+                    else {
+                        groups[group].push(newToken)
                     }
-                    text = text.slice(imageLength)
-                    offset = offset + imageLength
-                    column = column + imageLength // TODO: with newlines the column may be assigned twice
-                    canMatchedContainLineTerminator = this.patternIdxToCanLineTerminator[i]
-                    if (canMatchedContainLineTerminator) {
-                        let lineTerminatorsInMatch = countLineTerminators(matchedImage)
-                        // TODO: identify edge case of one token ending in '\r' and another one starting with '\n'
-                        if (lineTerminatorsInMatch !== 0) {
-                            line = line + lineTerminatorsInMatch
+                }
+                text = text.slice(imageLength)
+                offset = offset + imageLength
+                column = column + imageLength // TODO: with newlines the column may be assigned twice
+                canMatchedContainLineTerminator = this.patternIdxToCanLineTerminator[i]
+                if (canMatchedContainLineTerminator) {
+                    let lineTerminatorsInMatch = countLineTerminators(matchedImage)
+                    // TODO: identify edge case of one token ending in '\r' and another one starting with '\n'
+                    if (lineTerminatorsInMatch !== 0) {
+                        line = line + lineTerminatorsInMatch
 
-                            lastLTIdx = imageLength - 1
-                            while (lastLTIdx >= 0) {
-                                c = matchedImage.charCodeAt(lastLTIdx)
-                                // scan in reverse to find last lineTerminator in image
-                                if (c === 13 || c === 10) { // '\r' or '\n'
-                                    break;
-                                }
-                                lastLTIdx--
+                        lastLTIdx = imageLength - 1
+                        while (lastLTIdx >= 0) {
+                            c = matchedImage.charCodeAt(lastLTIdx)
+                            // scan in reverse to find last lineTerminator in image
+                            if (c === 13 || c === 10) { // '\r' or '\n'
+                                break
                             }
-                            column = imageLength - lastLTIdx
+                            lastLTIdx--
+                        }
+                        column = imageLength - lastLTIdx
 
-                            if (group !== undefined) { // a none skipped multi line Token, need to update endLine/endColumn
-                                lastCharIsLT = lastLTIdx === imageLength - 1
-                                fixForEndingInLT = lastCharIsLT ? -1 : 0
+                        if (group !== undefined) { // a none skipped multi line Token, need to update endLine/endColumn
+                            lastCharIsLT = lastLTIdx === imageLength - 1
+                            fixForEndingInLT = lastCharIsLT ? -1 : 0
 
-                                if (!(lineTerminatorsInMatch === 1 && lastCharIsLT)) {
-                                    // if a token ends in a LT that last LT only affects the line numbering of following Tokens
-                                    newToken.endLine = line + fixForEndingInLT
-                                    // the last LT in a token does not affect the endColumn either as the [columnStart ... columnEnd)
-                                    // inclusive to exclusive range.
-                                    newToken.endColumn = column - 1 + -fixForEndingInLT
-                                }
-                                // else single LT in the last character of a token, no need to modify the endLine/EndColumn
+                            if (!(lineTerminatorsInMatch === 1 && lastCharIsLT)) {
+                                // if a token ends in a LT that last LT only affects the line numbering of following Tokens
+                                newToken.endLine = line + fixForEndingInLT
+                                // the last LT in a token does not affect the endColumn either as the [columnStart ... columnEnd)
+                                // inclusive to exclusive range.
+                                newToken.endColumn = column - 1 + -fixForEndingInLT
                             }
+                            // else single LT in the last character of a token, no need to modify the endLine/EndColumn
                         }
                     }
-
                 }
-                else { // error recovery, drop characters until we identify a valid token's start point
-                    let errorStartOffset = offset
-                    let errorLine = line
-                    let errorColumn = column
-                    let foundResyncPoint = false
-                    while (!foundResyncPoint && text.length > 0) {
-                        // drop chars until we succeed in matching something
-                        droppedChar = text.charCodeAt(0)
-                        if (droppedChar === 10 || // '\n'
-                            (droppedChar === 13 &&
-                            (text.length === 1 || (text.length > 1 && text.charCodeAt(1) !== 10)))) { //'\r' not followed by '\n'
-                            line++
-                            column = 1
-                        }
-                        else { // this else also matches '\r\n' which is fine, the '\n' will be counted
-                            // either when skipping the next char, or when consuming the following pattern
-                            // (which will have to start in a '\n' if we manage to consume it)
-                            column++
-                        }
 
-                        text = text.substr(1)
-                        offset++;
-                        for (j = 0; j < this.allPatterns.length; j++) {
-                            foundResyncPoint = this.allPatterns[j].test(text)
-                            if (foundResyncPoint) {
-                                break
-                            }
-                        }
+            }
+            else { // error recovery, drop characters until we identify a valid token's start point
+                let errorStartOffset = offset
+                let errorLine = line
+                let errorColumn = column
+                let foundResyncPoint = false
+                while (!foundResyncPoint && text.length > 0) {
+                    // drop chars until we succeed in matching something
+                    droppedChar = text.charCodeAt(0)
+                    if (droppedChar === 10 || // '\n'
+                        (droppedChar === 13 &&
+                        (text.length === 1 || (text.length > 1 && text.charCodeAt(1) !== 10)))) { //'\r' not followed by '\n'
+                        line++
+                        column = 1
+                    }
+                    else { // this else also matches '\r\n' which is fine, the '\n' will be counted
+                        // either when skipping the next char, or when consuming the following pattern
+                        // (which will have to start in a '\n' if we manage to consume it)
+                        column++
                     }
 
-                    errLength = offset - errorStartOffset
-                    // at this point we either re-synced or reached the end of the input text
-                    errorMessage = `unexpected character: ->${orgInput.charAt(errorStartOffset)}<- at offset: ${errorStartOffset},` +
-                        ` skipped ${offset - errorStartOffset} characters.`
-                    errors.push({line: errorLine, column: errorColumn, length: errLength, message: errorMessage})
+                    text = text.substr(1)
+                    offset++;
+                    for (j = 0; j < this.allPatterns.length; j++) {
+                        foundResyncPoint = this.allPatterns[j].test(text)
+                        if (foundResyncPoint) {
+                            break
+                        }
+                    }
                 }
-            }
 
-            return {tokens: matchedTokens, groups: groups, errors: errors}
+                errLength = offset - errorStartOffset
+                // at this point we either re-synced or reached the end of the input text
+                errorMessage = `unexpected character: ->${orgInput.charAt(errorStartOffset)}<- at offset: ${errorStartOffset},` +
+                    ` skipped ${offset - errorStartOffset} characters.`
+                errors.push({line: errorLine, column: errorColumn, length: errLength, message: errorMessage})
+            }
         }
+
+        return {tokens: matchedTokens, groups: groups, errors: errors}
     }
 }
-
diff --git a/src/scan/tokens_public.ts b/src/scan/tokens_public.ts
index a35542bfb..be1e3ced2 100644
--- a/src/scan/tokens_public.ts
+++ b/src/scan/tokens_public.ts
@@ -1,97 +1,94 @@
-// using only root namespace name ('chevrotain') and not a longer name ('chevrotain.tokens')
-// because the external and internal API must have the same names for d.ts definition files to be valid
-namespace chevrotain {
+import {isString, isRegExp, isFunction, assign, isUndefined} from "../utils/utils"
+import {functionName} from "../lang/lang_extensions"
+import {Lexer} from "./lexer_public"
 
-    import lang = chevrotain.lang
-
-    export function tokenName(clazz:Function):string {
-        // used to support js inheritance patterns that do not use named functions
-        // in that situation setting a property tokenName on a token constructor will
-        // enable producing readable error messages.
-        if (utils.isString((<any>clazz).tokenName)) {
-            return (<any>clazz).tokenName
-        }
-        else {
-            return lang.functionName(clazz)
-        }
+export function tokenName(clazz:Function):string {
+    // used to support js inheritance patterns that do not use named functions
+    // in that situation setting a property tokenName on a token constructor will
+    // enable producing readable error messages.
+    if (isString((<any>clazz).tokenName)) {
+        return (<any>clazz).tokenName
     }
+    else {
+        return functionName(clazz)
+    }
+}
 
-    /**
-     * utility to help the poor souls who are still stuck writing pure javascript 5.1
-     * extend and create Token subclasses in a less verbose manner
-     *
-     * @param {string} tokenName - the name of the new TokenClass
-     * @param {RegExp|Function} patternOrParent - RegExp Pattern or Parent Token Constructor
-     * @param {Function} parentConstructor - the Token class to be extended
-     * @returns {Function} - a constructor for the new extended Token subclass
-     */
-    export function extendToken(tokenName:string, patternOrParent:any = undefined, parentConstructor:Function = Token) {
-        let pattern
-
-        if (utils.isRegExp(patternOrParent) ||
-            patternOrParent === chevrotain.Lexer.SKIPPED ||
-            patternOrParent === chevrotain.Lexer.NA) {
-            pattern = patternOrParent
-        }
-        else if (utils.isFunction(patternOrParent)) {
-            parentConstructor = patternOrParent
-            pattern = undefined
-        }
+/**
+ * utility to help the poor souls who are still stuck writing pure javascript 5.1
+ * extend and create Token subclasses in a less verbose manner
+ *
+ * @param {string} tokenName - the name of the new TokenClass
+ * @param {RegExp|Function} patternOrParent - RegExp Pattern or Parent Token Constructor
+ * @param {Function} parentConstructor - the Token class to be extended
+ * @returns {Function} - a constructor for the new extended Token subclass
+ */
+export function extendToken(tokenName:string, patternOrParent:any = undefined, parentConstructor:Function = Token) {
+    let pattern
 
-        let derivedCostructor:any = function () {
-            parentConstructor.apply(this, arguments)
-        }
+    if (isRegExp(patternOrParent) ||
+        patternOrParent === Lexer.SKIPPED ||
+        patternOrParent === Lexer.NA) {
+        pattern = patternOrParent
+    }
+    else if (isFunction(patternOrParent)) {
+        parentConstructor = patternOrParent
+        pattern = undefined
+    }
 
-        // static properties mixing
-        derivedCostructor = utils.assign(derivedCostructor, parentConstructor)
+    let derivedCostructor:any = function () {
+        parentConstructor.apply(this, arguments)
+    }
 
-        // the tokenName property will be used by the Parser for Error Messages if the Token's constructor is anonymous
-        derivedCostructor.tokenName = tokenName
-        derivedCostructor.prototype = Object.create(parentConstructor.prototype)
-        derivedCostructor.prototype.constructor = derivedCostructor
-        if (!utils.isUndefined(pattern)) {
-            derivedCostructor.PATTERN = pattern
-        }
+    // static properties mixing
+    derivedCostructor = assign(derivedCostructor, parentConstructor)
 
-        return derivedCostructor
+    // the tokenName property will be used by the Parser for Error Messages if the Token's constructor is anonymous
+    derivedCostructor.tokenName = tokenName
+    derivedCostructor.prototype = Object.create(parentConstructor.prototype)
+    derivedCostructor.prototype.constructor = derivedCostructor
+    if (!isUndefined(pattern)) {
+        derivedCostructor.PATTERN = pattern
     }
 
-    export class Token {
-        // this marks if a Token does not really exist and has been inserted "artificially" during parsing in rule error recovery
-        public isInsertedInRecovery:boolean = false
+    return derivedCostructor
+}
 
-        /**
-         * @param {string} image the textual representation of the Token as it appeared in the text
-         * @param {number} offset offset of the first character of the Token
-         * @param {number} startLine line of the first character of the Token
-         * @param {number} startColumn column of the first character of the Token
-         * @param {number} endLine line of the last character of the Token
-         * @param {number} endColumn column of the last character of the Token
-         *
-         * Things to note:
-         * * "do"  {startColumn : 1, endColumn: 2} --> the range is inclusive to exclusive 1...2 (2 chars long).
-         * * "\n"  {startLine : 1, endLine: 1} --> a lineTerminator as the last character does not effect the Token's line numbering.
-         * * "'hello\tworld\uBBBB'"  {image: "'hello\tworld\uBBBB'"} --> a Token's image is the "literal" text
-         *                                                              (unicode escaping is untouched).
-         */
-        constructor(public image:string,
-                    public offset:number,
-                    public startLine:number,
-                    public startColumn:number,
-                    public endLine:number = startLine,
-                    public endColumn:number = startColumn + image.length - 1) {}
-
-        // TODO: getter(computed) for endOffSet
-    }
+export class Token {
+    // this marks if a Token does not really exist and has been inserted "artificially" during parsing in rule error recovery
+    public isInsertedInRecovery:boolean = false
 
     /**
-     * a special kind of Token which does not really exist in the input
-     * (hence the 'Virtual' prefix). These type of Tokens can be used as special markers:
-     * for example, EOF (end-of-file).
+     * @param {string} image the textual representation of the Token as it appeared in the text
+     * @param {number} offset offset of the first character of the Token
+     * @param {number} startLine line of the first character of the Token
+     * @param {number} startColumn column of the first character of the Token
+     * @param {number} endLine line of the last character of the Token
+     * @param {number} endColumn column of the last character of the Token
+     *
+     * Things to note:
+     * * "do"  {startColumn : 1, endColumn: 2} --> the range is inclusive to exclusive 1...2 (2 chars long).
+     * * "\n"  {startLine : 1, endLine: 1} --> a lineTerminator as the last character does not effect the Token's line numbering.
+     * * "'hello\tworld\uBBBB'"  {image: "'hello\tworld\uBBBB'"} --> a Token's image is the "literal" text
+     *                                                              (unicode escaping is untouched).
      */
-    export class VirtualToken extends Token {
-        constructor() {super("", -1, -1, -1, -1, -1) }
-    }
+    constructor(public image:string,
+                public offset:number,
+                public startLine:number,
+                public startColumn:number,
+                public endLine:number = startLine,
+                public endColumn:number = startColumn + image.length - 1) {}
+
+    // TODO: getter(computed) for endOffSet
+}
 
-    export class EOF extends VirtualToken {}
+/**
+ * a special kind of Token which does not really exist in the input
+ * (hence the 'Virtual' prefix). These type of Tokens can be used as special markers:
+ * for example, EOF (end-of-file).
+ */
+export class VirtualToken extends Token {
+    constructor() {super("", -1, -1, -1, -1, -1) }
 }
+
+export class EOF extends VirtualToken {}
diff --git a/src/text/range.ts b/src/text/range.ts
index 4fe0760a2..30f316a18 100644
--- a/src/text/range.ts
+++ b/src/text/range.ts
@@ -1,52 +1,49 @@
-namespace chevrotain.range {
+export interface IRange {
 
-    export interface IRange {
+    start:number
+    end:number
 
-        start:number
-        end:number
+    contains(num:number):boolean
 
-        contains(num:number):boolean
+    containsRange(other:IRange):boolean
 
-        containsRange(other:IRange):boolean
+    isContainedInRange(other:IRange):boolean
 
-        isContainedInRange(other:IRange):boolean
+    strictlyContainsRange(other:IRange):boolean
 
-        strictlyContainsRange(other:IRange):boolean
-
-        isStrictlyContainedInRange(other:IRange):boolean
-    }
-
-    export class Range implements IRange {
-
-        constructor(public start:number, public end:number) {
-            if (!isValidRange(start, end)) {
-                throw new Error("INVALID RANGE")
-            }
-        }
+    isStrictlyContainedInRange(other:IRange):boolean
+}
 
-        contains(num:number):boolean {
-            return this.start <= num && this.end >= num
-        }
+export class Range implements IRange {
 
-        containsRange(other:IRange):boolean {
-            return this.start <= other.start && this.end >= other.end
+    constructor(public start:number, public end:number) {
+        if (!isValidRange(start, end)) {
+            throw new Error("INVALID RANGE")
         }
+    }
 
-        isContainedInRange(other:IRange):boolean {
-            return other.containsRange(this)
-        }
+    contains(num:number):boolean {
+        return this.start <= num && this.end >= num
+    }
 
-        strictlyContainsRange(other:IRange):boolean {
-            return this.start < other.start && this.end > other.end
-        }
+    containsRange(other:IRange):boolean {
+        return this.start <= other.start && this.end >= other.end
+    }
 
-        isStrictlyContainedInRange(other:IRange):boolean {
-            return other.strictlyContainsRange(this)
-        }
+    isContainedInRange(other:IRange):boolean {
+        return other.containsRange(this)
+    }
 
+    strictlyContainsRange(other:IRange):boolean {
+        return this.start < other.start && this.end > other.end
     }
 
-    export function isValidRange(start:number, end:number):boolean {
-        return !(start < 0 || end < start)
+    isStrictlyContainedInRange(other:IRange):boolean {
+        return other.strictlyContainsRange(this)
     }
+
+}
+
+export function isValidRange(start:number, end:number):boolean {
+    return !(start < 0 || end < start)
 }
diff --git a/src/utils/utils.ts b/src/utils/utils.ts
index 40a962fa7..0ff5134f6 100644
--- a/src/utils/utils.ts
+++ b/src/utils/utils.ts
@@ -7,282 +7,278 @@
  so writing several dozen utils which may be slower than the original lodash, does not matter as much
  considering they will not be invoked in hotspots...
  */
+export function isEmpty(arr:any[]):boolean {
+    return arr && arr.length === 0
+}
 
-namespace chevrotain.utils {
+export function keys(obj:any):string[] {
+    return Object.keys(obj)
+}
 
-    export function isEmpty(arr:any[]):boolean {
-        return arr && arr.length === 0
+export function values(obj:any):any[] {
+    let vals = []
+    let keys = Object.keys(obj)
+    for (let i = 0; i < keys.length; i++) {
+        vals.push(obj[keys[i]])
     }
+    return vals
+}
 
-    export function keys(obj:any):string[] {
-        return Object.keys(obj)
+export function map<I, O>(arr:I[], callback:(I, idx?:number) => O):O[] {
+    let result:O[] = []
+    for (let idx = 0; idx < arr.length; idx++) {
+        result.push(callback.call(null, arr[idx], idx))
     }
+    return result
+}
 
-    export function values(obj:any):any[] {
-        let vals = []
-        let keys = Object.keys(obj)
-        for (let i = 0; i < keys.length; i++) {
-            vals.push(obj[keys[i]])
-        }
-        return vals
-    }
+export function flatten<T>(arr:any[]):T[] {
+    let result = []
 
-    export function map<I, O>(arr:I[], callback:(I, idx?:number) => O):O[] {
-        let result:O[] = []
-        for (let idx = 0; idx < arr.length; idx++) {
-            result.push(callback.call(null, arr[idx], idx))
+    for (let idx = 0; idx < arr.length; idx++) {
+        let currItem = arr[idx]
+        if (Array.isArray(currItem)) {
+            result = result.concat(flatten(currItem))
         }
-        return result
-    }
-
-    export function flatten<T>(arr:any[]):T[] {
-        let result = []
-
-        for (let idx = 0; idx < arr.length; idx++) {
-            let currItem = arr[idx]
-            if (Array.isArray(currItem)) {
-                result = result.concat(flatten(currItem))
-            }
-            else {
-                result.push(currItem)
-            }
+        else {
+            result.push(currItem)
         }
-        return result
     }
+    return result
+}
 
-    export function first<T>(arr:T[]):T {
-        return isEmpty(arr) ? undefined : arr[0]
-    }
+export function first<T>(arr:T[]):T {
+    return isEmpty(arr) ? undefined : arr[0]
+}
 
-    export function last<T>(arr:T[]):T {
-        let len = arr && arr.length
-        return len ? arr[len - 1] : undefined
-    }
+export function last<T>(arr:T[]):T {
+    let len = arr && arr.length
+    return len ? arr[len - 1] : undefined
+}
 
-    export function forEach(arr:any[], iteratorCallback:Function):void {
-        if (Array.isArray(arr)) {
-            for (let i = 0; i < arr.length; i++) {
-                iteratorCallback.call(null, arr[i], i)
-            }
+export function forEach(arr:any[], iteratorCallback:Function):void {
+    if (Array.isArray(arr)) {
+        for (let i = 0; i < arr.length; i++) {
+            iteratorCallback.call(null, arr[i], i)
         }
     }
+}
 
-    export function isString(item:any):boolean {
-        return typeof item === "string"
-    }
+export function isString(item:any):boolean {
+    return typeof item === "string"
+}
 
-    export function isUndefined(item:any):boolean {
-        return item === undefined
-    }
+export function isUndefined(item:any):boolean {
+    return item === undefined
+}
 
-    export function isFunction(item:any):boolean {
-        return item instanceof Function
-    }
+export function isFunction(item:any):boolean {
+    return item instanceof Function
+}
 
-    export function drop<T>(arr:T[], howMuch:number = 1):T[] {
-        return arr.slice(howMuch, arr.length)
-    }
+export function drop<T>(arr:T[], howMuch:number = 1):T[] {
+    return arr.slice(howMuch, arr.length)
+}
 
-    export function dropRight<T>(arr:T[], howMuch:number = 1):T[] {
-        return arr.slice(0, arr.length - howMuch)
-    }
+export function dropRight<T>(arr:T[], howMuch:number = 1):T[] {
+    return arr.slice(0, arr.length - howMuch)
+}
 
-    export function filter<T>(arr:T[], predicate:(T) => boolean):T[] {
-        let result = []
-        if (Array.isArray(arr)) {
-            for (let i = 0; i < arr.length; i++) {
-                let item = arr[i]
-                if (predicate.call(null, item)) {
-                    result.push(item)
-                }
+export function filter<T>(arr:T[], predicate:(T) => boolean):T[] {
+    let result = []
+    if (Array.isArray(arr)) {
+        for (let i = 0; i < arr.length; i++) {
+            let item = arr[i]
+            if (predicate.call(null, item)) {
+                result.push(item)
             }
         }
-        return result
     }
+    return result
+}
 
-    export function reject<T>(arr:T[], predicate:(T) => boolean):T[] {
-        return filter(arr, (item) => !predicate(item))
-    }
+export function reject<T>(arr:T[], predicate:(T) => boolean):T[] {
+    return filter(arr, (item) => !predicate(item))
+}
 
-    export function pick(obj:Object, predicate:(item) => boolean) {
-        let keys = Object.keys(obj)
-        let result = {}
+export function pick(obj:Object, predicate:(item) => boolean) {
+    let keys = Object.keys(obj)
+    let result = {}
 
-        for (let i = 0; i < keys.length; i++) {
-            let currKey = keys[i]
-            let currItem = obj[currKey]
-            if (predicate(currItem)) {
-                result[currKey] = currItem
-            }
+    for (let i = 0; i < keys.length; i++) {
+        let currKey = keys[i]
+        let currItem = obj[currKey]
+        if (predicate(currItem)) {
+            result[currKey] = currItem
         }
-
-        return result
     }
 
-    export function has(obj:any, prop:string):boolean {
-        return obj.hasOwnProperty(prop)
-    }
+    return result
+}
 
-    export function contains<T>(arr:T[], item):boolean {
-        return find(arr, (currItem) => currItem === item) ? true : false
-    }
+export function has(obj:any, prop:string):boolean {
+    return obj.hasOwnProperty(prop)
+}
 
-    /**
-     * shallow clone
-     */
-    export function cloneArr<T>(arr:T[]):T[] {
-        return map(arr, (item) => item)
-    }
+export function contains<T>(arr:T[], item):boolean {
+    return find(arr, (currItem) => currItem === item) ? true : false
+}
 
-    /**
-     * shallow clone
-     */
-    export function cloneObj(obj:Object):any {
-        let clonedObj = {}
-        for (let key in obj) {
-            /* istanbul ignore else */
-            if (Object.prototype.hasOwnProperty.call(obj, key)) {
-                clonedObj[key] = obj[key]
-            }
+/**
+ * shallow clone
+ */
+export function cloneArr<T>(arr:T[]):T[] {
+    return map(arr, (item) => item)
+}
+
+/**
+ * shallow clone
+ */
+export function cloneObj(obj:Object):any {
+    let clonedObj = {}
+    for (let key in obj) {
+        /* istanbul ignore else */
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            clonedObj[key] = obj[key]
         }
-        return clonedObj
     }
+    return clonedObj
+}
 
-    export function find<T>(arr:T[], predicate:(item:T) => boolean):T {
-        for (let i = 0; i < arr.length; i++) {
-            let item = arr[i]
-            if (predicate.call(null, item)) {
-                return item
-            }
+export function find<T>(arr:T[], predicate:(item:T) => boolean):T {
+    for (let i = 0; i < arr.length; i++) {
+        let item = arr[i]
+        if (predicate.call(null, item)) {
+            return item
         }
-        return undefined
     }
+    return undefined
+}
 
-    export function reduce<T, A>(arrOrObj:Array<T>|Object, iterator:(result:A, item) => A, initial:A):A {
-        let vals = Array.isArray(arrOrObj) ? arrOrObj : values(arrOrObj)
+export function reduce<T, A>(arrOrObj:Array<T>|Object, iterator:(result:A, item) => A, initial:A):A {
+    let vals = Array.isArray(arrOrObj) ? arrOrObj : values(arrOrObj)
 
-        let accumulator = initial
-        for (let i = 0; i < vals.length; i++) {
-            accumulator = iterator.call(null, accumulator, vals[i])
-        }
-        return accumulator
+    let accumulator = initial
+    for (let i = 0; i < vals.length; i++) {
+        accumulator = iterator.call(null, accumulator, vals[i])
     }
+    return accumulator
+}
 
-    export function compact<T>(arr:T[]):T[] {
-        return reject(arr, (item) => item === null || item === undefined)
-    }
+export function compact<T>(arr:T[]):T[] {
+    return reject(arr, (item) => item === null || item === undefined)
+}
 
-    export function uniq<T>(arr:T[], identity:(item:T) => any = (item) => item):T[] {
-        let identities = []
-        return reduce(arr, (result, currItem) => {
-            let currIdentity = identity(currItem)
-            if (contains(identities, currIdentity)) {
-                return result
-            }
-            else {
-                identities.push(currIdentity)
-                return result.concat(currItem)
-            }
-        }, [])
-    }
+export function uniq<T>(arr:T[], identity:(item:T) => any = (item) => item):T[] {
+    let identities = []
+    return reduce(arr, (result, currItem) => {
+        let currIdentity = identity(currItem)
+        if (contains(identities, currIdentity)) {
+            return result
+        }
+        else {
+            identities.push(currIdentity)
+            return result.concat(currItem)
+        }
+    }, [])
+}
 
-    export function partial(func:Function, ...restArgs:any[]):Function {
-        let firstArg = [null]
-        let allArgs = firstArg.concat(restArgs)
-        return Function.bind.apply(func, allArgs)
-    }
+export function partial(func:Function, ...restArgs:any[]):Function {
+    let firstArg = [null]
+    let allArgs = firstArg.concat(restArgs)
+    return Function.bind.apply(func, allArgs)
+}
 
-    export function isArray(obj:any):boolean {
-        return Array.isArray(obj)
-    }
+export function isArray(obj:any):boolean {
+    return Array.isArray(obj)
+}
 
-    export function isRegExp(obj:any):boolean {
-        return obj instanceof RegExp
-    }
+export function isRegExp(obj:any):boolean {
+    return obj instanceof RegExp
+}
 
-    export function isObject(obj:any):boolean {
-        return obj instanceof Object
-    }
+export function isObject(obj:any):boolean {
+    return obj instanceof Object
+}
 
-    export function every<T>(arr:T[], predicate:(item:T) => boolean):boolean {
-        for (let i = 0; i < arr.length; i++) {
-            if (!predicate(arr[i])) {
-                return false
-            }
+export function every<T>(arr:T[], predicate:(item:T) => boolean):boolean {
+    for (let i = 0; i < arr.length; i++) {
+        if (!predicate(arr[i])) {
+            return false
         }
-        return true
     }
+    return true
+}
 
-    export function difference<T>(arr:T[], values:T[]):T[] {
-        return reject(arr, (item) => contains(values, item))
-    }
+export function difference<T>(arr:T[], values:T[]):T[] {
+    return reject(arr, (item) => contains(values, item))
+}
 
-    export function some<T>(arr:T[], predicate:(item:T) => boolean):boolean {
-        for (let i = 0; i < arr.length; i++) {
-            if (predicate(arr[i])) {
-                return true
-            }
+export function some<T>(arr:T[], predicate:(item:T) => boolean):boolean {
+    for (let i = 0; i < arr.length; i++) {
+        if (predicate(arr[i])) {
+            return true
         }
-        return false
     }
+    return false
+}
 
-    export function indexOf<T>(arr:T[], value:T):number {
-        for (let i = 0; i < arr.length; i++) {
-            if (arr[i] === value) {
-                return i
-            }
+export function indexOf<T>(arr:T[], value:T):number {
+    for (let i = 0; i < arr.length; i++) {
+        if (arr[i] === value) {
+            return i
         }
-        return -1
     }
+    return -1
+}
 
-    export function sortBy<T>(arr:T[], orderFunc:(item:T) => number):T[] {
-        let result = cloneArr(arr)
-        result.sort((a, b) => orderFunc(a) - orderFunc(b))
-        return result
-    }
+export function sortBy<T>(arr:T[], orderFunc:(item:T) => number):T[] {
+    let result = cloneArr(arr)
+    result.sort((a, b) => orderFunc(a) - orderFunc(b))
+    return result
+}
 
-    export function zipObject(keys:any[], values:any[]):Object {
-        if (keys.length !== values.length) {
-            throw Error("can't zipObject with different number of keys and values!")
-        }
+export function zipObject(keys:any[], values:any[]):Object {
+    if (keys.length !== values.length) {
+        throw Error("can't zipObject with different number of keys and values!")
+    }
 
-        let result = {}
-        for (let i = 0; i < keys.length; i++) {
-            result[keys[i]] = values[i]
-        }
-        return result
+    let result = {}
+    for (let i = 0; i < keys.length; i++) {
+        result[keys[i]] = values[i]
     }
+    return result
+}
 
-    /**
-     * mutates! (and returns) target
-     */
-    export function assign(target:Object, ...sources:Object[]):Object {
-        for (let i = 0; i < sources.length; i++) {
-            let curSource = sources[i]
-            let currSourceKeys = keys(curSource)
-            for (let j = 0; j < currSourceKeys.length; j++) {
-                let currKey = currSourceKeys[j]
-                target[currKey] = curSource[currKey]
-            }
+/**
+ * mutates! (and returns) target
+ */
+export function assign(target:Object, ...sources:Object[]):Object {
+    for (let i = 0; i < sources.length; i++) {
+        let curSource = sources[i]
+        let currSourceKeys = keys(curSource)
+        for (let j = 0; j < currSourceKeys.length; j++) {
+            let currKey = currSourceKeys[j]
+            target[currKey] = curSource[currKey]
         }
-        return target
     }
+    return target
+}
 
-    export function groupBy<T>(arr:T[], groupKeyFunc:(item:T) => string):{ [groupKey: string] : T[]} {
-        let result:{ [groupKey: string] : T[]} = {}
+export function groupBy<T>(arr:T[], groupKeyFunc:(item:T) => string):{ [groupKey: string] : T[]} {
+    let result:{ [groupKey: string] : T[]} = {}
 
-        forEach(arr, (item) => {
-            let currGroupKey = groupKeyFunc(item)
-            let currGroupArr = result[currGroupKey]
+    forEach(arr, (item) => {
+        let currGroupKey = groupKeyFunc(item)
+        let currGroupArr = result[currGroupKey]
 
-            if (currGroupArr) {
-                currGroupArr.push(item)
-            }
-            else {
-                result[currGroupKey] = [item]
-            }
-        })
+        if (currGroupArr) {
+            currGroupArr.push(item)
+        }
+        else {
+            result[currGroupKey] = [item]
+        }
+    })
 
-        return result
-    }
+    return result
 }
diff --git a/test/all.ts b/test/all.ts
new file mode 100644
index 000000000..5dc34b5c4
--- /dev/null
+++ b/test/all.ts
@@ -0,0 +1,3 @@
+declare let require
+let req = require.context("./", true, /spec\.js$/)
+req.keys().forEach(req)
diff --git a/test/env.d.ts b/test/env.d.ts
index 2659501a8..e8504d8bd 100644
--- a/test/env.d.ts
+++ b/test/env.d.ts
@@ -1 +1,2 @@
 declare let expect:Chai.ExpectStatic
+
diff --git a/test/full_flow/backtracking/backtracking_parser.ts b/test/full_flow/backtracking/backtracking_parser.ts
index 7c1d605da..f3a828187 100644
--- a/test/full_flow/backtracking/backtracking_parser.ts
+++ b/test/full_flow/backtracking/backtracking_parser.ts
@@ -1,113 +1,109 @@
+// DOCS: simple language with two statements which require backtracking to differentiate during parse time
+//       element A:ns1.ns2...nsN = 5;
+//       element B:ns1.ns2...nsN default 5;
+// generally one should avoid having to use backtracking, and this specific example can be resolved by parsing
+// both statements in a single rule and only distinguishing between them later, but lets see an example of using backtracking :)
+
+import {Token} from "../../../src/scan/tokens_public"
+import {Parser} from "../../../src/parse/parser_public"
+
+export enum RET_TYPE {
+    WITH_DEFAULT,
+    WITH_EQUALS,
+    QUALIFED_NAME,
+    INVALID_WITH_DEFAULT,
+    INVALID_WITH_EQUALS,
+    INVALID_STATEMENT,
+    INVALID_FQN
+}
 
-namespace chevrotain.examples.backtracking {
+export class NumberTok extends Token {}
+export class ElementTok extends Token {}
+export class DefaultTok extends Token {}
+export class DotTok extends Token {}
+export class ColonTok extends Token {}
+export class EqualsTok extends Token {}
+export class SemiColonTok extends Token {}
+export class IdentTok extends Token {}
+
+
+// extending the BaseErrorRecoveryRecognizer in this example because it too has logic related to backtracking
+// that needs to be tested too.
+export class BackTrackingParser extends Parser {
+
+    constructor(input:Token[] = []) {
+        // DOCS: note the second parameter in the super class. this is the namespace in which the token constructors are defined.
+        //       it is mandatory to provide this map to be able to perform self analysis
+        //       and allow the framework to "understand" the implemented grammar.
+        super(input, [NumberTok, ElementTok, DefaultTok, DotTok, ColonTok, EqualsTok, SemiColonTok, IdentTok])
+        // DOCS: The call to performSelfAnalysis needs to happen after all the RULEs have been defined
+        //       The typescript compiler places the constructor body last after initializations in the class's body
+        //       which is why place the call here meets the criteria.
+        Parser.performSelfAnalysis(this)
+    }
 
+    public statement = this.RULE("statement", this.parseStatement, INVALID(RET_TYPE.INVALID_STATEMENT))
+    public withEqualsStatement = this.RULE("withEqualsStatement", this.parseWithEqualsStatement, INVALID(RET_TYPE.INVALID_WITH_EQUALS))
+    public withDefaultStatement = this.RULE("withDefaultStatement",
+        this.parseWithDefaultStatement, INVALID(RET_TYPE.INVALID_WITH_DEFAULT))
+    // DOCs: example for a rule which will never try re-sync recovery as it is defined with 'RULE_NO_RESYNC'
+    public qualifiedName = this.RULE_NO_RESYNC("qualifiedName", this.parseQualifiedName, INVALID(RET_TYPE.INVALID_FQN))
+
+    private parseStatement():RET_TYPE {
+        let statementTypeFound:RET_TYPE = undefined;
+        this.OR(
+            [
+                // both statements have the same prefix which may be of "infinite" length, this means there is no K for which
+                // we can build an LL(K) parser that can distinguish the two alternatives as a negative example
+                // would be to simply create a qualifiedName with a length of k+1.
+                {
+                    WHEN:    this.BACKTRACK(this.withEqualsStatement, (result) => { return result === RET_TYPE.WITH_EQUALS }),
+                    THEN_DO: () => { statementTypeFound = this.SUBRULE(this.withEqualsStatement) }
+                },
+                {
+                    WHEN:    this.BACKTRACK(this.withDefaultStatement, (result) => { return result === RET_TYPE.WITH_DEFAULT }),
+                    THEN_DO: () => { statementTypeFound = this.SUBRULE(this.withDefaultStatement) }
+                },
+            ], " a statement")
+
+        return statementTypeFound
+    }
 
-    // DOCS: simple language with two statements which require backtracking to differentiate during parse time
-    //       element A:ns1.ns2...nsN = 5;
-    //       element B:ns1.ns2...nsN default 5;
-    // generally one should avoid having to use backtracking, and this specific example can be resolved by parsing
-    // both statements in a single rule and only distinguishing between them later, but lets see an example of using backtracking :)
+    private parseWithEqualsStatement():RET_TYPE {
+        this.CONSUME(ElementTok)
+        this.CONSUME(IdentTok)
+        this.CONSUME(ColonTok)
+        this.SUBRULE(this.qualifiedName) // this rule creates the no fixed look ahead issue
+        this.CONSUME(EqualsTok)
+        this.CONSUME(NumberTok)
+        this.CONSUME(SemiColonTok)
 
-    export enum RET_TYPE {
-        WITH_DEFAULT,
-        WITH_EQUALS,
-        QUALIFED_NAME,
-        INVALID_WITH_DEFAULT,
-        INVALID_WITH_EQUALS,
-        INVALID_STATEMENT,
-        INVALID_FQN
+        return RET_TYPE.WITH_EQUALS
     }
 
-    export class NumberTok extends Token {}
-    export class ElementTok extends Token {}
-    export class DefaultTok extends Token {}
-    export class DotTok extends Token {}
-    export class ColonTok extends Token {}
-    export class EqualsTok extends Token {}
-    export class SemiColonTok extends Token {}
-    export class IdentTok extends Token {}
-
-
-    // extending the BaseErrorRecoveryRecognizer in this example because it too has logic related to backtracking
-    // that needs to be tested too.
-    export class BackTrackingParser extends Parser {
-
-        constructor(input:Token[] = []) {
-            // DOCS: note the second parameter in the super class. this is the namespace in which the token constructors are defined.
-            //       it is mandatory to provide this map to be able to perform self analysis
-            //       and allow the framework to "understand" the implemented grammar.
-            super(input, <any>chevrotain.examples.backtracking)
-            // DOCS: The call to performSelfAnalysis needs to happen after all the RULEs have been defined
-            //       The typescript compiler places the constructor body last after initializations in the class's body
-            //       which is why place the call here meets the criteria.
-            Parser.performSelfAnalysis(this)
-        }
-
-
-        public statement = this.RULE("statement", this.parseStatement, INVALID(RET_TYPE.INVALID_STATEMENT))
-        public withEqualsStatement = this.RULE("withEqualsStatement", this.parseWithEqualsStatement, INVALID(RET_TYPE.INVALID_WITH_EQUALS))
-        public withDefaultStatement = this.RULE("withDefaultStatement",
-            this.parseWithDefaultStatement, INVALID(RET_TYPE.INVALID_WITH_DEFAULT))
-        // DOCs: example for a rule which will never try re-sync recovery as it is defined with 'RULE_NO_RESYNC'
-        public qualifiedName = this.RULE_NO_RESYNC("qualifiedName", this.parseQualifiedName, INVALID(RET_TYPE.INVALID_FQN))
-
-        private parseStatement():RET_TYPE {
-            let statementTypeFound:RET_TYPE = undefined;
-            this.OR(
-                [
-                    // both statements have the same prefix which may be of "infinite" length, this means there is no K for which
-                    // we can build an LL(K) parser that can distinguish the two alternatives as a negative example
-                    // would be to simply create a qualifiedName with a length of k+1.
-                    {
-                        WHEN:    this.BACKTRACK(this.withEqualsStatement, (result) => { return result === RET_TYPE.WITH_EQUALS }),
-                        THEN_DO: () => { statementTypeFound = this.SUBRULE(this.withEqualsStatement) }
-                    },
-                    {
-                        WHEN:    this.BACKTRACK(this.withDefaultStatement, (result) => { return result === RET_TYPE.WITH_DEFAULT }),
-                        THEN_DO: () => { statementTypeFound = this.SUBRULE(this.withDefaultStatement) }
-                    },
-                ], " a statement")
-
-            return statementTypeFound
-        }
-
-        private parseWithEqualsStatement():RET_TYPE {
-            this.CONSUME(ElementTok)
-            this.CONSUME(IdentTok)
-            this.CONSUME(ColonTok)
-            this.SUBRULE(this.qualifiedName) // this rule creates the no fixed look ahead issue
-            this.CONSUME(EqualsTok)
-            this.CONSUME(NumberTok)
-            this.CONSUME(SemiColonTok)
-
-            return RET_TYPE.WITH_EQUALS
-        }
-
-        private parseWithDefaultStatement():RET_TYPE {
-            this.CONSUME(ElementTok)
-            this.CONSUME(IdentTok)
-            this.CONSUME(ColonTok)
-            this.SUBRULE(this.qualifiedName) // this rule creates the no fixed look ahead issue
-            this.CONSUME(DefaultTok)
-            this.CONSUME(NumberTok)
-            this.CONSUME(SemiColonTok)
-
-            return RET_TYPE.WITH_DEFAULT
-        }
-
-        private parseQualifiedName():RET_TYPE {
-            this.CONSUME(IdentTok)
-            this.MANY(() => {
-                this.CONSUME(DotTok)
-                this.CONSUME2(IdentTok)
-            })
-            return RET_TYPE.QUALIFED_NAME
-        }
+    private parseWithDefaultStatement():RET_TYPE {
+        this.CONSUME(ElementTok)
+        this.CONSUME(IdentTok)
+        this.CONSUME(ColonTok)
+        this.SUBRULE(this.qualifiedName) // this rule creates the no fixed look ahead issue
+        this.CONSUME(DefaultTok)
+        this.CONSUME(NumberTok)
+        this.CONSUME(SemiColonTok)
 
+        return RET_TYPE.WITH_DEFAULT
     }
 
-    export function INVALID(stmtType:RET_TYPE):() => RET_TYPE {
-        return () => {return stmtType}
+    private parseQualifiedName():RET_TYPE {
+        this.CONSUME(IdentTok)
+        this.MANY(() => {
+            this.CONSUME(DotTok)
+            this.CONSUME2(IdentTok)
+        })
+        return RET_TYPE.QUALIFED_NAME
     }
 
 }
+
+export function INVALID(stmtType:RET_TYPE):() => RET_TYPE {
+    return () => {return stmtType}
+}
diff --git a/test/full_flow/backtracking/backtracking_parser_spec.ts b/test/full_flow/backtracking/backtracking_parser_spec.ts
index 9aadfae37..8f80a1c9b 100644
--- a/test/full_flow/backtracking/backtracking_parser_spec.ts
+++ b/test/full_flow/backtracking/backtracking_parser_spec.ts
@@ -1,53 +1,61 @@
-namespace chevrotain.examples.backtracking.spec {
-
-    describe("Simple backtracking example", function () {
-
-        // TODO: modify example to use the Chevrotain Lexer to increase readability
-        let largeFqnTokenVector = [
-            new IdentTok("ns1", 0, 1, 1), new DotTok(".", 0, 1, 1), new IdentTok("ns2", 0, 1, 1), new DotTok(".", 0, 1, 1),
-            new IdentTok("ns3", 0, 1, 1), new DotTok(".", 0, 1, 1), new IdentTok("ns4", 0, 1, 1), new DotTok(".", 0, 1, 1),
-            new IdentTok("ns5", 0, 1, 1), new DotTok(".", 0, 1, 1), new IdentTok("ns6", 0, 1, 1), new DotTok(".", 0, 1, 1),
-            new IdentTok("ns7", 0, 1, 1), new DotTok(".", 0, 1, 1), new IdentTok("ns8", 0, 1, 1), new DotTok(".", 0, 1, 1),
-            new IdentTok("ns9", 0, 1, 1), new DotTok(".", 0, 1, 1), new IdentTok("ns10", 0, 1, 1), new DotTok(".", 0, 1, 1),
-            new IdentTok("ns11", 0, 1, 1), new DotTok(".", 0, 1, 1), new IdentTok("ns12", 0, 1, 1)
-
-
-        ]
-        // element A:ns1.ns2.ns3.ns4.ns5.ns6.ns7.ns8.ns9.ns10.ns11.ns12 default 666;
-        // new ElementTok(1, 1), new IdentTok("A" , 0, 1, 1), new ColonTok(1,1),
-        // largeFqnTokenVector,new DefaultTok(1,1), new NumberTok(1,1,"666"), new SemiColonTok(";", 0, 1, 1)
-
-        it("can parse an element with Equals and a very long qualified name", function () {
-            let input:any = _.flatten([
-                // element A:ns1.ns2.ns3.ns4.ns5.ns6.ns7.ns8.ns9.ns10.ns11.ns12 = 666;
-                new ElementTok("element", 0, 1, 1), new IdentTok("A", 0, 1, 1), new ColonTok(":", 0, 1, 1),
-                largeFqnTokenVector, new EqualsTok("=", 0, 1, 1), new NumberTok("666", 0, 1, 1), new SemiColonTok(";", 0, 1, 1),
-            ])
-
-            let parser = new BackTrackingParser(input)
-            let result = parser.statement()
-
-            expect(parser.errors.length).to.equal(0)
-            expect(parser.isAtEndOfInput()).to.equal(true)
-            expect(result).to.equal(RET_TYPE.WITH_EQUALS)
-        })
-
-        it("can parse an element with Default and a very long qualified name", function () {
-            let input:any = _.flatten([
-                // element A:ns1.ns2.ns3.ns4.ns5.ns6.ns7.ns8.ns9.ns10.ns11.ns12 default 666;
-                new ElementTok("element", 0, 1, 1), new IdentTok("A", 0, 1, 1), new ColonTok(":", 0, 1, 1), largeFqnTokenVector,
-                new DefaultTok("deafult", 0, 1, 1), new NumberTok("666", 0, 1, 1), new SemiColonTok(";", 0, 1, 1),
-            ])
-
-            let parser = new BackTrackingParser(input)
-            let result = parser.statement()
+import {
+    IdentTok,
+    DotTok,
+    ElementTok,
+    EqualsTok,
+    NumberTok,
+    ColonTok,
+    SemiColonTok,
+    BackTrackingParser,
+    DefaultTok,
+    RET_TYPE
+} from "./backtracking_parser"
+import * as _ from "lodash"
+
+
+describe("Simple backtracking example", function () {
+
+    // TODO: modify example to use the Chevrotain Lexer to increase readability
+    let largeFqnTokenVector = [
+        new IdentTok("ns1", 0, 1, 1), new DotTok(".", 0, 1, 1), new IdentTok("ns2", 0, 1, 1), new DotTok(".", 0, 1, 1),
+        new IdentTok("ns3", 0, 1, 1), new DotTok(".", 0, 1, 1), new IdentTok("ns4", 0, 1, 1), new DotTok(".", 0, 1, 1),
+        new IdentTok("ns5", 0, 1, 1), new DotTok(".", 0, 1, 1), new IdentTok("ns6", 0, 1, 1), new DotTok(".", 0, 1, 1),
+        new IdentTok("ns7", 0, 1, 1), new DotTok(".", 0, 1, 1), new IdentTok("ns8", 0, 1, 1), new DotTok(".", 0, 1, 1),
+        new IdentTok("ns9", 0, 1, 1), new DotTok(".", 0, 1, 1), new IdentTok("ns10", 0, 1, 1), new DotTok(".", 0, 1, 1),
+        new IdentTok("ns11", 0, 1, 1), new DotTok(".", 0, 1, 1), new IdentTok("ns12", 0, 1, 1)
+    ]
+    // element A:ns1.ns2.ns3.ns4.ns5.ns6.ns7.ns8.ns9.ns10.ns11.ns12 default 666;
+    // new ElementTok(1, 1), new IdentTok("A" , 0, 1, 1), new ColonTok(1,1),
+    // largeFqnTokenVector,new DefaultTok(1,1), new NumberTok(1,1,"666"), new SemiColonTok(";", 0, 1, 1)
+
+    it("can parse an element with Equals and a very long qualified name", function () {
+        let input:any = _.flatten([
+            // element A:ns1.ns2.ns3.ns4.ns5.ns6.ns7.ns8.ns9.ns10.ns11.ns12 = 666;
+            new ElementTok("element", 0, 1, 1), new IdentTok("A", 0, 1, 1), new ColonTok(":", 0, 1, 1),
+            largeFqnTokenVector, new EqualsTok("=", 0, 1, 1), new NumberTok("666", 0, 1, 1), new SemiColonTok(";", 0, 1, 1),
+        ])
+
+        let parser = new BackTrackingParser(input)
+        let result = parser.statement()
+
+        expect(parser.errors.length).to.equal(0)
+        expect(parser.isAtEndOfInput()).to.equal(true)
+        expect(result).to.equal(RET_TYPE.WITH_EQUALS)
+    })
 
-            expect(parser.errors.length).to.equal(0)
-            expect(parser.isAtEndOfInput()).to.equal(true)
-            expect(result).to.equal(RET_TYPE.WITH_DEFAULT)
-        })
+    it("can parse an element with Default and a very long qualified name", function () {
+        let input:any = _.flatten([
+            // element A:ns1.ns2.ns3.ns4.ns5.ns6.ns7.ns8.ns9.ns10.ns11.ns12 default 666;
+            new ElementTok("element", 0, 1, 1), new IdentTok("A", 0, 1, 1), new ColonTok(":", 0, 1, 1), largeFqnTokenVector,
+            new DefaultTok("deafult", 0, 1, 1), new NumberTok("666", 0, 1, 1), new SemiColonTok(";", 0, 1, 1),
+        ])
 
+        let parser = new BackTrackingParser(input)
+        let result = parser.statement()
 
+        expect(parser.errors.length).to.equal(0)
+        expect(parser.isAtEndOfInput()).to.equal(true)
+        expect(result).to.equal(RET_TYPE.WITH_DEFAULT)
     })
 
-}
+})
diff --git a/test/full_flow/error_recovery/sql_statements/sql_recovery_parser.ts b/test/full_flow/error_recovery/sql_statements/sql_recovery_parser.ts
index 77d7f7b07..01406b64e 100644
--- a/test/full_flow/error_recovery/sql_statements/sql_recovery_parser.ts
+++ b/test/full_flow/error_recovery/sql_statements/sql_recovery_parser.ts
@@ -1,178 +1,200 @@
-namespace chevrotain.examples.recovery.sql {
-
-    /**
-     * a language made of a series of statements terminated by semicolons
-     *
-     * CREATE TABLE schema2.Persons
-     * INSERT (32, "SHAHAR") INTO schema2.Persons
-     * DELETE (31, "SHAHAR") FROM schema2.Persons
-     */
-    import pt = chevrotain.examples.tree
-    import gast = chevrotain.gast
-    import gastBuilder = chevrotain.gastBuilder
-    import follows = chevrotain.follow
-
-
-    // DOCS: to enable error recovery functionality one must extend BaseErrorRecoveryRecognizer
-    export class DDLExampleRecoveryParser extends Parser {
-
-        constructor(input:Token[] = [], isRecoveryEnabled = true) {
-            // DOCS: note the second parameter in the super class. this is the namespace in which the token constructors are defined.
-            //       it is mandatory to provide this map to be able to perform self analysis
-            //       and allow the framework to "understand" the implemented grammar.
-            super(input, <any>chevrotain.examples.recovery.sql, isRecoveryEnabled)
-            // DOCS: The call to performSelfAnalysis needs to happen after all the RULEs have been defined
-            //       The typescript compiler places the constructor body last after initializations in the class's body
-            //       which is why place the call here meets the criteria.
-            Parser.performSelfAnalysis(this)
-        }
-
-        // DOCS: the invocation to RULE(...) is what wraps our parsing implementation method
-        // with the error recovery re-sync behavior.
-        // note that when one parsing rule calls another (via SUBRULE) the invoked rule is the one defined here,
-        // without the "parse" prefix.
-        public ddl = this.RULE("ddl", this.parseDdl, INVALID(INVALID_DDL))
-        // DOCS: a specific return type has been provided in case of re-sync recovery.
-        public createStmt = this.RULE("createStmt", this.parseCreateStmt, INVALID(INVALID_CREATE_STMT))
-        public insertStmt = this.RULE("insertStmt", this.parseInsertStmt, INVALID(INVALID_INSERT_STMT))
-        public deleteStmt = this.RULE("deleteStmt", this.parseDeleteStmt, INVALID(INVALID_DELETE_STMT))
-        public qualifiedName = this.RULE("qualifiedName", this.parseQualifiedName, INVALID(INVALID_QUALIFIED_NAME))
-        public recordValue = this.RULE("recordValue", this.parseRecordValue, INVALID())
-        // DOCS: A Parsing rule may also be private and not part of the public API
-        private value = this.RULE("value", this.parseValue, INVALID())
-
-        // DOCS: note how all the parsing rules in this example return a ParseTree, we require some output from the parser
-        // to demonstrate the error recovery mechanisms. otherwise it is harder to prove we have indeed recovered.
-        private parseDdl():pt.ParseTree {
-            let stmts = []
-
-            this.MANY(() => {
-                this.OR([
-                    // @formatter:off
+/**
+ * a language made of a series of statements terminated by semicolons
+ *
+ * CREATE TABLE schema2.Persons
+ * INSERT (32, "SHAHAR") INTO schema2.Persons
+ * DELETE (31, "SHAHAR") FROM schema2.Persons
+ */
+import {Parser} from "../../../../src/parse/parser_public"
+import {Token, VirtualToken} from "../../../../src/scan/tokens_public"
+import * as allTokens from "./sql_recovery_tokens"
+import {
+    INVALID_DDL,
+    INVALID_CREATE_STMT,
+    INVALID_INSERT_STMT,
+    INVALID_DELETE_STMT,
+    INVALID_QUALIFIED_NAME,
+    STATEMENTS,
+    CreateTok,
+    TableTok,
+    SemiColonTok,
+    CREATE_STMT,
+    InsertTok,
+    IntoTok,
+    INSERT_STMT,
+    DeleteTok,
+    FromTok,
+    DELETE_STMT,
+    IdentTok,
+    DotTok,
+    DOTS,
+    QUALIFIED_NAME,
+    LParenTok,
+    CommaTok,
+    RParenTok,
+    COMMAS,
+    StringTok,
+    IntTok
+} from "./sql_recovery_tokens"
+import {ParseTree} from "../../parse_tree"
+
+// DOCS: to enable error recovery functionality one must extend BaseErrorRecoveryRecognizer
+export class DDLExampleRecoveryParser extends Parser {
+
+    constructor(input:Token[] = [], isRecoveryEnabled = true) {
+        // DOCS: note the second parameter in the super class. this is the namespace in which the token constructors are defined.
+        //       it is mandatory to provide this map to be able to perform self analysis
+        //       and allow the framework to "understand" the implemented grammar.
+        super(input, <any>allTokens, isRecoveryEnabled)
+        // DOCS: The call to performSelfAnalysis needs to happen after all the RULEs have been defined
+        //       The typescript compiler places the constructor body last after initializations in the class's body
+        //       which is why place the call here meets the criteria.
+        Parser.performSelfAnalysis(this)
+    }
+
+    // DOCS: the invocation to RULE(...) is what wraps our parsing implementation method
+    // with the error recovery re-sync behavior.
+    // note that when one parsing rule calls another (via SUBRULE) the invoked rule is the one defined here,
+    // without the "parse" prefix.
+    public ddl = this.RULE("ddl", this.parseDdl, INVALID(INVALID_DDL))
+    // DOCS: a specific return type has been provided in case of re-sync recovery.
+    public createStmt = this.RULE("createStmt", this.parseCreateStmt, INVALID(INVALID_CREATE_STMT))
+    public insertStmt = this.RULE("insertStmt", this.parseInsertStmt, INVALID(INVALID_INSERT_STMT))
+    public deleteStmt = this.RULE("deleteStmt", this.parseDeleteStmt, INVALID(INVALID_DELETE_STMT))
+    public qualifiedName = this.RULE("qualifiedName", this.parseQualifiedName, INVALID(INVALID_QUALIFIED_NAME))
+    public recordValue = this.RULE("recordValue", this.parseRecordValue, INVALID())
+    // DOCS: A Parsing rule may also be private and not part of the public API
+    private value = this.RULE("value", this.parseValue, INVALID())
+
+    // DOCS: note how all the parsing rules in this example return a ParseTree, we require some output from the parser
+    // to demonstrate the error recovery mechanisms. otherwise it is harder to prove we have indeed recovered.
+    private parseDdl():ParseTree {
+        let stmts = []
+
+        this.MANY(() => {
+            this.OR([
+                // @formatter:off
                     {ALT: () => { stmts.push(this.SUBRULE(this.createStmt)) }},
                     {ALT: () => { stmts.push(this.SUBRULE(this.insertStmt)) }},
                     {ALT: () => { stmts.push(this.SUBRULE(this.deleteStmt)) }},
                     // @formatter:on
-                ], "A Statement")
-            })
-
-            return PT(new STATEMENTS(), stmts)
-        }
-
-        private parseCreateStmt():pt.ParseTree {
-            let createKW, tableKW, qn, semiColon
-
-            createKW = this.CONSUME1(CreateTok)
-            tableKW = this.CONSUME1(TableTok)
-            qn = this.SUBRULE(this.qualifiedName)
-            semiColon = this.CONSUME1(SemiColonTok)
-
-            return PT(new CREATE_STMT(),
-                [PT(createKW), PT(tableKW), qn, PT(semiColon)])
-        }
-
-        private parseInsertStmt():pt.ParseTree {
-            let insertKW, recordValue, intoKW, qn, semiColon
-
-            // parse
-            insertKW = this.CONSUME1(InsertTok)
-            recordValue = this.SUBRULE(this.recordValue)
-            intoKW = this.CONSUME1(IntoTok)
-            qn = this.SUBRULE(this.qualifiedName)
-            semiColon = this.CONSUME1(SemiColonTok)
-
-            // tree rewrite
-            return PT(new INSERT_STMT(),
-                [PT(insertKW), recordValue, PT(intoKW), qn, PT(semiColon)])
-        }
-
-        private parseDeleteStmt():pt.ParseTree {
-            let deleteKW, recordValue, fromKW, qn, semiColon
-
-            // parse
-            deleteKW = this.CONSUME1(DeleteTok)
-            recordValue = this.SUBRULE(this.recordValue)
-            fromKW = this.CONSUME1(FromTok)
-            qn = this.SUBRULE(this.qualifiedName)
-            semiColon = this.CONSUME1(SemiColonTok)
-
-            // tree rewrite
-            return PT(new DELETE_STMT(),
-                [PT(deleteKW), recordValue, PT(fromKW), qn, PT(semiColon)])
-        }
-
-        private parseQualifiedName():pt.ParseTree {
-            let dots = []
-            let idents = []
-
-            // parse
-            // DOCS: note how we use CONSUME1(IdentTok) here
-            idents.push(this.CONSUME1(IdentTok))
-            this.MANY(() => {
-                dots.push(this.CONSUME1(DotTok))
-                // DOCS: yet here we use CONSUME2(IdentTok)
-                //       The number indicates the occurrence number of the consumption of the specific Token in the current
-                //       parse rule.
-                idents.push(this.CONSUME2(IdentTok))
-            })
-
-            // tree rewrite
-            let allIdentsPts = WRAP_IN_PT(idents)
-            let dotsPt = PT(new DOTS(), WRAP_IN_PT(dots))
-            let allPtChildren = allIdentsPts.concat([dotsPt])
-            return PT(new QUALIFIED_NAME(), <any>allPtChildren)
-        }
-
-        private parseRecordValue():pt.ParseTree {
-            let values = []
-            let commas = []
-
-            // parse
-            this.CONSUME1(LParenTok)
-            this.SUBRULE1(this.value)
-            this.MANY(() => {
-                commas.push(this.CONSUME1(CommaTok))
-                values.push(this.SUBRULE2(this.value))
-            })
-            this.CONSUME1(RParenTok)
-            // tree rewrite
-            let commasPt = PT(new COMMAS(), WRAP_IN_PT(commas))
-            let allPtChildren = values.concat([commasPt])
-            return PT(new QUALIFIED_NAME(), allPtChildren)
-        }
-
-        private parseValue():pt.ParseTree {
-            let value:Token = null
-            this.OR(
-                [   // @formatter:off
-                    {ALT: () => {value = this.CONSUME1(StringTok)}},
-                    {ALT: () => {value = this.CONSUME1(IntTok)}}
-                ])
-                    // @formatter:on
-            return PT(value)
-        }
+            ], "A Statement")
+        })
+
+        return PT(new STATEMENTS(), stmts)
+    }
+
+    private parseCreateStmt():ParseTree {
+        let createKW, tableKW, qn, semiColon
+
+        createKW = this.CONSUME1(CreateTok)
+        tableKW = this.CONSUME1(TableTok)
+        qn = this.SUBRULE(this.qualifiedName)
+        semiColon = this.CONSUME1(SemiColonTok)
+
+        return PT(new CREATE_STMT(),
+            [PT(createKW), PT(tableKW), qn, PT(semiColon)])
+    }
+
+    private parseInsertStmt():ParseTree {
+        let insertKW, recordValue, intoKW, qn, semiColon
+
+        // parse
+        insertKW = this.CONSUME1(InsertTok)
+        recordValue = this.SUBRULE(this.recordValue)
+        intoKW = this.CONSUME1(IntoTok)
+        qn = this.SUBRULE(this.qualifiedName)
+        semiColon = this.CONSUME1(SemiColonTok)
+
+        // tree rewrite
+        return PT(new INSERT_STMT(),
+            [PT(insertKW), recordValue, PT(intoKW), qn, PT(semiColon)])
+    }
+
+    private parseDeleteStmt():ParseTree {
+        let deleteKW, recordValue, fromKW, qn, semiColon
+
+        // parse
+        deleteKW = this.CONSUME1(DeleteTok)
+        recordValue = this.SUBRULE(this.recordValue)
+        fromKW = this.CONSUME1(FromTok)
+        qn = this.SUBRULE(this.qualifiedName)
+        semiColon = this.CONSUME1(SemiColonTok)
+
+        // tree rewrite
+        return PT(new DELETE_STMT(),
+            [PT(deleteKW), recordValue, PT(fromKW), qn, PT(semiColon)])
+    }
+
+    private parseQualifiedName():ParseTree {
+        let dots = []
+        let idents = []
+
+        // parse
+        // DOCS: note how we use CONSUME1(IdentTok) here
+        idents.push(this.CONSUME1(IdentTok))
+        this.MANY(() => {
+            dots.push(this.CONSUME1(DotTok))
+            // DOCS: yet here we use CONSUME2(IdentTok)
+            //       The number indicates the occurrence number of the consumption of the specific Token in the current
+            //       parse rule.
+            idents.push(this.CONSUME2(IdentTok))
+        })
+
+        // tree rewrite
+        let allIdentsPts = WRAP_IN_PT(idents)
+        let dotsPt = PT(new DOTS(), WRAP_IN_PT(dots))
+        let allPtChildren = allIdentsPts.concat([dotsPt])
+        return PT(new QUALIFIED_NAME(), <any>allPtChildren)
     }
 
-    // HELPER FUNCTIONS
-    function PT(token:Token, children:pt.ParseTree[] = []):pt.ParseTree {
-        return new pt.ParseTree(token, children)
+    private parseRecordValue():ParseTree {
+        let values = []
+        let commas = []
+
+        // parse
+        this.CONSUME1(LParenTok)
+        this.SUBRULE1(this.value)
+        this.MANY(() => {
+            commas.push(this.CONSUME1(CommaTok))
+            values.push(this.SUBRULE2(this.value))
+        })
+        this.CONSUME1(RParenTok)
+        // tree rewrite
+        let commasPt = PT(new COMMAS(), WRAP_IN_PT(commas))
+        let allPtChildren = values.concat([commasPt])
+        return PT(new QUALIFIED_NAME(), allPtChildren)
     }
 
-    export function WRAP_IN_PT(toks:Token[]):pt.ParseTree[] {
-        let parseTrees = new Array(toks.length)
-        for (let i = 0; i < toks.length; i++) {
-            parseTrees[i] = (PT(toks[i]))
-        }
-        return parseTrees
+    private parseValue():ParseTree {
+        let value:Token = null
+        this.OR(
+            [   // @formatter:off
+                    {ALT: () => {value = this.CONSUME1(StringTok)}},
+                    {ALT: () => {value = this.CONSUME1(IntTok)}}
+                ])
+                    // @formatter:on
+        return PT(value)
     }
+}
 
+// HELPER FUNCTIONS
+function PT(token:Token, children:ParseTree[] = []):ParseTree {
+    return new ParseTree(token, children)
+}
 
-    /* tslint:disable:class-name */
-    export class INVALID_INPUT extends VirtualToken {}
-    /* tslint:enable:class-name */
-    export function INVALID(tokType:Function = INVALID_INPUT):() => pt.ParseTree {
-        // virtual invalid tokens should have no parameters...
-        return () => {return PT(new (<any>tokType)()) }
+export function WRAP_IN_PT(toks:Token[]):ParseTree[] {
+    let parseTrees = new Array(toks.length)
+    for (let i = 0; i < toks.length; i++) {
+        parseTrees[i] = (PT(toks[i]))
     }
+    return parseTrees
+}
 
+/* tslint:disable:class-name */
+export class INVALID_INPUT extends VirtualToken {}
+/* tslint:enable:class-name */
+export function INVALID(tokType:Function = INVALID_INPUT):() => ParseTree {
+    // virtual invalid tokens should have no parameters...
+    return () => {return PT(new (<any>tokType)()) }
 }
diff --git a/test/full_flow/error_recovery/sql_statements/sql_recovery_spec.ts b/test/full_flow/error_recovery/sql_statements/sql_recovery_spec.ts
index 163de88d8..f9930fcb6 100644
--- a/test/full_flow/error_recovery/sql_statements/sql_recovery_spec.ts
+++ b/test/full_flow/error_recovery/sql_statements/sql_recovery_spec.ts
@@ -1,253 +1,275 @@
 // long lines for token init seems more readable to me than to break them up
 // into multiple line.
 /* tslint:disable:max-line-length  */
-namespace chevrotain.examples.recovery.sql.spec {
-
-    import pt =  chevrotain.examples.tree
-    import exceptions = chevrotain.exceptions
 
+import {
+    INVALID_DDL,
+    INVALID_CREATE_STMT,
+    INVALID_INSERT_STMT,
+    INVALID_DELETE_STMT,
+    STATEMENTS,
+    CreateTok,
+    TableTok,
+    SemiColonTok,
+    CREATE_STMT,
+    InsertTok,
+    IntoTok,
+    INSERT_STMT,
+    DeleteTok,
+    FromTok,
+    DELETE_STMT,
+    IdentTok,
+    DotTok,
+    LParenTok,
+    CommaTok,
+    RParenTok,
+    StringTok,
+    IntTok
+} from "./sql_recovery_tokens"
+import {DDLExampleRecoveryParser} from "./sql_recovery_parser"
+import {Token} from "../../../../src/scan/tokens_public"
+import {exceptions} from "../../../../src/parse/exceptions_public"
+import {ParseTree} from "../../parse_tree"
+import * as _ from "lodash"
+
+describe("Error Recovery SQL DDL Example", function () {
+    "use strict"
+
+    let schemaFQN = [new IdentTok(1, 1, "schema2"), new DotTok(1, 1), new IdentTok(1, 1, "Persons")]
+    /* tslint:disable:quotemark  */
+    let shahar32Record = [
+        new LParenTok(1, 1), new IntTok(1, 9, "32"), new CommaTok(1, 1), new StringTok(1, 1, '"SHAHAR"'), new RParenTok(1, 1)]
+    let shahar31Record = [new LParenTok(1, 1), new IntTok(1, 9, "31"), new CommaTok(1, 1), new StringTok(1, 1, '"SHAHAR"'), new RParenTok(1, 1)]
+    /* tslint:enable:quotemark  */
+
+    it("can parse a series of three statements successfully", function () {
+        let input:any = _.flatten([
+            // CREATE TABLE schema2.Persons
+            new CreateTok(1, 1), new TableTok(1, 1), schemaFQN, new SemiColonTok(1, 1),
+            // INSERT (32, "SHAHAR") INTO schema2.Persons
+            new InsertTok(1, 1), shahar32Record, new IntoTok(1, 1), schemaFQN, new SemiColonTok(1, 1),
+            // DELETE (31, "SHAHAR") FROM schema2.Persons
+            new DeleteTok(1, 1), shahar31Record, new FromTok(1, 1), schemaFQN, new SemiColonTok(1, 1)
+        ])
+
+        let parser = new DDLExampleRecoveryParser(input)
+        let ptResult = parser.ddl()
+        expect(parser.errors.length).to.equal(0)
+        expect(parser.isAtEndOfInput()).to.equal(true)
+        assertAllThreeStatementsPresentAndValid(ptResult)
+    })
 
-    describe("Error Recovery SQL DDL Example", function () {
-        "use strict"
 
-        let schemaFQN = [new IdentTok(1, 1, "schema2"), new DotTok(1, 1), new IdentTok(1, 1, "Persons")]
-        /* tslint:disable:quotemark  */
-        let shahar32Record = [
-            new LParenTok(1, 1), new IntTok(1, 9, "32"), new CommaTok(1, 1), new StringTok(1, 1, '"SHAHAR"'), new RParenTok(1, 1)]
-        let shahar31Record = [new LParenTok(1, 1), new IntTok(1, 9, "31"), new CommaTok(1, 1), new StringTok(1, 1, '"SHAHAR"'), new RParenTok(1, 1)]
-        /* tslint:enable:quotemark  */
-
-        it("can parse a series of three statements successfully", function () {
-            let input:any = _.flatten([
-                // CREATE TABLE schema2.Persons
-                new CreateTok(1, 1), new TableTok(1, 1), schemaFQN, new SemiColonTok(1, 1),
-                // INSERT (32, "SHAHAR") INTO schema2.Persons
-                new InsertTok(1, 1), shahar32Record, new IntoTok(1, 1), schemaFQN, new SemiColonTok(1, 1),
-                // DELETE (31, "SHAHAR") FROM schema2.Persons
-                new DeleteTok(1, 1), shahar31Record, new FromTok(1, 1), schemaFQN, new SemiColonTok(1, 1)
-            ])
+    describe("Single Token insertion recovery mechanism", () => {
+        let input:any = _.flatten([
+            // CREATE TABLE schema2.Persons
+            new CreateTok(1, 1), new TableTok(1, 1), schemaFQN, new SemiColonTok(1, 1),
+            // INSERT (32, "SHAHAR") INTO schema2.Persons
+            new InsertTok(1, 1), shahar32Record, new IntoTok(1, 1), schemaFQN, /*new SemiColonTok(1, 1), <-- missing semicolon!*/
+            // DELETE (31, "SHAHAR") FROM schema2.Persons
+            new DeleteTok(1, 1), shahar31Record, new FromTok(1, 1), schemaFQN, new SemiColonTok(1, 1)
+        ])
 
+        it("can perform single token insertion for a missing semicolon", function () {
             let parser = new DDLExampleRecoveryParser(input)
-            let ptResult = parser.ddl()
-            expect(parser.errors.length).to.equal(0)
+            let ptResult:any = parser.ddl()
+            // one error encountered
+            expect(parser.errors.length).to.equal(1)
+            // yet the whole input has been parsed
             expect(parser.isAtEndOfInput()).to.equal(true)
+            // and the output parseTree contains ALL three statements
             assertAllThreeStatementsPresentAndValid(ptResult)
+            let insertedSemiColon:Token = ptResult.children[1].children[4].payload
+            // the semicolon is present even though it did not exist in the input, magic!
+            expect(insertedSemiColon).to.be.an.instanceof(SemiColonTok)
+            expect(insertedSemiColon.isInsertedInRecovery).to.equal(true)
         })
 
-
-        describe("Single Token insertion recovery mechanism", () => {
-            let input:any = _.flatten([
-                // CREATE TABLE schema2.Persons
-                new CreateTok(1, 1), new TableTok(1, 1), schemaFQN, new SemiColonTok(1, 1),
-                // INSERT (32, "SHAHAR") INTO schema2.Persons
-                new InsertTok(1, 1), shahar32Record, new IntoTok(1, 1), schemaFQN, /*new SemiColonTok(1, 1), <-- missing semicolon!*/
-                // DELETE (31, "SHAHAR") FROM schema2.Persons
-                new DeleteTok(1, 1), shahar31Record, new FromTok(1, 1), schemaFQN, new SemiColonTok(1, 1)
-            ])
-
-            it("can perform single token insertion for a missing semicolon", function () {
-                let parser = new DDLExampleRecoveryParser(input)
-                let ptResult:any = parser.ddl()
-                // one error encountered
-                expect(parser.errors.length).to.equal(1)
-                // yet the whole input has been parsed
-                expect(parser.isAtEndOfInput()).to.equal(true)
-                // and the output parseTree contains ALL three statements
-                assertAllThreeStatementsPresentAndValid(ptResult)
-                let insertedSemiColon:Token = ptResult.children[1].children[4].payload
-                // the semicolon is present even though it did not exist in the input, magic!
-                expect(insertedSemiColon).to.be.an.instanceof(SemiColonTok)
-                expect(insertedSemiColon.isInsertedInRecovery).to.equal(true)
-            })
-
-            it("can disable single token insertion for a missing semicolon", function () {
-                let parser = new DDLExampleRecoveryParser(input, false)
-                let ptResult:any = parser.ddl()
-                expect(parser.errors.length).to.equal(1)
-                expect(parser.isAtEndOfInput()).to.equal(true)
-                expect(ptResult.payload).to.be.an.instanceof(INVALID_DDL)
-                expect(ptResult.children).to.have.length(0)
-            })
+        it("can disable single token insertion for a missing semicolon", function () {
+            let parser = new DDLExampleRecoveryParser(input, false)
+            let ptResult:any = parser.ddl()
+            expect(parser.errors.length).to.equal(1)
+            expect(parser.isAtEndOfInput()).to.equal(true)
+            expect(ptResult.payload).to.be.an.instanceof(INVALID_DDL)
+            expect(ptResult.children).to.have.length(0)
         })
+    })
 
+    describe("Single Token deletion recovery mechanism", () => {
 
-        describe("Single Token deletion recovery mechanism", () => {
+        let input:any = _.flatten([
+            // CREATE TABLE schema2.Persons
+            new CreateTok(1, 1), new TableTok(1, 1), schemaFQN, new SemiColonTok(1, 1),
+            // INSERT (32, "SHAHAR") INTO INTO schema2.Persons
+            new InsertTok(1, 1), shahar32Record, new IntoTok(1, 1), new IntoTok(1, 1), /* <-- "INTO INTO" oops */ schemaFQN, new SemiColonTok(1, 1),
+            // DELETE (31, "SHAHAR") FROM schema2.Persons
+            new DeleteTok(1, 1), shahar31Record, new FromTok(1, 1), schemaFQN, new SemiColonTok(1, 1)
+        ])
 
-            let input:any = _.flatten([
-                // CREATE TABLE schema2.Persons
-                new CreateTok(1, 1), new TableTok(1, 1), schemaFQN, new SemiColonTok(1, 1),
-                // INSERT (32, "SHAHAR") INTO INTO schema2.Persons
-                new InsertTok(1, 1), shahar32Record, new IntoTok(1, 1), new IntoTok(1, 1), /* <-- "INTO INTO" oops */ schemaFQN, new SemiColonTok(1, 1),
-                // DELETE (31, "SHAHAR") FROM schema2.Persons
-                new DeleteTok(1, 1), shahar31Record, new FromTok(1, 1), schemaFQN, new SemiColonTok(1, 1)
-            ])
+        it("can perform single token deletion for a redundant keyword", function () {
+            let parser = new DDLExampleRecoveryParser(input)
+            let ptResult = parser.ddl()
+            // one error encountered
+            expect(parser.errors.length).to.equal(1)
+            // yet the whole input has been parsed
+            expect(parser.isAtEndOfInput()).to.equal(true)
+            // and the output parseTree contains ALL three statements
+            assertAllThreeStatementsPresentAndValid(ptResult)
+        })
 
-            it("can perform single token deletion for a redundant keyword", function () {
-                let parser = new DDLExampleRecoveryParser(input)
-                let ptResult = parser.ddl()
-                // one error encountered
-                expect(parser.errors.length).to.equal(1)
-                // yet the whole input has been parsed
-                expect(parser.isAtEndOfInput()).to.equal(true)
-                // and the output parseTree contains ALL three statements
-                assertAllThreeStatementsPresentAndValid(ptResult)
-            })
-
-            it("can disable single token deletion for a redundant keyword", function () {
-                let parser = new DDLExampleRecoveryParser(input, false)
-                let ptResult:any = parser.ddl()
-                expect(parser.errors.length).to.equal(1)
-                expect(parser.isAtEndOfInput()).to.equal(true)
-                expect(ptResult.payload).to.be.an.instanceof(INVALID_DDL)
-                expect(ptResult.children).to.have.length(0)
-            })
+        it("can disable single token deletion for a redundant keyword", function () {
+            let parser = new DDLExampleRecoveryParser(input, false)
+            let ptResult:any = parser.ddl()
+            expect(parser.errors.length).to.equal(1)
+            expect(parser.isAtEndOfInput()).to.equal(true)
+            expect(ptResult.payload).to.be.an.instanceof(INVALID_DDL)
+            expect(ptResult.children).to.have.length(0)
         })
+    })
 
 
-        describe("resync recovery mechanism", () => {
-
-            it("can perform re-sync recovery and only 'lose' part of the input", function () {
-                let input:any = _.flatten([
-                    // CREATE TABLE schema2.Persons
-                    new CreateTok(1, 1), new TableTok(1, 1), schemaFQN, new SemiColonTok(1, 1),
-                    // INSERT (32, "SHAHAR") FROM (( schema2.Persons <-- this can't be recovered with a single token insertion of deletion, must do re-sync
-                    new InsertTok(1, 1), shahar32Record, new FromTok(1, 1), new LParenTok(1, 1), new LParenTok(1, 1), schemaFQN, new SemiColonTok(1, 1),
-                    // DELETE (31, "SHAHAR") FROM schema2.Persons
-                    new DeleteTok(1, 1), shahar31Record, new FromTok(1, 1), schemaFQN, new SemiColonTok(1, 1)
-                ])
-
-                let parser = new DDLExampleRecoveryParser(input)
-                let ptResult:any = parser.ddl()
-                // one error encountered
-                expect(parser.errors.length).to.equal(1)
-                // yet the whole input has been parsed
-                expect(parser.isAtEndOfInput()).to.equal(true)
-                expect(ptResult.payload).to.be.an.instanceof(STATEMENTS)
-                // 3 statements found
-                expect(ptResult.children.length).to.equal(3)
-                expect(ptResult.children[0].payload).to.be.an.instanceOf(CREATE_STMT)
-                expect(ptResult.children[0].payload).not.to.be.an.instanceof(INVALID_CREATE_STMT)
-                // but the second one is marked as invalid
-                expect(ptResult.children[1].payload).to.be.an.instanceof(INVALID_INSERT_STMT)
-                // yet the third one is still valid!, we recovered and continued parsing.
-                expect(ptResult.children[2].payload).to.be.an.instanceof(DELETE_STMT)
-                expect(ptResult.children[2].payload).not.to.be.an.instanceof(INVALID_DELETE_STMT)
-            })
-            // (32, "SHAHAR" ( <-- wrong parenthesis
-            let badShahar32Record = [
-                new LParenTok(1, 1), new IntTok(1, 9, "32"), new CommaTok(1, 1), new StringTok(1, 1, "\"SHAHAR\""), new LParenTok(1, 1)]
+    describe("resync recovery mechanism", () => {
 
+        it("can perform re-sync recovery and only 'lose' part of the input", function () {
             let input:any = _.flatten([
                 // CREATE TABLE schema2.Persons
                 new CreateTok(1, 1), new TableTok(1, 1), schemaFQN, new SemiColonTok(1, 1),
-                // issues:
-                // 1. FromTok instead of IntoTok so this rule also includes a bug
-                // 2. using the bad/invalid record Token.
-                new InsertTok(1, 1), badShahar32Record, new FromTok(1, 1), schemaFQN, new SemiColonTok(1, 1),
+                // INSERT (32, "SHAHAR") FROM (( schema2.Persons <-- this can't be recovered with a single token insertion of deletion, must do re-sync
+                new InsertTok(1, 1), shahar32Record, new FromTok(1, 1), new LParenTok(1, 1), new LParenTok(1, 1), schemaFQN, new SemiColonTok(1, 1),
                 // DELETE (31, "SHAHAR") FROM schema2.Persons
                 new DeleteTok(1, 1), shahar31Record, new FromTok(1, 1), schemaFQN, new SemiColonTok(1, 1)
             ])
 
-            it("can perform re-sync recovery and only 'lose' part of the input even when re-syncing to two rules 'above'", function () {
-                let parser = new DDLExampleRecoveryParser(input)
-                let ptResult:any = parser.ddl()
-                // one error encountered
-                expect(parser.errors.length).to.equal(1)
-                // yet the whole input has been parsed
-                expect(parser.isAtEndOfInput()).to.equal(true)
-                expect(ptResult.payload).to.be.an.instanceof(STATEMENTS)
-                // 3 statements found
-                expect(ptResult.children.length).to.equal(3)
-                expect(ptResult.children[0].payload).to.be.an.instanceof(CREATE_STMT)
-                expect(ptResult.children[0].payload).not.to.be.an.instanceof(INVALID_CREATE_STMT)
-                // but the second one is marked as invalid, this means we kept trying to re-sync to an "higher" rule
-                expect(ptResult.children[1].payload).to.be.an.instanceof(INVALID_INSERT_STMT)
-                // yet the third one is still valid!, we recovered and continued parsing.
-                expect(ptResult.children[2].payload).to.be.an.instanceof(DELETE_STMT)
-                expect(ptResult.children[2].payload).not.to.be.an.instanceof(INVALID_DELETE_STMT)
-            })
-
-            it("can disable re-sync recovery and only 'lose' part of the input even when re-syncing to two rules 'above'", function () {
-                let parser = new DDLExampleRecoveryParser(input, false)
-                let ptResult:any = parser.ddl()
-                // one error encountered
-                expect(parser.errors.length).to.equal(1)
-                // yet the whole input has been parsed
-                expect(parser.isAtEndOfInput()).to.equal(true)
-                expect(ptResult.payload).to.be.an.instanceof(INVALID_DDL)
-                expect(ptResult.children).to.have.length(0)
-            })
-        })
-
-
-        function assertAllThreeStatementsPresentAndValid(ptResult:pt.ParseTree):void {
+            let parser = new DDLExampleRecoveryParser(input)
+            let ptResult:any = parser.ddl()
+            // one error encountered
+            expect(parser.errors.length).to.equal(1)
+            // yet the whole input has been parsed
+            expect(parser.isAtEndOfInput()).to.equal(true)
             expect(ptResult.payload).to.be.an.instanceof(STATEMENTS)
             // 3 statements found
             expect(ptResult.children.length).to.equal(3)
-            expect(ptResult.children[0].payload).to.be.an.instanceof(CREATE_STMT)
+            expect(ptResult.children[0].payload).to.be.an.instanceOf(CREATE_STMT)
             expect(ptResult.children[0].payload).not.to.be.an.instanceof(INVALID_CREATE_STMT)
-            expect(ptResult.children[1].payload).to.be.an.instanceof(INSERT_STMT)
-            expect(ptResult.children[1].payload).not.to.be.an.instanceof(INVALID_INSERT_STMT)
+            // but the second one is marked as invalid
+            expect(ptResult.children[1].payload).to.be.an.instanceof(INVALID_INSERT_STMT)
+            // yet the third one is still valid!, we recovered and continued parsing.
             expect(ptResult.children[2].payload).to.be.an.instanceof(DELETE_STMT)
             expect(ptResult.children[2].payload).not.to.be.an.instanceof(INVALID_DELETE_STMT)
-        }
-
-
-        it("will encounter an NotAllInputParsedException when some of the input vector has not been parsed", function () {
-            let input:any = _.flatten([
-                // CREATE TABLE schema2.Persons; TABLE <-- redundant "TABLE" token
-                new CreateTok(1, 1), new TableTok(1, 1), schemaFQN, new SemiColonTok(1, 1), new TableTok(1, 1)])
+        })
+        // (32, "SHAHAR" ( <-- wrong parenthesis
+        let badShahar32Record = [
+            new LParenTok(1, 1), new IntTok(1, 9, "32"), new CommaTok(1, 1), new StringTok(1, 1, "\"SHAHAR\""), new LParenTok(1, 1)]
+
+        let input:any = _.flatten([
+            // CREATE TABLE schema2.Persons
+            new CreateTok(1, 1), new TableTok(1, 1), schemaFQN, new SemiColonTok(1, 1),
+            // issues:
+            // 1. FromTok instead of IntoTok so this rule also includes a bug
+            // 2. using the bad/invalid record Token.
+            new InsertTok(1, 1), badShahar32Record, new FromTok(1, 1), schemaFQN, new SemiColonTok(1, 1),
+            // DELETE (31, "SHAHAR") FROM schema2.Persons
+            new DeleteTok(1, 1), shahar31Record, new FromTok(1, 1), schemaFQN, new SemiColonTok(1, 1)
+        ])
+
+        it("can perform re-sync recovery and only 'lose' part of the input even when re-syncing to two rules 'above'", function () {
             let parser = new DDLExampleRecoveryParser(input)
-
-            parser.ddl()
+            let ptResult:any = parser.ddl()
+            // one error encountered
             expect(parser.errors.length).to.equal(1)
-            expect(parser.errors[0]).to.be.an.instanceof(exceptions.NotAllInputParsedException)
-        })
-
-        it("can use the same parser instance to parse multiple inputs", function () {
-            let input1:any = _.flatten([
-                // CREATE TABLE schema2.Persons;
-                new CreateTok(1, 1), new TableTok(1, 1), schemaFQN, new SemiColonTok(1, 1)])
-            let parser = new DDLExampleRecoveryParser(input1)
-            parser.ddl()
-            expect(parser.errors.length).to.equal(0)
+            // yet the whole input has been parsed
             expect(parser.isAtEndOfInput()).to.equal(true)
+            expect(ptResult.payload).to.be.an.instanceof(STATEMENTS)
+            // 3 statements found
+            expect(ptResult.children.length).to.equal(3)
+            expect(ptResult.children[0].payload).to.be.an.instanceof(CREATE_STMT)
+            expect(ptResult.children[0].payload).not.to.be.an.instanceof(INVALID_CREATE_STMT)
+            // but the second one is marked as invalid, this means we kept trying to re-sync to an "higher" rule
+            expect(ptResult.children[1].payload).to.be.an.instanceof(INVALID_INSERT_STMT)
+            // yet the third one is still valid!, we recovered and continued parsing.
+            expect(ptResult.children[2].payload).to.be.an.instanceof(DELETE_STMT)
+            expect(ptResult.children[2].payload).not.to.be.an.instanceof(INVALID_DELETE_STMT)
+        })
 
-
-            let input2:any = _.flatten([
-                // DELETE (31, "SHAHAR") FROM schema2.Persons
-                new DeleteTok(1, 1), shahar31Record, new FromTok(1, 1), schemaFQN, new SemiColonTok(1, 1)])
-            // the parser is being reset instead of creating a new instance for each new input
-            parser.reset();
-            parser.input = input2
+        it("can disable re-sync recovery and only 'lose' part of the input even when re-syncing to two rules 'above'", function () {
+            let parser = new DDLExampleRecoveryParser(input, false)
             let ptResult:any = parser.ddl()
-            expect(parser.errors.length).to.equal(0)
+            // one error encountered
+            expect(parser.errors.length).to.equal(1)
+            // yet the whole input has been parsed
             expect(parser.isAtEndOfInput()).to.equal(true)
-            // verify returned ParseTree
-            expect(ptResult.payload).to.be.an.instanceof(STATEMENTS)
-            expect(ptResult.children.length).to.equal(1)
-            expect(ptResult.children[0].payload).to.be.an.instanceof(DELETE_STMT)
-            expect(ptResult.children[0].payload).not.to.be.an.instanceof(INVALID_DELETE_STMT)
+            expect(ptResult.payload).to.be.an.instanceof(INVALID_DDL)
+            expect(ptResult.children).to.have.length(0)
         })
+    })
 
-        it("can re-sync to the next iteration in a MANY rule", function () {
-            let input:any = _.flatten([
-                // CREATE TABLE schema2.Persons
-                new CreateTok(1, 1), new TableTok(1, 1), schemaFQN, new SemiColonTok(1, 1),
-                // INSERT (32, "SHAHAR") INTO schema2.Persons TABLE <-- the redundant 'TABLE' should trigger in repetition recovery
-                new InsertTok(1, 1), shahar32Record, new IntoTok(1, 1), schemaFQN, new SemiColonTok(1, 1), new TableTok(1, 1),
 
-                // DELETE (31, "SHAHAR") FROM schema2.Persons
-                new DeleteTok(1, 1), shahar31Record, new FromTok(1, 1), schemaFQN, new SemiColonTok(1, 1)
-            ])
+    function assertAllThreeStatementsPresentAndValid(ptResult:ParseTree):void {
+        expect(ptResult.payload).to.be.an.instanceof(STATEMENTS)
+        // 3 statements found
+        expect(ptResult.children.length).to.equal(3)
+        expect(ptResult.children[0].payload).to.be.an.instanceof(CREATE_STMT)
+        expect(ptResult.children[0].payload).not.to.be.an.instanceof(INVALID_CREATE_STMT)
+        expect(ptResult.children[1].payload).to.be.an.instanceof(INSERT_STMT)
+        expect(ptResult.children[1].payload).not.to.be.an.instanceof(INVALID_INSERT_STMT)
+        expect(ptResult.children[2].payload).to.be.an.instanceof(DELETE_STMT)
+        expect(ptResult.children[2].payload).not.to.be.an.instanceof(INVALID_DELETE_STMT)
+    }
+
+
+    it("will encounter an NotAllInputParsedException when some of the input vector has not been parsed", function () {
+        let input:any = _.flatten([
+            // CREATE TABLE schema2.Persons; TABLE <-- redundant "TABLE" token
+            new CreateTok(1, 1), new TableTok(1, 1), schemaFQN, new SemiColonTok(1, 1), new TableTok(1, 1)])
+        let parser = new DDLExampleRecoveryParser(input)
+
+        parser.ddl()
+        expect(parser.errors.length).to.equal(1)
+        expect(parser.errors[0]).to.be.an.instanceof(exceptions.NotAllInputParsedException)
+    })
 
-            let parser = new DDLExampleRecoveryParser(input)
-            let ptResult = parser.ddl()
-            expect(parser.errors.length).to.equal(1)
-            expect(parser.isAtEndOfInput()).to.equal(true)
-            assertAllThreeStatementsPresentAndValid(ptResult)
-        })
+    it("can use the same parser instance to parse multiple inputs", function () {
+        let input1:any = _.flatten([
+            // CREATE TABLE schema2.Persons;
+            new CreateTok(1, 1), new TableTok(1, 1), schemaFQN, new SemiColonTok(1, 1)])
+        let parser = new DDLExampleRecoveryParser(input1)
+        parser.ddl()
+        expect(parser.errors.length).to.equal(0)
+        expect(parser.isAtEndOfInput()).to.equal(true)
+
+
+        let input2:any = _.flatten([
+            // DELETE (31, "SHAHAR") FROM schema2.Persons
+            new DeleteTok(1, 1), shahar31Record, new FromTok(1, 1), schemaFQN, new SemiColonTok(1, 1)])
+        // the parser is being reset instead of creating a new instance for each new input
+        parser.reset();
+        parser.input = input2
+        let ptResult:any = parser.ddl()
+        expect(parser.errors.length).to.equal(0)
+        expect(parser.isAtEndOfInput()).to.equal(true)
+        // verify returned ParseTree
+        expect(ptResult.payload).to.be.an.instanceof(STATEMENTS)
+        expect(ptResult.children.length).to.equal(1)
+        expect(ptResult.children[0].payload).to.be.an.instanceof(DELETE_STMT)
+        expect(ptResult.children[0].payload).not.to.be.an.instanceof(INVALID_DELETE_STMT)
+    })
 
+    it("can re-sync to the next iteration in a MANY rule", function () {
+        let input:any = _.flatten([
+            // CREATE TABLE schema2.Persons
+            new CreateTok(1, 1), new TableTok(1, 1), schemaFQN, new SemiColonTok(1, 1),
+            // INSERT (32, "SHAHAR") INTO schema2.Persons TABLE <-- the redundant 'TABLE' should trigger in repetition recovery
+            new InsertTok(1, 1), shahar32Record, new IntoTok(1, 1), schemaFQN, new SemiColonTok(1, 1), new TableTok(1, 1),
+
+            // DELETE (31, "SHAHAR") FROM schema2.Persons
+            new DeleteTok(1, 1), shahar31Record, new FromTok(1, 1), schemaFQN, new SemiColonTok(1, 1)
+        ])
+
+        let parser = new DDLExampleRecoveryParser(input)
+        let ptResult = parser.ddl()
+        expect(parser.errors.length).to.equal(1)
+        expect(parser.isAtEndOfInput()).to.equal(true)
+        assertAllThreeStatementsPresentAndValid(ptResult)
     })
 
-}
+})
diff --git a/test/full_flow/error_recovery/sql_statements/sql_recovery_tokens.ts b/test/full_flow/error_recovery/sql_statements/sql_recovery_tokens.ts
index 032b7012c..2017ee652 100644
--- a/test/full_flow/error_recovery/sql_statements/sql_recovery_tokens.ts
+++ b/test/full_flow/error_recovery/sql_statements/sql_recovery_tokens.ts
@@ -1,85 +1,80 @@
+import {Token, VirtualToken} from "../../../../src/scan/tokens_public"
 
-namespace chevrotain.examples.recovery.sql {
-
-
-    export class IdentTok extends Token {
-        constructor(startLine:number, startColumn:number, image:string) { super(image, -1, startLine, startColumn) }
-    }
-
-    // DOCS: once again an example of Token types hierarchies
-    export class LiteralTok extends Token {}
-    export class StringTok extends LiteralTok {
-        constructor(startLine:number, startColumn:number, image:string) { super(image, -1, startLine, startColumn) }
-    }
-    export class IntTok extends LiteralTok {
-        constructor(startLine:number, startColumn:number, image:string) { super(image, -1, startLine, startColumn) }
-    }
-
-    export class Keyword extends Token {}
-
-    export class CreateTok extends Keyword {
-        constructor(startLine:number, startColumn:number) { super("CREATE", -1, startLine, startColumn) }
-    }
-
-    export class TableTok extends Keyword {
-        constructor(startLine:number, startColumn:number) { super("TABLE", -1, startLine, startColumn) }
-    }
-
-    export class InsertTok extends Keyword {
-        constructor(startLine:number, startColumn:number) { super("INSERT", -1, startLine, startColumn) }
-    }
-
-    export class IntoTok extends Keyword {
-        constructor(startLine:number, startColumn:number) { super("INTO", -1, startLine, startColumn) }
-    }
-
-    export class DeleteTok extends Keyword {
-        constructor(startLine:number, startColumn:number) { super("DELETE", -1, startLine, startColumn) }
-    }
-
-    export class FromTok extends Keyword {
-        constructor(startLine:number, startColumn:number) { super("FROM", -1, startLine, startColumn) }
-    }
-
-    export class LParenTok extends Token {
-        constructor(startLine:number, startColumn:number) { super("(", -1, startLine, startColumn) }
-    }
-
-    export class RParenTok extends Token {
-        constructor(startLine:number, startColumn:number) { super(")", -1, startLine, startColumn) }
-    }
-
-    export class CommaTok extends Token {
-        constructor(startLine:number, startColumn:number) { super(",", -1, startLine, startColumn) }
-    }
-
-    export class SemiColonTok extends Token {
-        constructor(startLine:number, startColumn:number) { super(";", -1, startLine, startColumn) }
-    }
-
-    export class DotTok extends Token {
-        constructor(startLine:number, startColumn:number) { super(".", -1, startLine, startColumn) }
-    }
-
-
-    /* tslint:disable:class-name */
-    // virtual tokens for Building the parseTree, these just give a "type/specification/categorization" to a ParseTree
-    export class STATEMENTS extends VirtualToken {}
-    export class CREATE_STMT extends VirtualToken {}
-    export class INSERT_STMT extends VirtualToken {}
-    export class DELETE_STMT extends VirtualToken {}
-    export class QUALIFIED_NAME extends VirtualToken {}
-    export class DOTS extends VirtualToken {}
-    export class COMMAS extends VirtualToken {}
-
-
-    // some "INVALID" virtual tokens can be defined to output a more "precise" ParseTree in case of an re-sync error
-    // defining them as subclasses of the "valid" virtual tokens can making handling of invalid input easier in whatever
-    // component which consumes the output ParseTree in order to build some Ast or other data structure.
-    export class INVALID_DDL extends VirtualToken {}
-    export class INVALID_CREATE_STMT extends CREATE_STMT {}
-    export class INVALID_INSERT_STMT extends INSERT_STMT {}
-    export class INVALID_DELETE_STMT extends DELETE_STMT {}
-    export class INVALID_QUALIFIED_NAME extends QUALIFIED_NAME {}
-    /* tslint:enable:class-name */
+export class IdentTok extends Token {
+    constructor(startLine:number, startColumn:number, image:string) { super(image, -1, startLine, startColumn) }
 }
+
+// DOCS: once again an example of Token types hierarchies
+export class LiteralTok extends Token {}
+export class StringTok extends LiteralTok {
+    constructor(startLine:number, startColumn:number, image:string) { super(image, -1, startLine, startColumn) }
+}
+export class IntTok extends LiteralTok {
+    constructor(startLine:number, startColumn:number, image:string) { super(image, -1, startLine, startColumn) }
+}
+
+export class Keyword extends Token {}
+
+export class CreateTok extends Keyword {
+    constructor(startLine:number, startColumn:number) { super("CREATE", -1, startLine, startColumn) }
+}
+
+export class TableTok extends Keyword {
+    constructor(startLine:number, startColumn:number) { super("TABLE", -1, startLine, startColumn) }
+}
+
+export class InsertTok extends Keyword {
+    constructor(startLine:number, startColumn:number) { super("INSERT", -1, startLine, startColumn) }
+}
+
+export class IntoTok extends Keyword {
+    constructor(startLine:number, startColumn:number) { super("INTO", -1, startLine, startColumn) }
+}
+
+export class DeleteTok extends Keyword {
+    constructor(startLine:number, startColumn:number) { super("DELETE", -1, startLine, startColumn) }
+}
+
+export class FromTok extends Keyword {
+    constructor(startLine:number, startColumn:number) { super("FROM", -1, startLine, startColumn) }
+}
+
+export class LParenTok extends Token {
+    constructor(startLine:number, startColumn:number) { super("(", -1, startLine, startColumn) }
+}
+
+export class RParenTok extends Token {
+    constructor(startLine:number, startColumn:number) { super(")", -1, startLine, startColumn) }
+}
+
+export class CommaTok extends Token {
+    constructor(startLine:number, startColumn:number) { super(",", -1, startLine, startColumn) }
+}
+
+export class SemiColonTok extends Token {
+    constructor(startLine:number, startColumn:number) { super(";", -1, startLine, startColumn) }
+}
+
+export class DotTok extends Token {
+    constructor(startLine:number, startColumn:number) { super(".", -1, startLine, startColumn) }
+}
+
+/* tslint:disable:class-name */
+// virtual tokens for Building the parseTree, these just give a "type/specification/categorization" to a ParseTree
+export class STATEMENTS extends VirtualToken {}
+export class CREATE_STMT extends VirtualToken {}
+export class INSERT_STMT extends VirtualToken {}
+export class DELETE_STMT extends VirtualToken {}
+export class QUALIFIED_NAME extends VirtualToken {}
+export class DOTS extends VirtualToken {}
+export class COMMAS extends VirtualToken {}
+
+// some "INVALID" virtual tokens can be defined to output a more "precise" ParseTree in case of an re-sync error
+// defining them as subclasses of the "valid" virtual tokens can making handling of invalid input easier in whatever
+// component which consumes the output ParseTree in order to build some Ast or other data structure.
+export class INVALID_DDL extends VirtualToken {}
+export class INVALID_CREATE_STMT extends CREATE_STMT {}
+export class INVALID_INSERT_STMT extends INSERT_STMT {}
+export class INVALID_DELETE_STMT extends DELETE_STMT {}
+export class INVALID_QUALIFIED_NAME extends QUALIFIED_NAME {}
+/* tslint:enable:class-name */
diff --git a/test/full_flow/error_recovery/switch_case/Switchcase_recovery_tokens.ts b/test/full_flow/error_recovery/switch_case/Switchcase_recovery_tokens.ts
index f3c576989..e52eeba04 100644
--- a/test/full_flow/error_recovery/switch_case/Switchcase_recovery_tokens.ts
+++ b/test/full_flow/error_recovery/switch_case/Switchcase_recovery_tokens.ts
@@ -1,47 +1,44 @@
+import {Token} from "../../../../src/scan/tokens_public"
 
-namespace chevrotain.examples.recovery.switchcase {
+export class IdentTok extends Token {}
+export class LiteralTok extends Token {}
+export class IntTok extends LiteralTok {}
+export class StringTok extends LiteralTok {}
+export class Keyword extends Token {}
 
+export class SwitchTok extends Keyword {
+    constructor(startLine:number, startColumn:number) { super("switch", -1, startLine, startColumn) }
+}
 
-    export class IdentTok extends Token {}
-    export class LiteralTok extends Token {}
-    export class IntTok extends LiteralTok {}
-    export class StringTok extends LiteralTok {}
-    export class Keyword extends Token {}
-
-    export class SwitchTok extends Keyword {
-        constructor(startLine:number, startColumn:number) { super("switch", -1, startLine, startColumn) }
-    }
-
-    export class CaseTok extends Keyword {
-        constructor(startLine:number, startColumn:number) { super("case", -1, startLine, startColumn) }
-    }
-
-    export class ReturnTok extends Keyword {
-        constructor(startLine:number, startColumn:number) { super("INTO", -1, startLine, startColumn) }
-    }
+export class CaseTok extends Keyword {
+    constructor(startLine:number, startColumn:number) { super("case", -1, startLine, startColumn) }
+}
 
-    export class LParenTok extends Token {
-        constructor(startLine:number, startColumn:number) { super("(", -1, startLine, startColumn) }
-    }
+export class ReturnTok extends Keyword {
+    constructor(startLine:number, startColumn:number) { super("INTO", -1, startLine, startColumn) }
+}
 
-    export class RParenTok extends Token {
-        constructor(startLine:number, startColumn:number) { super(")", -1, startLine, startColumn) }
-    }
+export class LParenTok extends Token {
+    constructor(startLine:number, startColumn:number) { super("(", -1, startLine, startColumn) }
+}
 
-    export class LCurlyTok extends Token {
-        constructor(startLine:number, startColumn:number) { super("{", -1, startLine, startColumn) }
-    }
+export class RParenTok extends Token {
+    constructor(startLine:number, startColumn:number) { super(")", -1, startLine, startColumn) }
+}
 
-    export class RCurlyTok extends Token {
-        constructor(startLine:number, startColumn:number) { super("}", -1, startLine, startColumn) }
-    }
+export class LCurlyTok extends Token {
+    constructor(startLine:number, startColumn:number) { super("{", -1, startLine, startColumn) }
+}
 
-    export class ColonTok extends Token {
-        constructor(startLine:number, startColumn:number) { super(":", -1, startLine, startColumn) }
-    }
+export class RCurlyTok extends Token {
+    constructor(startLine:number, startColumn:number) { super("}", -1, startLine, startColumn) }
+}
 
-    export class SemiColonTok extends Token {
-        constructor(startLine:number, startColumn:number) { super(";", -1, startLine, startColumn) }
-    }
+export class ColonTok extends Token {
+    constructor(startLine:number, startColumn:number) { super(":", -1, startLine, startColumn) }
+}
 
+export class SemiColonTok extends Token {
+    constructor(startLine:number, startColumn:number) { super(";", -1, startLine, startColumn) }
 }
+
diff --git a/test/full_flow/error_recovery/switch_case/switchcase_recovery_parser.ts b/test/full_flow/error_recovery/switch_case/switchcase_recovery_parser.ts
index 26c25ed74..486605505 100644
--- a/test/full_flow/error_recovery/switch_case/switchcase_recovery_parser.ts
+++ b/test/full_flow/error_recovery/switch_case/switchcase_recovery_parser.ts
@@ -1,134 +1,144 @@
-
-namespace chevrotain.examples.recovery.switchcase {
-
-    /**
-     * a simple language made up of only
-     * switch/case/return identifiers strings and integers
-     *
-     * example:
-     * switch (name) {
+/**
+ * a simple language made up of only
+ * switch/case/return identifiers strings and integers
+ *
+ * example:
+ * switch (name) {
      *    case "Terry" : return 2;
      *    case "Robert" : return 4;
      *    case "Brandon" : return 6;
      * }
-     *
-     * In this case the parser result is a "JSON" object representing the switch case:
-     * for the above example the result would be:
-     *
-     * {
+ *
+ * In this case the parser result is a "JSON" object representing the switch case:
+ * for the above example the result would be:
+ *
+ * {
      *    "Terry"    : 2,
      *    "Robert"   : 4,
      *    "Brandon"   : 6
      * }
-     *
-     * forEach invalid case statement an invalidN property will be added
-     * with an undefined value. for example :
-     *
-     * {
+ *
+ * forEach invalid case statement an invalidN property will be added
+ * with an undefined value. for example :
+ *
+ * {
      *    "Terry"    : 2,
      *    "invalid1  : undefined
      *    "Brandon"   : 6
      * }
-     */
-
-    export interface RetType { [caseValue: string] : number }
-
-    import pt = chevrotain.examples.tree
-    import gast = chevrotain.gast
-    import gastBuilder = chevrotain.gastBuilder
-    import follows = chevrotain.follow
-
-    // DOCS: to enable error recovery functionality one must extend BaseErrorRecoveryRecognizer
-    export class SwitchCaseRecoveryParser extends Parser {
-
-        constructor(input:Token[] = []) {
-            // DOCS: note the second parameter in the super class. this is the namespace in which the token constructors are defined.
-            //       it is mandatory to provide this map to be able to perform self analysis
-            //       and allow the framework to "understand" the implemented grammar.
-            super(input, <any>chevrotain.examples.recovery.switchcase)
-            // DOCS: The call to performSelfAnalysis needs to happen after all the RULEs have been defined
-            //       The typescript compiler places the constructor body last after initializations in the class's body
-            //       which is why place the call here meets the criteria.
-            Parser.performSelfAnalysis(this)
-        }
+ */
+
+import {Parser} from "../../../../src/parse/parser_public"
+import * as allTokens from "./Switchcase_recovery_tokens"
+import {Token} from "../../../../src/scan/tokens_public"
+import {
+    IdentTok,
+    StringTok,
+    IntTok,
+    SwitchTok,
+    LParenTok,
+    RParenTok,
+    LCurlyTok,
+    RCurlyTok,
+    CaseTok,
+    ColonTok,
+    ReturnTok,
+    SemiColonTok
+} from "./Switchcase_recovery_tokens"
+import * as _ from "lodash"
+
+
+export interface RetType { [caseValue: string] : number }
+
+// DOCS: to enable error recovery functionality one must extend BaseErrorRecoveryRecognizer
+export class SwitchCaseRecoveryParser extends Parser {
+
+    constructor(input:Token[] = []) {
+        // DOCS: note the second parameter in the super class. this is the namespace in which the token constructors are defined.
+        //       it is mandatory to provide this map to be able to perform self analysis
+        //       and allow the framework to "understand" the implemented grammar.
+        super(input, <any>allTokens)
+        // DOCS: The call to performSelfAnalysis needs to happen after all the RULEs have been defined
+        //       The typescript compiler places the constructor body last after initializations in the class's body
+        //       which is why place the call here meets the criteria.
+        Parser.performSelfAnalysis(this)
+    }
 
-        public switchStmt = this.RULE("switchStmt", this.parseSwitchStmt, () => { return {} })
-        public caseStmt = this.RULE("caseStmt", this.parseCaseStmt, this.INVALID())
+    public switchStmt = this.RULE("switchStmt", this.parseSwitchStmt, () => { return {} })
+    public caseStmt = this.RULE("caseStmt", this.parseCaseStmt, this.INVALID())
 
 
-        // DOCS: in this example we avoid automatic missing token insertion for tokens that have additional semantic meaning.
-        //       to understand this first consider the positive case, which tokens can we safely insert?
-        //       a missing colon / semicolon ? yes a missing parenthesis ? yes
-        //       but what about a missing StringToken? if we insert one, what will be its string value?
-        //       an empty string? in the grammar this could lead to an empty key in the created object...
-        //       what about a string with some random value? this could still lead to duplicate keys in the returned parse result
-        private tokTypesThatCannotBeInsertedInRecovery = [IdentTok, StringTok, IntTok]
+    // DOCS: in this example we avoid automatic missing token insertion for tokens that have additional semantic meaning.
+    //       to understand this first consider the positive case, which tokens can we safely insert?
+    //       a missing colon / semicolon ? yes a missing parenthesis ? yes
+    //       but what about a missing StringToken? if we insert one, what will be its string value?
+    //       an empty string? in the grammar this could lead to an empty key in the created object...
+    //       what about a string with some random value? this could still lead to duplicate keys in the returned parse result
+    private tokTypesThatCannotBeInsertedInRecovery = [IdentTok, StringTok, IntTok]
 
 
-        // DOCS: overriding this method allows us to customize the logic for which tokens may not be automaticaly inserted
-        // during error recovery.
-        public canTokenTypeBeInsertedInRecovery(tokType:Function) {
-            return !_.contains(this.tokTypesThatCannotBeInsertedInRecovery, tokType)
-        }
+    // DOCS: overriding this method allows us to customize the logic for which tokens may not be automaticaly inserted
+    // during error recovery.
+    public canTokenTypeBeInsertedInRecovery(tokType:Function) {
+        return !_.contains(this.tokTypesThatCannotBeInsertedInRecovery, tokType)
+    }
 
-        public parseSwitchStmt():RetType {
-            // house keeping so the invalid property names will not be dependent on
-            // previous grammar rule invocations.
-            this.invalidIdx = 1;
+    public parseSwitchStmt():RetType {
+        // house keeping so the invalid property names will not be dependent on
+        // previous grammar rule invocations.
+        this.invalidIdx = 1;
 
-            let retObj:RetType = {}
+        let retObj:RetType = {}
 
-            this.CONSUME(SwitchTok)
-            this.CONSUME(LParenTok)
-            this.CONSUME(IdentTok)
-            this.CONSUME(RParenTok)
-            this.CONSUME(LCurlyTok)
+        this.CONSUME(SwitchTok)
+        this.CONSUME(LParenTok)
+        this.CONSUME(IdentTok)
+        this.CONSUME(RParenTok)
+        this.CONSUME(LCurlyTok)
 
-            this.AT_LEAST_ONE(() => {
-                    _.assign(retObj, this.SUBRULE(this.caseStmt))
-                }
-                // DOCS: currently the following token and its index must be specified to enable error recovery
-                //       inside repetition rules (MANY/AT_LEAST_ONCE), if this information is not provided
-                //       a re-sync recovery trigger inside the rules called by the repetition may cause the whole
-                //       rule containing the repetition to fail.
-                //       ** this may be automatically inferred in a future version.
-                , "case Stmt")
+        this.AT_LEAST_ONE(() => {
+                _.assign(retObj, this.SUBRULE(this.caseStmt))
+            }
+            // DOCS: currently the following token and its index must be specified to enable error recovery
+            //       inside repetition rules (MANY/AT_LEAST_ONCE), if this information is not provided
+            //       a re-sync recovery trigger inside the rules called by the repetition may cause the whole
+            //       rule containing the repetition to fail.
+            //       ** this may be automatically inferred in a future version.
+            , "case Stmt")
 
-            this.CONSUME(RCurlyTok)
+        this.CONSUME(RCurlyTok)
 
-            return retObj
-        }
+        return retObj
+    }
 
-        private parseCaseStmt():RetType {
-            let keyTok, valueTok, key, value
-
-            this.CONSUME(CaseTok)
-            keyTok = this.CONSUME(StringTok)
-            this.CONSUME(ColonTok)
-            this.CONSUME(ReturnTok)
-            valueTok = this.CONSUME(IntTok)
-            this.OPTION(() => {
-                this.CONSUME(SemiColonTok)
-            })
-
-            key = keyTok.image
-            value = parseInt(valueTok.image, 10)
-            let caseKeyValue:RetType = {}
-            caseKeyValue[key] = value
-            return caseKeyValue
-        }
+    private parseCaseStmt():RetType {
+        let keyTok, valueTok, key, value
+
+        this.CONSUME(CaseTok)
+        keyTok = this.CONSUME(StringTok)
+        this.CONSUME(ColonTok)
+        this.CONSUME(ReturnTok)
+        valueTok = this.CONSUME(IntTok)
+        this.OPTION(() => {
+            this.CONSUME(SemiColonTok)
+        })
+
+        key = keyTok.image
+        value = parseInt(valueTok.image, 10)
+        let caseKeyValue:RetType = {}
+        caseKeyValue[key] = value
+        return caseKeyValue
+    }
 
-        // because we are building a javascript object we must not have any duplications
-        // in the name of the keys, the index below is used to solve this.
-        private invalidIdx = 1
+    // because we are building a javascript object we must not have any duplications
+    // in the name of the keys, the index below is used to solve this.
+    private invalidIdx = 1
 
-        private INVALID():() => RetType {
-            return () => {
-                let retObj:RetType = {}
-                retObj["invalid" + this.invalidIdx++] = undefined;
-                return retObj
-            }
+    private INVALID():() => RetType {
+        return () => {
+            let retObj:RetType = {}
+            retObj["invalid" + this.invalidIdx++] = undefined;
+            return retObj
         }
     }
-
 }
diff --git a/test/full_flow/error_recovery/switch_case/swithcase_recovery_spec.ts b/test/full_flow/error_recovery/switch_case/swithcase_recovery_spec.ts
index f6424dccc..0ff350a1b 100644
--- a/test/full_flow/error_recovery/switch_case/swithcase_recovery_spec.ts
+++ b/test/full_flow/error_recovery/switch_case/swithcase_recovery_spec.ts
@@ -1,186 +1,199 @@
 // long lines for token init seems more readable to me than to break them up into multiple line.
 /* tslint:disable:max-line-length  */
-namespace chevrotain.examples.recovery.switchcase.spec {
-
-    import tok = chevrotain.tokens
-    import pt =  chevrotain.examples.tree
-
-    describe("Error Recovery switch-case Example", function () {
-        "use strict"
-
-        it("can parse a valid text successfully", function () {
-            let input = [
-                // switch (name) {
-                new SwitchTok(1, 1), new LParenTok(1, 1), new IdentTok("name", 0, 1, 1), new RParenTok(1, 1), new LCurlyTok(1, 1),
-                // case "Terry" : return 2;
-                new CaseTok(1, 1), new StringTok("Terry", 0, 1, 1), new ColonTok(1, 1), new ReturnTok(1, 1), new IntTok("2", 0, 1, 1), new SemiColonTok(1, 1),
-                // case "Robert" : return 4;
-                new CaseTok(1, 1), new StringTok("Robert", 0, 1, 1), new ColonTok(1, 1), new ReturnTok(1, 1), new IntTok("4", 0, 1, 1), new SemiColonTok(1, 1),
-                // case "Brandon" : return 6;
-                new CaseTok(1, 1), new StringTok("Brandon", 0, 1, 1), new ColonTok(1, 1), new ReturnTok(1, 1), new IntTok("6", 0, 1, 1), new SemiColonTok(1, 1),
-                new RCurlyTok(1, 1)
-            ]
-
-            let parser = new SwitchCaseRecoveryParser(input)
-            let parseResult = parser.switchStmt()
-            expect(parser.errors.length).to.equal(0)
-            expect(parser.isAtEndOfInput()).to.equal(true)
-
-            expect(parseResult).to.deep.equal({
-                "Terry":   2,
-                "Robert":  4,
-                "Brandon": 6
-            })
-        })
 
-        it("can perform re-sync recovery to the next case stmt", function () {
-            let input = [
-                // switch (name) {
-                new SwitchTok(1, 1), new LParenTok(1, 1), new IdentTok("name", 0, 1, 1), new RParenTok(1, 1), new LCurlyTok(1, 1),
-                // case "Terry" : return 2;
-                new CaseTok(1, 1), new StringTok("Terry", 0, 1, 1), new ColonTok(1, 1), new ReturnTok(1, 1), new IntTok("2", 0, 1, 1), new SemiColonTok(1, 1),
-                // case "Robert" ::: return 4; <-- using 3 colons to trigger re-sync recovery
-                new CaseTok(1, 1), new StringTok("Robert", 0, 1, 1), new ColonTok(1, 1), new ColonTok(1, 1), new ColonTok(1, 1), new ReturnTok(1, 1), new IntTok("4", 0, 1, 1), new SemiColonTok(1, 1),
-                // case "Brandon" : return 6;
-                new CaseTok(1, 1), new StringTok("Brandon", 0, 1, 1), new ColonTok(1, 1), new ReturnTok(1, 1), new IntTok("6", 0, 1, 1), new SemiColonTok(1, 1),
-                new RCurlyTok(1, 1)
-            ]
-
-            let parser = new SwitchCaseRecoveryParser(input)
-            let parseResult = parser.switchStmt()
-            expect(parser.errors.length).to.equal(1)
-            expect(parser.isAtEndOfInput()).to.equal(true)
-
-            expect(parseResult).to.deep.equal({
-                "Terry":    2,
-                "invalid1": undefined,
-                "Brandon":  6
-            })
+import {
+    SwitchTok,
+    LParenTok,
+    IdentTok,
+    RParenTok,
+    LCurlyTok,
+    CaseTok,
+    StringTok,
+    ColonTok,
+    ReturnTok,
+    IntTok,
+    RCurlyTok,
+    SemiColonTok
+} from "./Switchcase_recovery_tokens"
+import {SwitchCaseRecoveryParser} from "./switchcase_recovery_parser"
+import {exceptions} from "../../../../src/parse/exceptions_public"
+import * as _ from "lodash"
+
+
+describe("Error Recovery switch-case Example", function () {
+    "use strict"
+
+    it("can parse a valid text successfully", function () {
+        let input = [
+            // switch (name) {
+            new SwitchTok(1, 1), new LParenTok(1, 1), new IdentTok("name", 0, 1, 1), new RParenTok(1, 1), new LCurlyTok(1, 1),
+            // case "Terry" : return 2;
+            new CaseTok(1, 1), new StringTok("Terry", 0, 1, 1), new ColonTok(1, 1), new ReturnTok(1, 1), new IntTok("2", 0, 1, 1), new SemiColonTok(1, 1),
+            // case "Robert" : return 4;
+            new CaseTok(1, 1), new StringTok("Robert", 0, 1, 1), new ColonTok(1, 1), new ReturnTok(1, 1), new IntTok("4", 0, 1, 1), new SemiColonTok(1, 1),
+            // case "Brandon" : return 6;
+            new CaseTok(1, 1), new StringTok("Brandon", 0, 1, 1), new ColonTok(1, 1), new ReturnTok(1, 1), new IntTok("6", 0, 1, 1), new SemiColonTok(1, 1),
+            new RCurlyTok(1, 1)
+        ]
+
+        let parser = new SwitchCaseRecoveryParser(input)
+        let parseResult = parser.switchStmt()
+        expect(parser.errors.length).to.equal(0)
+        expect(parser.isAtEndOfInput()).to.equal(true)
+
+        expect(parseResult).to.deep.equal({
+            "Terry":   2,
+            "Robert":  4,
+            "Brandon": 6
         })
+    })
 
-        it("will detect an error if missing AT_LEAST_ONCE occurrence", function () {
-            let input = [
-                // switch (name) { }
-                new SwitchTok(1, 1), new LParenTok(1, 1), new IdentTok("name", 0, 1, 1), new RParenTok(1, 1), new LCurlyTok(1, 1), new RCurlyTok(1, 1)
-            ]
-
-            let parser = new SwitchCaseRecoveryParser(input)
-            let parseResult = parser.switchStmt()
-            expect(parser.errors.length).to.equal(1)
-            expect(parser.errors[0]).to.be.an.instanceof(exceptions.EarlyExitException)
-            // we have re-synced to the end of the input therefore all the input has been "parsed"
-            expect(parser.isAtEndOfInput()).to.equal(true)
-            expect(parseResult).to.deep.equal({})
+    it("can perform re-sync recovery to the next case stmt", function () {
+        let input = [
+            // switch (name) {
+            new SwitchTok(1, 1), new LParenTok(1, 1), new IdentTok("name", 0, 1, 1), new RParenTok(1, 1), new LCurlyTok(1, 1),
+            // case "Terry" : return 2;
+            new CaseTok(1, 1), new StringTok("Terry", 0, 1, 1), new ColonTok(1, 1), new ReturnTok(1, 1), new IntTok("2", 0, 1, 1), new SemiColonTok(1, 1),
+            // case "Robert" ::: return 4; <-- using 3 colons to trigger re-sync recovery
+            new CaseTok(1, 1), new StringTok("Robert", 0, 1, 1), new ColonTok(1, 1), new ColonTok(1, 1), new ColonTok(1, 1), new ReturnTok(1, 1), new IntTok("4", 0, 1, 1), new SemiColonTok(1, 1),
+            // case "Brandon" : return 6;
+            new CaseTok(1, 1), new StringTok("Brandon", 0, 1, 1), new ColonTok(1, 1), new ReturnTok(1, 1), new IntTok("6", 0, 1, 1), new SemiColonTok(1, 1),
+            new RCurlyTok(1, 1)
+        ]
+
+        let parser = new SwitchCaseRecoveryParser(input)
+        let parseResult = parser.switchStmt()
+        expect(parser.errors.length).to.equal(1)
+        expect(parser.isAtEndOfInput()).to.equal(true)
+
+        expect(parseResult).to.deep.equal({
+            "Terry":    2,
+            "invalid1": undefined,
+            "Brandon":  6
         })
+    })
 
+    it("will detect an error if missing AT_LEAST_ONCE occurrence", function () {
+        let input = [
+            // switch (name) { }
+            new SwitchTok(1, 1), new LParenTok(1, 1), new IdentTok("name", 0, 1, 1), new RParenTok(1, 1), new LCurlyTok(1, 1), new RCurlyTok(1, 1)
+        ]
+
+        let parser = new SwitchCaseRecoveryParser(input)
+        let parseResult = parser.switchStmt()
+        expect(parser.errors.length).to.equal(1)
+        expect(parser.errors[0]).to.be.an.instanceof(exceptions.EarlyExitException)
+        // we have re-synced to the end of the input therefore all the input has been "parsed"
+        expect(parser.isAtEndOfInput()).to.equal(true)
+        expect(parseResult).to.deep.equal({})
+    })
 
-        it("can perform re-sync recovery to the next case stmt even if the unexpected tokens are between valid case stmts", function () {
-            let input = [
-                // switch (name) {
-                new SwitchTok(1, 1), new LParenTok(1, 1), new IdentTok("name", 0, 1, 1), new RParenTok(1, 1), new LCurlyTok(1, 1),
-                // case "Terry" : return 2;
-                new CaseTok(1, 1), new StringTok("Terry", 0, 1, 1), new ColonTok(1, 1), new ReturnTok(1, 1), new IntTok("2", 0, 1, 1), new SemiColonTok(1, 1),
-                // case "Robert" : return 4;
-                new CaseTok(1, 1), new StringTok("Robert", 0, 1, 1), new ColonTok(1, 1), new ReturnTok(1, 1), new IntTok("4", 0, 1, 1), new SemiColonTok(1, 1),
-                // "ima" "aba" "bamba" <-- these three strings do not belong here, but instead of failing everything
-                // we should still get a valid output as these tokens will be ignored and the parser will re-sync to the next case stmt
-                new StringTok("ima", 0, 1, 1), new StringTok("aba", 0, 1, 1), new StringTok("bamba", 0, 1, 1),
-                // case "Brandon" : return 6;
-                new CaseTok(1, 1), new StringTok("Brandon", 0, 1, 1), new ColonTok(1, 1), new ReturnTok(1, 1), new IntTok("6", 0, 1, 1), new SemiColonTok(1, 1),
-
-                new RCurlyTok(1, 1)
-            ]
-
-            let parser = new SwitchCaseRecoveryParser(input)
-            let parseResult = parser.switchStmt()
-            expect(parser.errors.length).to.equal(1)
-            expect(parser.isAtEndOfInput()).to.equal(true)
-
-            expect(parseResult).to.deep.equal({
-                "Terry":   2,
-                "Robert":  4,
-                "Brandon": 6
-            })
-        })
 
-        it("can also sometimes fail in automatic error recovery :)", function () {
-            let input = [
-                // switch (name) {
-                new SwitchTok(1, 1), new LParenTok(1, 1), new IdentTok("name", 0, 1, 1), new RParenTok(1, 1), new LCurlyTok(1, 1),
-                // case "Terry" : return 2;
-                new CaseTok(1, 1), new StringTok("Terry", 0, 1, 1), new ColonTok(1, 1), new ReturnTok(1, 1), new IntTok("2", 0, 1, 1), new SemiColonTok(1, 1),
-                // case "Robert" : return 4;
-                new CaseTok(1, 1), new StringTok("Robert", 0, 1, 1), new ColonTok(1, 1), new ReturnTok(1, 1), new IntTok("4", 0, 1, 1), new SemiColonTok(1, 1),
-                // case "Brandon" : return 6;
-                new CaseTok(1, 1), new StringTok("Brandon", 0, 1, 1), new ColonTok(1, 1), new ReturnTok(1, 1), new IntTok("6", 0, 1, 1), new SemiColonTok(1, 1),
-                // in this sample input the "bad" input is after a valid iteration of a caseStmt
-                // so inRepetition recovery won't work because we have no other iteration to re-sync to, and because
-                // "switchStmt" is the top rule the re-sync is to EOF.
-                new StringTok("ima", 0, 1, 1), new StringTok("aba", 0, 1, 1), new StringTok("bamba", 0, 1, 1),
-                new RCurlyTok(1, 1)
-            ]
-
-            let parser = new SwitchCaseRecoveryParser(input)
-            let parseResult = parser.switchStmt()
-            expect(parser.errors.length).to.equal(1)
-            expect(parser.isAtEndOfInput()).to.equal(true)
-            expect(parseResult).to.deep.equal({})
+    it("can perform re-sync recovery to the next case stmt even if the unexpected tokens are between valid case stmts", function () {
+        let input = [
+            // switch (name) {
+            new SwitchTok(1, 1), new LParenTok(1, 1), new IdentTok("name", 0, 1, 1), new RParenTok(1, 1), new LCurlyTok(1, 1),
+            // case "Terry" : return 2;
+            new CaseTok(1, 1), new StringTok("Terry", 0, 1, 1), new ColonTok(1, 1), new ReturnTok(1, 1), new IntTok("2", 0, 1, 1), new SemiColonTok(1, 1),
+            // case "Robert" : return 4;
+            new CaseTok(1, 1), new StringTok("Robert", 0, 1, 1), new ColonTok(1, 1), new ReturnTok(1, 1), new IntTok("4", 0, 1, 1), new SemiColonTok(1, 1),
+            // "ima" "aba" "bamba" <-- these three strings do not belong here, but instead of failing everything
+            // we should still get a valid output as these tokens will be ignored and the parser will re-sync to the next case stmt
+            new StringTok("ima", 0, 1, 1), new StringTok("aba", 0, 1, 1), new StringTok("bamba", 0, 1, 1),
+            // case "Brandon" : return 6;
+            new CaseTok(1, 1), new StringTok("Brandon", 0, 1, 1), new ColonTok(1, 1), new ReturnTok(1, 1), new IntTok("6", 0, 1, 1), new SemiColonTok(1, 1),
+
+            new RCurlyTok(1, 1)
+        ]
+
+        let parser = new SwitchCaseRecoveryParser(input)
+        let parseResult = parser.switchStmt()
+        expect(parser.errors.length).to.equal(1)
+        expect(parser.isAtEndOfInput()).to.equal(true)
+
+        expect(parseResult).to.deep.equal({
+            "Terry":   2,
+            "Robert":  4,
+            "Brandon": 6
         })
+    })
 
-        it("can perform single token deletion recovery", function () {
-            let input = [
-                // switch (name) {
-                new SwitchTok(1, 1), new LParenTok(1, 1), new IdentTok("name", 0, 1, 1), new RParenTok(1, 1), new LCurlyTok(1, 1),
-                // case "Terry" : return 2;
-                new CaseTok(1, 1), new StringTok("Terry", 0, 1, 1), new ColonTok(1, 1), new ReturnTok(1, 1), new IntTok("2", 0, 1, 1), new SemiColonTok(1, 1),
-                // case "Robert" : return 4;
-                new CaseTok(1, 1), new StringTok("Robert", 0, 1, 1), new ColonTok(1, 1), new ReturnTok(1, 1), new IntTok("4", 0, 1, 1), new SemiColonTok(1, 1),
-                // case "Brandon" : return 6;
-                new CaseTok(1, 1), new StringTok("Brandon", 0, 1, 1), new ColonTok(1, 1), new ReturnTok(1, 1), new IntTok("6", 0, 1, 1), new SemiColonTok(1, 1),
-                new SemiColonTok(1, 1), // <-- the redundant token to be deleted
-                new RCurlyTok(1, 1)
-            ]
-
-            let parser = new SwitchCaseRecoveryParser(input)
-            let parseResult = parser.switchStmt()
-            expect(parser.errors.length).to.equal(1)
-            expect(parser.isAtEndOfInput()).to.equal(true)
-            expect(parseResult).to.deep.equal({
-                "Terry":   2,
-                "Robert":  4,
-                "Brandon": 6
-            })
-        })
+    it("can also sometimes fail in automatic error recovery :)", function () {
+        let input = [
+            // switch (name) {
+            new SwitchTok(1, 1), new LParenTok(1, 1), new IdentTok("name", 0, 1, 1), new RParenTok(1, 1), new LCurlyTok(1, 1),
+            // case "Terry" : return 2;
+            new CaseTok(1, 1), new StringTok("Terry", 0, 1, 1), new ColonTok(1, 1), new ReturnTok(1, 1), new IntTok("2", 0, 1, 1), new SemiColonTok(1, 1),
+            // case "Robert" : return 4;
+            new CaseTok(1, 1), new StringTok("Robert", 0, 1, 1), new ColonTok(1, 1), new ReturnTok(1, 1), new IntTok("4", 0, 1, 1), new SemiColonTok(1, 1),
+            // case "Brandon" : return 6;
+            new CaseTok(1, 1), new StringTok("Brandon", 0, 1, 1), new ColonTok(1, 1), new ReturnTok(1, 1), new IntTok("6", 0, 1, 1), new SemiColonTok(1, 1),
+            // in this sample input the "bad" input is after a valid iteration of a caseStmt
+            // so inRepetition recovery won't work because we have no other iteration to re-sync to, and because
+            // "switchStmt" is the top rule the re-sync is to EOF.
+            new StringTok("ima", 0, 1, 1), new StringTok("aba", 0, 1, 1), new StringTok("bamba", 0, 1, 1),
+            new RCurlyTok(1, 1)
+        ]
+
+        let parser = new SwitchCaseRecoveryParser(input)
+        let parseResult = parser.switchStmt()
+        expect(parser.errors.length).to.equal(1)
+        expect(parser.isAtEndOfInput()).to.equal(true)
+        expect(parseResult).to.deep.equal({})
+    })
 
-        it("will perform single token insertion for a missing colon", function () {
-            let input = [
-                // case "Terry" return 2 <-- missing the colon between "Terry" and return
-                new CaseTok(1, 1), new StringTok("Terry", 0, 1, 1), /* new ColonTok(1, 1) ,*/ new ReturnTok(1, 1), new IntTok("2", 0, 1, 1), new SemiColonTok(1, 1),
-            ]
-
-            let parser = new SwitchCaseRecoveryParser(input)
-            let parseResult = parser.caseStmt()
-            expect(parser.errors.length).to.equal(1)
-            expect(parser.errors[0]).to.be.an.instanceof(exceptions.MismatchedTokenException)
-            expect(parser.isAtEndOfInput()).to.equal(true)
-            expect(parseResult).to.deep.equal({"Terry": 2})
+    it("can perform single token deletion recovery", function () {
+        let input = [
+            // switch (name) {
+            new SwitchTok(1, 1), new LParenTok(1, 1), new IdentTok("name", 0, 1, 1), new RParenTok(1, 1), new LCurlyTok(1, 1),
+            // case "Terry" : return 2;
+            new CaseTok(1, 1), new StringTok("Terry", 0, 1, 1), new ColonTok(1, 1), new ReturnTok(1, 1), new IntTok("2", 0, 1, 1), new SemiColonTok(1, 1),
+            // case "Robert" : return 4;
+            new CaseTok(1, 1), new StringTok("Robert", 0, 1, 1), new ColonTok(1, 1), new ReturnTok(1, 1), new IntTok("4", 0, 1, 1), new SemiColonTok(1, 1),
+            // case "Brandon" : return 6;
+            new CaseTok(1, 1), new StringTok("Brandon", 0, 1, 1), new ColonTok(1, 1), new ReturnTok(1, 1), new IntTok("6", 0, 1, 1), new SemiColonTok(1, 1),
+            new SemiColonTok(1, 1), // <-- the redundant token to be deleted
+            new RCurlyTok(1, 1)
+        ]
+
+        let parser = new SwitchCaseRecoveryParser(input)
+        let parseResult = parser.switchStmt()
+        expect(parser.errors.length).to.equal(1)
+        expect(parser.isAtEndOfInput()).to.equal(true)
+        expect(parseResult).to.deep.equal({
+            "Terry":   2,
+            "Robert":  4,
+            "Brandon": 6
         })
+    })
 
-        it("will NOT perform single token insertion for a missing string", function () {
-            let input = [
-                // case  : return 2 <-- missing the string for the case's value
-                new CaseTok(1, 1), /* new StringTok("Terry" , 0, 1, 1),*/  new ColonTok(1, 1), new ReturnTok(1, 1),
-                new IntTok("2", 0, 1, 1), new SemiColonTok(1, 1),
-            ]
-
-            let parser = new SwitchCaseRecoveryParser(input)
-            let parseResult = parser.caseStmt()
-            expect(parser.errors.length).to.equal(1)
-            expect(parser.errors[0]).to.be.an.instanceof(exceptions.MismatchedTokenException)
-            expect(parser.isAtEndOfInput()).to.equal(true) // in rule recovery failed, will now re-sync to EOF
-            expect(parseResult).to.deep.equal({"invalid1": undefined})
-        })
+    it("will perform single token insertion for a missing colon", function () {
+        let input = [
+            // case "Terry" return 2 <-- missing the colon between "Terry" and return
+            new CaseTok(1, 1), new StringTok("Terry", 0, 1, 1), /* new ColonTok(1, 1) ,*/ new ReturnTok(1, 1), new IntTok("2", 0, 1, 1), new SemiColonTok(1, 1),
+        ]
+
+        let parser = new SwitchCaseRecoveryParser(input)
+        let parseResult = parser.caseStmt()
+        expect(parser.errors.length).to.equal(1)
+        expect(parser.errors[0]).to.be.an.instanceof(exceptions.MismatchedTokenException)
+        expect(parser.isAtEndOfInput()).to.equal(true)
+        expect(parseResult).to.deep.equal({"Terry": 2})
+    })
 
+    it("will NOT perform single token insertion for a missing string", function () {
+        let input = [
+            // case  : return 2 <-- missing the string for the case's value
+            new CaseTok(1, 1), /* new StringTok("Terry" , 0, 1, 1),*/  new ColonTok(1, 1), new ReturnTok(1, 1),
+            new IntTok("2", 0, 1, 1), new SemiColonTok(1, 1),
+        ]
+
+        let parser = new SwitchCaseRecoveryParser(input)
+        let parseResult = parser.caseStmt()
+        expect(parser.errors.length).to.equal(1)
+        expect(parser.errors[0]).to.be.an.instanceof(exceptions.MismatchedTokenException)
+        expect(parser.isAtEndOfInput()).to.equal(true) // in rule recovery failed, will now re-sync to EOF
+        expect(parseResult).to.deep.equal({"invalid1": undefined})
     })
 
-}
+})
diff --git a/test/full_flow/parse_tree.ts b/test/full_flow/parse_tree.ts
index 889256521..272241575 100644
--- a/test/full_flow/parse_tree.ts
+++ b/test/full_flow/parse_tree.ts
@@ -1,38 +1,36 @@
-namespace chevrotain.examples.tree {
+import {Token} from "../../src/scan/tokens_public"
 
-    export class ParseTree {
-        getImage():string { return this.payload.image }
+export class ParseTree {
+    getImage():string { return this.payload.image }
 
-        getLine():number { return this.payload.startLine }
+    getLine():number { return this.payload.startLine }
 
-        getColumn():number { return this.payload.startColumn }
+    getColumn():number { return this.payload.startColumn }
 
-        constructor(public payload:Token, public children:ParseTree[] = []) {}
-    }
+    constructor(public payload:Token, public children:ParseTree[] = []) {}
+}
 
-    /**
-     * convenience factory for ParseTrees
-     *
-     * @param {Function|Token} tokenOrTokenClass The Token instance to be used as the root node, or a constructor Function
-     *                         that will create the root node.
-     * @param {ParseTree[]} children The sub nodes of the ParseTree to the built
-     * @returns {ParseTree}
-     */
-    export function PT(tokenOrTokenClass:Function|Token, children:ParseTree[] = []):ParseTree {
-        let childrenCompact = _.compact(children)
+/**
+ * convenience factory for ParseTrees
+ *
+ * @param {Function|Token} tokenOrTokenClass The Token instance to be used as the root node, or a constructor Function
+ *                         that will create the root node.
+ * @param {ParseTree[]} children The sub nodes of the ParseTree to the built
+ * @returns {ParseTree}
+ */
+export function PT(tokenOrTokenClass:Function|Token, children:ParseTree[] = []):ParseTree {
+    let childrenCompact = _.compact(children)
 
-        if (tokenOrTokenClass instanceof Token) {
-            return new ParseTree(tokenOrTokenClass, childrenCompact)
-        }
-        else if (_.isFunction(tokenOrTokenClass)) {
-            return new ParseTree(new (<any>tokenOrTokenClass)(), childrenCompact)
-        }
-        else if (_.isUndefined(tokenOrTokenClass) || _.isNull(tokenOrTokenClass)) {
-            return null
-        }
-        else {
-            throw `Invalid parameter ${tokenOrTokenClass} to PT factory.`
-        }
+    if (tokenOrTokenClass instanceof Token) {
+        return new ParseTree(tokenOrTokenClass, childrenCompact)
+    }
+    else if (_.isFunction(tokenOrTokenClass)) {
+        return new ParseTree(new (<any>tokenOrTokenClass)(), childrenCompact)
+    }
+    else if (_.isUndefined(tokenOrTokenClass) || _.isNull(tokenOrTokenClass)) {
+        return null
+    }
+    else {
+        throw `Invalid parameter ${tokenOrTokenClass} to PT factory.`
     }
-
 }
diff --git a/test/lang/hash_table_spec.ts b/test/lang/hash_table_spec.ts
index b3f4e6a71..8acd2df16 100644
--- a/test/lang/hash_table_spec.ts
+++ b/test/lang/hash_table_spec.ts
@@ -1,26 +1,23 @@
+import {HashTable} from "../../src/lang/lang_extensions"
 
-namespace chevrotain.lang.spec {
+describe("The HashTable implementation", function () {
 
-    describe("The HashTable implementation", function () {
+    it("will return undefined for a key that does not exist, and the value for a key that does exist", function () {
+        let hashTable = new HashTable<number>();
+        hashTable.put("one", 1)
+        hashTable.put("two", 2)
 
-        it("will return undefined for a key that does not exist, and the value for a key that does exist", function () {
-            let hashTable = new HashTable<number>();
-            hashTable.put("one", 1)
-            hashTable.put("two", 2)
-
-            expect(hashTable.get("one")).to.equal(1)
-            expect(hashTable.get("two")).to.equal(2)
-            expect(hashTable.get("three")).to.equal(undefined)
-        })
+        expect(hashTable.get("one")).to.equal(1)
+        expect(hashTable.get("two")).to.equal(2)
+        expect(hashTable.get("three")).to.equal(undefined)
+    })
 
-        it("support property names that are also names of built in properties on javascript Object", function () {
-            let hashTable = new HashTable<number>();
-            hashTable.put("toString", 1)
-            hashTable.put("hasOwnProperty", 2)
+    it("support property names that are also names of built in properties on javascript Object", function () {
+        let hashTable = new HashTable<number>();
+        hashTable.put("toString", 1)
+        hashTable.put("hasOwnProperty", 2)
 
-            expect(hashTable.get("toString")).to.equal(1)
-            expect(hashTable.get("hasOwnProperty")).to.equal(2)
-        })
+        expect(hashTable.get("toString")).to.equal(1)
+        expect(hashTable.get("hasOwnProperty")).to.equal(2)
     })
-
-}
+})
diff --git a/test/mocha.opts b/test/mocha.opts
new file mode 100644
index 000000000..6a5013198
--- /dev/null
+++ b/test/mocha.opts
@@ -0,0 +1,4 @@
+--require ./test/test.config
+--reporter spec
+--ui bdd
+--recursive
\ No newline at end of file
diff --git a/test/parse/gast_builder_spec.ts b/test/parse/gast_builder_spec.ts
index 331b95828..b89563034 100644
--- a/test/parse/gast_builder_spec.ts
+++ b/test/parse/gast_builder_spec.ts
@@ -1,432 +1,475 @@
-namespace chevrotain.gastBuilder.spec {
-
-    import r = chevrotain.range
-    import b = chevrotain.gastBuilder
-    import tok = specs.samples
-    import matchers = specs.matchers
-    import lang = chevrotain.lang
-
-    describe("The GAst Builder namespace", function () {
-        "use strict"
-
-        let typeDefText = "// parse\r\n" +
-            "            let typeKw = this.CONSUME1(tok.TypeTok)\r\n" +
-            "            let typeName = this.CONSUME1(tok.IdentTok)\r\n" +
-            "            let typeSpec = this.OR([\r\n" +
-            "                {WHEN: this.isStructType, THEN_DO: ()=> {\r\n" +
-            "                    let structType = this.SUBRULE(this.structuredType)\r\n" +
-            "                    this.OPTION(()=> {return this.NEXT_TOKEN() instanceof tok.SemicolonTok}, ()=> {\r\n" +
-            "                        semiColon = this.CONSUME1(tok.SemicolonTok)\r\n" +
-            "                    })\r\n" +
-            "                    return structType\r\n" +
-            "                }},\r\n" +
-            "                {WHEN: this.isAssignedTypeSpec, THEN_DO: ()=> {\r\n" +
-            "                    let assTypeSpec = this.SUBRULE(this.assignedTypeSpec)\r\n" +
-            "                    semiColon = this.CONSUME2(tok.SemicolonTok)\r\n" +
-            "                    return assTypeSpec\r\n" +
-            "                }}\r\n" +
-            "            ], \"StructuredType or AssignedTypeSpec\").tree"
-
-        let elementDefText = "this.OPTION(this.isRequiredKw, ()=> {\r\n" +
-            "                requiredKW = this.CONSUME1(tok.RequiredTok)\r\n" +
-            "            })\r\n" +
-            "            this.OPTION(this.isKeyKw, ()=> {\r\n" +
-            "                keyKW = this.CONSUME1(tok.KeyTok)\r\n" +
-            "            })\r\n" +
-            "            let elementKW = this.CONSUME1(tok.ElementTok)\r\n" +
-            "            let elementName = this.CONSUME1(tok.IdentTok)\r\n" +
-            "\r\n" +
-            "            let assTypeSpec = this.OR([\r\n" +
-            "                {WHEN: this.isAssignedTypeSpec, THEN_DO: ()=> {\r\n" +
-            "                    return this.SUBRULE(this.assignedTypeSpec)\r\n" +
-            "                }},\r\n" +
-            "                {WHEN: ()=> {return true}, THEN_DO: ()=> {\r\n" +
-            "                    return this.SUBRULE(this.assignedTypeSpecImplicit)\r\n" +
-            "                }}\r\n" +
-            "            ], \"\").tree\r\n" +
-            "\r\n" +
-            "            let semiColon = this.CONSUME1(tok.SemicolonTok)"
-
-        let literalArrayText = "let lSquare = this.CONSUME1(tok.LSquareTok)\r\n" +
-            "            arrValues.push(this.SUBRULE(this.expression))\r\n" +
-            "            this.MANY(this.isAdditionalArgument, () => {\r\n" +
-            "                    commas.push(this.CONSUME1(tok.CommaTok))\r\n" +
-            "                    arrValues.push(this.SUBRULE2(this.expression))\r\n" +
-            "                }\r\n" +
-            "            )\r\n" +
-            "            let rSquare = this.CONSUME1(tok.RSquareTok)"
-
-
-        it("can extract Terminals IPRODRanges from a text", function () {
-            let actual = b.createTerminalRanges(typeDefText)
-            expect(actual.length).to.equal(4)
-            let terminalTypes = _.map(actual, (rangeProd) => { return rangeProd.type})
-            expect(_.uniq(terminalTypes).length).to.equal(1)
-            expect(terminalTypes[0]).to.equal(b.ProdType.TERMINAL)
-
-            let terminalTexts = _.map(actual, (rangeProd) => { return rangeProd.text})
-            expect(terminalTexts[0]).to.equal(".CONSUME1(tok.TypeTok")
-            expect(terminalTexts[1]).to.equal(".CONSUME1(tok.IdentTok")
-            expect(terminalTexts[2]).to.equal(".CONSUME1(tok.SemicolonTok")
-            expect(terminalTexts[3]).to.equal(".CONSUME2(tok.SemicolonTok")
-        })
+import {gast} from "../../src/parse/grammar/gast_public"
+
+let RepetitionMandatory = gast.RepetitionMandatory
+let Repetition = gast.Repetition
+let NonTerminal = gast.NonTerminal
+let RepetitionWithSeparator = gast.RepetitionWithSeparator
+let Terminal = gast.Terminal
+let Option = gast.Option
+let Alternation = gast.Alternation
+let Flat = gast.Flat
+
+import * as gastBuilder from "../../src/parse/gast_builder"
+import {
+    createTerminalRanges,
+    ProdType,
+    createRefsRanges,
+    createOptionRanges,
+    createAtLeastOneRanges,
+    createManyRanges,
+    createOrRanges,
+    createRanges,
+    removeComments,
+    getDirectlyContainedRanges,
+    removeStringLiterals,
+    IProdRange,
+    findClosingOffset,
+    buildProdGast,
+    buildTopProduction
+} from "../../src/parse/gast_builder"
+import {setEquality} from "../utils/matchers"
+import {Range} from "../../src/text/range"
+import * as tok from "./grammar/samples"
+import {
+    IdentTok,
+    LSquareTok,
+    CommaTok,
+    RSquareTok,
+    RequiredTok,
+    SemicolonTok,
+    ElementTok,
+    KeyTok
+} from "./grammar/samples"
+import * as _ from "lodash"
+
+
+describe("The GAst Builder namespace", function () {
+    "use strict"
+
+    let typeDefText = "// parse\r\n" +
+        "            let typeKw = this.CONSUME1(TypeTok)\r\n" +
+        "            let typeName = this.CONSUME1(IdentTok)\r\n" +
+        "            let typeSpec = this.OR([\r\n" +
+        "                {WHEN: this.isStructType, THEN_DO: ()=> {\r\n" +
+        "                    let structType = this.SUBRULE(this.structuredType)\r\n" +
+        "                    this.OPTION(()=> {return this.NEXT_TOKEN() instanceof SemicolonTok}, ()=> {\r\n" +
+        "                        semiColon = this.CONSUME1(SemicolonTok)\r\n" +
+        "                    })\r\n" +
+        "                    return structType\r\n" +
+        "                }},\r\n" +
+        "                {WHEN: this.isAssignedTypeSpec, THEN_DO: ()=> {\r\n" +
+        "                    let assTypeSpec = this.SUBRULE(this.assignedTypeSpec)\r\n" +
+        "                    semiColon = this.CONSUME2(SemicolonTok)\r\n" +
+        "                    return assTypeSpec\r\n" +
+        "                }}\r\n" +
+        "            ], \"StructuredType or AssignedTypeSpec\").tree"
+
+    let elementDefText = "this.OPTION(this.isRequiredKw, ()=> {\r\n" +
+        "                requiredKW = this.CONSUME1(RequiredTok)\r\n" +
+        "            })\r\n" +
+        "            this.OPTION(this.isKeyKw, ()=> {\r\n" +
+        "                keyKW = this.CONSUME1(KeyTok)\r\n" +
+        "            })\r\n" +
+        "            let elementKW = this.CONSUME1(ElementTok)\r\n" +
+        "            let elementName = this.CONSUME1(IdentTok)\r\n" +
+        "\r\n" +
+        "            let assTypeSpec = this.OR([\r\n" +
+        "                {WHEN: this.isAssignedTypeSpec, THEN_DO: ()=> {\r\n" +
+        "                    return this.SUBRULE(this.assignedTypeSpec)\r\n" +
+        "                }},\r\n" +
+        "                {WHEN: ()=> {return true}, THEN_DO: ()=> {\r\n" +
+        "                    return this.SUBRULE(this.assignedTypeSpecImplicit)\r\n" +
+        "                }}\r\n" +
+        "            ], \"\").tree\r\n" +
+        "\r\n" +
+        "            let semiColon = this.CONSUME1(SemicolonTok)"
+
+    let literalArrayText = "let lSquare = this.CONSUME1(LSquareTok)\r\n" +
+        "            arrValues.push(this.SUBRULE(this.expression))\r\n" +
+        "            this.MANY(this.isAdditionalArgument, () => {\r\n" +
+        "                    commas.push(this.CONSUME1(CommaTok))\r\n" +
+        "                    arrValues.push(this.SUBRULE2(this.expression))\r\n" +
+        "                }\r\n" +
+        "            )\r\n" +
+        "            let rSquare = this.CONSUME1(RSquareTok)"
+
+
+    it("can extract Terminals IPRODRanges from a text", function () {
+        let actual = createTerminalRanges(typeDefText)
+        expect(actual.length).to.equal(4)
+        let terminalTypes = _.map(actual, (rangeProd) => { return rangeProd.type})
+        expect(_.uniq(terminalTypes).length).to.equal(1)
+        expect(terminalTypes[0]).to.equal(ProdType.TERMINAL)
+
+        let terminalTexts = _.map(actual, (rangeProd) => { return rangeProd.text})
+        expect(terminalTexts[0]).to.equal(".CONSUME1(TypeTok")
+        expect(terminalTexts[1]).to.equal(".CONSUME1(IdentTok")
+        expect(terminalTexts[2]).to.equal(".CONSUME1(SemicolonTok")
+        expect(terminalTexts[3]).to.equal(".CONSUME2(SemicolonTok")
+    })
 
-        it("can extract SubRule references IPRODRanges from a text", function () {
-            let actual = b.createRefsRanges(typeDefText)
-            expect(actual.length).to.equal(2)
-            let refTypes = _.map(actual, (rangeProd) => { return rangeProd.type})
-            expect(_.uniq(refTypes).length).to.equal(1)
-            expect(refTypes[0]).to.equal(b.ProdType.REF)
+    it("can extract SubRule references IPRODRanges from a text", function () {
+        let actual = createRefsRanges(typeDefText)
+        expect(actual.length).to.equal(2)
+        let refTypes = _.map(actual, (rangeProd) => { return rangeProd.type})
+        expect(_.uniq(refTypes).length).to.equal(1)
+        expect(refTypes[0]).to.equal(ProdType.REF)
 
-            let refText = _.map(actual, (rangeProd) => { return rangeProd.text})
-            expect(refText[0]).to.equal(".SUBRULE(this.structuredType")
-            expect(refText[1]).to.equal(".SUBRULE(this.assignedTypeSpec")
-        })
+        let refText = _.map(actual, (rangeProd) => { return rangeProd.text})
+        expect(refText[0]).to.equal(".SUBRULE(this.structuredType")
+        expect(refText[1]).to.equal(".SUBRULE(this.assignedTypeSpec")
+    })
 
-        it("can extract Option IPRODRanges from a text", function () {
-            let actual = b.createOptionRanges(elementDefText)
-            expect(actual.length).to.equal(2)
-            let refTypes = _.map(actual, (rangeProd) => { return rangeProd.type})
-            expect(_.uniq(refTypes).length).to.equal(1)
-            expect(refTypes[0]).to.equal(b.ProdType.OPTION)
-
-            let refText = _.map(actual, (rangeProd) => { return rangeProd.text})
-            expect(refText[0]).to.equal(".OPTION(this.isRequiredKw, ()=> {\r\n" +
-                "                requiredKW = this.CONSUME1(tok.RequiredTok)\r\n" +
-                "            })")
-            expect(refText[1]).to.equal(".OPTION(this.isKeyKw, ()=> {\r\n" +
-                "                keyKW = this.CONSUME1(tok.KeyTok)\r\n" +
-                "            })")
-        })
+    it("can extract Option IPRODRanges from a text", function () {
+        let actual = createOptionRanges(elementDefText)
+        expect(actual.length).to.equal(2)
+        let refTypes = _.map(actual, (rangeProd) => { return rangeProd.type})
+        expect(_.uniq(refTypes).length).to.equal(1)
+        expect(refTypes[0]).to.equal(ProdType.OPTION)
+
+        let refText = _.map(actual, (rangeProd) => { return rangeProd.text})
+        expect(refText[0]).to.equal(".OPTION(this.isRequiredKw, ()=> {\r\n" +
+            "                requiredKW = this.CONSUME1(RequiredTok)\r\n" +
+            "            })")
+        expect(refText[1]).to.equal(".OPTION(this.isKeyKw, ()=> {\r\n" +
+            "                keyKW = this.CONSUME1(KeyTok)\r\n" +
+            "            })")
+    })
 
-        it("can extract 'at least one' IPRODRanges from a text", function () {
-            let actual = b.createAtLeastOneRanges("this.MANY(...) this.AT_LEAST_ONE(bamba) this.AT_LEAST_ONE(THIS.OPTION(bisli))")
-            expect(actual.length).to.equal(2)
-            let refTypes = _.map(actual, (rangeProd) => { return rangeProd.type})
-            expect(_.uniq(refTypes).length).to.equal(1)
-            expect(refTypes[0]).to.equal(b.ProdType.AT_LEAST_ONE)
+    it("can extract 'at least one' IPRODRanges from a text", function () {
+        let actual = createAtLeastOneRanges("this.MANY(...) this.AT_LEAST_ONE(bamba) this.AT_LEAST_ONE(THIS.OPTION(bisli))")
+        expect(actual.length).to.equal(2)
+        let refTypes = _.map(actual, (rangeProd) => { return rangeProd.type})
+        expect(_.uniq(refTypes).length).to.equal(1)
+        expect(refTypes[0]).to.equal(ProdType.AT_LEAST_ONE)
 
-            let refText = _.map(actual, (rangeProd) => { return rangeProd.text})
-            expect(refText[0]).to.equal(".AT_LEAST_ONE(bamba)")
-            expect(refText[1]).to.equal(".AT_LEAST_ONE(THIS.OPTION(bisli))")
-        })
+        let refText = _.map(actual, (rangeProd) => { return rangeProd.text})
+        expect(refText[0]).to.equal(".AT_LEAST_ONE(bamba)")
+        expect(refText[1]).to.equal(".AT_LEAST_ONE(THIS.OPTION(bisli))")
+    })
 
-        it("can extract 'many' IPRODRanges from a text", function () {
-            let actual = b.createManyRanges(literalArrayText)
-            expect(actual.length).to.equal(1)
-            let refTypes = _.map(actual, (rangeProd) => { return rangeProd.type})
-            expect(_.uniq(refTypes).length).to.equal(1)
-            expect(refTypes[0]).to.equal(b.ProdType.MANY)
-
-            let refText = _.map(actual, (rangeProd) => { return rangeProd.text})
-            expect(refText[0]).to.equal(".MANY(this.isAdditionalArgument, () => {\r\n" +
-                "                    commas.push(this.CONSUME1(tok.CommaTok))\r\n" +
-                "                    arrValues.push(this.SUBRULE2(this.expression))\r\n" +
-                "                }\r\n" +
-                "            )")
-        })
+    it("can extract 'many' IPRODRanges from a text", function () {
+        let actual = createManyRanges(literalArrayText)
+        expect(actual.length).to.equal(1)
+        let refTypes = _.map(actual, (rangeProd) => { return rangeProd.type})
+        expect(_.uniq(refTypes).length).to.equal(1)
+        expect(refTypes[0]).to.equal(ProdType.MANY)
 
-        it("can extract 'or' IPRODRanges from a text", function () {
-            let actual = b.createOrRanges(elementDefText)
-            // 1 or range + 2 orPart ranges (flat ranges)
-            expect(actual.length).to.equal(3)
-            let refTypes = _.map(actual, (rangeProd) => { return rangeProd.type})
-            expect(_.uniq(refTypes).length).to.equal(2)
-            matchers.setEquality(_.uniq(refTypes), [b.ProdType.OR, b.ProdType.FLAT])
-
-            let refText = _.map(actual, (rangeProd) => { return rangeProd.text})
-            expect(refText[0]).to.equal(".OR([\r\n" +
-                "                {WHEN: this.isAssignedTypeSpec, THEN_DO: ()=> {\r\n" +
-                "                    return this.SUBRULE(this.assignedTypeSpec)\r\n" +
-                "                }},\r\n" +
-                "                {WHEN: ()=> {return true}, THEN_DO: ()=> {\r\n" +
-                "                    return this.SUBRULE(this.assignedTypeSpecImplicit)\r\n" +
-                "                }}\r\n" +
-                "            ], \"\")")
-        })
+        let refText = _.map(actual, (rangeProd) => { return rangeProd.text})
+        expect(refText[0]).to.equal(".MANY(this.isAdditionalArgument, () => {\r\n" +
+            "                    commas.push(this.CONSUME1(CommaTok))\r\n" +
+            "                    arrValues.push(this.SUBRULE2(this.expression))\r\n" +
+            "                }\r\n" +
+            "            )")
+    })
 
-        it("can extract all IPRODRanges from a text", function () {
-            let ter = ".CONSUME3(tok.one1"
-            let option = ".OPTION(2)"
-            let many = ".MANY(3)"
-            let many_sep = ".MANY_SEP(Comma,)"
-            let at_least_one_sep = ".AT_LEAST_ONE_SEP(Comma,)"
-            let ref = ".SUBRULE5(this.other"
-            let atLeastOne = ".AT_LEAST_ONE(6)"
-            let or = ".OR(7)"
-
-            let actual = b.createRanges(
-                ter + ") " +
-                option +
-                many_sep  + " " +
-                at_least_one_sep + " " +
-                many +
-                ref + ") " +
-                atLeastOne +
-                or)
-
-            expect(actual.length).to.equal(8)
-            let refTypes = _.map(actual, (rangeProd) => { return rangeProd.type})
-            expect(_.uniq(refTypes).length).to.equal(8)
-
-            let refText = _.map(actual, (rangeProd) => { return rangeProd.text})
-            matchers.setEquality(refText, [ter, option, many, many_sep, ref, at_least_one_sep, atLeastOne, or])
-        })
+    it("can extract 'or' IPRODRanges from a text", function () {
+        let actual = createOrRanges(elementDefText)
+        // 1 or range + 2 orPart ranges (flat ranges)
+        expect(actual.length).to.equal(3)
+        let refTypes = _.map(actual, (rangeProd) => { return rangeProd.type})
+        expect(_.uniq(refTypes).length).to.equal(2)
+        setEquality(_.uniq(refTypes), [ProdType.OR, ProdType.FLAT])
 
-        it("has a utility function that can remove comments(single line and multiline) from texts", function () {
-            let input = "// single line comment" +
-                "\nhello" +
-                "/* multi line comment \n" +
-                "* blah blah blah" +
-                "*/" +
-                " world" +
-                "// another single line!"
-
-            let actual = b.removeComments(input)
-            expect(actual).to.equal("\nhello world")
-        })
+        let refText = _.map(actual, (rangeProd) => { return rangeProd.text})
+        expect(refText[0]).to.equal(".OR([\r\n" +
+            "                {WHEN: this.isAssignedTypeSpec, THEN_DO: ()=> {\r\n" +
+            "                    return this.SUBRULE(this.assignedTypeSpec)\r\n" +
+            "                }},\r\n" +
+            "                {WHEN: ()=> {return true}, THEN_DO: ()=> {\r\n" +
+            "                    return this.SUBRULE(this.assignedTypeSpecImplicit)\r\n" +
+            "                }}\r\n" +
+            "            ], \"\")")
+    })
+
+    it("can extract all IPRODRanges from a text", function () {
+        let ter = ".CONSUME3(one1"
+        let option = ".OPTION(2)"
+        let many = ".MANY(3)"
+        let many_sep = ".MANY_SEP(Comma,)"
+        let at_least_one_sep = ".AT_LEAST_ONE_SEP(Comma,)"
+        let ref = ".SUBRULE5(this.other"
+        let atLeastOne = ".AT_LEAST_ONE(6)"
+        let or = ".OR(7)"
+
+        let actual = createRanges(
+            ter + ") " +
+            option +
+            many_sep + " " +
+            at_least_one_sep + " " +
+            many +
+            ref + ") " +
+            atLeastOne +
+            or)
+
+        expect(actual.length).to.equal(8)
+        let refTypes = _.map(actual, (rangeProd) => { return rangeProd.type})
+        expect(_.uniq(refTypes).length).to.equal(8)
+
+        let refText = _.map(actual, (rangeProd) => { return rangeProd.text})
+        setEquality(refText, [ter, option, many, many_sep, ref, at_least_one_sep, atLeastOne, or])
+    })
 
-        it("has a utility function that can remove string literals from texts", function () {
-            let input = "'single quotes string'" +
-                "\nhello" +
-                "\"\"" +
-                "\"double quotes string\"" +
-                " world" +
-                "'bam\\'ba\"\"'"
+    it("has a utility function that can remove comments(single line and multiline) from texts", function () {
+        let input = "// single line comment" +
+            "\nhello" +
+            "/* multi line comment \n" +
+            "* blah blah blah" +
+            "*/" +
+            " world" +
+            "// another single line!"
+
+        let actual = removeComments(input)
+        expect(actual).to.equal("\nhello world")
+    })
 
-            let actual = b.removeStringLiterals(input)
-            expect(actual).to.equal("\nhello world")
-        })
+    it("has a utility function that can remove string literals from texts", function () {
+        let input = "'single quotes string'" +
+            "\nhello" +
+            "\"\"" +
+            "\"double quotes string\"" +
+            " world" +
+            "'bam\\'ba\"\"'"
 
-        it("can detect missing closing parenthesis in a string", function () {
-            let input = " ((()))" // the input is assumed to start right after an opening parenthesis
-            expect(() => b.findClosingOffset("(", ")", 0, input)).to.throw("INVALID INPUT TEXT, UNTERMINATED PARENTHESIS")
-        })
+        let actual = removeStringLiterals(input)
+        expect(actual).to.equal("\nhello world")
+    })
 
-        it("can find the direct 'childs' of another Production from an IProd representation", function () {
-            let allProdRanges:b.IProdRange[] = [
-                {range: new r.Range(1, 10), text: "1.1", type: b.ProdType.TERMINAL},
-                {range: new r.Range(11, 200), text: "1.2", type: b.ProdType.OR},
-                {range: new r.Range(20, 180), text: "1.2.1", type: b.ProdType.MANY},
-                {range: new r.Range(30, 100), text: "1.2.1.1", type: b.ProdType.TERMINAL},
-                {range: new r.Range(101, 170), text: "1.2.1.2", type: b.ProdType.TERMINAL},
-                {range: new r.Range(181, 190), text: "1.2.2", type: b.ProdType.TERMINAL},
-                {range: new r.Range(201, 209), text: "1.3", type: b.ProdType.TERMINAL}
-            ]
-
-            let topRange = b.getDirectlyContainedRanges(new r.Range(0, 210), allProdRanges)
-            expect(topRange.length).to.equal(3)
-            expect(topRange[0].text).to.equal("1.1")
-            expect(topRange[1].text).to.equal("1.2")
-            expect(topRange[2].text).to.equal("1.3")
-
-
-            let orRange = b.getDirectlyContainedRanges(new r.Range(11, 200), allProdRanges)
-            expect(orRange.length).to.equal(2)
-            expect(orRange[0].text).to.equal("1.2.1")
-            expect(orRange[1].text).to.equal("1.2.2")
-
-            let manyRange = b.getDirectlyContainedRanges(new r.Range(20, 180), allProdRanges)
-            expect(manyRange.length).to.equal(2)
-            expect(manyRange[0].text).to.equal("1.2.1.1")
-            expect(manyRange[1].text).to.equal("1.2.1.2")
-        })
+    it("can detect missing closing parenthesis in a string", function () {
+        let input = " ((()))" // the input is assumed to start right after an opening parenthesis
+        expect(() => findClosingOffset("(", ")", 0, input)).to.throw("INVALID INPUT TEXT, UNTERMINATED PARENTHESIS")
+    })
 
-        it("can build a Terminal Production from a RangeProd", function () {
-            b.terminalNameToConstructor = <any>tok
-            let actual = b.buildProdGast({
-                range: new r.Range(1, 2),
-                text:  "this.CONSUME2(tok.IdentTok)",
-                type:  b.ProdType.TERMINAL
-            }, [])
-            expect(actual).to.be.an.instanceof(gast.Terminal)
-            expect((<gast.Terminal>actual).occurrenceInParent).to.equal(2)
-            expect((<gast.Terminal>actual).terminalType).to.equal(tok.IdentTok)
-        })
+    it("can find the direct 'childs' of another Production from an IProd representation", function () {
+        let allProdRanges:IProdRange[] = [
+            {range: new Range(1, 10), text: "1.1", type: ProdType.TERMINAL},
+            {range: new Range(11, 200), text: "1.2", type: ProdType.OR},
+            {range: new Range(20, 180), text: "1.2.1", type: ProdType.MANY},
+            {range: new Range(30, 100), text: "1.2.1.1", type: ProdType.TERMINAL},
+            {range: new Range(101, 170), text: "1.2.1.2", type: ProdType.TERMINAL},
+            {range: new Range(181, 190), text: "1.2.2", type: ProdType.TERMINAL},
+            {range: new Range(201, 209), text: "1.3", type: ProdType.TERMINAL}
+        ]
+
+        let topRange = getDirectlyContainedRanges(new Range(0, 210), allProdRanges)
+        expect(topRange.length).to.equal(3)
+        expect(topRange[0].text).to.equal("1.1")
+        expect(topRange[1].text).to.equal("1.2")
+        expect(topRange[2].text).to.equal("1.3")
+
+
+        let orRange = getDirectlyContainedRanges(new Range(11, 200), allProdRanges)
+        expect(orRange.length).to.equal(2)
+        expect(orRange[0].text).to.equal("1.2.1")
+        expect(orRange[1].text).to.equal("1.2.2")
+
+        let manyRange = getDirectlyContainedRanges(new Range(20, 180), allProdRanges)
+        expect(manyRange.length).to.equal(2)
+        expect(manyRange[0].text).to.equal("1.2.1.1")
+        expect(manyRange[1].text).to.equal("1.2.1.2")
+    })
 
-        it("will fail building a terminal if it cannot find it's constructor", function () {
-            b.terminalNameToConstructor = {}
-            let buildMissingTerminal = () => b.buildProdGast({
-                range: new r.Range(1, 2),
-                text:  "this.CONSUME2(tok.IdentTok)",
-                type:  b.ProdType.TERMINAL
-            }, [])
+    it("can build a Terminal Production from a RangeProd", function () {
+        gastBuilder.terminalNameToConstructor = <any>tok
+        let actual = buildProdGast({
+            range: new Range(1, 2),
+            text:  "this.CONSUME2(IdentTok)",
+            type:  ProdType.TERMINAL
+        }, [])
+        expect(actual).to.be.an.instanceof(Terminal)
+        expect((<gast.Terminal>actual).occurrenceInParent).to.equal(2)
+        expect((<gast.Terminal>actual).terminalType).to.equal(IdentTok)
+    })
 
-            expect(buildMissingTerminal).to.throw("Terminal Token name: " + "IdentTok" + " not found")
-        })
+    it("will fail building a terminal if it cannot find it's constructor", function () {
+        gastBuilder.terminalNameToConstructor = {}
+        let buildMissingTerminal = () => buildProdGast({
+            range: new Range(1, 2),
+            text:  "this.CONSUME2(IdentTok)",
+            type:  ProdType.TERMINAL
+        }, [])
 
-        it("can build a Ref Production from a RangeProd", function () {
-            let actual = b.buildProdGast({
-                range: new r.Range(1, 2),
-                text:  "this.SUBRULE(this.bamba(1))",
-                type:  b.ProdType.REF
-            }, [])
-            expect(actual).to.be.an.instanceof(gast.NonTerminal)
-            expect((<gast.NonTerminal>actual).occurrenceInParent).to.equal(1)
-            expect((<gast.NonTerminal>actual).nonTerminalName).to.equal("bamba")
-        })
+        expect(buildMissingTerminal).to.throw("Terminal Token name: " + "IdentTok" + " not found")
+    })
 
-        it("can build an OR Production from a RangeProd", function () {
-            let actual = b.buildProdGast({range: new r.Range(1, 2), text: "this.OR(...)", type: b.ProdType.OR}, [])
-            expect(actual).to.be.an.instanceof(gast.Alternation)
-            expect((<gast.Alternation>actual).definition.length).to.equal(0)
-        })
+    it("can build a Ref Production from a RangeProd", function () {
+        let actual = buildProdGast({
+            range: new Range(1, 2),
+            text:  "this.SUBRULE(this.bamba(1))",
+            type:  ProdType.REF
+        }, [])
+        expect(actual).to.be.an.instanceof(NonTerminal)
+        expect((<gast.NonTerminal>actual).occurrenceInParent).to.equal(1)
+        expect((<gast.NonTerminal>actual).nonTerminalName).to.equal("bamba")
+    })
 
-        it("can build a MANY Production from a RangeProd", function () {
-            let actual = b.buildProdGast({range: new r.Range(1, 2), text: "this.MANY(...)", type: b.ProdType.MANY}, [])
-            expect(actual).to.be.an.instanceof(gast.Repetition)
-            expect((<gast.Repetition>actual).definition.length).to.equal(0)
-        })
+    it("can build an OR Production from a RangeProd", function () {
+        let actual = buildProdGast({range: new Range(1, 2), text: "this.OR(...)", type: ProdType.OR}, [])
+        expect(actual).to.be.an.instanceof(Alternation)
+        expect((<gast.Alternation>actual).definition.length).to.equal(0)
+    })
 
-        it("can build a MANY_SEP Production from a RangeProd", function () {
-            // hack, using "toString" because it exists on plain js object as the "separator".
-            let actual = b.buildProdGast({range: new r.Range(1, 2), text: "this.MANY_SEP(toString...)", type: b.ProdType.MANY_SEP}, [])
-            expect(actual).to.be.an.instanceof(gast.RepetitionWithSeparator)
-            expect((<gast.Repetition>actual).definition.length).to.equal(0)
-        })
+    it("can build a MANY Production from a RangeProd", function () {
+        let actual = buildProdGast({range: new Range(1, 2), text: "this.MANY(...)", type: ProdType.MANY}, [])
+        expect(actual).to.be.an.instanceof(Repetition)
+        expect((<gast.Repetition>actual).definition.length).to.equal(0)
+    })
 
-        it("will fail when building a MANY_SEP Production from a RangeProd in the seperator is not known", function () {
-            expect(() => b.buildProdGast({range: new r.Range(1, 2), text: "this.MANY_SEP(MISSING...)", type: b.ProdType.MANY_SEP}, [])).
-                to.throw("Separator Terminal Token name: MISSING not found")
-        })
+    it("can build a MANY_SEP Production from a RangeProd", function () {
+        // hack, using "toString" because it exists on plain js object as the "separator".
+        let actual = buildProdGast({
+            range: new Range(1, 2),
+            text:  "this.MANY_SEP(toString...)",
+            type:  ProdType.MANY_SEP
+        }, [])
+        expect(actual).to.be.an.instanceof(RepetitionWithSeparator)
+        expect((<gast.Repetition>actual).definition.length).to.equal(0)
+    })
 
-        it("can build an AT_LEAST_ONE Production from a RangeProd", function () {
-            let actual = b.buildProdGast({
-                range: new r.Range(1, 2),
-                text:  "this.AT_LEAST_ONE(...)",
-                type:  b.ProdType.AT_LEAST_ONE
-            }, [])
-            expect(actual).to.be.an.instanceof(gast.RepetitionMandatory)
-            expect((<gast.RepetitionMandatory>actual).definition.length).to.equal(0)
-        })
+    it("will fail when building a MANY_SEP Production from a RangeProd in the seperator is not known", function () {
+        expect(() => buildProdGast({
+            range: new Range(1, 2),
+            text:  "this.MANY_SEP(MISSING...)",
+            type:  ProdType.MANY_SEP
+        }, [])).to.throw("Separator Terminal Token name: MISSING not found")
+    })
 
-        it("can build an OPTION Production from a RangeProd", function () {
-            let actual = b.buildProdGast({
-                range: new r.Range(1, 2),
-                text:  "this.OPTION(...)",
-                type:  b.ProdType.OPTION
-            }, [])
-            expect(actual).to.be.an.instanceof(gast.Option)
-            expect((<gast.Option>actual).definition.length).to.equal(0)
-        })
+    it("can build an AT_LEAST_ONE Production from a RangeProd", function () {
+        let actual = buildProdGast({
+            range: new Range(1, 2),
+            text:  "this.AT_LEAST_ONE(...)",
+            type:  ProdType.AT_LEAST_ONE
+        }, [])
+        expect(actual).to.be.an.instanceof(RepetitionMandatory)
+        expect((<gast.RepetitionMandatory>actual).definition.length).to.equal(0)
+    })
 
-        it("can build an OR Production from a RangeProd", function () {
-            let actual = b.buildProdGast({range: new r.Range(1, 2), text: "this.OR(...)", type: b.ProdType.OR}, [])
-            expect(actual).to.be.an.instanceof(gast.Alternation)
-            expect((<gast.Alternation>actual).definition.length).to.equal(0)
-        })
+    it("can build an OPTION Production from a RangeProd", function () {
+        let actual = buildProdGast({
+            range: new Range(1, 2),
+            text:  "this.OPTION(...)",
+            type:  ProdType.OPTION
+        }, [])
+        expect(actual).to.be.an.instanceof(Option)
+        expect((<gast.Option>actual).definition.length).to.equal(0)
+    })
 
-        it("can build The Gast representation of a literalArray Grammar Rule", function () {
-            let actual = b.buildTopProduction(literalArrayText, "literalArray", <any>tok)
-            expect(actual.name).to.equal("literalArray")
-            expect(actual.orgText).to.equal(literalArrayText)
-            let def = actual.definition
-            expect(def.length).to.equal(4)
-            expect(def[0]).to.be.an.instanceof(gast.Terminal)
-            expect((<gast.Terminal>def[0]).occurrenceInParent).to.equal(1)
-            expect((<gast.Terminal>def[0]).terminalType).to.equal(tok.LSquareTok)
-
-            expect(def[1]).to.be.an.instanceof(gast.NonTerminal)
-            expect((<gast.NonTerminal>def[1]).occurrenceInParent).to.equal(1)
-            expect((<gast.NonTerminal>def[1]).nonTerminalName).to.equal("expression")
-
-            expect(def[2]).to.be.an.instanceof(gast.Repetition)
-            // -- MANY part begin
-            let manyDef = (<gast.Repetition>def[2]).definition
-            expect(manyDef.length).to.equal(2)
-
-            expect(manyDef[0]).to.be.an.instanceof(gast.Terminal)
-            expect((<gast.Terminal>manyDef[0]).occurrenceInParent).to.equal(1)
-            expect((<gast.Terminal>manyDef[0]).terminalType).to.equal(tok.CommaTok)
-
-            expect(manyDef[1]).to.be.an.instanceof(gast.NonTerminal)
-            expect((<gast.NonTerminal>manyDef[1]).occurrenceInParent).to.equal(2)
-            expect((<gast.NonTerminal>manyDef[1]).nonTerminalName).to.equal("expression")
-            // -- MANY part end
-
-            expect(def[3]).to.be.an.instanceof(gast.Terminal)
-            expect((<gast.Terminal>def[3]).occurrenceInParent).to.equal(1)
-            expect((<gast.Terminal>def[3]).terminalType).to.equal(tok.RSquareTok)
-        })
+    it("can build an OR Production from a RangeProd", function () {
+        let actual = buildProdGast({range: new Range(1, 2), text: "this.OR(...)", type: ProdType.OR}, [])
+        expect(actual).to.be.an.instanceof(Alternation)
+        expect((<gast.Alternation>actual).definition.length).to.equal(0)
+    })
+
+    it("can build The Gast representation of a literalArray Grammar Rule", function () {
+        let actual = buildTopProduction(literalArrayText, "literalArray", <any>tok)
+        expect(actual.name).to.equal("literalArray")
+        expect(actual.orgText).to.equal(literalArrayText)
+        let def = actual.definition
+        expect(def.length).to.equal(4)
+        expect(def[0]).to.be.an.instanceof(Terminal)
+        expect((<gast.Terminal>def[0]).occurrenceInParent).to.equal(1)
+        expect((<gast.Terminal>def[0]).terminalType).to.equal(LSquareTok)
+
+        expect(def[1]).to.be.an.instanceof(NonTerminal)
+        expect((<gast.NonTerminal>def[1]).occurrenceInParent).to.equal(1)
+        expect((<gast.NonTerminal>def[1]).nonTerminalName).to.equal("expression")
+
+        expect(def[2]).to.be.an.instanceof(Repetition)
+        // -- MANY part begin
+        let manyDef = (<gast.Repetition>def[2]).definition
+        expect(manyDef.length).to.equal(2)
+
+        expect(manyDef[0]).to.be.an.instanceof(Terminal)
+        expect((<gast.Terminal>manyDef[0]).occurrenceInParent).to.equal(1)
+        expect((<gast.Terminal>manyDef[0]).terminalType).to.equal(CommaTok)
+
+        expect(manyDef[1]).to.be.an.instanceof(NonTerminal)
+        expect((<gast.NonTerminal>manyDef[1]).occurrenceInParent).to.equal(2)
+        expect((<gast.NonTerminal>manyDef[1]).nonTerminalName).to.equal("expression")
+        // -- MANY part end
+
+        expect(def[3]).to.be.an.instanceof(Terminal)
+        expect((<gast.Terminal>def[3]).occurrenceInParent).to.equal(1)
+        expect((<gast.Terminal>def[3]).terminalType).to.equal(RSquareTok)
+    })
 
 
-        it("can build The Gast representation of an elementDefinition Grammar Rule", function () {
-            let actual = b.buildTopProduction(elementDefText, "elementDef", <any>tok)
-            expect(actual.orgText).to.equal(elementDefText)
-            expect(actual.name).to.equal("elementDef")
-            let def = actual.definition
-            expect(def.length).to.equal(6)
-            expect(def[0]).to.be.an.instanceof(gast.Option)
-            let option1Def = (<gast.Option>def[0]).definition
-            expect(option1Def.length).to.equal(1)
-            expect(option1Def[0]).to.be.an.instanceof(gast.Terminal)
-            expect((<gast.Terminal>option1Def[0]).occurrenceInParent).to.equal(1)
-            expect((<gast.Terminal>option1Def[0]).terminalType).to.equal(tok.RequiredTok)
-
-            expect(def[1]).to.be.an.instanceof(gast.Option)
-            let option2Def = (<gast.Option>def[1]).definition
-            expect(option2Def.length).to.equal(1)
-            expect(option2Def[0]).to.be.an.instanceof(gast.Terminal)
-            expect((<gast.Terminal>option2Def[0]).occurrenceInParent).to.equal(1)
-            expect((<gast.Terminal>option2Def[0]).terminalType).to.equal(tok.KeyTok)
-
-            expect(def[2]).to.be.an.instanceof(gast.Terminal)
-            expect((<gast.Terminal>def[2]).occurrenceInParent).to.equal(1)
-            expect((<gast.Terminal>def[2]).terminalType).to.equal(tok.ElementTok)
-
-            expect(def[3]).to.be.an.instanceof(gast.Terminal)
-            expect((<gast.Terminal>def[3]).occurrenceInParent).to.equal(1)
-            expect((<gast.Terminal>def[3]).terminalType).to.equal(tok.IdentTok)
-
-            expect(def[4]).to.be.an.instanceof(gast.Alternation)
-            let orDef = (<gast.Alternation>def[4]).definition
-            expect(orDef.length).to.equal(2)
-            expect(orDef[0]).to.be.an.instanceof(gast.Flat)
-            let orPartDef1 = (<gast.Flat>orDef[0]).definition
-            expect(orPartDef1.length).to.equal(1)
-            expect(orPartDef1[0]).to.be.an.instanceof(gast.NonTerminal)
-            expect((<gast.NonTerminal>orPartDef1[0]).occurrenceInParent).to.equal(1)
-            expect((<gast.NonTerminal>orPartDef1[0]).nonTerminalName).to.equal("assignedTypeSpec")
-
-            expect(orDef[1]).to.be.an.instanceof(gast.Flat)
-            let orPartDef2 = (<gast.Flat>orDef[1]).definition
-            expect(orPartDef2.length).to.equal(1)
-            expect(orPartDef2[0]).to.be.an.instanceof(gast.NonTerminal)
-            expect((<gast.NonTerminal>orPartDef2[0]).occurrenceInParent).to.equal(1)
-            expect((<gast.NonTerminal>orPartDef2[0]).nonTerminalName).to.equal("assignedTypeSpecImplicit")
-
-            expect(def[5]).to.be.an.instanceof(gast.Terminal)
-            expect((<gast.Terminal>def[5]).occurrenceInParent).to.equal(1)
-            expect((<gast.Terminal>def[5]).terminalType).to.equal(tok.SemicolonTok)
-        })
+    it("can build The Gast representation of an elementDefinition Grammar Rule", function () {
+        let actual = buildTopProduction(elementDefText, "elementDef", <any>tok)
+        expect(actual.orgText).to.equal(elementDefText)
+        expect(actual.name).to.equal("elementDef")
+        let def = actual.definition
+        expect(def.length).to.equal(6)
+        expect(def[0]).to.be.an.instanceof(Option)
+        let option1Def = (<gast.Option>def[0]).definition
+        expect(option1Def.length).to.equal(1)
+        expect(option1Def[0]).to.be.an.instanceof(Terminal)
+        expect((<gast.Terminal>option1Def[0]).occurrenceInParent).to.equal(1)
+        expect((<gast.Terminal>option1Def[0]).terminalType).to.equal(RequiredTok)
+
+        expect(def[1]).to.be.an.instanceof(Option)
+        let option2Def = (<gast.Option>def[1]).definition
+        expect(option2Def.length).to.equal(1)
+        expect(option2Def[0]).to.be.an.instanceof(Terminal)
+        expect((<gast.Terminal>option2Def[0]).occurrenceInParent).to.equal(1)
+        expect((<gast.Terminal>option2Def[0]).terminalType).to.equal(KeyTok)
+
+        expect(def[2]).to.be.an.instanceof(Terminal)
+        expect((<gast.Terminal>def[2]).occurrenceInParent).to.equal(1)
+        expect((<gast.Terminal>def[2]).terminalType).to.equal(ElementTok)
+
+        expect(def[3]).to.be.an.instanceof(Terminal)
+        expect((<gast.Terminal>def[3]).occurrenceInParent).to.equal(1)
+        expect((<gast.Terminal>def[3]).terminalType).to.equal(IdentTok)
+
+        expect(def[4]).to.be.an.instanceof(Alternation)
+        let orDef = (<gast.Alternation>def[4]).definition
+        expect(orDef.length).to.equal(2)
+        expect(orDef[0]).to.be.an.instanceof(Flat)
+        let orPartDef1 = (<gast.Flat>orDef[0]).definition
+        expect(orPartDef1.length).to.equal(1)
+        expect(orPartDef1[0]).to.be.an.instanceof(NonTerminal)
+        expect((<gast.NonTerminal>orPartDef1[0]).occurrenceInParent).to.equal(1)
+        expect((<gast.NonTerminal>orPartDef1[0]).nonTerminalName).to.equal("assignedTypeSpec")
+
+        expect(orDef[1]).to.be.an.instanceof(Flat)
+        let orPartDef2 = (<gast.Flat>orDef[1]).definition
+        expect(orPartDef2.length).to.equal(1)
+        expect(orPartDef2[0]).to.be.an.instanceof(NonTerminal)
+        expect((<gast.NonTerminal>orPartDef2[0]).occurrenceInParent).to.equal(1)
+        expect((<gast.NonTerminal>orPartDef2[0]).nonTerminalName).to.equal("assignedTypeSpecImplicit")
+
+        expect(def[5]).to.be.an.instanceof(Terminal)
+        expect((<gast.Terminal>def[5]).occurrenceInParent).to.equal(1)
+        expect((<gast.Terminal>def[5]).terminalType).to.equal(SemicolonTok)
+    })
 
 
-        it("can build nested OR grammar successfully", function () {
+    it("can build nested OR grammar successfully", function () {
 
-            let input = " let max = this.OR([\n\
+        let input = " let max = this.OR([\n\
                 {WHEN: isExpression, THEN_DO: ()=> {\n\
                     this.OR([\n\
                             \n\
                         {WHEN: isAlias, THEN_DO: ()=> {\n\
-                            return PT(this.CONSUME1(tok.ViaTok))\n\
+                            return PT(this.CONSUME1(ViaTok))\n\
                         }}\n\
                     ], 'Expression or Star Token')\n\
                 }}\n\
             ], 'Expression or Star Token').tree "
 
 
-            let orRanges = b.createOrRanges(input)
-            expect(orRanges.length).to.equal(4)
+        let orRanges = createOrRanges(input)
+        expect(orRanges.length).to.equal(4)
 
-            let allFlatRanges = _.filter(orRanges, (prodRange:b.IProdRange) => {
-                return prodRange.type === b.ProdType.FLAT
-            })
-            expect(allFlatRanges.length).to.equal(2)
+        let allFlatRanges = _.filter(orRanges, (prodRange:IProdRange) => {
+            return prodRange.type === ProdType.FLAT
+        })
+        expect(allFlatRanges.length).to.equal(2)
 
-            let allOrRanges = _.filter(orRanges, (prodRange:b.IProdRange) => {
-                return prodRange.type === b.ProdType.FLAT
-            })
-            expect(allOrRanges.length).to.equal(2)
+        let allOrRanges = _.filter(orRanges, (prodRange:IProdRange) => {
+            return prodRange.type === ProdType.FLAT
         })
+        expect(allOrRanges.length).to.equal(2)
     })
-}
+})
diff --git a/test/parse/grammar/checks_spec.ts b/test/parse/grammar/checks_spec.ts
index ac530828e..0e0a7cadd 100644
--- a/test/parse/grammar/checks_spec.ts
+++ b/test/parse/grammar/checks_spec.ts
@@ -1,506 +1,526 @@
-namespace chevrotain.checks.spec {
-    import gast = chevrotain.gast
-    import samples = specs.samples
-
-    describe("the grammar validations", function () {
-
-        it("validates every one of the TOP_RULEs in the input", function () {
-
-            let expectedErrorsNoMsg = [{
-                "type":       ParserDefinitionErrorType.DUPLICATE_PRODUCTIONS,
-                "ruleName":   "qualifiedNameErr1",
-                "dslName":    "CONSUME",
-                "occurrence": 1,
-                "parameter":  "IdentTok"
-            }, {
-                "type":       ParserDefinitionErrorType.DUPLICATE_PRODUCTIONS,
-                "ruleName":   "qualifiedNameErr2",
-                "dslName":    "MANY",
-                "occurrence": 1
-            }, {
-                "type":       ParserDefinitionErrorType.DUPLICATE_PRODUCTIONS,
-                "ruleName":   "qualifiedNameErr2",
-                "dslName":    "CONSUME",
-                "occurrence": 1,
-                "parameter":  "DotTok"
-            }, {
-                "type":       ParserDefinitionErrorType.DUPLICATE_PRODUCTIONS,
-                "ruleName":   "qualifiedNameErr2",
-                "dslName":    "CONSUME",
-                "occurrence": 2,
-                "parameter":  "IdentTok"
-            }]
-
-
-            let qualifiedNameErr1 = new gast.Rule("qualifiedNameErr1", [
-                new gast.Terminal(samples.IdentTok, 1),
-                new gast.Repetition([
-                    new gast.Terminal(samples.DotTok),
-                    new gast.Terminal(samples.IdentTok, 1) // duplicate Terminal IdentTok with occurrence index 1
-                ])
+import {Parser, ParserDefinitionErrorType, EMPTY_ALT} from "../../../src/parse/parser_public"
+import {IdentTok, DotTok, qualifiedName, actionDec} from "./samples"
+
+import {gast} from "../../../src/parse/grammar/gast_public"
+
+let Rule = gast.Rule
+let RepetitionMandatory = gast.RepetitionMandatory
+let Repetition = gast.Repetition
+let NonTerminal = gast.NonTerminal
+let Terminal = gast.Terminal
+let Option = gast.Option
+let Alternation = gast.Alternation
+let Flat = gast.Flat
+
+import {
+    validateRuleName,
+    validateGrammar,
+    identifyProductionForDuplicates,
+    OccurrenceValidationCollector,
+    getFirstNoneTerminal
+} from "../../../src/parse/grammar/checks"
+import {Token, extendToken} from "../../../src/scan/tokens_public"
+import * as _ from "lodash"
+
+describe("the grammar validations", function () {
+
+    it("validates every one of the TOP_RULEs in the input", function () {
+
+        let expectedErrorsNoMsg = [{
+            "type":       ParserDefinitionErrorType.DUPLICATE_PRODUCTIONS,
+            "ruleName":   "qualifiedNameErr1",
+            "dslName":    "CONSUME",
+            "occurrence": 1,
+            "parameter":  "IdentTok"
+        }, {
+            "type":       ParserDefinitionErrorType.DUPLICATE_PRODUCTIONS,
+            "ruleName":   "qualifiedNameErr2",
+            "dslName":    "MANY",
+            "occurrence": 1
+        }, {
+            "type":       ParserDefinitionErrorType.DUPLICATE_PRODUCTIONS,
+            "ruleName":   "qualifiedNameErr2",
+            "dslName":    "CONSUME",
+            "occurrence": 1,
+            "parameter":  "DotTok"
+        }, {
+            "type":       ParserDefinitionErrorType.DUPLICATE_PRODUCTIONS,
+            "ruleName":   "qualifiedNameErr2",
+            "dslName":    "CONSUME",
+            "occurrence": 2,
+            "parameter":  "IdentTok"
+        }]
+
+
+        let qualifiedNameErr1 = new Rule("qualifiedNameErr1", [
+            new Terminal(IdentTok, 1),
+            new Repetition([
+                new Terminal(DotTok),
+                new Terminal(IdentTok, 1) // duplicate Terminal IdentTok with occurrence index 1
             ])
-
-            let qualifiedNameErr2 = new gast.Rule("qualifiedNameErr2", [
-                new gast.Terminal(samples.IdentTok, 1),
-                new gast.Repetition([
-                    new gast.Terminal(samples.DotTok),
-                    new gast.Terminal(samples.IdentTok, 2)
-                ]),
-                new gast.Repetition([
-                    new gast.Terminal(samples.DotTok),
-                    new gast.Terminal(samples.IdentTok, 2)
-                ])
+        ])
+
+        let qualifiedNameErr2 = new Rule("qualifiedNameErr2", [
+            new Terminal(IdentTok, 1),
+            new Repetition([
+                new Terminal(DotTok),
+                new Terminal(IdentTok, 2)
+            ]),
+            new Repetition([
+                new Terminal(DotTok),
+                new Terminal(IdentTok, 2)
             ])
-            let actualErrors = validateGrammar([qualifiedNameErr1, qualifiedNameErr2])
-            expect(actualErrors.length).to.equal(4)
-
-            let actualErrorsNoMsg = _.map(actualErrors, err => _.omit(err, "message"))
-            expect(actualErrorsNoMsg).to.deep.include.members(expectedErrorsNoMsg)
-            expect(expectedErrorsNoMsg).to.deep.include.members(actualErrorsNoMsg)
-        })
+        ])
+        let actualErrors = validateGrammar([qualifiedNameErr1, qualifiedNameErr2])
+        expect(actualErrors.length).to.equal(4)
 
-        it("does not allow duplicate grammar rule names", function () {
-            let noErrors = validateRuleName("A", ["B", "C"], "className")
-            //noinspection BadExpressionStatementJS
-            expect(noErrors).to.be.empty
-
-            let duplicateErr = validateRuleName("A", ["A", "B", "C"], "className")
-            //noinspection BadExpressionStatementJS
-            expect(duplicateErr).to.have.length(1)
-            expect(duplicateErr[0]).to.have.property("message")
-            expect(duplicateErr[0]).to.have.property("type", ParserDefinitionErrorType.DUPLICATE_RULE_NAME)
-            expect(duplicateErr[0]).to.have.property("ruleName", "A")
-        })
+        let actualErrorsNoMsg = _.map(actualErrors, err => _.omit(err, "message"))
+        expect(actualErrorsNoMsg).to.deep.include.members(expectedErrorsNoMsg)
+        expect(expectedErrorsNoMsg).to.deep.include.members(actualErrorsNoMsg)
+    })
 
-        it("only allows a subset of ECMAScript identifiers as rule names", function () {
-            let res1 = validateRuleName("1baa", [], "className")
-            expect(res1).to.have.lengthOf(1)
-            expect(res1[0]).to.have.property("message")
-            expect(res1[0]).to.have.property("type", ParserDefinitionErrorType.INVALID_RULE_NAME)
-            expect(res1[0]).to.have.property("ruleName", "1baa")
-
-            let res2 = validateRuleName("שלום", [], "className")
-            expect(res2).to.have.lengthOf(1)
-            expect(res2[0]).to.have.property("message")
-            expect(res2[0]).to.have.property("type", ParserDefinitionErrorType.INVALID_RULE_NAME)
-            expect(res2[0]).to.have.property("ruleName", "שלום")
-
-            let res3 = validateRuleName("$bamba", [], "className")
-            expect(res3).to.have.lengthOf(1)
-            expect(res3[0]).to.have.property("message")
-            expect(res3[0]).to.have.property("type", ParserDefinitionErrorType.INVALID_RULE_NAME)
-            expect(res3[0]).to.have.property("ruleName", "$bamba")
-        })
+    it("does not allow duplicate grammar rule names", function () {
+        let noErrors = validateRuleName("A", ["B", "C"], "className")
+        //noinspection BadExpressionStatementJS
+        expect(noErrors).to.be.empty
+
+        let duplicateErr = validateRuleName("A", ["A", "B", "C"], "className")
+        //noinspection BadExpressionStatementJS
+        expect(duplicateErr).to.have.length(1)
+        expect(duplicateErr[0]).to.have.property("message")
+        expect(duplicateErr[0]).to.have.property("type", ParserDefinitionErrorType.DUPLICATE_RULE_NAME)
+        expect(duplicateErr[0]).to.have.property("ruleName", "A")
     })
 
+    it("only allows a subset of ECMAScript identifiers as rule names", function () {
+        let res1 = validateRuleName("1baa", [], "className")
+        expect(res1).to.have.lengthOf(1)
+        expect(res1[0]).to.have.property("message")
+        expect(res1[0]).to.have.property("type", ParserDefinitionErrorType.INVALID_RULE_NAME)
+        expect(res1[0]).to.have.property("ruleName", "1baa")
+
+        let res2 = validateRuleName("שלום", [], "className")
+        expect(res2).to.have.lengthOf(1)
+        expect(res2[0]).to.have.property("message")
+        expect(res2[0]).to.have.property("type", ParserDefinitionErrorType.INVALID_RULE_NAME)
+        expect(res2[0]).to.have.property("ruleName", "שלום")
+
+        let res3 = validateRuleName("$bamba", [], "className")
+        expect(res3).to.have.lengthOf(1)
+        expect(res3[0]).to.have.property("message")
+        expect(res3[0]).to.have.property("type", ParserDefinitionErrorType.INVALID_RULE_NAME)
+        expect(res3[0]).to.have.property("ruleName", "$bamba")
+    })
+})
 
-    describe("identifyProductionForDuplicates function", function () {
-        it("generates DSL code for a ProdRef", function () {
-            let dslCode = identifyProductionForDuplicates(new gast.NonTerminal("ActionDeclaration"))
-            expect(dslCode).to.equal("SUBRULE_#_1_#_ActionDeclaration")
-        })
 
-        it("generates DSL code for a OPTION", function () {
-            let dslCode = identifyProductionForDuplicates(new gast.Option([], 3))
-            expect(dslCode).to.equal("OPTION_#_3_#_")
-        })
+describe("identifyProductionForDuplicates function", function () {
+    it("generates DSL code for a ProdRef", function () {
+        let dslCode = identifyProductionForDuplicates(new NonTerminal("ActionDeclaration"))
+        expect(dslCode).to.equal("SUBRULE_#_1_#_ActionDeclaration")
+    })
 
-        it("generates DSL code for a AT_LEAST_ONE", function () {
-            let dslCode = identifyProductionForDuplicates(new gast.RepetitionMandatory([]))
-            expect(dslCode).to.equal("AT_LEAST_ONE_#_1_#_")
-        })
+    it("generates DSL code for a OPTION", function () {
+        let dslCode = identifyProductionForDuplicates(new Option([], 3))
+        expect(dslCode).to.equal("OPTION_#_3_#_")
+    })
 
-        it("generates DSL code for a MANY", function () {
-            let dslCode = identifyProductionForDuplicates(new gast.Repetition([], 5))
-            expect(dslCode).to.equal("MANY_#_5_#_")
-        })
+    it("generates DSL code for a AT_LEAST_ONE", function () {
+        let dslCode = identifyProductionForDuplicates(new RepetitionMandatory([]))
+        expect(dslCode).to.equal("AT_LEAST_ONE_#_1_#_")
+    })
 
-        it("generates DSL code for a OR", function () {
-            let dslCode = identifyProductionForDuplicates(new gast.Alternation([], 1))
-            expect(dslCode).to.equal("OR_#_1_#_")
-        })
+    it("generates DSL code for a MANY", function () {
+        let dslCode = identifyProductionForDuplicates(new Repetition([], 5))
+        expect(dslCode).to.equal("MANY_#_5_#_")
+    })
 
-        it("generates DSL code for a Terminal", function () {
-            let dslCode = identifyProductionForDuplicates(new gast.Terminal(samples.IdentTok, 4))
-            expect(dslCode).to.equal("CONSUME_#_4_#_IdentTok")
-        })
+    it("generates DSL code for a OR", function () {
+        let dslCode = identifyProductionForDuplicates(new Alternation([], 1))
+        expect(dslCode).to.equal("OR_#_1_#_")
     })
 
+    it("generates DSL code for a Terminal", function () {
+        let dslCode = identifyProductionForDuplicates(new Terminal(IdentTok, 4))
+        expect(dslCode).to.equal("CONSUME_#_4_#_IdentTok")
+    })
+})
 
-    describe("OccurrenceValidationCollector GASTVisitor class", function () {
 
-        it("collects all the productions relevant to occurrence validation", function () {
-            let qualifiedNameVisitor = new OccurrenceValidationCollector()
-            samples.qualifiedName.accept(qualifiedNameVisitor)
-            expect(qualifiedNameVisitor.allProductions.length).to.equal(4)
+describe("OccurrenceValidationCollector GASTVisitor class", function () {
 
-            // TODO: check set equality
+    it("collects all the productions relevant to occurrence validation", function () {
+        let qualifiedNameVisitor = new OccurrenceValidationCollector()
+        qualifiedName.accept(qualifiedNameVisitor)
+        expect(qualifiedNameVisitor.allProductions.length).to.equal(4)
 
-            let actionDecVisitor = new OccurrenceValidationCollector()
-            samples.actionDec.accept(actionDecVisitor)
-            expect(actionDecVisitor.allProductions.length).to.equal(13)
+        // TODO: check set equality
 
-            // TODO: check set equality
-        })
+        let actionDecVisitor = new OccurrenceValidationCollector()
+        actionDec.accept(actionDecVisitor)
+        expect(actionDecVisitor.allProductions.length).to.equal(13)
 
+        // TODO: check set equality
     })
 
-    class DummyToken extends Token {}
-    let dummyRule = new gast.Rule("dummyRule", [new gast.Terminal(DummyToken)])
-    let dummyRule2 = new gast.Rule("dummyRule2", [new gast.Terminal(DummyToken)])
-    let dummyRule3 = new gast.Rule("dummyRule3", [new gast.Terminal(DummyToken)])
-
-    describe("the getFirstNoneTerminal function", function () {
+})
 
-        it("can find the firstNoneTerminal of an empty sequence", function () {
-            expect(checks.getFirstNoneTerminal([])).to.be.empty
-        })
+class DummyToken extends Token {}
+let dummyRule = new Rule("dummyRule", [new Terminal(DummyToken)])
+let dummyRule2 = new Rule("dummyRule2", [new Terminal(DummyToken)])
+let dummyRule3 = new Rule("dummyRule3", [new Terminal(DummyToken)])
 
-        it("can find the firstNoneTerminal of a sequence with only one item", function () {
-            let result = checks.getFirstNoneTerminal([new gast.NonTerminal("dummyRule", dummyRule)])
-            expect(result).to.have.length(1)
-            expect(_.first(result).name).to.equal("dummyRule")
-        })
+describe("the getFirstNoneTerminal function", function () {
 
-        it("can find the firstNoneTerminal of a sequence with two items", function () {
-            let sqeuence = [
-                new gast.NonTerminal("dummyRule", dummyRule),
-                new gast.NonTerminal("dummyRule2", dummyRule2)]
-            let result = checks.getFirstNoneTerminal(sqeuence)
-            expect(result).to.have.length(1)
-            expect(_.first(result).name).to.equal("dummyRule")
-        })
+    it("can find the firstNoneTerminal of an empty sequence", function () {
+        expect(getFirstNoneTerminal([])).to.be.empty
+    })
 
-        it("can find the firstNoneTerminal of a sequence with two items where the first is optional", function () {
-            let sqeuence = [
-                new gast.Option([
-                    new gast.NonTerminal("dummyRule", dummyRule)
-                ]),
-                new gast.NonTerminal("dummyRule2", dummyRule2)]
-            let result = checks.getFirstNoneTerminal(sqeuence)
-            expect(result).to.have.length(2)
-            let resultRuleNames = _.pluck(result, "name")
-            expect(resultRuleNames).to.include.members(["dummyRule", "dummyRule2"])
-        })
+    it("can find the firstNoneTerminal of a sequence with only one item", function () {
+        let result = getFirstNoneTerminal([new NonTerminal("dummyRule", dummyRule)])
+        expect(result).to.have.length(1)
+        expect(_.first(result).name).to.equal("dummyRule")
+    })
 
-        it("can find the firstNoneTerminal of an alternation", function () {
-            let alternation = [
-                new gast.Alternation([
-                    new gast.Flat([new gast.NonTerminal("dummyRule", dummyRule)]),
-                    new gast.Flat([new gast.NonTerminal("dummyRule2", dummyRule2)]),
-                    new gast.Flat([new gast.NonTerminal("dummyRule3", dummyRule3)])
-                ]),
-            ]
-            let result = checks.getFirstNoneTerminal(alternation)
-            expect(result).to.have.length(3)
-            let resultRuleNames = _.pluck(result, "name")
-            expect(resultRuleNames).to.include.members(["dummyRule", "dummyRule2", "dummyRule3"])
-        })
+    it("can find the firstNoneTerminal of a sequence with two items", function () {
+        let sqeuence = [
+            new NonTerminal("dummyRule", dummyRule),
+            new NonTerminal("dummyRule2", dummyRule2)]
+        let result = getFirstNoneTerminal(sqeuence)
+        expect(result).to.have.length(1)
+        expect(_.first(result).name).to.equal("dummyRule")
+    })
 
-        it("can find the firstNoneTerminal of an optional repetition", function () {
-            let alternation = [
-                new gast.Repetition([
-                    new gast.Flat([new gast.NonTerminal("dummyRule", dummyRule)]),
-                    new gast.Flat([new gast.NonTerminal("dummyRule2", dummyRule2)]),
-                ]),
-                new gast.NonTerminal("dummyRule3", dummyRule3)
-            ]
-            let result = checks.getFirstNoneTerminal(alternation)
-            expect(result).to.have.length(2)
-            let resultRuleNames = _.pluck(result, "name")
-            expect(resultRuleNames).to.include.members(["dummyRule", "dummyRule3"])
-        })
+    it("can find the firstNoneTerminal of a sequence with two items where the first is optional", function () {
+        let sqeuence = [
+            new Option([
+                new NonTerminal("dummyRule", dummyRule)
+            ]),
+            new NonTerminal("dummyRule2", dummyRule2)]
+        let result = getFirstNoneTerminal(sqeuence)
+        expect(result).to.have.length(2)
+        let resultRuleNames = _.pluck(result, "name")
+        expect(resultRuleNames).to.include.members(["dummyRule", "dummyRule2"])
+    })
 
-        it("can find the firstNoneTerminal of a mandatory repetition", function () {
-            let alternation = [
-                new gast.RepetitionMandatory([
-                    new gast.Flat([new gast.NonTerminal("dummyRule", dummyRule)]),
-                    new gast.Flat([new gast.NonTerminal("dummyRule2", dummyRule2)]),
-                ]),
-                new gast.NonTerminal("dummyRule3", dummyRule3)
-            ]
-            let result = checks.getFirstNoneTerminal(alternation)
-            expect(result).to.have.length(1)
-            let resultRuleNames = _.pluck(result, "name")
-            expect(resultRuleNames).to.include.members(["dummyRule"])
-        })
+    it("can find the firstNoneTerminal of an alternation", function () {
+        let alternation = [
+            new Alternation([
+                new Flat([new NonTerminal("dummyRule", dummyRule)]),
+                new Flat([new NonTerminal("dummyRule2", dummyRule2)]),
+                new Flat([new NonTerminal("dummyRule3", dummyRule3)])
+            ]),
+        ]
+        let result = getFirstNoneTerminal(alternation)
+        expect(result).to.have.length(3)
+        let resultRuleNames = _.pluck(result, "name")
+        expect(resultRuleNames).to.include.members(["dummyRule", "dummyRule2", "dummyRule3"])
     })
 
-    export class PlusTok extends Token {
-        constructor() { super("+", 0, 1, 1) }
-    }
+    it("can find the firstNoneTerminal of an optional repetition", function () {
+        let alternation = [
+            new Repetition([
+                new Flat([new NonTerminal("dummyRule", dummyRule)]),
+                new Flat([new NonTerminal("dummyRule2", dummyRule2)]),
+            ]),
+            new NonTerminal("dummyRule3", dummyRule3)
+        ]
+        let result = getFirstNoneTerminal(alternation)
+        expect(result).to.have.length(2)
+        let resultRuleNames = _.pluck(result, "name")
+        expect(resultRuleNames).to.include.members(["dummyRule", "dummyRule3"])
+    })
 
-    export class MinusTok extends Token {
-        constructor() { super("+", 0, 1, 1) }
-    }
+    it("can find the firstNoneTerminal of a mandatory repetition", function () {
+        let alternation = [
+            new RepetitionMandatory([
+                new Flat([new NonTerminal("dummyRule", dummyRule)]),
+                new Flat([new NonTerminal("dummyRule2", dummyRule2)]),
+            ]),
+            new NonTerminal("dummyRule3", dummyRule3)
+        ]
+        let result = getFirstNoneTerminal(alternation)
+        expect(result).to.have.length(1)
+        let resultRuleNames = _.pluck(result, "name")
+        expect(resultRuleNames).to.include.members(["dummyRule"])
+    })
+})
 
-    export class StarTok extends Token {
-        constructor() { super("*", 0, 1, 1) }
-    }
+export class PlusTok extends Token {
+    constructor() { super("+", 0, 1, 1) }
+}
 
-    class ErroneousOccurrenceNumUsageParser1 extends Parser {
+export class MinusTok extends Token {
+    constructor() { super("+", 0, 1, 1) }
+}
 
-        constructor(input:Token[] = []) {
-            super(input, [PlusTok])
-            Parser.performSelfAnalysis(this)
-        }
+export class StarTok extends Token {
+    constructor() { super("*", 0, 1, 1) }
+}
 
-        public duplicateRef = this.RULE("duplicateRef", () => {
-            this.SUBRULE1(this.anotherRule)
-            this.SUBRULE(this.anotherRule)
-        })
+class ErroneousOccurrenceNumUsageParser1 extends Parser {
 
-        public anotherRule = this.RULE("anotherRule", () => {
-            this.CONSUME(PlusTok)
-        })
+    constructor(input:Token[] = []) {
+        super(input, [PlusTok])
+        Parser.performSelfAnalysis(this)
     }
 
-    class ErroneousOccurrenceNumUsageParser2 extends Parser {
+    public duplicateRef = this.RULE("duplicateRef", () => {
+        this.SUBRULE1(this.anotherRule)
+        this.SUBRULE(this.anotherRule)
+    })
 
-        constructor(input:Token[] = []) {
-            super(input, [PlusTok])
-            Parser.performSelfAnalysis(this)
-        }
+    public anotherRule = this.RULE("anotherRule", () => {
+        this.CONSUME(PlusTok)
+    })
+}
 
-        public duplicateTerminal = this.RULE("duplicateTerminal", () => {
-            this.CONSUME3(PlusTok)
-            this.CONSUME3(PlusTok)
-        })
+class ErroneousOccurrenceNumUsageParser2 extends Parser {
+
+    constructor(input:Token[] = []) {
+        super(input, [PlusTok])
+        Parser.performSelfAnalysis(this)
     }
 
-    class ErroneousOccurrenceNumUsageParser3 extends Parser {
+    public duplicateTerminal = this.RULE("duplicateTerminal", () => {
+        this.CONSUME3(PlusTok)
+        this.CONSUME3(PlusTok)
+    })
+}
 
-        constructor(input:Token[] = []) {
-            super(input, [PlusTok, MinusTok])
-            Parser.performSelfAnalysis(this)
-        }
+class ErroneousOccurrenceNumUsageParser3 extends Parser {
+
+    constructor(input:Token[] = []) {
+        super(input, [PlusTok, MinusTok])
+        Parser.performSelfAnalysis(this)
+    }
 
-        public duplicateMany = this.RULE("duplicateMany", () => {
+    public duplicateMany = this.RULE("duplicateMany", () => {
+        this.MANY(() => {
+            this.CONSUME1(MinusTok)
             this.MANY(() => {
-                this.CONSUME1(MinusTok)
-                this.MANY(() => {
-                    this.CONSUME1(PlusTok)
-                })
+                this.CONSUME1(PlusTok)
             })
         })
-    }
-
-    let myToken = extendToken("myToken")
-    let myOtherToken = extendToken("myOtherToken")
+    })
+}
 
-    class ValidOccurrenceNumUsageParser extends Parser {
+let myToken = extendToken("myToken")
+let myOtherToken = extendToken("myOtherToken")
 
-        constructor(input:Token[] = []) {
-            super(input, [myToken, myOtherToken])
-            Parser.performSelfAnalysis(this)
-        }
+class ValidOccurrenceNumUsageParser extends Parser {
 
-        public anonymousTokens = this.RULE("anonymousTokens", () => {
-            this.CONSUME1(myToken)
-            this.CONSUME1(myOtherToken)
-        })
+    constructor(input:Token[] = []) {
+        super(input, [myToken, myOtherToken])
+        Parser.performSelfAnalysis(this)
     }
 
-    describe("The duplicate occurrence validations full flow", function () {
+    public anonymousTokens = this.RULE("anonymousTokens", () => {
+        this.CONSUME1(myToken)
+        this.CONSUME1(myOtherToken)
+    })
+}
 
-        it("will throw errors on duplicate Terminals consumption in the same top level rule", function () {
-            expect(() => new ErroneousOccurrenceNumUsageParser1()).to.throw("SUBRULE")
-            expect(() => new ErroneousOccurrenceNumUsageParser1()).to.throw("1")
-            expect(() => new ErroneousOccurrenceNumUsageParser1()).to.throw("duplicateRef")
-            expect(() => new ErroneousOccurrenceNumUsageParser1()).to.throw("anotherRule")
-            expect(() => new ErroneousOccurrenceNumUsageParser1()).to.throw("both have the same occurrence index 1")
-        })
+describe("The duplicate occurrence validations full flow", function () {
 
-        it("will throw errors on duplicate Subrules references in the same top level rule", function () {
-            expect(() => new ErroneousOccurrenceNumUsageParser2()).to.throw("CONSUME")
-            expect(() => new ErroneousOccurrenceNumUsageParser2()).to.throw("3")
-            expect(() => new ErroneousOccurrenceNumUsageParser2()).to.throw("PlusTok")
-            expect(() => new ErroneousOccurrenceNumUsageParser2()).to.throw("duplicateTerminal")
-        })
+    it("will throw errors on duplicate Terminals consumption in the same top level rule", function () {
+        expect(() => new ErroneousOccurrenceNumUsageParser1()).to.throw("SUBRULE")
+        expect(() => new ErroneousOccurrenceNumUsageParser1()).to.throw("1")
+        expect(() => new ErroneousOccurrenceNumUsageParser1()).to.throw("duplicateRef")
+        expect(() => new ErroneousOccurrenceNumUsageParser1()).to.throw("anotherRule")
+        expect(() => new ErroneousOccurrenceNumUsageParser1()).to.throw("both have the same occurrence index 1")
+    })
 
-        it("will throw errors on duplicate MANY productions in the same top level rule", function () {
-            expect(() => new ErroneousOccurrenceNumUsageParser3()).to.throw("MANY")
-            expect(() => new ErroneousOccurrenceNumUsageParser3()).to.throw("1")
-            expect(() => new ErroneousOccurrenceNumUsageParser3()).to.throw("duplicateMany")
-            expect(() => new ErroneousOccurrenceNumUsageParser3()).to.throw("both have the same occurrence index 1")
-        })
+    it("will throw errors on duplicate Subrules references in the same top level rule", function () {
+        expect(() => new ErroneousOccurrenceNumUsageParser2()).to.throw("CONSUME")
+        expect(() => new ErroneousOccurrenceNumUsageParser2()).to.throw("3")
+        expect(() => new ErroneousOccurrenceNumUsageParser2()).to.throw("PlusTok")
+        expect(() => new ErroneousOccurrenceNumUsageParser2()).to.throw("duplicateTerminal")
+    })
 
-        it("won't detect issues in a Parser using Tokens created by extendToken(...) utility (anonymous)", function () {
-            //noinspection JSUnusedLocalSymbols
-            let parser = new ValidOccurrenceNumUsageParser()
-        })
+    it("will throw errors on duplicate MANY productions in the same top level rule", function () {
+        expect(() => new ErroneousOccurrenceNumUsageParser3()).to.throw("MANY")
+        expect(() => new ErroneousOccurrenceNumUsageParser3()).to.throw("1")
+        expect(() => new ErroneousOccurrenceNumUsageParser3()).to.throw("duplicateMany")
+        expect(() => new ErroneousOccurrenceNumUsageParser3()).to.throw("both have the same occurrence index 1")
     })
 
+    it("won't detect issues in a Parser using Tokens created by extendToken(...) utility (anonymous)", function () {
+        //noinspection JSUnusedLocalSymbols
+        let parser = new ValidOccurrenceNumUsageParser()
+    })
+})
 
-    class InvalidRefParser extends Parser {
 
-        constructor(input:Token[] = []) {
-            super(input, [myToken, myOtherToken])
-            Parser.performSelfAnalysis(this)
-        }
+class InvalidRefParser extends Parser {
 
-        public one = this.RULE("one", () => {
-            this.SUBRULE2((<any>this).oopsTypo)
-        })
+    constructor(input:Token[] = []) {
+        super(input, [myToken, myOtherToken])
+        Parser.performSelfAnalysis(this)
     }
 
-    class InvalidRefParser2 extends Parser {
+    public one = this.RULE("one", () => {
+        this.SUBRULE2((<any>this).oopsTypo)
+    })
+}
 
-        constructor(input:Token[] = []) {
-            super(input, [myToken, myOtherToken])
-            Parser.performSelfAnalysis(this)
-        }
+class InvalidRefParser2 extends Parser {
 
-        public one = this.RULE("one", () => {
-            this.SUBRULE2((<any>this).oopsTypo)
-        })
+    constructor(input:Token[] = []) {
+        super(input, [myToken, myOtherToken])
+        Parser.performSelfAnalysis(this)
     }
 
-    describe("The reference resolver validation full flow", function () {
+    public one = this.RULE("one", () => {
+        this.SUBRULE2((<any>this).oopsTypo)
+    })
+}
 
-        it("will throw an error when trying to init a parser with unresolved rule references", function () {
-            expect(() => new InvalidRefParser()).to.throw("oopsTypo")
-            expect(() => new InvalidRefParser()).to.throw("Parser Definition Errors detected")
-            expect(() => new InvalidRefParser()).to.throw("reference to rule which is not defined")
-        })
+describe("The reference resolver validation full flow", function () {
 
-        it("won't throw an error when trying to init a parser with definition errors but with a flag active to defer handling" +
-            "of definition errors", function () {
-            Parser.DEFER_DEFINITION_ERRORS_HANDLING = true
-            expect(() => new InvalidRefParser2()).to.not.throw()
-            expect(() => new InvalidRefParser2()).to.not.throw()
-            expect(() => new InvalidRefParser2()).to.not.throw()
-            Parser.DEFER_DEFINITION_ERRORS_HANDLING = false
-        })
+    it("will throw an error when trying to init a parser with unresolved rule references", function () {
+        expect(() => new InvalidRefParser()).to.throw("oopsTypo")
+        expect(() => new InvalidRefParser()).to.throw("Parser Definition Errors detected")
+        expect(() => new InvalidRefParser()).to.throw("reference to rule which is not defined")
     })
 
+    it("won't throw an error when trying to init a parser with definition errors but with a flag active to defer handling" +
+        "of definition errors", function () {
+        Parser.DEFER_DEFINITION_ERRORS_HANDLING = true
+        expect(() => new InvalidRefParser2()).to.not.throw()
+        expect(() => new InvalidRefParser2()).to.not.throw()
+        expect(() => new InvalidRefParser2()).to.not.throw()
+        Parser.DEFER_DEFINITION_ERRORS_HANDLING = false
+    })
+})
 
-    class DuplicateRulesParser extends Parser {
 
-        constructor(input:Token[] = []) {
-            super(input, [myToken, myOtherToken])
-            Parser.performSelfAnalysis(this)
-        }
+class DuplicateRulesParser extends Parser {
 
-        public one = this.RULE("oops_duplicate", () => {})
-        public two = this.RULE("oops_duplicate", () => {})
+    constructor(input:Token[] = []) {
+        super(input, [myToken, myOtherToken])
+        Parser.performSelfAnalysis(this)
     }
 
-    class InvalidRuleNameParser extends Parser {
+    public one = this.RULE("oops_duplicate", () => {})
+    public two = this.RULE("oops_duplicate", () => {})
+}
 
-        constructor(input:Token[] = []) {
-            super(input, [myToken, myOtherToken])
-            Parser.performSelfAnalysis(this)
-        }
+class InvalidRuleNameParser extends Parser {
 
-        public one = this.RULE("שלום", () => {})
+    constructor(input:Token[] = []) {
+        super(input, [myToken, myOtherToken])
+        Parser.performSelfAnalysis(this)
     }
 
-    describe("The rule names validation full flow", function () {
+    public one = this.RULE("שלום", () => {})
+}
 
-        it("will throw an error when trying to init a parser with duplicate ruleNames", function () {
-            expect(() => new DuplicateRulesParser()).to.throw("is already defined in the grammar")
-            expect(() => new DuplicateRulesParser()).to.throw("DuplicateRulesParser")
-            expect(() => new DuplicateRulesParser()).to.throw("oops_duplicate")
-        })
+describe("The rule names validation full flow", function () {
 
-        it("will throw an error when trying to init a parser with an invalid rule names", function () {
-            expect(() => new InvalidRuleNameParser()).to.throw("it must match the pattern")
-            expect(() => new InvalidRuleNameParser()).to.throw("Invalid Grammar rule name")
-            expect(() => new InvalidRuleNameParser()).to.throw("שלום")
-        })
+    it("will throw an error when trying to init a parser with duplicate ruleNames", function () {
+        expect(() => new DuplicateRulesParser()).to.throw("is already defined in the grammar")
+        expect(() => new DuplicateRulesParser()).to.throw("DuplicateRulesParser")
+        expect(() => new DuplicateRulesParser()).to.throw("oops_duplicate")
+    })
 
-        it("won't throw an errors when trying to init a parser with definition errors but with a flag active to defer handling" +
-            "of definition errors (ruleName validation", function () {
-            Parser.DEFER_DEFINITION_ERRORS_HANDLING = true
-            expect(() => new InvalidRuleNameParser()).to.not.throw()
-            expect(() => new InvalidRuleNameParser()).to.not.throw()
-            expect(() => new DuplicateRulesParser()).to.not.throw()
-            expect(() => new DuplicateRulesParser()).to.not.throw()
-            Parser.DEFER_DEFINITION_ERRORS_HANDLING = false
-        })
+    it("will throw an error when trying to init a parser with an invalid rule names", function () {
+        expect(() => new InvalidRuleNameParser()).to.throw("it must match the pattern")
+        expect(() => new InvalidRuleNameParser()).to.throw("Invalid Grammar rule name")
+        expect(() => new InvalidRuleNameParser()).to.throw("שלום")
     })
 
+    it("won't throw an errors when trying to init a parser with definition errors but with a flag active to defer handling" +
+        "of definition errors (ruleName validation", function () {
+        Parser.DEFER_DEFINITION_ERRORS_HANDLING = true
+        expect(() => new InvalidRuleNameParser()).to.not.throw()
+        expect(() => new InvalidRuleNameParser()).to.not.throw()
+        expect(() => new DuplicateRulesParser()).to.not.throw()
+        expect(() => new DuplicateRulesParser()).to.not.throw()
+        Parser.DEFER_DEFINITION_ERRORS_HANDLING = false
+    })
+})
 
-    class StarToken extends Token {}
 
-    class DirectlyLeftRecursive extends Parser {
+class StarToken extends Token {}
 
-        constructor(input:Token[] = []) {
-            super(input, [StarToken])
-            Parser.performSelfAnalysis(this)
-        }
+class DirectlyLeftRecursive extends Parser {
 
-        public A = this.RULE("A", () => {
-            this.SUBRULE1(this.A)
-        })
+    constructor(input:Token[] = []) {
+        super(input, [StarToken])
+        Parser.performSelfAnalysis(this)
     }
 
-    class InDirectlyLeftRecursive extends Parser {
-
-        constructor(input:Token[] = []) {
-            super(input, [StarToken])
-            Parser.performSelfAnalysis(this)
-        }
+    public A = this.RULE("A", () => {
+        this.SUBRULE1(this.A)
+    })
+}
 
-        public A = this.RULE("A", () => {
-            this.SUBRULE1(this.B)
-        })
+class InDirectlyLeftRecursive extends Parser {
 
-        public B = this.RULE("B", () => {
-            this.SUBRULE1(this.A)
-        })
+    constructor(input:Token[] = []) {
+        super(input, [StarToken])
+        Parser.performSelfAnalysis(this)
     }
 
-    class ComplexInDirectlyLeftRecursive extends Parser {
+    public A = this.RULE("A", () => {
+        this.SUBRULE1(this.B)
+    })
 
-        constructor(input:Token[] = []) {
-            super(input, [StarToken])
-            Parser.performSelfAnalysis(this)
-        }
+    public B = this.RULE("B", () => {
+        this.SUBRULE1(this.A)
+    })
+}
 
-        public A = this.RULE("A", () => {
-            this.SUBRULE1(this.B)
-        })
+class ComplexInDirectlyLeftRecursive extends Parser {
 
-        public B = this.RULE("B", () => {
-            this.OPTION(() => {
-                this.SUBRULE1(this.A)
-            })
-            this.CONSUME(StarToken)
-        })
+    constructor(input:Token[] = []) {
+        super(input, [StarToken])
+        Parser.performSelfAnalysis(this)
     }
 
-    describe("The left recursion detection full flow", function () {
+    public A = this.RULE("A", () => {
+        this.SUBRULE1(this.B)
+    })
 
-        it("will throw an error when trying to init a parser with direct left recursion", function () {
-            expect(() => new DirectlyLeftRecursive()).to.throw("Left Recursion found in grammar")
-            expect(() => new DirectlyLeftRecursive()).to.throw("A --> A")
+    public B = this.RULE("B", () => {
+        this.OPTION(() => {
+            this.SUBRULE1(this.A)
         })
+        this.CONSUME(StarToken)
+    })
+}
 
-        it("will throw an error when trying to init a parser with indirect left recursion", function () {
-            expect(() => new InDirectlyLeftRecursive()).to.throw("Left Recursion found in grammar")
-            expect(() => new InDirectlyLeftRecursive()).to.throw("A --> B --> A")
-        })
+describe("The left recursion detection full flow", function () {
 
-        it("will throw an error when trying to init a parser with indirect left recursion", function () {
-            expect(() => new ComplexInDirectlyLeftRecursive()).to.throw("Left Recursion found in grammar")
-            expect(() => new ComplexInDirectlyLeftRecursive()).to.throw("A --> B --> A")
-        })
+    it("will throw an error when trying to init a parser with direct left recursion", function () {
+        expect(() => new DirectlyLeftRecursive()).to.throw("Left Recursion found in grammar")
+        expect(() => new DirectlyLeftRecursive()).to.throw("A --> A")
     })
 
-    describe("The empty alternative detection full flow", () => {
+    it("will throw an error when trying to init a parser with indirect left recursion", function () {
+        expect(() => new InDirectlyLeftRecursive()).to.throw("Left Recursion found in grammar")
+        expect(() => new InDirectlyLeftRecursive()).to.throw("A --> B --> A")
+    })
 
-        it("will throw an error when an empty alternative is not the last alternative", () => {
-            let emptyAltAmbiguityParser = class emptyAltAmbiguityParser extends Parser {
+    it("will throw an error when trying to init a parser with indirect left recursion", function () {
+        expect(() => new ComplexInDirectlyLeftRecursive()).to.throw("Left Recursion found in grammar")
+        expect(() => new ComplexInDirectlyLeftRecursive()).to.throw("A --> B --> A")
+    })
+})
+
+describe("The empty alternative detection full flow", () => {
 
-                constructor(input:Token[] = []) {
-                    super(input, <any>chevrotain.checks.spec)
-                    Parser.performSelfAnalysis(this)
-                }
+    it("will throw an error when an empty alternative is not the last alternative", () => {
+        let emptyAltAmbiguityParser = class emptyAltAmbiguityParser extends Parser {
+
+            constructor(input:Token[] = []) {
+                super(input, [PlusTok, StarTok])
+                Parser.performSelfAnalysis(this)
+            }
 
-                public noneLastEmpty = this.RULE("noneLastEmpty", () => {
-                    // @formatter:off
+            public noneLastEmpty = this.RULE("noneLastEmpty", () => {
+                // @formatter:off
                     this.OR1([
                         {ALT: () => {
                             this.CONSUME1(PlusTok)
@@ -514,24 +534,24 @@ namespace chevrotain.checks.spec {
                         }}
                     ], "digits")
                     // @formatter:on
-                })
+            })
 
-            }
-            expect(() => new emptyAltAmbiguityParser()).to.throw("Ambiguous empty alternative")
-            expect(() => new emptyAltAmbiguityParser()).to.throw("3")
-            expect(() => new emptyAltAmbiguityParser()).to.throw("2")
-        })
+        }
+        expect(() => new emptyAltAmbiguityParser()).to.throw("Ambiguous empty alternative")
+        expect(() => new emptyAltAmbiguityParser()).to.throw("3")
+        expect(() => new emptyAltAmbiguityParser()).to.throw("2")
+    })
 
-        it("will throw an error when an empty alternative is not the last alternative #2", () => {
-            let emptyAltAmbiguityParser = class emptyAltAmbiguityParser extends Parser {
+    it("will throw an error when an empty alternative is not the last alternative #2", () => {
+        let emptyAltAmbiguityParser = class emptyAltAmbiguityParser extends Parser {
 
-                constructor(input:Token[] = []) {
-                    super(input, <any>chevrotain.checks.spec)
-                    Parser.performSelfAnalysis(this)
-                }
+            constructor(input:Token[] = []) {
+                super(input, [PlusTok, StarTok])
+                Parser.performSelfAnalysis(this)
+            }
 
-                public noneLastEmpty = this.RULE("noneLastEmpty", () => {
-                    // @formatter:off
+            public noneLastEmpty = this.RULE("noneLastEmpty", () => {
+                // @formatter:off
                     this.OR([ // using OR without occurrence suffix, test to check for fix for https://github.com/SAP/chevrotain/issues/101
                          {ALT: EMPTY_ALT()},  // empty alternative #1 which is not the last one!
                         {ALT: () => {
@@ -542,14 +562,13 @@ namespace chevrotain.checks.spec {
                         }}
                     ], "digits")
                     // @formatter:on
-                })
+            })
 
-            }
-            expect(() => new emptyAltAmbiguityParser()).to.throw("Ambiguous empty alternative")
-            expect(() => new emptyAltAmbiguityParser()).to.throw("1")
-            expect(() => new emptyAltAmbiguityParser()).to.throw("Only the last alternative may be an empty alternative.")
-            expect(() => new emptyAltAmbiguityParser()).to.not.throw("undefined")
-        })
+        }
+        expect(() => new emptyAltAmbiguityParser()).to.throw("Ambiguous empty alternative")
+        expect(() => new emptyAltAmbiguityParser()).to.throw("1")
+        expect(() => new emptyAltAmbiguityParser()).to.throw("Only the last alternative may be an empty alternative.")
+        expect(() => new emptyAltAmbiguityParser()).to.not.throw("undefined")
     })
+})
 
-}
diff --git a/test/parse/grammar/first_spec.ts b/test/parse/grammar/first_spec.ts
index 0d5c12de0..b17c19bd5 100644
--- a/test/parse/grammar/first_spec.ts
+++ b/test/parse/grammar/first_spec.ts
@@ -1,78 +1,80 @@
+import {gast} from "../../../src/parse/grammar/gast_public"
 
-namespace chevrotain.first.spec {
+let Terminal = gast.Terminal
+let Option = gast.Option
+let Alternation = gast.Alternation
+let Flat = gast.Flat
 
-    import t = specs.samples
-    import gast = chevrotain.gast
-    import matchers = specs.matchers
+import {first} from "../../../src/parse/grammar/first"
+import {EntityTok, CommaTok, NamespaceTok, TypeTok, ColonTok, ConstTok} from "./samples"
+import {setEquality} from "../../utils/matchers"
 
-    describe("The Grammar Ast first model", function () {
-        "use strict"
+describe("The Grammar Ast first model", function () {
+    "use strict"
 
-        it("can compute the first for a terminal", function () {
-            let terminal = new gast.Terminal(t.EntityTok)
-            let actual = first(terminal)
-            expect(actual.length).to.equal(1)
-            expect(actual[0]).to.equal(t.EntityTok)
+    it("can compute the first for a terminal", function () {
+        let terminal = new Terminal(EntityTok)
+        let actual = first(terminal)
+        expect(actual.length).to.equal(1)
+        expect(actual[0]).to.equal(EntityTok)
 
-            let terminal2 = new gast.Terminal(t.CommaTok)
-            let actual2 = first(terminal2)
-            expect(actual2.length).to.equal(1)
-            expect(actual2[0]).to.equal(t.CommaTok)
-        })
-
-        it("can compute the first for a Sequence production ", function () {
-            let seqProduction = new gast.Flat([new gast.Terminal(t.EntityTok)])
-            let actual = first(seqProduction)
-            expect(actual.length).to.equal(1)
-            expect(actual[0]).to.equal(t.EntityTok)
+        let terminal2 = new Terminal(CommaTok)
+        let actual2 = first(terminal2)
+        expect(actual2.length).to.equal(1)
+        expect(actual2[0]).to.equal(CommaTok)
+    })
 
-            let seqProduction2 = new gast.Flat(
-                [
-                    new gast.Terminal(t.EntityTok),
-                    new gast.Option([new gast.Terminal(t.NamespaceTok)])
-                ])
-            let actual2 = first(seqProduction2)
-            expect(actual2.length).to.equal(1)
-            expect(actual2[0]).to.equal(t.EntityTok)
-        })
+    it("can compute the first for a Sequence production ", function () {
+        let seqProduction = new Flat([new Terminal(EntityTok)])
+        let actual = first(seqProduction)
+        expect(actual.length).to.equal(1)
+        expect(actual[0]).to.equal(EntityTok)
 
-        it("can compute the first for an alternatives production ", function () {
-            let altProduction = new gast.Alternation(
-                [
-                    new gast.Terminal(t.EntityTok),
-                    new gast.Terminal(t.NamespaceTok),
-                    new gast.Terminal(t.TypeTok)
+        let seqProduction2 = new Flat(
+            [
+                new Terminal(EntityTok),
+                new Option([new Terminal(NamespaceTok)])
+            ])
+        let actual2 = first(seqProduction2)
+        expect(actual2.length).to.equal(1)
+        expect(actual2[0]).to.equal(EntityTok)
+    })
 
-                ])
-            let actual = first(altProduction)
-            expect(actual.length).to.equal(3)
-            expect(actual[0]).to.equal(t.EntityTok)
-            expect(actual[1]).to.equal(t.NamespaceTok)
-            expect(actual[2]).to.equal(t.TypeTok)
+    it("can compute the first for an alternatives production ", function () {
+        let altProduction = new Alternation(
+            [
+                new Terminal(EntityTok),
+                new Terminal(NamespaceTok),
+                new Terminal(TypeTok)
 
-        })
+            ])
+        let actual = first(altProduction)
+        expect(actual.length).to.equal(3)
+        expect(actual[0]).to.equal(EntityTok)
+        expect(actual[1]).to.equal(NamespaceTok)
+        expect(actual[2]).to.equal(TypeTok)
 
-        it("can compute the first for an production with optional prefix", function () {
-            let withOptionalPrefix = new gast.Flat(
-                [
-                    new gast.Option([new gast.Terminal(t.NamespaceTok)]),
-                    new gast.Terminal(t.EntityTok)
-                ])
-            let actual = first(withOptionalPrefix)
-            matchers.setEquality(actual, [t.NamespaceTok, t.EntityTok])
+    })
 
+    it("can compute the first for an production with optional prefix", function () {
+        let withOptionalPrefix = new Flat(
+            [
+                new Option([new Terminal(NamespaceTok)]),
+                new Terminal(EntityTok)
+            ])
+        let actual = first(withOptionalPrefix)
+        setEquality(actual, [NamespaceTok, EntityTok])
 
-            let withTwoOptPrefix = new gast.Flat(
-                [
-                    new gast.Option([new gast.Terminal(t.NamespaceTok)]),
-                    new gast.Option([new gast.Terminal(t.ColonTok)]),
-                    new gast.Terminal(t.EntityTok),
-                    new gast.Option([new gast.Terminal(t.ConstTok)])
-                ])
-            let actual2 = first(withTwoOptPrefix)
-            matchers.setEquality(actual2, [t.NamespaceTok, t.ColonTok, t.EntityTok])
-        })
 
+        let withTwoOptPrefix = new Flat(
+            [
+                new Option([new Terminal(NamespaceTok)]),
+                new Option([new Terminal(ColonTok)]),
+                new Terminal(EntityTok),
+                new Option([new Terminal(ConstTok)])
+            ])
+        let actual2 = first(withTwoOptPrefix)
+        setEquality(actual2, [NamespaceTok, ColonTok, EntityTok])
     })
 
-}
+})
diff --git a/test/parse/grammar/follow_spec.ts b/test/parse/grammar/follow_spec.ts
index 778c38070..801ff6227 100644
--- a/test/parse/grammar/follow_spec.ts
+++ b/test/parse/grammar/follow_spec.ts
@@ -1,51 +1,53 @@
+import {gast} from "../../../src/parse/grammar/gast_public"
+
+let Rule = gast.Rule
+let Terminal = gast.Terminal
+
+import {IdentTok, EntityTok, actionDec, CommaTok, RParenTok, SemicolonTok} from "./samples"
+import {
+    buildInProdFollowPrefix,
+    buildBetweenProdsFollowPrefix,
+    ResyncFollowsWalker,
+    computeAllProdsFollows
+} from "../../../src/parse/grammar/follow"
+import {setEquality} from "../../utils/matchers"
+
+describe("The Grammar Ast Follows model", function () {
+
+    it("can build a followNamePrefix from a Terminal", function () {
+        let terminal = new Terminal(IdentTok)
+        let actual = buildInProdFollowPrefix(terminal)
+        expect(actual).to.equal("IdentTok1_~IN~_")
+
+        let terminal2 = new Terminal(EntityTok)
+        terminal2.occurrenceInParent = 3
+        let actual2 = buildInProdFollowPrefix(terminal2)
+        expect(actual2).to.equal("EntityTok3_~IN~_")
+    })
+
+    it("can build a followName prefix from a TopLevel Production and index", function () {
+        let prod = new Rule("bamba", [])
+        let index = 5
 
-namespace chevrotain.follow.spec {
-
-    import t = specs.samples
-    import gast = chevrotain.gast
-    import samples = specs.samples
-    import matchers = specs.matchers
-
-    describe("The Grammar Ast Follows model", function () {
-        "use strict"
-
-        it("can build a followNamePrefix from a Terminal", function () {
-            let terminal = new gast.Terminal(t.IdentTok)
-            let actual = buildInProdFollowPrefix(terminal)
-            expect(actual).to.equal("IdentTok1_~IN~_")
-
-            let terminal2 = new gast.Terminal(t.EntityTok)
-            terminal2.occurrenceInParent = 3
-            let actual2 = buildInProdFollowPrefix(terminal2)
-            expect(actual2).to.equal("EntityTok3_~IN~_")
-        })
-
-        it("can build a followName prefix from a TopLevel Production and index", function () {
-            let prod = new gast.Rule("bamba", [])
-            let index = 5
-
-            let actual = buildBetweenProdsFollowPrefix(prod, index)
-            expect(actual).to.equal("bamba5_~IN~_")
-        })
-
-        it("can compute the follows for Top level production ref in ActionDec", function () {
-            let actual:any = new ResyncFollowsWalker(samples.actionDec).startWalking()
-            let actualFollowNames = actual.keys()
-            expect(actualFollowNames.length).to.equal(3)
-            expect(actual.get("paramSpec1_~IN~_actionDec").length).to.equal(2)
-            matchers.setEquality(actual.get("paramSpec1_~IN~_actionDec"), [t.CommaTok, t.RParenTok])
-            expect(actual.get("paramSpec2_~IN~_actionDec").length).to.equal(2)
-            matchers.setEquality(actual.get("paramSpec1_~IN~_actionDec"), [t.CommaTok, t.RParenTok])
-            expect(actual.get("qualifiedName1_~IN~_actionDec").length).to.equal(1)
-            matchers.setEquality(actual.get("qualifiedName1_~IN~_actionDec"), [t.SemicolonTok])
-        })
-
-        it("can compute all follows for a set of top level productions", function () {
-            let actual = computeAllProdsFollows([samples.actionDec])
-            expect(actual.keys().length).to.equal(3)
-        })
+        let actual = buildBetweenProdsFollowPrefix(prod, index)
+        expect(actual).to.equal("bamba5_~IN~_")
+    })
 
+    it("can compute the follows for Top level production ref in ActionDec", function () {
+        let actual:any = new ResyncFollowsWalker(actionDec).startWalking()
+        let actualFollowNames = actual.keys()
+        expect(actualFollowNames.length).to.equal(3)
+        expect(actual.get("paramSpec1_~IN~_actionDec").length).to.equal(2)
+        setEquality(actual.get("paramSpec1_~IN~_actionDec"), [CommaTok, RParenTok])
+        expect(actual.get("paramSpec2_~IN~_actionDec").length).to.equal(2)
+        setEquality(actual.get("paramSpec1_~IN~_actionDec"), [CommaTok, RParenTok])
+        expect(actual.get("qualifiedName1_~IN~_actionDec").length).to.equal(1)
+        setEquality(actual.get("qualifiedName1_~IN~_actionDec"), [SemicolonTok])
+    })
 
+    it("can compute all follows for a set of top level productions", function () {
+        let actual = computeAllProdsFollows([actionDec])
+        expect(actual.keys().length).to.equal(3)
     })
 
-}
+})
diff --git a/test/parse/grammar/gast_spec.ts b/test/parse/grammar/gast_spec.ts
index 78f6e5ce5..fea1e1d8a 100644
--- a/test/parse/grammar/gast_spec.ts
+++ b/test/parse/grammar/gast_spec.ts
@@ -1,15 +1,12 @@
+import {gast} from "../../../src/parse/grammar/gast_public"
 
-namespace chevrotain.gast.spec {
+describe("GAst namespace", () => {
 
-    describe("GAst namespace", function () {
+    describe("the ProdRef class", () => {
 
-        describe("the ProdRef class", function () {
-
-            it("will always return a valid empty definition, even if it's ref is unresolved", function () {
-                let prodRef = new NonTerminal("SomeGrammarRuleName")
-                expect(prodRef.definition).to.be.an.instanceof(Array)
-            })
+        it("will always return a valid empty definition, even if it's ref is unresolved", () => {
+            let prodRef = new gast.NonTerminal("SomeGrammarRuleName")
+            expect(prodRef.definition).to.be.an.instanceof(Array)
         })
     })
-
-}
+})
diff --git a/test/parse/grammar/interperter_spec.ts b/test/parse/grammar/interperter_spec.ts
index 3a8d450b0..8bcbc5d69 100644
--- a/test/parse/grammar/interperter_spec.ts
+++ b/test/parse/grammar/interperter_spec.ts
@@ -1,614 +1,648 @@
+import {ITokenGrammarPath, IRuleGrammarPath} from "../../../src/parse/grammar/path"
+import {
+    ActionTok,
+    actionDec,
+    IdentTok,
+    LParenTok,
+    RParenTok,
+    ColonTok,
+    SemicolonTok,
+    LSquareTok,
+    RSquareTok,
+    DotTok,
+    CommaTok,
+    paramSpec,
+    qualifiedName,
+    callArguments,
+    actionDecSep,
+    atLeastOneRule,
+    EntityTok,
+    UnsignedIntegerLiteralTok,
+    AsteriskTok,
+    cardinality,
+    lotsOfOrs,
+    KeyTok,
+    qualifiedNameSep,
+    atLeastOneSepRule,
+    manyActions
+} from "./samples"
+import {
+    NextAfterTokenWalker,
+    NextInsideOptionWalker,
+    NextInsideManyWalker,
+    NextInsideManySepWalker,
+    NextInsideOrWalker,
+    NextTerminalAfterAtLeastOneWalker,
+    NextTerminalAfterManyWalker,
+    NextTerminalAfterManySepWalker,
+    NextInsideAtLeastOneWalker,
+    NextInsideAtLeastOneSepWalker,
+    NextTerminalAfterAtLeastOneSepWalker
+} from "../../../src/parse/grammar/interpreter"
+import {setEquality} from "../../utils/matchers"
+
+describe("The Grammar Interpeter namespace", function () {
+    "use strict"
+
+    describe("The NextAfterTokenWalker", function () {
+
+        it("can compute the next possible token types From ActionDec in scope of ActionDec #1", function () {
+            let caPath:ITokenGrammarPath = {
+                ruleStack:         ["actionDec"],
+                occurrenceStack:   [1],
+                lastTok:           ActionTok,
+                lastTokOccurrence: 1
+            }
+
+            let possibleNextTokTypes = new NextAfterTokenWalker(actionDec, caPath).startWalking()
+            expect(possibleNextTokTypes.length).to.equal(1)
+            expect(possibleNextTokTypes[0]).to.equal(IdentTok)
+        })
+
+        it("can compute the next possible token types From ActionDec in scope of ActionDec #2", function () {
+            let caPath:ITokenGrammarPath = {
+                ruleStack:         ["actionDec"],
+                occurrenceStack:   [1],
+                lastTok:           IdentTok,
+                lastTokOccurrence: 1
+            }
+
+            let possibleNextTokTypes = new NextAfterTokenWalker(actionDec, caPath).startWalking()
+            expect(possibleNextTokTypes.length).to.equal(1)
+            expect(possibleNextTokTypes[0]).to.equal(LParenTok)
+        })
+
+        it("can compute the next possible token types From ActionDec in scope of ActionDec #3", function () {
+            let caPath:ITokenGrammarPath = {
+                ruleStack:         ["actionDec"],
+                occurrenceStack:   [1],
+                lastTok:           LParenTok,
+                lastTokOccurrence: 1
+            }
+
+            let possibleNextTokTypes = new NextAfterTokenWalker(actionDec, caPath).startWalking()
+            expect(possibleNextTokTypes.length).to.equal(2)
+            setEquality(possibleNextTokTypes, [IdentTok, RParenTok])
+        })
+
+        it("can compute the next possible token types From ActionDec in scope of ActionDec #4", function () {
+            let caPath:ITokenGrammarPath = {
+                ruleStack:         ["actionDec"],
+                occurrenceStack:   [1],
+                lastTok:           CommaTok,
+                lastTokOccurrence: 1
+            }
+
+            let possibleNextTokTypes = new NextAfterTokenWalker(actionDec, caPath).startWalking()
+            expect(possibleNextTokTypes.length).to.equal(1)
+            expect(possibleNextTokTypes[0]).to.equal(IdentTok)
+        })
+
+        it("can compute the next possible token types From ActionDec in scope of ActionDec #5", function () {
+            let caPath:ITokenGrammarPath = {
+                ruleStack:         ["actionDec"],
+                occurrenceStack:   [1],
+                lastTok:           RParenTok,
+                lastTokOccurrence: 1
+            }
+
+            let possibleNextTokTypes = new NextAfterTokenWalker(actionDec, caPath).startWalking()
+            expect(possibleNextTokTypes.length).to.equal(2)
+            setEquality(possibleNextTokTypes, [SemicolonTok, ColonTok])
+        })
+
+        it("can compute the next possible token types From ActionDec in scope of ActionDec #6", function () {
+            let caPath:ITokenGrammarPath = {
+                ruleStack:         ["actionDec"],
+                occurrenceStack:   [1],
+                lastTok:           ColonTok,
+                lastTokOccurrence: 1
+            }
+
+            let possibleNextTokTypes = new NextAfterTokenWalker(actionDec, caPath).startWalking()
+            expect(possibleNextTokTypes.length).to.equal(1)
+            expect(possibleNextTokTypes[0]).to.equal(IdentTok)
+        })
+
+        it("can compute the next possible token types From ActionDec in scope of ActionDec #7", function () {
+            let caPath:ITokenGrammarPath = {
+                ruleStack:         ["actionDec"],
+                occurrenceStack:   [1],
+                lastTok:           SemicolonTok,
+                lastTokOccurrence: 1
+            }
 
-namespace chevrotain.interpreter.spec {
-
-    import t = specs.samples
-    import samples = specs.samples
-    import p = chevrotain.path
-    import matchers = specs.matchers
-
-    describe("The Grammar Interpeter namespace", function () {
-        "use strict"
-
-        describe("The NextAfterTokenWalker", function () {
-
-            it("can compute the next possible token types From ActionDec in scope of ActionDec #1", function () {
-                let caPath:p.ITokenGrammarPath = {
-                    ruleStack:         ["actionDec"],
-                    occurrenceStack:   [1],
-                    lastTok:           t.ActionTok,
-                    lastTokOccurrence: 1
-                }
-
-                let possibleNextTokTypes = new NextAfterTokenWalker(samples.actionDec, caPath).startWalking()
-                expect(possibleNextTokTypes.length).to.equal(1)
-                expect(possibleNextTokTypes[0]).to.equal(t.IdentTok)
-            })
-
-            it("can compute the next possible token types From ActionDec in scope of ActionDec #2", function () {
-                let caPath:p.ITokenGrammarPath = {
-                    ruleStack:         ["actionDec"],
-                    occurrenceStack:   [1],
-                    lastTok:           t.IdentTok,
-                    lastTokOccurrence: 1
-                }
-
-                let possibleNextTokTypes = new NextAfterTokenWalker(samples.actionDec, caPath).startWalking()
-                expect(possibleNextTokTypes.length).to.equal(1)
-                expect(possibleNextTokTypes[0]).to.equal(t.LParenTok)
-            })
-
-            it("can compute the next possible token types From ActionDec in scope of ActionDec #3", function () {
-                let caPath:p.ITokenGrammarPath = {
-                    ruleStack:         ["actionDec"],
-                    occurrenceStack:   [1],
-                    lastTok:           t.LParenTok,
-                    lastTokOccurrence: 1
-                }
-
-                let possibleNextTokTypes = new NextAfterTokenWalker(samples.actionDec, caPath).startWalking()
-                expect(possibleNextTokTypes.length).to.equal(2)
-                matchers.setEquality(possibleNextTokTypes, [t.IdentTok, t.RParenTok])
-            })
-
-            it("can compute the next possible token types From ActionDec in scope of ActionDec #4", function () {
-                let caPath:p.ITokenGrammarPath = {
-                    ruleStack:         ["actionDec"],
-                    occurrenceStack:   [1],
-                    lastTok:           t.CommaTok,
-                    lastTokOccurrence: 1
-                }
-
-                let possibleNextTokTypes = new NextAfterTokenWalker(samples.actionDec, caPath).startWalking()
-                expect(possibleNextTokTypes.length).to.equal(1)
-                expect(possibleNextTokTypes[0]).to.equal(t.IdentTok)
-            })
-
-            it("can compute the next possible token types From ActionDec in scope of ActionDec #5", function () {
-                let caPath:p.ITokenGrammarPath = {
-                    ruleStack:         ["actionDec"],
-                    occurrenceStack:   [1],
-                    lastTok:           t.RParenTok,
-                    lastTokOccurrence: 1
-                }
-
-                let possibleNextTokTypes = new NextAfterTokenWalker(samples.actionDec, caPath).startWalking()
-                expect(possibleNextTokTypes.length).to.equal(2)
-                matchers.setEquality(possibleNextTokTypes, [t.SemicolonTok, t.ColonTok])
-            })
-
-            it("can compute the next possible token types From ActionDec in scope of ActionDec #6", function () {
-                let caPath:p.ITokenGrammarPath = {
-                    ruleStack:         ["actionDec"],
-                    occurrenceStack:   [1],
-                    lastTok:           t.ColonTok,
-                    lastTokOccurrence: 1
-                }
-
-                let possibleNextTokTypes = new NextAfterTokenWalker(samples.actionDec, caPath).startWalking()
-                expect(possibleNextTokTypes.length).to.equal(1)
-                expect(possibleNextTokTypes[0]).to.equal(t.IdentTok)
-            })
-
-            it("can compute the next possible token types From ActionDec in scope of ActionDec #7", function () {
-                let caPath:p.ITokenGrammarPath = {
-                    ruleStack:         ["actionDec"],
-                    occurrenceStack:   [1],
-                    lastTok:           t.SemicolonTok,
-                    lastTokOccurrence: 1
-                }
-
-                let possibleNextTokTypes = new NextAfterTokenWalker(samples.actionDec, caPath).startWalking()
-                expect(possibleNextTokTypes.length).to.equal(0)
-            })
-
-            it("can compute the next possible token types From the first paramSpec INSIDE ActionDec #1", function () {
-                let caPath:p.ITokenGrammarPath = {
-                    ruleStack:         ["actionDec",
-                        "paramSpec"
-                    ],
-                    occurrenceStack:   [1, 1],
-                    lastTok:           t.IdentTok,
-                    lastTokOccurrence: 1
-                }
-
-                let possibleNextTokTypes = new NextAfterTokenWalker(samples.actionDec, caPath).startWalking()
-                expect(possibleNextTokTypes.length).to.equal(1)
-                expect(possibleNextTokTypes[0]).to.equal(t.ColonTok)
-            })
-
-            it("can compute the next possible token types From the first paramSpec INSIDE ActionDec #2", function () {
-                let caPath:p.ITokenGrammarPath = {
-                    ruleStack:         ["actionDec",
-                        "paramSpec"
-                    ],
-                    occurrenceStack:   [1, 1],
-                    lastTok:           t.ColonTok,
-                    lastTokOccurrence: 1
-                }
-
-                let possibleNextTokTypes = new NextAfterTokenWalker(samples.actionDec, caPath).startWalking()
-                expect(possibleNextTokTypes.length).to.equal(1)
-                expect(possibleNextTokTypes[0]).to.equal(t.IdentTok)
-            })
-
-            it("can compute the next possible token types From the first paramSpec INSIDE ActionDec #3", function () {
-                let caPath:p.ITokenGrammarPath = {
-                    ruleStack:         ["actionDec",
-                        "paramSpec"
-                    ],
-                    occurrenceStack:   [1, 1],
-                    lastTok:           t.LSquareTok,
-                    lastTokOccurrence: 1
-                }
-
-                let possibleNextTokTypes = new NextAfterTokenWalker(samples.actionDec, caPath).startWalking()
-                expect(possibleNextTokTypes.length).to.equal(1)
-                expect(possibleNextTokTypes[0]).to.equal(t.RSquareTok)
-            })
-
-            it("can compute the next possible token types From the first paramSpec INSIDE ActionDec #4", function () {
-                let caPath:p.ITokenGrammarPath = {
-                    ruleStack:         ["actionDec",
-                        "paramSpec"
-                    ],
-                    occurrenceStack:   [1, 1],
-                    lastTok:           t.RSquareTok,
-                    lastTokOccurrence: 1
-                }
-
-                let possibleNextTokTypes = new NextAfterTokenWalker(samples.actionDec, caPath).startWalking()
-                expect(possibleNextTokTypes.length).to.equal(2)
-                matchers.setEquality(possibleNextTokTypes, [t.CommaTok, t.RParenTok])
-            })
-
-            it("can compute the next possible token types From the second paramSpec INSIDE ActionDec #1", function () {
-                let caPath:p.ITokenGrammarPath = {
-                    ruleStack:         ["actionDec",
-                        "paramSpec"
-                    ],
-                    occurrenceStack:   [1, 2],
-                    lastTok:           t.IdentTok,
-                    lastTokOccurrence: 1
-                }
-
-                let possibleNextTokTypes = new NextAfterTokenWalker(samples.actionDec, caPath).startWalking()
-                expect(possibleNextTokTypes.length).to.equal(1)
-                expect(possibleNextTokTypes[0]).to.equal(t.ColonTok)
-            })
-
-            it("can compute the next possible token types From the second paramSpec INSIDE ActionDec #2", function () {
-                let caPath:p.ITokenGrammarPath = {
-                    ruleStack:         ["actionDec",
-                        "paramSpec"
-                    ],
-                    occurrenceStack:   [1, 2],
-                    lastTok:           t.ColonTok,
-                    lastTokOccurrence: 1
-                }
-
-                let possibleNextTokTypes = new NextAfterTokenWalker(samples.actionDec, caPath).startWalking()
-                expect(possibleNextTokTypes.length).to.equal(1)
-                expect(possibleNextTokTypes[0]).to.equal(t.IdentTok)
-            })
-
-            it("can compute the next possible token types From the second paramSpec INSIDE ActionDec #3", function () {
-                let caPath:p.ITokenGrammarPath = {
-                    ruleStack:         ["actionDec",
-                        "paramSpec"
-                    ],
-                    occurrenceStack:   [1, 2],
-                    lastTok:           t.LSquareTok,
-                    lastTokOccurrence: 1
-                }
-
-                let possibleNextTokTypes = new NextAfterTokenWalker(samples.actionDec, caPath).startWalking()
-                expect(possibleNextTokTypes.length).to.equal(1)
-                expect(possibleNextTokTypes[0]).to.equal(t.RSquareTok)
-            })
-
-            it("can compute the next possible token types From the second paramSpec INSIDE ActionDec #4", function () {
-                let caPath:p.ITokenGrammarPath = {
-                    ruleStack:         ["actionDec",
-                        "paramSpec"
-                    ],
-                    occurrenceStack:   [1, 2],
-                    lastTok:           t.RSquareTok,
-                    lastTokOccurrence: 1
-                }
-
-                let possibleNextTokTypes = new NextAfterTokenWalker(samples.actionDec, caPath).startWalking()
-                expect(possibleNextTokTypes.length).to.equal(2)
-                matchers.setEquality(possibleNextTokTypes, [t.CommaTok, t.RParenTok])
-            })
-
-            it("can compute the next possible token types From a fqn inside an actionParamSpec" +
+            let possibleNextTokTypes = new NextAfterTokenWalker(actionDec, caPath).startWalking()
+            expect(possibleNextTokTypes.length).to.equal(0)
+        })
+
+        it("can compute the next possible token types From the first paramSpec INSIDE ActionDec #1", function () {
+            let caPath:ITokenGrammarPath = {
+                ruleStack:         ["actionDec",
+                    "paramSpec"
+                ],
+                occurrenceStack:   [1, 1],
+                lastTok:           IdentTok,
+                lastTokOccurrence: 1
+            }
+
+            let possibleNextTokTypes = new NextAfterTokenWalker(actionDec, caPath).startWalking()
+            expect(possibleNextTokTypes.length).to.equal(1)
+            expect(possibleNextTokTypes[0]).to.equal(ColonTok)
+        })
+
+        it("can compute the next possible token types From the first paramSpec INSIDE ActionDec #2", function () {
+            let caPath:ITokenGrammarPath = {
+                ruleStack:         ["actionDec",
+                    "paramSpec"
+                ],
+                occurrenceStack:   [1, 1],
+                lastTok:           ColonTok,
+                lastTokOccurrence: 1
+            }
+
+            let possibleNextTokTypes = new NextAfterTokenWalker(actionDec, caPath).startWalking()
+            expect(possibleNextTokTypes.length).to.equal(1)
+            expect(possibleNextTokTypes[0]).to.equal(IdentTok)
+        })
+
+        it("can compute the next possible token types From the first paramSpec INSIDE ActionDec #3", function () {
+            let caPath:ITokenGrammarPath = {
+                ruleStack:         ["actionDec",
+                    "paramSpec"
+                ],
+                occurrenceStack:   [1, 1],
+                lastTok:           LSquareTok,
+                lastTokOccurrence: 1
+            }
+
+            let possibleNextTokTypes = new NextAfterTokenWalker(actionDec, caPath).startWalking()
+            expect(possibleNextTokTypes.length).to.equal(1)
+            expect(possibleNextTokTypes[0]).to.equal(RSquareTok)
+        })
+
+        it("can compute the next possible token types From the first paramSpec INSIDE ActionDec #4", function () {
+            let caPath:ITokenGrammarPath = {
+                ruleStack:         ["actionDec",
+                    "paramSpec"
+                ],
+                occurrenceStack:   [1, 1],
+                lastTok:           RSquareTok,
+                lastTokOccurrence: 1
+            }
+
+            let possibleNextTokTypes = new NextAfterTokenWalker(actionDec, caPath).startWalking()
+            expect(possibleNextTokTypes.length).to.equal(2)
+            setEquality(possibleNextTokTypes, [CommaTok, RParenTok])
+        })
+
+        it("can compute the next possible token types From the second paramSpec INSIDE ActionDec #1", function () {
+            let caPath:ITokenGrammarPath = {
+                ruleStack:         ["actionDec",
+                    "paramSpec"
+                ],
+                occurrenceStack:   [1, 2],
+                lastTok:           IdentTok,
+                lastTokOccurrence: 1
+            }
+
+            let possibleNextTokTypes = new NextAfterTokenWalker(actionDec, caPath).startWalking()
+            expect(possibleNextTokTypes.length).to.equal(1)
+            expect(possibleNextTokTypes[0]).to.equal(ColonTok)
+        })
+
+        it("can compute the next possible token types From the second paramSpec INSIDE ActionDec #2", function () {
+            let caPath:ITokenGrammarPath = {
+                ruleStack:         ["actionDec",
+                    "paramSpec"
+                ],
+                occurrenceStack:   [1, 2],
+                lastTok:           ColonTok,
+                lastTokOccurrence: 1
+            }
+
+            let possibleNextTokTypes = new NextAfterTokenWalker(actionDec, caPath).startWalking()
+            expect(possibleNextTokTypes.length).to.equal(1)
+            expect(possibleNextTokTypes[0]).to.equal(IdentTok)
+        })
+
+        it("can compute the next possible token types From the second paramSpec INSIDE ActionDec #3", function () {
+            let caPath:ITokenGrammarPath = {
+                ruleStack:         ["actionDec",
+                    "paramSpec"
+                ],
+                occurrenceStack:   [1, 2],
+                lastTok:           LSquareTok,
+                lastTokOccurrence: 1
+            }
+
+            let possibleNextTokTypes = new NextAfterTokenWalker(actionDec, caPath).startWalking()
+            expect(possibleNextTokTypes.length).to.equal(1)
+            expect(possibleNextTokTypes[0]).to.equal(RSquareTok)
+        })
+
+        it("can compute the next possible token types From the second paramSpec INSIDE ActionDec #4", function () {
+            let caPath:ITokenGrammarPath = {
+                ruleStack:         ["actionDec",
+                    "paramSpec"
+                ],
+                occurrenceStack:   [1, 2],
+                lastTok:           RSquareTok,
+                lastTokOccurrence: 1
+            }
+
+            let possibleNextTokTypes = new NextAfterTokenWalker(actionDec, caPath).startWalking()
+            expect(possibleNextTokTypes.length).to.equal(2)
+            setEquality(possibleNextTokTypes, [CommaTok, RParenTok])
+        })
+
+        it("can compute the next possible token types From a fqn inside an actionParamSpec" +
             " inside an paramSpec INSIDE ActionDec #1", function () {
-                let caPath:p.ITokenGrammarPath = {
-                    ruleStack:         ["actionDec",
-                        "paramSpec",
-                        "qualifiedName"
-                    ],
-                    occurrenceStack:   [1, 1, 1],
-                    lastTok:           t.IdentTok,
-                    lastTokOccurrence: 1
-                }
-
-                let possibleNextTokTypes = new NextAfterTokenWalker(samples.actionDec, caPath).startWalking()
-                expect(possibleNextTokTypes.length).to.equal(4)
-                matchers.setEquality(possibleNextTokTypes, [t.DotTok, t.LSquareTok, t.CommaTok, t.RParenTok])
-            })
-
-            it("can compute the next possible token types From a fqn inside an actionParamSpec" +
+            let caPath:ITokenGrammarPath = {
+                ruleStack:         ["actionDec",
+                    "paramSpec",
+                    "qualifiedName"
+                ],
+                occurrenceStack:   [1, 1, 1],
+                lastTok:           IdentTok,
+                lastTokOccurrence: 1
+            }
+
+            let possibleNextTokTypes = new NextAfterTokenWalker(actionDec, caPath).startWalking()
+            expect(possibleNextTokTypes.length).to.equal(4)
+            setEquality(possibleNextTokTypes, [DotTok, LSquareTok, CommaTok, RParenTok])
+        })
+
+        it("can compute the next possible token types From a fqn inside an actionParamSpec" +
             " inside an paramSpec INSIDE ActionDec #2", function () {
-                let caPath:p.ITokenGrammarPath = {
-                    ruleStack:         ["actionDec",
-                        "paramSpec",
-                        "qualifiedName"
-                    ],
-                    occurrenceStack:   [1, 1, 1],
-                    lastTok:           t.DotTok,
-                    lastTokOccurrence: 1
-                }
-
-                let possibleNextTokTypes = new NextAfterTokenWalker(samples.actionDec, caPath).startWalking()
-                expect(possibleNextTokTypes.length).to.equal(1)
-                expect(possibleNextTokTypes[0]).to.equal(t.IdentTok)
-            })
-
-            it("can compute the next possible token types From a fqn inside an actionParamSpec" +
+            let caPath:ITokenGrammarPath = {
+                ruleStack:         ["actionDec",
+                    "paramSpec",
+                    "qualifiedName"
+                ],
+                occurrenceStack:   [1, 1, 1],
+                lastTok:           DotTok,
+                lastTokOccurrence: 1
+            }
+
+            let possibleNextTokTypes = new NextAfterTokenWalker(actionDec, caPath).startWalking()
+            expect(possibleNextTokTypes.length).to.equal(1)
+            expect(possibleNextTokTypes[0]).to.equal(IdentTok)
+        })
+
+        it("can compute the next possible token types From a fqn inside an actionParamSpec" +
             " inside an paramSpec INSIDE ActionDec #3", function () {
-                let caPath:p.ITokenGrammarPath = {
-                    ruleStack:         ["actionDec",
-                        "paramSpec",
-                        "qualifiedName"
-                    ],
-                    occurrenceStack:   [1, 1, 1],
-                    lastTok:           t.IdentTok,
-                    lastTokOccurrence: 2
-                }
-
-                let possibleNextTokTypes = new NextAfterTokenWalker(samples.actionDec, caPath).startWalking()
-                expect(possibleNextTokTypes.length).to.equal(4)
-                matchers.setEquality(possibleNextTokTypes, [t.DotTok, t.LSquareTok, t.CommaTok, t.RParenTok])
-            })
-
-            it("can compute the next possible token types From a fqn inside an actionParamSpec" +
+            let caPath:ITokenGrammarPath = {
+                ruleStack:         ["actionDec",
+                    "paramSpec",
+                    "qualifiedName"
+                ],
+                occurrenceStack:   [1, 1, 1],
+                lastTok:           IdentTok,
+                lastTokOccurrence: 2
+            }
+
+            let possibleNextTokTypes = new NextAfterTokenWalker(actionDec, caPath).startWalking()
+            expect(possibleNextTokTypes.length).to.equal(4)
+            setEquality(possibleNextTokTypes, [DotTok, LSquareTok, CommaTok, RParenTok])
+        })
+
+        it("can compute the next possible token types From a fqn inside an actionParamSpec" +
             " inside an paramSpec INSIDE ActionDec #3", function () {
-                let caPath:p.ITokenGrammarPath = {
-                    ruleStack:         ["paramSpec",
-                        "qualifiedName"
-                    ],
-                    occurrenceStack:   [1, 1],
-                    lastTok:           t.IdentTok,
-                    lastTokOccurrence: 1
-                }
-
-                let possibleNextTokTypes = new NextAfterTokenWalker(samples.paramSpec, caPath).startWalking()
-                expect(possibleNextTokTypes.length).to.equal(2)
-                matchers.setEquality(possibleNextTokTypes, [t.DotTok, t.LSquareTok])
-            })
-
-            it("can compute the next possible token types From a fqn inside an actionParamSpec" +
+            let caPath:ITokenGrammarPath = {
+                ruleStack:         ["paramSpec",
+                    "qualifiedName"
+                ],
+                occurrenceStack:   [1, 1],
+                lastTok:           IdentTok,
+                lastTokOccurrence: 1
+            }
+
+            let possibleNextTokTypes = new NextAfterTokenWalker(paramSpec, caPath).startWalking()
+            expect(possibleNextTokTypes.length).to.equal(2)
+            setEquality(possibleNextTokTypes, [DotTok, LSquareTok])
+        })
+
+        it("can compute the next possible token types From a fqn inside an actionParamSpec" +
             " inside an paramSpec INSIDE ActionDec #3", function () {
-                let caPath:p.ITokenGrammarPath = {
-                    ruleStack:         ["paramSpec",
-                        "qualifiedName"
-                    ],
-                    occurrenceStack:   [1, 1],
-                    lastTok:           t.DotTok,
-                    lastTokOccurrence: 1
-                }
-
-                let possibleNextTokTypes = new NextAfterTokenWalker(samples.paramSpec, caPath).startWalking()
-                expect(possibleNextTokTypes.length).to.equal(1)
-                expect(possibleNextTokTypes[0]).to.equal(t.IdentTok)
-            })
-
-            it("can compute the next possible token types From a fqn inside an actionParamSpec" +
+            let caPath:ITokenGrammarPath = {
+                ruleStack:         ["paramSpec",
+                    "qualifiedName"
+                ],
+                occurrenceStack:   [1, 1],
+                lastTok:           DotTok,
+                lastTokOccurrence: 1
+            }
+
+            let possibleNextTokTypes = new NextAfterTokenWalker(paramSpec, caPath).startWalking()
+            expect(possibleNextTokTypes.length).to.equal(1)
+            expect(possibleNextTokTypes[0]).to.equal(IdentTok)
+        })
+
+        it("can compute the next possible token types From a fqn inside an actionParamSpec" +
             " inside an paramSpec INSIDE ActionDec #3", function () {
-                let caPath:p.ITokenGrammarPath = {
-                    ruleStack:         ["paramSpec",
-                        "qualifiedName"
-                    ],
-                    occurrenceStack:   [1, 1],
-                    lastTok:           t.IdentTok,
-                    lastTokOccurrence: 2
-                }
-
-                let possibleNextTokTypes = new NextAfterTokenWalker(samples.paramSpec, caPath).startWalking()
-                expect(possibleNextTokTypes.length).to.equal(2)
-                matchers.setEquality(possibleNextTokTypes, [t.DotTok, t.LSquareTok])
-            })
-
-            it("will fail if we try to compute the next token starting from a rule that does not match the path", function () {
-                let caPath:p.ITokenGrammarPath = {
-                    ruleStack:         ["I_WILL_FAIL_THE_WALKER",
-                        "qualifiedName"
-                    ],
-                    occurrenceStack:   [1, 1],
-                    lastTok:           t.IdentTok,
-                    lastTokOccurrence: 2
-                }
-
-                let walker = new NextAfterTokenWalker(samples.paramSpec, caPath)
-                expect(() => walker.startWalking()).to.throw("The path does not start with the walker's top Rule!")
-            })
-        })
-
-
-        describe("The NextInsideOptionWalker", function () {
-            it("can compute the next possible token types inside the OPTION in paramSpec", function () {
-                let path:p.IRuleGrammarPath = {
-                    ruleStack:       ["paramSpec"],
-                    occurrenceStack: [1],
-                    occurrence:      1
-                }
-
-                let possibleNextTokTypes = new NextInsideOptionWalker(samples.paramSpec, path).startWalking()
-                matchers.setEquality(possibleNextTokTypes, [t.LSquareTok])
-            })
-
-            it("can compute the next possible token types inside the OPTION in paramSpec inside ActionDec", function () {
-                let path:p.IRuleGrammarPath = {
-                    ruleStack:       ["actionDec", "paramSpec"],
-                    occurrenceStack: [1, 1],
-                    occurrence:      1
-                }
-
-                let possibleNextTokTypes = new NextInsideOptionWalker(samples.actionDec, path).startWalking()
-                matchers.setEquality(possibleNextTokTypes, [t.LSquareTok])
-            })
-
-            it("can compute the next possible token types inside the OPTION in paramSpec inside ActionDec", function () {
-                let path:p.IRuleGrammarPath = {
-                    ruleStack:       ["actionDec"],
-                    occurrenceStack: [1],
-                    occurrence:      2
-                }
-
-                let possibleNextTokTypes = new NextInsideOptionWalker(samples.actionDec, path).startWalking()
-                matchers.setEquality(possibleNextTokTypes, [t.ColonTok])
-            })
-        })
-
-        describe("The NextInsideManyWalker", function () {
-            it("can compute the next possible token types inside the MANY in QualifiedName", function () {
-                let path:p.IRuleGrammarPath = {
-                    ruleStack:       ["qualifiedName"],
-                    occurrenceStack: [1],
-                    occurrence:      1
-                }
-
-                let possibleNextTokTypes = new NextInsideManyWalker(samples.qualifiedName, path).startWalking()
-                matchers.setEquality(possibleNextTokTypes, [t.DotTok])
-            })
-
-            it("can compute the next possible token types inside the MANY in paramSpec inside ActionDec", function () {
-                let path:p.IRuleGrammarPath = {
-                    ruleStack:       ["actionDec"],
-                    occurrenceStack: [1],
-                    occurrence:      1
-                }
-
-                let possibleNextTokTypes = new NextInsideManyWalker(samples.actionDec, path).startWalking()
-                matchers.setEquality(possibleNextTokTypes, [t.CommaTok])
-            })
-
-            it("can compute the next possible token types inside the MANY in paramSpec inside ParamSpec --> QualifiedName", function () {
-                let path:p.IRuleGrammarPath = {
-                    ruleStack:       ["paramSpec", "qualifiedName"],
-                    occurrenceStack: [1, 1],
-                    occurrence:      1
-                }
-
-                let possibleNextTokTypes = new NextInsideManyWalker(samples.paramSpec, path).startWalking()
-                matchers.setEquality(possibleNextTokTypes, [t.DotTok])
-            })
-
-            it("can compute the next possible token types inside the MANY inside: manyActions --> actionDec ", function () {
-                let path:p.IRuleGrammarPath = {
-                    ruleStack:       ["manyActions", "actionDec"],
-                    occurrenceStack: [1, 1],
-                    occurrence:      1
-                }
-
-                let possibleNextTokTypes = new NextInsideManyWalker(samples.manyActions, path).startWalking()
-                matchers.setEquality(possibleNextTokTypes, [t.CommaTok])
-            })
-        })
-
-        describe("The NextInsideManySepWalker", function () {
-            it("can compute the next possible token types inside the MANY_SEP in callArguments", function () {
-                let path:p.IRuleGrammarPath = {
-                    ruleStack:       ["callArguments"],
-                    occurrenceStack: [1],
-                    occurrence:      1
-                }
-
-                let possibleNextTokTypes = new NextInsideManySepWalker(samples.callArguments, path).startWalking()
-                matchers.setEquality(possibleNextTokTypes, [t.IdentTok])
-            })
-
-            it("can compute the next possible token types inside the MANY_SEP in actionDecSep", function () {
-                let path:p.IRuleGrammarPath = {
-                    ruleStack:       ["actionDecSep"],
-                    occurrenceStack: [1],
-                    occurrence:      1
-                }
-
-                let possibleNextTokTypes = new NextInsideManySepWalker(samples.actionDecSep, path).startWalking()
-                matchers.setEquality(possibleNextTokTypes, [t.IdentTok])
-            })
-        })
-
-        describe("The NextInsideAtLeastOneWalker", function () {
-            it("can compute the next possible token types inside the AT_LEAST_ONE in callArguments", function () {
-                let path:p.IRuleGrammarPath = {
-                    ruleStack:       ["atLeastOneRule"],
-                    occurrenceStack: [1],
-                    occurrence:      1
-                }
-
-                let possibleNextTokTypes = new NextInsideAtLeastOneWalker(samples.atLeastOneRule, path).startWalking()
-                matchers.setEquality(possibleNextTokTypes, [t.EntityTok])
-            })
-
-            it("can compute the next possible token types inside the AT_LEAST_ONE in actionDecSep", function () {
-                let path:p.IRuleGrammarPath = {
-                    ruleStack:       ["atLeastOneRule"],
-                    occurrenceStack: [1],
-                    occurrence:      2
-                }
-
-                let possibleNextTokTypes = new NextInsideAtLeastOneWalker(samples.atLeastOneRule, path).startWalking()
-                matchers.setEquality(possibleNextTokTypes, [t.EntityTok])
-            })
-
-            it("can compute the next possible token types inside the AT_LEAST_ONE in actionDecSep", function () {
-                let path:p.IRuleGrammarPath = {
-                    ruleStack:       ["atLeastOneRule"],
-                    occurrenceStack: [1],
-                    occurrence:      3
-                }
-
-                let possibleNextTokTypes = new NextInsideAtLeastOneWalker(samples.atLeastOneRule, path).startWalking()
-                matchers.setEquality(possibleNextTokTypes, [t.EntityTok])
-            })
-        })
-
-        describe("The NextInsideAtLeastOneSepWalker", function () {
-            it("can compute the next possible token types inside the AT_LEAST_ONE_SEP in atLeastOneSepRule", function () {
-                let path:p.IRuleGrammarPath = {
-                    ruleStack:       ["atLeastOneSepRule"],
-                    occurrenceStack: [1],
-                    occurrence:      1
-                }
-
-                let possibleNextTokTypes = new NextInsideAtLeastOneSepWalker(samples.atLeastOneSepRule, path).startWalking()
-                matchers.setEquality(possibleNextTokTypes, [t.EntityTok])
-            })
-
-            it("can compute the next possible token types inside the AT_LEAST_ONE_SEP in atLeastOneSepRule 2", function () {
-                let path:p.IRuleGrammarPath = {
-                    ruleStack:       ["atLeastOneSepRule"],
-                    occurrenceStack: [1],
-                    occurrence:      2
-                }
-
-                let possibleNextTokTypes = new NextInsideAtLeastOneSepWalker(samples.atLeastOneSepRule, path).startWalking()
-                matchers.setEquality(possibleNextTokTypes, [t.EntityTok])
-            })
-
-            it("can compute the next possible token types inside the AT_LEAST_ONE_SEP in atLeastOneSepRule 3", function () {
-                let path:p.IRuleGrammarPath = {
-                    ruleStack:       ["atLeastOneSepRule"],
-                    occurrenceStack: [1],
-                    occurrence:      3
-                }
-
-                let possibleNextTokTypes = new NextInsideAtLeastOneSepWalker(samples.atLeastOneSepRule, path).startWalking()
-                matchers.setEquality(possibleNextTokTypes, [t.EntityTok])
-            })
-
-            it("can compute the next possible token types inside the AT_LEAST_ONE_SEP in qualifiedNameSep", function () {
-                let path:p.IRuleGrammarPath = {
-                    ruleStack:       ["qualifiedNameSep"],
-                    occurrenceStack: [1],
-                    occurrence:      1
-                }
-
-                let possibleNextTokTypes = new NextInsideAtLeastOneSepWalker(samples.qualifiedNameSep, path).startWalking()
-                matchers.setEquality(possibleNextTokTypes, [t.IdentTok])
-            })
+            let caPath:ITokenGrammarPath = {
+                ruleStack:         ["paramSpec",
+                    "qualifiedName"
+                ],
+                occurrenceStack:   [1, 1],
+                lastTok:           IdentTok,
+                lastTokOccurrence: 2
+            }
+
+            let possibleNextTokTypes = new NextAfterTokenWalker(paramSpec, caPath).startWalking()
+            expect(possibleNextTokTypes.length).to.equal(2)
+            setEquality(possibleNextTokTypes, [DotTok, LSquareTok])
+        })
+
+        it("will fail if we try to compute the next token starting from a rule that does not match the path", function () {
+            let caPath:ITokenGrammarPath = {
+                ruleStack:         ["I_WILL_FAIL_THE_WALKER",
+                    "qualifiedName"
+                ],
+                occurrenceStack:   [1, 1],
+                lastTok:           IdentTok,
+                lastTokOccurrence: 2
+            }
+
+            let walker = new NextAfterTokenWalker(paramSpec, caPath)
+            expect(() => walker.startWalking()).to.throw("The path does not start with the walker's top Rule!")
         })
     })
 
-    describe("The NextTerminalAfterManyWalker", function () {
-        it("can compute the next possible token types after the MANY in QualifiedName", function () {
-            let result = new NextTerminalAfterManyWalker(samples.qualifiedName, 1).startWalking()
-            //noinspection BadExpressionStatementJS
-            expect(result.occurrence).to.be.undefined
-            //noinspection BadExpressionStatementJS
-            expect(result.token).to.be.undefined
+
+    describe("The NextInsideOptionWalker", function () {
+        it("can compute the next possible token types inside the OPTION in paramSpec", function () {
+            let path:IRuleGrammarPath = {
+                ruleStack:       ["paramSpec"],
+                occurrenceStack: [1],
+                occurrence:      1
+            }
+
+            let possibleNextTokTypes = new NextInsideOptionWalker(paramSpec, path).startWalking()
+            setEquality(possibleNextTokTypes, [LSquareTok])
         })
 
-        it("can compute the next possible token types after the MANY in paramSpec inside ActionDec", function () {
-            let result = new NextTerminalAfterManyWalker(samples.actionDec, 1).startWalking()
-            expect(result.occurrence).to.equal(1)
-            expect(result.token).to.equal(t.RParenTok)
+        it("can compute the next possible token types inside the OPTION in paramSpec inside ActionDec", function () {
+            let path:IRuleGrammarPath = {
+                ruleStack:       ["actionDec", "paramSpec"],
+                occurrenceStack: [1, 1],
+                occurrence:      1
+            }
+
+            let possibleNextTokTypes = new NextInsideOptionWalker(actionDec, path).startWalking()
+            setEquality(possibleNextTokTypes, [LSquareTok])
+        })
+
+        it("can compute the next possible token types inside the OPTION in paramSpec inside ActionDec", function () {
+            let path:IRuleGrammarPath = {
+                ruleStack:       ["actionDec"],
+                occurrenceStack: [1],
+                occurrence:      2
+            }
+
+            let possibleNextTokTypes = new NextInsideOptionWalker(actionDec, path).startWalking()
+            setEquality(possibleNextTokTypes, [ColonTok])
         })
     })
 
-    describe("The NextTerminalAfterManySepWalker", function () {
-        it("can compute the next possible token types after the MANY_SEP in QualifiedName", function () {
-            let result = new NextTerminalAfterManySepWalker(samples.callArguments, 1).startWalking()
-            //noinspection BadExpressionStatementJS
-            expect(result.occurrence).to.be.undefined
-            //noinspection BadExpressionStatementJS
-            expect(result.token).to.be.undefined
+    describe("The NextInsideManyWalker", function () {
+        it("can compute the next possible token types inside the MANY in QualifiedName", function () {
+            let path:IRuleGrammarPath = {
+                ruleStack:       ["qualifiedName"],
+                occurrenceStack: [1],
+                occurrence:      1
+            }
+
+            let possibleNextTokTypes = new NextInsideManyWalker(qualifiedName, path).startWalking()
+            setEquality(possibleNextTokTypes, [DotTok])
         })
 
-        it("can compute the next possible token types after the MANY in paramSpec inside ActionDec", function () {
-            let result = new NextTerminalAfterManySepWalker(samples.actionDecSep, 1).startWalking()
-            expect(result.occurrence).to.equal(1)
-            expect(result.token).to.equal(t.RParenTok)
+        it("can compute the next possible token types inside the MANY in paramSpec inside ActionDec", function () {
+            let path:IRuleGrammarPath = {
+                ruleStack:       ["actionDec"],
+                occurrenceStack: [1],
+                occurrence:      1
+            }
+
+            let possibleNextTokTypes = new NextInsideManyWalker(actionDec, path).startWalking()
+            setEquality(possibleNextTokTypes, [CommaTok])
+        })
+
+        it("can compute the next possible token types inside the MANY in paramSpec inside ParamSpec --> QualifiedName", function () {
+            let path:IRuleGrammarPath = {
+                ruleStack:       ["paramSpec", "qualifiedName"],
+                occurrenceStack: [1, 1],
+                occurrence:      1
+            }
+
+            let possibleNextTokTypes = new NextInsideManyWalker(paramSpec, path).startWalking()
+            setEquality(possibleNextTokTypes, [DotTok])
+        })
+
+        it("can compute the next possible token types inside the MANY inside: manyActions --> actionDec ", function () {
+            let path:IRuleGrammarPath = {
+                ruleStack:       ["manyActions", "actionDec"],
+                occurrenceStack: [1, 1],
+                occurrence:      1
+            }
+
+            let possibleNextTokTypes = new NextInsideManyWalker(manyActions, path).startWalking()
+            setEquality(possibleNextTokTypes, [CommaTok])
         })
     })
 
-    describe("The NextTerminalAfterAtLeastOneWalker", function () {
-        it("can compute the next possible token types after an AT_LEAST_ONE production", function () {
-            let result = new NextTerminalAfterAtLeastOneWalker(samples.atLeastOneRule, 1).startWalking()
-            expect(result.occurrence).to.equal(2)
-            expect(result.token).to.equal(t.DotTok)
+    describe("The NextInsideManySepWalker", function () {
+        it("can compute the next possible token types inside the MANY_SEP in callArguments", function () {
+            let path:IRuleGrammarPath = {
+                ruleStack:       ["callArguments"],
+                occurrenceStack: [1],
+                occurrence:      1
+            }
 
-            let result2 = new NextTerminalAfterAtLeastOneWalker(samples.atLeastOneRule, 2).startWalking()
-            expect(result2.occurrence).to.equal(1)
-            expect(result2.token).to.equal(t.DotTok)
+            let possibleNextTokTypes = new NextInsideManySepWalker(callArguments, path).startWalking()
+            setEquality(possibleNextTokTypes, [IdentTok])
+        })
+
+        it("can compute the next possible token types inside the MANY_SEP in actionDecSep", function () {
+            let path:IRuleGrammarPath = {
+                ruleStack:       ["actionDecSep"],
+                occurrenceStack: [1],
+                occurrence:      1
+            }
 
-            let result3 = new NextTerminalAfterAtLeastOneWalker(samples.atLeastOneRule, 3).startWalking()
-            expect(result3.occurrence).to.equal(1)
-            expect(result3.token).to.equal(t.CommaTok)
+            let possibleNextTokTypes = new NextInsideManySepWalker(actionDecSep, path).startWalking()
+            setEquality(possibleNextTokTypes, [IdentTok])
         })
     })
 
-    describe("The NextTerminalAfterAtLeastOneSepWalker", function () {
-        it("can compute the next possible token types after an AT_LEAST_ONE_SEP production", function () {
-            let result = new NextTerminalAfterAtLeastOneSepWalker(samples.atLeastOneSepRule, 1).startWalking()
-            expect(result.occurrence).to.equal(2)
-            expect(result.token).to.equal(t.DotTok)
+    describe("The NextInsideAtLeastOneWalker", function () {
+        it("can compute the next possible token types inside the AT_LEAST_ONE in callArguments", function () {
+            let path:IRuleGrammarPath = {
+                ruleStack:       ["atLeastOneRule"],
+                occurrenceStack: [1],
+                occurrence:      1
+            }
+
+            let possibleNextTokTypes = new NextInsideAtLeastOneWalker(atLeastOneRule, path).startWalking()
+            setEquality(possibleNextTokTypes, [EntityTok])
+        })
 
-            let result2 = new NextTerminalAfterAtLeastOneSepWalker(samples.atLeastOneSepRule, 2).startWalking()
-            expect(result2.occurrence).to.equal(1)
-            expect(result2.token).to.equal(t.DotTok)
+        it("can compute the next possible token types inside the AT_LEAST_ONE in actionDecSep", function () {
+            let path:IRuleGrammarPath = {
+                ruleStack:       ["atLeastOneRule"],
+                occurrenceStack: [1],
+                occurrence:      2
+            }
 
-            let result3 = new NextTerminalAfterAtLeastOneSepWalker(samples.atLeastOneSepRule, 3).startWalking()
-            expect(result3.occurrence).to.equal(1)
-            expect(result3.token).to.equal(t.CommaTok)
+            let possibleNextTokTypes = new NextInsideAtLeastOneWalker(atLeastOneRule, path).startWalking()
+            setEquality(possibleNextTokTypes, [EntityTok])
         })
 
-        it("can compute the next possible token types after an AT_LEAST_ONE_SEP production EMPTY", function () {
-            let result = new NextTerminalAfterAtLeastOneSepWalker(samples.qualifiedNameSep, 1).startWalking()
-            //noinspection BadExpressionStatementJS
-            expect(result.occurrence).to.be.undefined
-            //noinspection BadExpressionStatementJS
-            expect(result.token).to.be.undefined
+        it("can compute the next possible token types inside the AT_LEAST_ONE in actionDecSep", function () {
+            let path:IRuleGrammarPath = {
+                ruleStack:       ["atLeastOneRule"],
+                occurrenceStack: [1],
+                occurrence:      3
+            }
+
+            let possibleNextTokTypes = new NextInsideAtLeastOneWalker(atLeastOneRule, path).startWalking()
+            setEquality(possibleNextTokTypes, [EntityTok])
         })
     })
 
-    describe("The NextInsideOrWalker", function () {
+    describe("The NextInsideAtLeastOneSepWalker", function () {
+        it("can compute the next possible token types inside the AT_LEAST_ONE_SEP in atLeastOneSepRule", function () {
+            let path:IRuleGrammarPath = {
+                ruleStack:       ["atLeastOneSepRule"],
+                occurrenceStack: [1],
+                occurrence:      1
+            }
+
+            let possibleNextTokTypes = new NextInsideAtLeastOneSepWalker(atLeastOneSepRule, path).startWalking()
+            setEquality(possibleNextTokTypes, [EntityTok])
+        })
+
+        it("can compute the next possible token types inside the AT_LEAST_ONE_SEP in atLeastOneSepRule 2", function () {
+            let path:IRuleGrammarPath = {
+                ruleStack:       ["atLeastOneSepRule"],
+                occurrenceStack: [1],
+                occurrence:      2
+            }
+
+            let possibleNextTokTypes = new NextInsideAtLeastOneSepWalker(atLeastOneSepRule, path).startWalking()
+            setEquality(possibleNextTokTypes, [EntityTok])
+        })
+
+        it("can compute the next possible token types inside the AT_LEAST_ONE_SEP in atLeastOneSepRule 3", function () {
+            let path:IRuleGrammarPath = {
+                ruleStack:       ["atLeastOneSepRule"],
+                occurrenceStack: [1],
+                occurrence:      3
+            }
 
-        it("can compute the First Tokens for all alternatives of an OR", function () {
-            let result = new NextInsideOrWalker(samples.cardinality, 1).startWalking()
-            expect(result.length).to.equal(2)
-            matchers.setEquality(<any>result[0], [t.UnsignedIntegerLiteralTok])
-            matchers.setEquality(<any>result[1], [t.AsteriskTok])
+            let possibleNextTokTypes = new NextInsideAtLeastOneSepWalker(atLeastOneSepRule, path).startWalking()
+            setEquality(possibleNextTokTypes, [EntityTok])
         })
 
-        it("can compute the First Tokens for all alternatives of an OR (complex)", function () {
-            let result1 = new NextInsideOrWalker(samples.lotsOfOrs, 1).startWalking()
-            expect(result1.length).to.equal(2)
-            matchers.setEquality(<any>result1[0], [t.CommaTok, t.KeyTok])
-            matchers.setEquality(<any>result1[1], [t.EntityTok])
+        it("can compute the next possible token types inside the AT_LEAST_ONE_SEP in qualifiedNameSep", function () {
+            let path:IRuleGrammarPath = {
+                ruleStack:       ["qualifiedNameSep"],
+                occurrenceStack: [1],
+                occurrence:      1
+            }
+
+            let possibleNextTokTypes = new NextInsideAtLeastOneSepWalker(qualifiedNameSep, path).startWalking()
+            setEquality(possibleNextTokTypes, [IdentTok])
         })
     })
-}
+})
+
+describe("The NextTerminalAfterManyWalker", function () {
+    it("can compute the next possible token types after the MANY in QualifiedName", function () {
+        let result = new NextTerminalAfterManyWalker(qualifiedName, 1).startWalking()
+        //noinspection BadExpressionStatementJS
+        expect(result.occurrence).to.be.undefined
+        //noinspection BadExpressionStatementJS
+        expect(result.token).to.be.undefined
+    })
+
+    it("can compute the next possible token types after the MANY in paramSpec inside ActionDec", function () {
+        let result = new NextTerminalAfterManyWalker(actionDec, 1).startWalking()
+        expect(result.occurrence).to.equal(1)
+        expect(result.token).to.equal(RParenTok)
+    })
+})
+
+describe("The NextTerminalAfterManySepWalker", function () {
+    it("can compute the next possible token types after the MANY_SEP in QualifiedName", function () {
+        let result = new NextTerminalAfterManySepWalker(callArguments, 1).startWalking()
+        //noinspection BadExpressionStatementJS
+        expect(result.occurrence).to.be.undefined
+        //noinspection BadExpressionStatementJS
+        expect(result.token).to.be.undefined
+    })
+
+    it("can compute the next possible token types after the MANY in paramSpec inside ActionDec", function () {
+        let result = new NextTerminalAfterManySepWalker(actionDecSep, 1).startWalking()
+        expect(result.occurrence).to.equal(1)
+        expect(result.token).to.equal(RParenTok)
+    })
+})
+
+describe("The NextTerminalAfterAtLeastOneWalker", function () {
+    it("can compute the next possible token types after an AT_LEAST_ONE production", function () {
+        let result = new NextTerminalAfterAtLeastOneWalker(atLeastOneRule, 1).startWalking()
+        expect(result.occurrence).to.equal(2)
+        expect(result.token).to.equal(DotTok)
+
+        let result2 = new NextTerminalAfterAtLeastOneWalker(atLeastOneRule, 2).startWalking()
+        expect(result2.occurrence).to.equal(1)
+        expect(result2.token).to.equal(DotTok)
+
+        let result3 = new NextTerminalAfterAtLeastOneWalker(atLeastOneRule, 3).startWalking()
+        expect(result3.occurrence).to.equal(1)
+        expect(result3.token).to.equal(CommaTok)
+    })
+})
+
+describe("The NextTerminalAfterAtLeastOneSepWalker", function () {
+    it("can compute the next possible token types after an AT_LEAST_ONE_SEP production", function () {
+        let result = new NextTerminalAfterAtLeastOneSepWalker(atLeastOneSepRule, 1).startWalking()
+        expect(result.occurrence).to.equal(2)
+        expect(result.token).to.equal(DotTok)
+
+        let result2 = new NextTerminalAfterAtLeastOneSepWalker(atLeastOneSepRule, 2).startWalking()
+        expect(result2.occurrence).to.equal(1)
+        expect(result2.token).to.equal(DotTok)
+
+        let result3 = new NextTerminalAfterAtLeastOneSepWalker(atLeastOneSepRule, 3).startWalking()
+        expect(result3.occurrence).to.equal(1)
+        expect(result3.token).to.equal(CommaTok)
+    })
+
+    it("can compute the next possible token types after an AT_LEAST_ONE_SEP production EMPTY", function () {
+        let result = new NextTerminalAfterAtLeastOneSepWalker(qualifiedNameSep, 1).startWalking()
+        //noinspection BadExpressionStatementJS
+        expect(result.occurrence).to.be.undefined
+        //noinspection BadExpressionStatementJS
+        expect(result.token).to.be.undefined
+    })
+})
+
+describe("The NextInsideOrWalker", function () {
+
+    it("can compute the First Tokens for all alternatives of an OR", function () {
+        let result = new NextInsideOrWalker(cardinality, 1).startWalking()
+        expect(result.length).to.equal(2)
+        setEquality(<any>result[0], [UnsignedIntegerLiteralTok])
+        setEquality(<any>result[1], [AsteriskTok])
+    })
+
+    it("can compute the First Tokens for all alternatives of an OR (complex)", function () {
+        let result1 = new NextInsideOrWalker(lotsOfOrs, 1).startWalking()
+        expect(result1.length).to.equal(2)
+        setEquality(<any>result1[0], [CommaTok, KeyTok])
+        setEquality(<any>result1[1], [EntityTok])
+    })
+})
diff --git a/test/parse/grammar/lookahead_spec.ts b/test/parse/grammar/lookahead_spec.ts
index b8c5d5201..2db19b00c 100644
--- a/test/parse/grammar/lookahead_spec.ts
+++ b/test/parse/grammar/lookahead_spec.ts
@@ -1,117 +1,121 @@
-namespace chevrotain.lookahead.spec {
-
-    import samples = specs.samples
-    import lookahead = chevrotain.lookahead
-    import matchers = specs.matchers
-
-    class ColonParserMock extends Parser {
-        protected NEXT_TOKEN():Token {
-            return new samples.ColonTok(":", 0, 1, 1)
-        }
+import {Parser} from "../../../src/parse/parser_public"
+import {Token} from "../../../src/scan/tokens_public"
+import {ColonTok, IdentTok, CommaTok, EntityTok, KeyTok, ActionTok, actionDec, lotsOfOrs, emptyAltOr} from "./samples"
+import {
+    checkAlternativesAmbiguities,
+    buildLookaheadForTopLevel,
+    buildLookaheadForOr,
+    buildLookaheadForOption,
+    buildLookaheadForMany
+} from "../../../src/parse/grammar/lookahead"
+
+class ColonParserMock extends Parser {
+    protected NEXT_TOKEN():Token {
+        return new ColonTok(":", 0, 1, 1)
     }
+}
 
-    class IdentParserMock extends Parser {
-        protected NEXT_TOKEN():Token {
-            return new samples.IdentTok("bamba", 0, 1, 1)
-        }
+class IdentParserMock extends Parser {
+    protected NEXT_TOKEN():Token {
+        return new IdentTok("bamba", 0, 1, 1)
     }
+}
 
-    class CommaParserMock extends Parser {
-        protected NEXT_TOKEN():Token {
-            return new samples.CommaTok(",", 0, 1, 1)
-        }
+class CommaParserMock extends Parser {
+    protected NEXT_TOKEN():Token {
+        return new CommaTok(",", 0, 1, 1)
     }
+}
 
-    class EntityParserMock extends Parser {
-        protected NEXT_TOKEN():Token {
-            return new samples.EntityTok(",", 0, 1, 1)
-        }
+class EntityParserMock extends Parser {
+    protected NEXT_TOKEN():Token {
+        return new EntityTok(",", 0, 1, 1)
     }
+}
 
-    class KeyParserMock extends Parser {
-        protected NEXT_TOKEN():Token {
-            return new samples.KeyTok(",", 0, 1, 1)
-        }
+class KeyParserMock extends Parser {
+    protected NEXT_TOKEN():Token {
+        return new KeyTok(",", 0, 1, 1)
     }
+}
 
-    class ActionParserMock extends Parser {
-        protected NEXT_TOKEN():Token {
-            return new samples.ActionTok(",", 0, 1, 1)
-        }
+class ActionParserMock extends Parser {
+    protected NEXT_TOKEN():Token {
+        return new ActionTok(",", 0, 1, 1)
     }
+}
 
-    describe("The Grammar Lookahead namespace", function () {
-        "use strict"
+describe("The Grammar Lookahead namespace", function () {
+    "use strict"
 
-        it("can compute the lookahead function for the first OPTION in ActionDec", function () {
-            let laFunc = lookahead.buildLookaheadForOption(1, samples.actionDec)
+    it("can compute the lookahead function for the first OPTION in ActionDec", function () {
+        let laFunc = buildLookaheadForOption(1, actionDec)
 
-            expect(laFunc.call(new ColonParserMock([], []))).to.equal(false)
-            expect(laFunc.call(new IdentParserMock([], []))).to.equal(true)
-        })
+        expect(laFunc.call(new ColonParserMock([], []))).to.equal(false)
+        expect(laFunc.call(new IdentParserMock([], []))).to.equal(true)
+    })
 
-        it("can compute the lookahead function for the second OPTION in ActionDec", function () {
-            let laFunc = lookahead.buildLookaheadForOption(2, samples.actionDec)
+    it("can compute the lookahead function for the second OPTION in ActionDec", function () {
+        let laFunc = buildLookaheadForOption(2, actionDec)
 
-            expect(laFunc.call(new ColonParserMock([], []))).to.equal(true)
-            expect(laFunc.call(new IdentParserMock([], []))).to.equal(false)
-        })
+        expect(laFunc.call(new ColonParserMock([], []))).to.equal(true)
+        expect(laFunc.call(new IdentParserMock([], []))).to.equal(false)
+    })
 
-        it("can compute the lookahead function for the first MANY in ActionDec", function () {
-            let laFunc = lookahead.buildLookaheadForMany(1, samples.actionDec)
+    it("can compute the lookahead function for the first MANY in ActionDec", function () {
+        let laFunc = buildLookaheadForMany(1, actionDec)
 
-            expect(laFunc.call(new CommaParserMock([], []))).to.equal(true)
-            expect(laFunc.call(new IdentParserMock([], []))).to.equal(false)
-        })
+        expect(laFunc.call(new CommaParserMock([], []))).to.equal(true)
+        expect(laFunc.call(new IdentParserMock([], []))).to.equal(false)
+    })
 
-        it("can compute the lookahead function for lots of ORs sample", function () {
-            let laFunc = lookahead.buildLookaheadForOr(1, samples.lotsOfOrs)
+    it("can compute the lookahead function for lots of ORs sample", function () {
+        let laFunc = buildLookaheadForOr(1, lotsOfOrs)
 
-            expect(laFunc.call(new CommaParserMock([], []))).to.equal(0)
-            expect(laFunc.call(new KeyParserMock([], []))).to.equal(0)
-            expect(laFunc.call(new EntityParserMock([], []))).to.equal(1)
-            expect(laFunc.call(new ColonParserMock([], []))).to.equal(-1)
-        })
+        expect(laFunc.call(new CommaParserMock([], []))).to.equal(0)
+        expect(laFunc.call(new KeyParserMock([], []))).to.equal(0)
+        expect(laFunc.call(new EntityParserMock([], []))).to.equal(1)
+        expect(laFunc.call(new ColonParserMock([], []))).to.equal(-1)
+    })
 
-        it("can compute the lookahead function for EMPTY OR sample", function () {
-            let laFunc = lookahead.buildLookaheadForOr(1, samples.emptyAltOr)
+    it("can compute the lookahead function for EMPTY OR sample", function () {
+        let laFunc = buildLookaheadForOr(1, emptyAltOr)
 
-            expect(laFunc.call(new KeyParserMock([], []))).to.equal(0)
-            expect(laFunc.call(new EntityParserMock([], []))).to.equal(1)
-            // none matches so the last empty alternative should be taken (idx 2)
-            expect(laFunc.call(new CommaParserMock([], []))).to.equal(2)
-        })
+        expect(laFunc.call(new KeyParserMock([], []))).to.equal(0)
+        expect(laFunc.call(new EntityParserMock([], []))).to.equal(1)
+        // none matches so the last empty alternative should be taken (idx 2)
+        expect(laFunc.call(new CommaParserMock([], []))).to.equal(2)
+    })
 
-        it("can compute the lookahead function for a Top Level Rule", function () {
-            let laFunc = lookahead.buildLookaheadForTopLevel(samples.actionDec)
+    it("can compute the lookahead function for a Top Level Rule", function () {
+        let laFunc = buildLookaheadForTopLevel(actionDec)
 
-            expect(laFunc.call(new ActionParserMock([], []))).to.equal(true)
-            expect(laFunc.call(new IdentParserMock([], []))).to.equal(false)
-        })
+        expect(laFunc.call(new ActionParserMock([], []))).to.equal(true)
+        expect(laFunc.call(new IdentParserMock([], []))).to.equal(false)
+    })
 
-        it("can compute the lookahead function for a Top Level Rule #2", function () {
-            let laFunc = lookahead.buildLookaheadForTopLevel(samples.lotsOfOrs)
+    it("can compute the lookahead function for a Top Level Rule #2", function () {
+        let laFunc = buildLookaheadForTopLevel(lotsOfOrs)
 
-            expect(laFunc.call(new CommaParserMock([], []))).to.equal(true)
-            expect(laFunc.call(new EntityParserMock([], []))).to.equal(true)
-            expect(laFunc.call(new KeyParserMock([], []))).to.equal(true)
-            expect(laFunc.call(new ActionParserMock([], []))).to.equal(false)
-        })
+        expect(laFunc.call(new CommaParserMock([], []))).to.equal(true)
+        expect(laFunc.call(new EntityParserMock([], []))).to.equal(true)
+        expect(laFunc.call(new KeyParserMock([], []))).to.equal(true)
+        expect(laFunc.call(new ActionParserMock([], []))).to.equal(false)
     })
+})
 
-    class A extends Token {}
-    class B extends Token {}
-    class C extends Token {}
-    class D extends Token {}
-    class E extends Token {}
+class A extends Token {}
+class B extends Token {}
+class C extends Token {}
+class D extends Token {}
+class E extends Token {}
 
-    describe("The Grammar Lookahead namespace", function () {
+describe("The Grammar Lookahead namespace", function () {
 
-        it("can detect ambiguities when calculating lookahead functions for OR alternatives", function () {
-            let input = [[A, B], [C, D], [E, C]]
-            let ambiguities = lookahead.checkAlternativesAmbiguities(input)
-            expect(ambiguities.length).to.equal(1)
-            expect(ambiguities[0].alts).to.deep.equal([2, 3])
-        })
+    it("can detect ambiguities when calculating lookahead functions for OR alternatives", function () {
+        let input = [[A, B], [C, D], [E, C]]
+        let ambiguities = checkAlternativesAmbiguities(input)
+        expect(ambiguities.length).to.equal(1)
+        expect(ambiguities[0].alts).to.deep.equal([2, 3])
     })
-}
+})
diff --git a/test/parse/grammar/resolver_spec.ts b/test/parse/grammar/resolver_spec.ts
index 6e1a4f10d..46cbd6354 100644
--- a/test/parse/grammar/resolver_spec.ts
+++ b/test/parse/grammar/resolver_spec.ts
@@ -1,19 +1,20 @@
-namespace chevrotain.resolver.spec {
-    import gast = chevrotain.gast
+import {gast} from "../../../src/parse/grammar/gast_public"
+import {HashTable} from "../../../src/lang/lang_extensions"
+import {GastRefResolverVisitor} from "../../../src/parse/grammar/resolver"
+import {ParserDefinitionErrorType} from "../../../src/parse/parser_public"
 
-    describe("The RefResolverVisitor", function () {
+describe("The RefResolverVisitor", function () {
 
-        it("will fail when trying to resolve a ref to a grammar rule that does not exist", function () {
-            let ref = new gast.NonTerminal("missingRule")
-            let topLevel = new gast.Rule("TOP", [ref])
-            let topLevelRules = new lang.HashTable<gast.Rule>()
-            topLevelRules.put("TOP", topLevel)
-            let resolver = new GastRefResolverVisitor(topLevelRules)
-            resolver.resolveRefs()
-            expect(resolver.errors).to.have.lengthOf(1)
-            expect(resolver.errors[0].message).to.contain("Invalid grammar, reference to rule which is not defined --> missingRule")
-            expect(resolver.errors[0].type).to.equal(ParserDefinitionErrorType.UNRESOLVED_SUBRULE_REF)
-            expect(resolver.errors[0].ruleName).to.equal("TOP")
-        })
+    it("will fail when trying to resolve a ref to a grammar rule that does not exist", function () {
+        let ref = new gast.NonTerminal("missingRule")
+        let topLevel = new gast.Rule("TOP", [ref])
+        let topLevelRules = new HashTable<gast.Rule>()
+        topLevelRules.put("TOP", topLevel)
+        let resolver = new GastRefResolverVisitor(topLevelRules)
+        resolver.resolveRefs()
+        expect(resolver.errors).to.have.lengthOf(1)
+        expect(resolver.errors[0].message).to.contain("Invalid grammar, reference to rule which is not defined --> missingRule")
+        expect(resolver.errors[0].type).to.equal(ParserDefinitionErrorType.UNRESOLVED_SUBRULE_REF)
+        expect(resolver.errors[0].ruleName).to.equal("TOP")
     })
-}
+})
diff --git a/test/parse/grammar/samples.ts b/test/parse/grammar/samples.ts
index 4f78cfc9c..96b73626d 100644
--- a/test/parse/grammar/samples.ts
+++ b/test/parse/grammar/samples.ts
@@ -1,179 +1,188 @@
-namespace specs.samples {
-
-    import gast = chevrotain.gast
-
-    export class IdentTok extends chevrotain.Token {}
-    export class DotTok extends chevrotain.Token {}
-    export class DotDotTok extends chevrotain.Token {}
-    export class ColonTok extends chevrotain.Token {}
-    export class LSquareTok extends chevrotain.Token {}
-    export class RSquareTok extends chevrotain.Token {}
-    export class ActionTok extends chevrotain.Token {}
-    export class LParenTok extends chevrotain.Token {}
-    export class RParenTok extends chevrotain.Token {}
-    export class CommaTok extends chevrotain.Token {}
-    export class SemicolonTok extends chevrotain.Token {}
-    export class UnsignedIntegerLiteralTok extends chevrotain.Token {}
-    export class DefaultTok extends chevrotain.Token {}
-    export class AsteriskTok extends chevrotain.Token {}
-    export class EntityTok extends chevrotain.Token {}
-    export class NamespaceTok extends chevrotain.Token {}
-    export class TypeTok extends chevrotain.Token {}
-    export class ConstTok extends chevrotain.Token {}
-    export class RequiredTok extends chevrotain.Token {}
-    export class KeyTok extends chevrotain.Token {}
-    export class ElementTok extends chevrotain.Token {}
-
-    export let atLeastOneRule = new gast.Rule("atLeastOneRule", [
-        new gast.RepetitionMandatory([
-            new gast.RepetitionMandatory([
-                new gast.RepetitionMandatory([
-                    new gast.Terminal(EntityTok)
-                ], 3),
-                new gast.Terminal(CommaTok)
-            ], 2),
-            new gast.Terminal(DotTok, 1)
-        ]),
-        new gast.Terminal(DotTok, 2)
-    ])
-
-    export let atLeastOneSepRule = new gast.Rule("atLeastOneSepRule", [
-        new gast.RepetitionMandatoryWithSeparator([
-            new gast.RepetitionMandatoryWithSeparator([
-                new gast.RepetitionMandatoryWithSeparator([
-                    new gast.Terminal(EntityTok)
-                ], SemicolonTok, 3),
-                new gast.Terminal(CommaTok)
-            ], SemicolonTok, 2),
-            new gast.Terminal(DotTok, 1)
-        ], SemicolonTok),
-        new gast.Terminal(DotTok, 2)
-    ])
-
-    export let qualifiedName = new gast.Rule("qualifiedName", [
-        new gast.Terminal(IdentTok),
-        new gast.Repetition([
-            new gast.Terminal(DotTok),
-            new gast.Terminal(IdentTok, 2)
-        ])
-    ])
-
-
-    export let qualifiedNameSep = new gast.Rule("qualifiedNameSep", [
-        new gast.RepetitionMandatoryWithSeparator([
-            new gast.Terminal(IdentTok, 1)
-        ], DotTok)
-    ])
-
-    export let paramSpec = new gast.Rule("paramSpec", [
-        new gast.Terminal(IdentTok),
-        new gast.Terminal(ColonTok),
-        new gast.NonTerminal("qualifiedName", qualifiedName),
-        new gast.Option([
-            new gast.Terminal(LSquareTok),
-            new gast.Terminal(RSquareTok)
-        ])
-    ])
-
-    export let actionDec = new gast.Rule("actionDec", [
-        new gast.Terminal(ActionTok),
-        new gast.Terminal(IdentTok),
-        new gast.Terminal(LParenTok),
-        new gast.Option([
-            new gast.NonTerminal("paramSpec", paramSpec),
-            new gast.Repetition([
-                new gast.Terminal(CommaTok),
-                new gast.NonTerminal("paramSpec", paramSpec, 2)
-            ])
-        ]),
-        new gast.Terminal(RParenTok),
-        new gast.Option([
-            new gast.Terminal(ColonTok),
-            new gast.NonTerminal("qualifiedName", qualifiedName)
+import {Token} from "../../../src/scan/tokens_public"
+import {gast} from "../../../src/parse/grammar/gast_public"
+
+let Rule = gast.Rule
+let RepetitionMandatory = gast.RepetitionMandatory
+let RepetitionMandatoryWithSeparator = gast.RepetitionMandatoryWithSeparator
+let Repetition = gast.Repetition
+let NonTerminal = gast.NonTerminal
+let RepetitionWithSeparator = gast.RepetitionWithSeparator
+let Terminal = gast.Terminal
+let Option = gast.Option
+let Alternation = gast.Alternation
+let Flat = gast.Flat
+
+export class IdentTok extends Token {}
+export class DotTok extends Token {}
+export class DotDotTok extends Token {}
+export class ColonTok extends Token {}
+export class LSquareTok extends Token {}
+export class RSquareTok extends Token {}
+export class ActionTok extends Token {}
+export class LParenTok extends Token {}
+export class RParenTok extends Token {}
+export class CommaTok extends Token {}
+export class SemicolonTok extends Token {}
+export class UnsignedIntegerLiteralTok extends Token {}
+export class DefaultTok extends Token {}
+export class AsteriskTok extends Token {}
+export class EntityTok extends Token {}
+export class NamespaceTok extends Token {}
+export class TypeTok extends Token {}
+export class ConstTok extends Token {}
+export class RequiredTok extends Token {}
+export class KeyTok extends Token {}
+export class ElementTok extends Token {}
+
+export let atLeastOneRule = new Rule("atLeastOneRule", [
+    new RepetitionMandatory([
+        new RepetitionMandatory([
+            new RepetitionMandatory([
+                new Terminal(EntityTok)
+            ], 3),
+            new Terminal(CommaTok)
         ], 2),
-        new gast.Terminal(SemicolonTok)
+        new Terminal(DotTok, 1)
+    ]),
+    new Terminal(DotTok, 2)
+])
+
+export let atLeastOneSepRule = new Rule("atLeastOneSepRule", [
+    new RepetitionMandatoryWithSeparator([
+        new RepetitionMandatoryWithSeparator([
+            new RepetitionMandatoryWithSeparator([
+                new Terminal(EntityTok)
+            ], SemicolonTok, 3),
+            new Terminal(CommaTok)
+        ], SemicolonTok, 2),
+        new Terminal(DotTok, 1)
+    ], SemicolonTok),
+    new Terminal(DotTok, 2)
+])
+
+export let qualifiedName = new Rule("qualifiedName", [
+    new Terminal(IdentTok),
+    new Repetition([
+        new Terminal(DotTok),
+        new Terminal(IdentTok, 2)
     ])
-
-    export let actionDecSep = new gast.Rule("actionDecSep", [
-        new gast.Terminal(ActionTok),
-        new gast.Terminal(IdentTok),
-        new gast.Terminal(LParenTok),
-
-        new gast.RepetitionWithSeparator([
-            new gast.NonTerminal("paramSpec", paramSpec, 2)
-        ], CommaTok),
-
-        new gast.Terminal(RParenTok),
-        new gast.Option([
-            new gast.Terminal(ColonTok),
-            new gast.NonTerminal("qualifiedName", qualifiedName)
-        ], 2),
-        new gast.Terminal(SemicolonTok)
+])
+
+
+export let qualifiedNameSep = new Rule("qualifiedNameSep", [
+    new RepetitionMandatoryWithSeparator([
+        new Terminal(IdentTok, 1)
+    ], DotTok)
+])
+
+export let paramSpec = new Rule("paramSpec", [
+    new Terminal(IdentTok),
+    new Terminal(ColonTok),
+    new NonTerminal("qualifiedName", qualifiedName),
+    new Option([
+        new Terminal(LSquareTok),
+        new Terminal(RSquareTok)
     ])
-
-    export let manyActions = new gast.Rule("manyActions", [
-        new gast.Repetition([
-            new gast.NonTerminal("actionDec", actionDec, 1)
+])
+
+export let actionDec = new Rule("actionDec", [
+    new Terminal(ActionTok),
+    new Terminal(IdentTok),
+    new Terminal(LParenTok),
+    new Option([
+        new NonTerminal("paramSpec", paramSpec),
+        new Repetition([
+            new Terminal(CommaTok),
+            new NonTerminal("paramSpec", paramSpec, 2)
         ])
+    ]),
+    new Terminal(RParenTok),
+    new Option([
+        new Terminal(ColonTok),
+        new NonTerminal("qualifiedName", qualifiedName)
+    ], 2),
+    new Terminal(SemicolonTok)
+])
+
+export let actionDecSep = new Rule("actionDecSep", [
+    new Terminal(ActionTok),
+    new Terminal(IdentTok),
+    new Terminal(LParenTok),
+
+    new RepetitionWithSeparator([
+        new NonTerminal("paramSpec", paramSpec, 2)
+    ], CommaTok),
+
+    new Terminal(RParenTok),
+    new Option([
+        new Terminal(ColonTok),
+        new NonTerminal("qualifiedName", qualifiedName)
+    ], 2),
+    new Terminal(SemicolonTok)
+])
+
+export let manyActions = new Rule("manyActions", [
+    new Repetition([
+        new NonTerminal("actionDec", actionDec, 1)
     ])
-
-    export let cardinality = new gast.Rule("cardinality", [
-        new gast.Terminal(LSquareTok),
-        new gast.Terminal(UnsignedIntegerLiteralTok),
-        new gast.Terminal(DotDotTok),
-        new gast.Alternation([
-            new gast.Terminal(UnsignedIntegerLiteralTok, 2),
-            new gast.Terminal(AsteriskTok)
+])
+
+export let cardinality = new Rule("cardinality", [
+    new Terminal(LSquareTok),
+    new Terminal(UnsignedIntegerLiteralTok),
+    new Terminal(DotDotTok),
+    new Alternation([
+        new Terminal(UnsignedIntegerLiteralTok, 2),
+        new Terminal(AsteriskTok)
+    ]),
+    new Terminal(RSquareTok)
+])
+
+export let assignedTypeSpec = new Rule("assignedTypeSpec", [
+    new Terminal(ColonTok),
+    new NonTerminal("assignedType"),
+
+    new Option([
+        new NonTerminal("enumClause")
+    ]),
+
+    new Option([
+        new Terminal(DefaultTok),
+        new NonTerminal("expression")
+    ], 2)
+])
+
+export let lotsOfOrs = new Rule("lotsOfOrs", [
+    new Option([
+        new Alternation([
+            new Flat([
+                new Alternation([
+                    new Terminal(CommaTok, 1),
+                    new Terminal(KeyTok, 1)
+                ], 2)
+            ]),
+            new Terminal(EntityTok, 1)
         ]),
-        new gast.Terminal(RSquareTok)
-    ])
-
-    export let assignedTypeSpec = new gast.Rule("assignedTypeSpec", [
-        new gast.Terminal(ColonTok),
-        new gast.NonTerminal("assignedType"),
-
-        new gast.Option([
-            new gast.NonTerminal("enumClause")
+        new Alternation([
+            new Terminal(DotTok, 1),
+        ], 3)
+    ]),
+])
+
+export let emptyAltOr = new Rule("emptyAltOr", [
+    new Alternation([
+        new Flat([
+            new Terminal(KeyTok, 1)
         ]),
-
-        new gast.Option([
-            new gast.Terminal(DefaultTok),
-            new gast.NonTerminal("expression")
-        ], 2)
-    ])
-
-    export let lotsOfOrs = new gast.Rule("lotsOfOrs", [
-        new gast.Option([
-            new gast.Alternation([
-                new gast.Flat([
-                    new gast.Alternation([
-                        new gast.Terminal(CommaTok, 1),
-                        new gast.Terminal(KeyTok, 1)
-                    ], 2)
-                ]),
-                new gast.Terminal(EntityTok, 1)
-            ]),
-            new gast.Alternation([
-                new gast.Terminal(DotTok, 1),
-            ], 3)
+        new Flat([
+            new Terminal(EntityTok, 1)
         ]),
+        new Flat([]) // an empty alternative
     ])
+])
 
-    export let emptyAltOr = new gast.Rule("emptyAltOr", [
-        new gast.Alternation([
-            new gast.Flat([
-                new gast.Terminal(KeyTok, 1)
-            ]),
-            new gast.Flat([
-                new gast.Terminal(EntityTok, 1)
-            ]),
-            new gast.Flat([]) // an empty alternative
-        ])
-    ])
-
-    export let callArguments = new gast.Rule("callArguments", [
-        new gast.RepetitionWithSeparator([
-            new gast.Terminal(IdentTok, 1)
-        ], CommaTok)
-    ])
-}
+export let callArguments = new Rule("callArguments", [
+    new RepetitionWithSeparator([
+        new Terminal(IdentTok, 1)
+    ], CommaTok)
+])
diff --git a/test/parse/recognizer_lookahead_spec.ts b/test/parse/recognizer_lookahead_spec.ts
index 7e64936e4..68acdb595 100644
--- a/test/parse/recognizer_lookahead_spec.ts
+++ b/test/parse/recognizer_lookahead_spec.ts
@@ -1,919 +1,924 @@
-namespace chevrotain.recognizer.lookahead.spec {
+import {Token} from "../../src/scan/tokens_public"
+import {Parser} from "../../src/parse/parser_public"
+import {HashTable} from "../../src/lang/lang_extensions"
+import {getLookaheadFuncsForClass} from "../../src/parse/cache"
 
-    export class OneTok extends Token {
-        constructor() { super("One", 0, 1, 1) }
-    }
-
-    export class TwoTok extends Token {
-        constructor() { super("Two", 0, 1, 1) }
-    }
-
-    export class ThreeTok extends Token {
-        constructor() { super("Three", 0, 1, 1) }
-    }
-
-    export class FourTok extends Token {
-        constructor() { super("Four", 0, 1, 1) }
-    }
-
-    export class FiveTok extends Token {
-        constructor() { super("Five", 0, 1, 1) }
-    }
-
-    export class SixTok extends Token {
-        constructor() { super("Six", 0, 1, 1) }
-    }
-
-    export class Comma extends Token {
-        constructor() { super(",", 0, 1, 1) }
-    }
-
-    class OptionsImplicitLookAheadParser extends Parser {
-
-        public getLookAheadCache():lang.HashTable<Function> {
-            return cache.getLookaheadFuncsForClass(this.className)
-        }
+export class OneTok extends Token {
+    constructor() { super("One", 0, 1, 1) }
+}
 
-        constructor(input:Token[] = []) {
-            super(input, <any>chevrotain.recognizer.lookahead.spec)
-            Parser.performSelfAnalysis(this)
-        }
+export class TwoTok extends Token {
+    constructor() { super("Two", 0, 1, 1) }
+}
 
-        public manyOptionsRule = this.RULE("manyOptionsRule", this.parseManyOptionsRule, () => { return "-666" })
+export class ThreeTok extends Token {
+    constructor() { super("Three", 0, 1, 1) }
+}
 
-        private parseManyOptionsRule():string {
-            let total = ""
+export class FourTok extends Token {
+    constructor() { super("Four", 0, 1, 1) }
+}
 
-            this.OPTION1(() => {
-                this.CONSUME1(OneTok)
-                total += "1"
-            })
+export class FiveTok extends Token {
+    constructor() { super("Five", 0, 1, 1) }
+}
 
-            this.OPTION2(() => {
-                this.CONSUME1(TwoTok)
-                total += "2"
-            })
+export class SixTok extends Token {
+    constructor() { super("Six", 0, 1, 1) }
+}
 
-            this.OPTION3(() => {
-                this.CONSUME1(ThreeTok)
-                total += "3"
-            })
+export class Comma extends Token {
+    constructor() { super(",", 0, 1, 1) }
+}
 
-            this.OPTION4(() => {
-                this.CONSUME1(FourTok)
-                total += "4"
-            })
+const ALL_TOKENS = [OneTok, TwoTok, ThreeTok, FourTok, FiveTok, SixTok, Comma]
 
-            this.OPTION5(() => {
-                this.CONSUME1(FiveTok)
-                total += "5"
-            })
+class OptionsImplicitLookAheadParser extends Parser {
 
-            return total
-        }
+    public getLookAheadCache():HashTable<Function> {
+        return getLookaheadFuncsForClass(this.className)
     }
 
-    class OptionsExplicitLookAheadParser extends Parser {
-
-        public getLookAheadCache():lang.HashTable<Function> {
-            return cache.getLookaheadFuncsForClass(this.className)
-        }
-
-        constructor(input:Token[] = []) {
-            super(input, <any>chevrotain.recognizer.lookahead.spec)
-            Parser.performSelfAnalysis(this)
-        }
-
-        public manyOptionsRule = this.RULE("manyOptionsRule", this.parseManyOptionsRule, () => { return "-666" })
+    constructor(input:Token[] = []) {
+        super(input, ALL_TOKENS)
+        Parser.performSelfAnalysis(this)
+    }
 
-        private parseManyOptionsRule():string {
-            let total = ""
+    public manyOptionsRule = this.RULE("manyOptionsRule", this.parseManyOptionsRule, () => { return "-666" })
 
-            this.OPTION1(isOneTok, () => {
-                this.CONSUME1(OneTok)
-                total += "1"
-            })
+    private parseManyOptionsRule():string {
+        let total = ""
 
-            this.OPTION2(isTwoTok, () => {
-                this.CONSUME1(TwoTok)
-                total += "2"
-            })
+        this.OPTION1(() => {
+            this.CONSUME1(OneTok)
+            total += "1"
+        })
 
-            this.OPTION3(isThreeTok, () => {
-                this.CONSUME1(ThreeTok)
-                total += "3"
-            })
+        this.OPTION2(() => {
+            this.CONSUME1(TwoTok)
+            total += "2"
+        })
 
-            this.OPTION4(isFourTok, () => {
-                this.CONSUME1(FourTok)
-                total += "4"
-            })
+        this.OPTION3(() => {
+            this.CONSUME1(ThreeTok)
+            total += "3"
+        })
 
-            this.OPTION5(isFiveTok, () => {
-                this.CONSUME1(FiveTok)
-                total += "5"
-            })
+        this.OPTION4(() => {
+            this.CONSUME1(FourTok)
+            total += "4"
+        })
 
-            return total
-        }
-    }
+        this.OPTION5(() => {
+            this.CONSUME1(FiveTok)
+            total += "5"
+        })
 
-    function isOneTok():boolean {
-        return this.NEXT_TOKEN() instanceof OneTok
+        return total
     }
+}
 
-    function isTwoTok():boolean {
-        return this.NEXT_TOKEN() instanceof TwoTok
-    }
+class OptionsExplicitLookAheadParser extends Parser {
 
-    function isThreeTok():boolean {
-        return this.NEXT_TOKEN() instanceof ThreeTok
+    public getLookAheadCache():HashTable<Function> {
+        return getLookaheadFuncsForClass(this.className)
     }
 
-    function isFourTok():boolean {
-        return this.NEXT_TOKEN() instanceof FourTok
+    constructor(input:Token[] = []) {
+        super(input, ALL_TOKENS)
+        Parser.performSelfAnalysis(this)
     }
 
-    function isFiveTok():boolean {
-        return this.NEXT_TOKEN() instanceof FiveTok
-    }
+    public manyOptionsRule = this.RULE("manyOptionsRule", this.parseManyOptionsRule, () => { return "-666" })
 
-    describe("The implicit lookahead calculation functionality of the Recognizer For OPTION", function () {
+    private parseManyOptionsRule():string {
+        let total = ""
 
-        it("will cache the generatedLookAhead functions BEFORE (check cache is clean)", function () {
-            let parser = new OptionsImplicitLookAheadParser()
-            let lookaheadCache = parser.getLookAheadCache()
-            expect(lookaheadCache.keys().length).to.equal(0)
+        this.OPTION1(isOneTok, () => {
+            this.CONSUME1(OneTok)
+            total += "1"
         })
 
-        it("can automatically compute lookahead for OPTION1", function () {
-            let input = [new OneTok()]
-            let parser = new OptionsImplicitLookAheadParser(input)
-            expect(parser.manyOptionsRule()).to.equal("1")
+        this.OPTION2(isTwoTok, () => {
+            this.CONSUME1(TwoTok)
+            total += "2"
         })
 
-        it("can automatically compute lookahead for OPTION2", function () {
-            let input = [new TwoTok()]
-            let parser = new OptionsImplicitLookAheadParser(input)
-            expect(parser.manyOptionsRule()).to.equal("2")
+        this.OPTION3(isThreeTok, () => {
+            this.CONSUME1(ThreeTok)
+            total += "3"
         })
 
-        it("can automatically compute lookahead for OPTION3", function () {
-            let input = [new ThreeTok()]
-            let parser = new OptionsImplicitLookAheadParser(input)
-            expect(parser.manyOptionsRule()).to.equal("3")
+        this.OPTION4(isFourTok, () => {
+            this.CONSUME1(FourTok)
+            total += "4"
         })
 
-        it("can automatically compute lookahead for OPTION4", function () {
-            let input = [new FourTok()]
-            let parser = new OptionsImplicitLookAheadParser(input)
-            expect(parser.manyOptionsRule()).to.equal("4")
+        this.OPTION5(isFiveTok, () => {
+            this.CONSUME1(FiveTok)
+            total += "5"
         })
 
-        it("can automatically compute lookahead for OPTION5", function () {
-            let input = [new FiveTok()]
-            let parser = new OptionsImplicitLookAheadParser(input)
-            expect(parser.manyOptionsRule()).to.equal("5")
-        })
+        return total
+    }
+}
 
-        it("will cache the generatedLookAhead functions AFTER (check cache is filled)", function () {
-            let parser = new OptionsImplicitLookAheadParser()
-            let lookaheadCache = parser.getLookAheadCache()
-            expect(lookaheadCache.keys().length).to.equal(5)
-        })
-    })
+function isOneTok():boolean {
+    return this.NEXT_TOKEN() instanceof OneTok
+}
 
+function isTwoTok():boolean {
+    return this.NEXT_TOKEN() instanceof TwoTok
+}
 
-    describe("The Explicit lookahead functionality of the Recognizer for OPTION", function () {
+function isThreeTok():boolean {
+    return this.NEXT_TOKEN() instanceof ThreeTok
+}
 
-        it("can accept lookahead function param for OPTION1", function () {
-            let input = [new OneTok()]
-            let parser = new OptionsExplicitLookAheadParser(input)
-            expect(parser.manyOptionsRule()).to.equal("1")
-        })
+function isFourTok():boolean {
+    return this.NEXT_TOKEN() instanceof FourTok
+}
 
-        it("can accept lookahead function param for OPTION2", function () {
-            let input = [new TwoTok()]
-            let parser = new OptionsExplicitLookAheadParser(input)
-            expect(parser.manyOptionsRule()).to.equal("2")
-        })
+function isFiveTok():boolean {
+    return this.NEXT_TOKEN() instanceof FiveTok
+}
 
-        it("can accept lookahead function param for OPTION3", function () {
-            let input = [new ThreeTok()]
-            let parser = new OptionsExplicitLookAheadParser(input)
-            expect(parser.manyOptionsRule()).to.equal("3")
-        })
+describe("The implicit lookahead calculation functionality of the Recognizer For OPTION", function () {
 
-        it("can accept lookahead function param for OPTION4", function () {
-            let input = [new FourTok()]
-            let parser = new OptionsExplicitLookAheadParser(input)
-            expect(parser.manyOptionsRule()).to.equal("4")
-        })
+    it("will cache the generatedLookAhead functions BEFORE (check cache is clean)", function () {
+        let parser = new OptionsImplicitLookAheadParser()
+        let lookaheadCache = parser.getLookAheadCache()
+        expect(lookaheadCache.keys().length).to.equal(0)
+    })
 
-        it("can accept lookahead function param for OPTION5", function () {
-            let input = [new FiveTok()]
-            let parser = new OptionsExplicitLookAheadParser(input)
-            expect(parser.manyOptionsRule()).to.equal("5")
-        })
+    it("can automatically compute lookahead for OPTION1", function () {
+        let input = [new OneTok()]
+        let parser = new OptionsImplicitLookAheadParser(input)
+        expect(parser.manyOptionsRule()).to.equal("1")
+    })
 
-        it("Will not cache any ImplicitLookahead functions", function () {
-            let parser = new OptionsExplicitLookAheadParser()
-            let lookaheadCache = parser.getLookAheadCache()
-            expect(lookaheadCache.keys().length).to.equal(0)
-        })
+    it("can automatically compute lookahead for OPTION2", function () {
+        let input = [new TwoTok()]
+        let parser = new OptionsImplicitLookAheadParser(input)
+        expect(parser.manyOptionsRule()).to.equal("2")
     })
 
+    it("can automatically compute lookahead for OPTION3", function () {
+        let input = [new ThreeTok()]
+        let parser = new OptionsImplicitLookAheadParser(input)
+        expect(parser.manyOptionsRule()).to.equal("3")
+    })
 
-    class ManyImplicitLookAheadParser extends Parser {
+    it("can automatically compute lookahead for OPTION4", function () {
+        let input = [new FourTok()]
+        let parser = new OptionsImplicitLookAheadParser(input)
+        expect(parser.manyOptionsRule()).to.equal("4")
+    })
 
-        public getLookAheadCache():lang.HashTable<Function> {
-            return cache.getLookaheadFuncsForClass(this.className)
-        }
+    it("can automatically compute lookahead for OPTION5", function () {
+        let input = [new FiveTok()]
+        let parser = new OptionsImplicitLookAheadParser(input)
+        expect(parser.manyOptionsRule()).to.equal("5")
+    })
 
-        constructor(input:Token[] = []) {
-            super(input, <any>chevrotain.recognizer.lookahead.spec)
-            Parser.performSelfAnalysis(this)
-        }
+    it("will cache the generatedLookAhead functions AFTER (check cache is filled)", function () {
+        let parser = new OptionsImplicitLookAheadParser()
+        let lookaheadCache = parser.getLookAheadCache()
+        expect(lookaheadCache.keys().length).to.equal(5)
+    })
+})
 
-        public manyRule = this.RULE("manyRule", this.parseManyRule, () => { return "-666" })
 
-        private parseManyRule():string {
-            let total = ""
+describe("The Explicit lookahead functionality of the Recognizer for OPTION", function () {
 
-            this.MANY1(() => {
-                this.CONSUME1(OneTok)
-                total += "1"
-            })
+    it("can accept lookahead function param for OPTION1", function () {
+        let input = [new OneTok()]
+        let parser = new OptionsExplicitLookAheadParser(input)
+        expect(parser.manyOptionsRule()).to.equal("1")
+    })
 
-            this.MANY2(() => {
-                this.CONSUME1(TwoTok)
-                total += "2"
-            })
+    it("can accept lookahead function param for OPTION2", function () {
+        let input = [new TwoTok()]
+        let parser = new OptionsExplicitLookAheadParser(input)
+        expect(parser.manyOptionsRule()).to.equal("2")
+    })
 
-            this.MANY3(() => {
-                this.CONSUME1(ThreeTok)
-                total += "3"
-            })
+    it("can accept lookahead function param for OPTION3", function () {
+        let input = [new ThreeTok()]
+        let parser = new OptionsExplicitLookAheadParser(input)
+        expect(parser.manyOptionsRule()).to.equal("3")
+    })
 
-            this.MANY4(() => {
-                this.CONSUME1(FourTok)
-                total += "4"
-            })
+    it("can accept lookahead function param for OPTION4", function () {
+        let input = [new FourTok()]
+        let parser = new OptionsExplicitLookAheadParser(input)
+        expect(parser.manyOptionsRule()).to.equal("4")
+    })
 
-            this.MANY5(() => {
-                this.CONSUME1(FiveTok)
-                total += "5"
-            })
+    it("can accept lookahead function param for OPTION5", function () {
+        let input = [new FiveTok()]
+        let parser = new OptionsExplicitLookAheadParser(input)
+        expect(parser.manyOptionsRule()).to.equal("5")
+    })
 
-            return total
-        }
+    it("Will not cache any ImplicitLookahead functions", function () {
+        let parser = new OptionsExplicitLookAheadParser()
+        let lookaheadCache = parser.getLookAheadCache()
+        expect(lookaheadCache.keys().length).to.equal(0)
+    })
+})
+
+
+class ManyImplicitLookAheadParser extends Parser {
+
+    public getLookAheadCache():HashTable<Function> {
+        return getLookaheadFuncsForClass(this.className)
     }
 
-    class ManyExplicitLookAheadParser extends Parser {
+    constructor(input:Token[] = []) {
+        super(input, ALL_TOKENS)
+        Parser.performSelfAnalysis(this)
+    }
 
-        public getLookAheadCache():lang.HashTable<Function> {
-            return cache.getLookaheadFuncsForClass(this.className)
-        }
+    public manyRule = this.RULE("manyRule", this.parseManyRule, () => { return "-666" })
 
-        constructor(input:Token[] = []) {
-            super(input, <any>chevrotain.recognizer.lookahead.spec)
-            Parser.performSelfAnalysis(this)
-        }
+    private parseManyRule():string {
+        let total = ""
 
-        public manyRule = this.RULE("manyRule", this.parseManyRule, () => { return "-666" })
+        this.MANY1(() => {
+            this.CONSUME1(OneTok)
+            total += "1"
+        })
 
-        private parseManyRule():string {
-            let total = ""
+        this.MANY2(() => {
+            this.CONSUME1(TwoTok)
+            total += "2"
+        })
 
-            this.MANY1(isOneTok, () => {
-                this.CONSUME1(OneTok)
-                total += "1"
-            })
+        this.MANY3(() => {
+            this.CONSUME1(ThreeTok)
+            total += "3"
+        })
 
-            this.MANY2(isTwoTok, () => {
-                this.CONSUME1(TwoTok)
-                total += "2"
-            })
+        this.MANY4(() => {
+            this.CONSUME1(FourTok)
+            total += "4"
+        })
 
-            this.MANY3(isThreeTok, () => {
-                this.CONSUME1(ThreeTok)
-                total += "3"
-            })
+        this.MANY5(() => {
+            this.CONSUME1(FiveTok)
+            total += "5"
+        })
 
-            this.MANY4(isFourTok, () => {
-                this.CONSUME1(FourTok)
-                total += "4"
-            })
+        return total
+    }
+}
 
-            this.MANY5(isFiveTok, () => {
-                this.CONSUME1(FiveTok)
-                total += "5"
-            })
+class ManyExplicitLookAheadParser extends Parser {
 
-            return total
-        }
+    public getLookAheadCache():HashTable<Function> {
+        return getLookaheadFuncsForClass(this.className)
     }
 
-    describe("The implicit lookahead calculation functionality of the Recognizer For MANY", function () {
+    constructor(input:Token[] = []) {
+        super(input, ALL_TOKENS)
+        Parser.performSelfAnalysis(this)
+    }
 
-        it("will cache the generatedLookAhead functions BEFORE (check cache is clean)", function () {
-            let parser = new ManyImplicitLookAheadParser()
-            let lookaheadCache = parser.getLookAheadCache()
-            expect(lookaheadCache.keys().length).to.equal(0)
-        })
+    public manyRule = this.RULE("manyRule", this.parseManyRule, () => { return "-666" })
 
-        it("can automatically compute lookahead for MANY1", function () {
-            let input = [new OneTok()]
-            let parser = new ManyImplicitLookAheadParser(input)
-            expect(parser.manyRule()).to.equal("1")
-        })
+    private parseManyRule():string {
+        let total = ""
 
-        it("can automatically compute lookahead for MANY2", function () {
-            let input = [new TwoTok()]
-            let parser = new ManyImplicitLookAheadParser(input)
-            expect(parser.manyRule()).to.equal("2")
+        this.MANY1(isOneTok, () => {
+            this.CONSUME1(OneTok)
+            total += "1"
         })
 
-        it("can automatically compute lookahead for MANY3", function () {
-            let input = [new ThreeTok()]
-            let parser = new ManyImplicitLookAheadParser(input)
-            expect(parser.manyRule()).to.equal("3")
+        this.MANY2(isTwoTok, () => {
+            this.CONSUME1(TwoTok)
+            total += "2"
         })
 
-        it("can automatically compute lookahead for MANY4", function () {
-            let input = [new FourTok()]
-            let parser = new ManyImplicitLookAheadParser(input)
-            expect(parser.manyRule()).to.equal("4")
+        this.MANY3(isThreeTok, () => {
+            this.CONSUME1(ThreeTok)
+            total += "3"
         })
 
-        it("can automatically compute lookahead for MANY5", function () {
-            let input = [new FiveTok()]
-            let parser = new ManyImplicitLookAheadParser(input)
-            expect(parser.manyRule()).to.equal("5")
+        this.MANY4(isFourTok, () => {
+            this.CONSUME1(FourTok)
+            total += "4"
         })
 
-        it("can accept lookahead function param for flow mixing several MANYs", function () {
-            let input = [new OneTok(), new OneTok(), new ThreeTok(), new ThreeTok(), new ThreeTok(), new FiveTok()]
-            let parser = new ManyImplicitLookAheadParser(input)
-            expect(parser.manyRule()).to.equal("113335")
+        this.MANY5(isFiveTok, () => {
+            this.CONSUME1(FiveTok)
+            total += "5"
         })
 
-        it("will cache the generatedLookAhead functions AFTER (check cache is filled)", function () {
-            let parser = new ManyImplicitLookAheadParser()
-            let lookaheadCache = parser.getLookAheadCache()
-            expect(lookaheadCache.keys().length).to.equal(5)
-        })
-    })
+        return total
+    }
+}
 
+describe("The implicit lookahead calculation functionality of the Recognizer For MANY", function () {
 
-    describe("The Explicit lookahead functionality of the Recognizer for MANY", function () {
+    it("will cache the generatedLookAhead functions BEFORE (check cache is clean)", function () {
+        let parser = new ManyImplicitLookAheadParser()
+        let lookaheadCache = parser.getLookAheadCache()
+        expect(lookaheadCache.keys().length).to.equal(0)
+    })
 
-        it("can accept lookahead function param for MANY1", function () {
-            let input = [new OneTok()]
-            let parser = new ManyExplicitLookAheadParser(input)
-            expect(parser.manyRule()).to.equal("1")
-        })
+    it("can automatically compute lookahead for MANY1", function () {
+        let input = [new OneTok()]
+        let parser = new ManyImplicitLookAheadParser(input)
+        expect(parser.manyRule()).to.equal("1")
+    })
 
-        it("can accept lookahead function param for MANY2", function () {
-            let input = [new TwoTok()]
-            let parser = new ManyExplicitLookAheadParser(input)
-            expect(parser.manyRule()).to.equal("2")
-        })
+    it("can automatically compute lookahead for MANY2", function () {
+        let input = [new TwoTok()]
+        let parser = new ManyImplicitLookAheadParser(input)
+        expect(parser.manyRule()).to.equal("2")
+    })
 
-        it("can accept lookahead function param for MANY3", function () {
-            let input = [new ThreeTok()]
-            let parser = new ManyExplicitLookAheadParser(input)
-            expect(parser.manyRule()).to.equal("3")
-        })
+    it("can automatically compute lookahead for MANY3", function () {
+        let input = [new ThreeTok()]
+        let parser = new ManyImplicitLookAheadParser(input)
+        expect(parser.manyRule()).to.equal("3")
+    })
 
-        it("can accept lookahead function param for MANY4", function () {
-            let input = [new FourTok()]
-            let parser = new ManyExplicitLookAheadParser(input)
-            expect(parser.manyRule()).to.equal("4")
-        })
+    it("can automatically compute lookahead for MANY4", function () {
+        let input = [new FourTok()]
+        let parser = new ManyImplicitLookAheadParser(input)
+        expect(parser.manyRule()).to.equal("4")
+    })
 
-        it("can accept lookahead function param for MANY5", function () {
-            let input = [new FiveTok()]
-            let parser = new ManyExplicitLookAheadParser(input)
-            expect(parser.manyRule()).to.equal("5")
-        })
+    it("can automatically compute lookahead for MANY5", function () {
+        let input = [new FiveTok()]
+        let parser = new ManyImplicitLookAheadParser(input)
+        expect(parser.manyRule()).to.equal("5")
+    })
 
-        it("can accept lookahead function param for flow mixing several MANYs", function () {
-            let input = [new OneTok(), new OneTok(), new ThreeTok(), new ThreeTok(), new ThreeTok(), new FiveTok()]
-            let parser = new ManyExplicitLookAheadParser(input)
-            expect(parser.manyRule()).to.equal("113335")
-        })
+    it("can accept lookahead function param for flow mixing several MANYs", function () {
+        let input = [new OneTok(), new OneTok(), new ThreeTok(), new ThreeTok(), new ThreeTok(), new FiveTok()]
+        let parser = new ManyImplicitLookAheadParser(input)
+        expect(parser.manyRule()).to.equal("113335")
+    })
 
-        it("Will not cache any ImplicitLookahead functions when provided with explicit versions", function () {
-            let parser = new ManyExplicitLookAheadParser()
-            let lookaheadCache = parser.getLookAheadCache()
-            expect(lookaheadCache.keys().length).to.equal(0)
-        })
+    it("will cache the generatedLookAhead functions AFTER (check cache is filled)", function () {
+        let parser = new ManyImplicitLookAheadParser()
+        let lookaheadCache = parser.getLookAheadCache()
+        expect(lookaheadCache.keys().length).to.equal(5)
     })
+})
 
 
-    class ManySepImplicitLookAheadParser extends Parser {
+describe("The Explicit lookahead functionality of the Recognizer for MANY", function () {
 
-        public getLookAheadCache():lang.HashTable<Function> {
-            return cache.getLookaheadFuncsForClass(this.className)
-        }
+    it("can accept lookahead function param for MANY1", function () {
+        let input = [new OneTok()]
+        let parser = new ManyExplicitLookAheadParser(input)
+        expect(parser.manyRule()).to.equal("1")
+    })
 
-        constructor(input:Token[] = []) {
-            super(input, <any>chevrotain.recognizer.lookahead.spec)
-            Parser.performSelfAnalysis(this)
-        }
+    it("can accept lookahead function param for MANY2", function () {
+        let input = [new TwoTok()]
+        let parser = new ManyExplicitLookAheadParser(input)
+        expect(parser.manyRule()).to.equal("2")
+    })
 
-        public manySepRule = this.RULE("manySepRule", this.parseManyRule, () => { return {total: 666, separators: []} })
+    it("can accept lookahead function param for MANY3", function () {
+        let input = [new ThreeTok()]
+        let parser = new ManyExplicitLookAheadParser(input)
+        expect(parser.manyRule()).to.equal("3")
+    })
 
-        private parseManyRule():any {
+    it("can accept lookahead function param for MANY4", function () {
+        let input = [new FourTok()]
+        let parser = new ManyExplicitLookAheadParser(input)
+        expect(parser.manyRule()).to.equal("4")
+    })
 
-            let total = ""
-            let separators = []
+    it("can accept lookahead function param for MANY5", function () {
+        let input = [new FiveTok()]
+        let parser = new ManyExplicitLookAheadParser(input)
+        expect(parser.manyRule()).to.equal("5")
+    })
 
-            separators = separators.concat(this.MANY_SEP1(Comma, () => {
-                this.CONSUME1(OneTok)
-                total += "1"
-            }))
+    it("can accept lookahead function param for flow mixing several MANYs", function () {
+        let input = [new OneTok(), new OneTok(), new ThreeTok(), new ThreeTok(), new ThreeTok(), new FiveTok()]
+        let parser = new ManyExplicitLookAheadParser(input)
+        expect(parser.manyRule()).to.equal("113335")
+    })
 
-            separators = separators.concat(this.MANY_SEP2(Comma, () => {
-                this.CONSUME1(TwoTok)
-                total += "2"
-            }))
+    it("Will not cache any ImplicitLookahead functions when provided with explicit versions", function () {
+        let parser = new ManyExplicitLookAheadParser()
+        let lookaheadCache = parser.getLookAheadCache()
+        expect(lookaheadCache.keys().length).to.equal(0)
+    })
+})
 
-            separators = separators.concat(this.MANY_SEP3(Comma, () => {
-                this.CONSUME1(ThreeTok)
-                total += "3"
-            }))
 
-            separators = separators.concat(this.MANY_SEP4(Comma, () => {
-                this.CONSUME1(FourTok)
-                total += "4"
-            }))
+class ManySepImplicitLookAheadParser extends Parser {
 
-            separators = separators.concat(this.MANY_SEP5(Comma, () => {
-                this.CONSUME1(FiveTok)
-                total += "5"
-            }))
+    public getLookAheadCache():HashTable<Function> {
+        return getLookaheadFuncsForClass(this.className)
+    }
 
-            return {total: total, separators: separators}
-        }
+    constructor(input:Token[] = []) {
+        super(input, ALL_TOKENS)
+        Parser.performSelfAnalysis(this)
     }
 
-    class ManySepExplicitLookAheadParser extends Parser {
+    public manySepRule = this.RULE("manySepRule", this.parseManyRule, () => { return {total: 666, separators: []} })
 
-        public getLookAheadCache():lang.HashTable<Function> {
-            return cache.getLookaheadFuncsForClass(this.className)
-        }
+    private parseManyRule():any {
 
-        constructor(input:Token[] = []) {
-            super(input, <any>chevrotain.recognizer.lookahead.spec)
-            Parser.performSelfAnalysis(this)
-        }
+        let total = ""
+        let separators = []
 
-        public manySepRule = this.RULE("manySepRule", this.parseManyRule, () => { return "-666" })
+        separators = separators.concat(this.MANY_SEP1(Comma, () => {
+            this.CONSUME1(OneTok)
+            total += "1"
+        }))
 
-        private parseManyRule():string {
-            let total = ""
+        separators = separators.concat(this.MANY_SEP2(Comma, () => {
+            this.CONSUME1(TwoTok)
+            total += "2"
+        }))
 
-            this.MANY_SEP1(Comma, isOneTok, () => {
-                this.CONSUME1(OneTok)
-                total += "1"
-            })
+        separators = separators.concat(this.MANY_SEP3(Comma, () => {
+            this.CONSUME1(ThreeTok)
+            total += "3"
+        }))
 
-            this.MANY_SEP2(Comma, isTwoTok, () => {
-                this.CONSUME1(TwoTok)
-                total += "2"
-            })
+        separators = separators.concat(this.MANY_SEP4(Comma, () => {
+            this.CONSUME1(FourTok)
+            total += "4"
+        }))
 
-            this.MANY_SEP3(Comma, isThreeTok, () => {
-                this.CONSUME1(ThreeTok)
-                total += "3"
-            })
+        separators = separators.concat(this.MANY_SEP5(Comma, () => {
+            this.CONSUME1(FiveTok)
+            total += "5"
+        }))
 
-            this.MANY_SEP4(Comma, isFourTok, () => {
-                this.CONSUME1(FourTok)
-                total += "4"
-            })
+        return {total: total, separators: separators}
+    }
+}
 
-            this.MANY_SEP5(Comma, isFiveTok, () => {
-                this.CONSUME1(FiveTok)
-                total += "5"
-            })
+class ManySepExplicitLookAheadParser extends Parser {
 
-            return total
-        }
+    public getLookAheadCache():HashTable<Function> {
+        return getLookaheadFuncsForClass(this.className)
     }
 
-    describe("The implicit lookahead calculation functionality of the Recognizer For MANY_SEP", function () {
+    constructor(input:Token[] = []) {
+        super(input, ALL_TOKENS)
+        Parser.performSelfAnalysis(this)
+    }
 
-        it("will cache the generatedLookAhead functions BEFORE (check cache is clean)", function () {
-            let parser = new ManySepImplicitLookAheadParser()
-            let lookaheadCache = parser.getLookAheadCache()
-            expect(lookaheadCache.keys().length).to.equal(0)
-        })
+    public manySepRule = this.RULE("manySepRule", this.parseManyRule, () => { return "-666" })
 
-        it("can automatically compute lookahead for MANY_SEP1", function () {
-            let input = [new OneTok()]
-            let parser = new ManySepImplicitLookAheadParser(input)
-            expect(parser.manySepRule().total).to.equal("1")
-        })
+    private parseManyRule():string {
+        let total = ""
 
-        it("can automatically compute lookahead for MANY_SEP2", function () {
-            let input = [new TwoTok()]
-            let parser = new ManySepImplicitLookAheadParser(input)
-            expect(parser.manySepRule().total).to.equal("2")
+        this.MANY_SEP1(Comma, isOneTok, () => {
+            this.CONSUME1(OneTok)
+            total += "1"
         })
 
-        it("can automatically compute lookahead for MANY_SEP3", function () {
-            let input = [new ThreeTok()]
-            let parser = new ManySepImplicitLookAheadParser(input)
-            expect(parser.manySepRule().total).to.equal("3")
+        this.MANY_SEP2(Comma, isTwoTok, () => {
+            this.CONSUME1(TwoTok)
+            total += "2"
         })
 
-        it("can automatically compute lookahead for MANY_SEP4", function () {
-            let input = [new FourTok()]
-            let parser = new ManySepImplicitLookAheadParser(input)
-            expect(parser.manySepRule().total).to.equal("4")
+        this.MANY_SEP3(Comma, isThreeTok, () => {
+            this.CONSUME1(ThreeTok)
+            total += "3"
         })
 
-        it("can automatically compute lookahead for MANY_SEP5", function () {
-            let input = [new FiveTok()]
-            let parser = new ManySepImplicitLookAheadParser(input)
-            expect(parser.manySepRule().total).to.equal("5")
+        this.MANY_SEP4(Comma, isFourTok, () => {
+            this.CONSUME1(FourTok)
+            total += "4"
         })
 
-        it("can accept lookahead function param for flow mixing several MANY_SEPs", function () {
-            let input = [new OneTok(), new Comma(), new OneTok(), new ThreeTok(), new Comma(),
-                new ThreeTok(), new Comma(), new ThreeTok(), new FiveTok()]
-            let parser = new ManySepImplicitLookAheadParser(input)
-            let result = parser.manySepRule()
-            expect(result.total).to.equal("113335")
-            expect(result.separators).to.have.length(3)
-            expect(result.separators).to.deep.equal([new Comma(), new Comma(), new Comma()])
+        this.MANY_SEP5(Comma, isFiveTok, () => {
+            this.CONSUME1(FiveTok)
+            total += "5"
         })
 
-        it("will cache the generatedLookAhead functions AFTER (check cache is filled)", function () {
-            let parser = new ManySepImplicitLookAheadParser()
-            let lookaheadCache = parser.getLookAheadCache()
-            expect(lookaheadCache.keys().length).to.equal(5)
-        })
+        return total
+    }
+}
+
+describe("The implicit lookahead calculation functionality of the Recognizer For MANY_SEP", function () {
+
+    it("will cache the generatedLookAhead functions BEFORE (check cache is clean)", function () {
+        let parser = new ManySepImplicitLookAheadParser()
+        let lookaheadCache = parser.getLookAheadCache()
+        expect(lookaheadCache.keys().length).to.equal(0)
     })
 
+    it("can automatically compute lookahead for MANY_SEP1", function () {
+        let input = [new OneTok()]
+        let parser = new ManySepImplicitLookAheadParser(input)
+        expect(parser.manySepRule().total).to.equal("1")
+    })
 
-    describe("The Explicit lookahead functionality of the Recognizer for MANY", function () {
+    it("can automatically compute lookahead for MANY_SEP2", function () {
+        let input = [new TwoTok()]
+        let parser = new ManySepImplicitLookAheadParser(input)
+        expect(parser.manySepRule().total).to.equal("2")
+    })
 
-        it("can accept lookahead function param for MANY1", function () {
-            let input = [new OneTok()]
-            let parser = new ManySepExplicitLookAheadParser(input)
-            expect(parser.manySepRule()).to.equal("1")
-        })
+    it("can automatically compute lookahead for MANY_SEP3", function () {
+        let input = [new ThreeTok()]
+        let parser = new ManySepImplicitLookAheadParser(input)
+        expect(parser.manySepRule().total).to.equal("3")
+    })
 
-        it("can accept lookahead function param for MANY2", function () {
-            let input = [new TwoTok()]
-            let parser = new ManySepExplicitLookAheadParser(input)
-            expect(parser.manySepRule()).to.equal("2")
-        })
+    it("can automatically compute lookahead for MANY_SEP4", function () {
+        let input = [new FourTok()]
+        let parser = new ManySepImplicitLookAheadParser(input)
+        expect(parser.manySepRule().total).to.equal("4")
+    })
 
-        it("can accept lookahead function param for MANY3", function () {
-            let input = [new ThreeTok()]
-            let parser = new ManySepExplicitLookAheadParser(input)
-            expect(parser.manySepRule()).to.equal("3")
-        })
+    it("can automatically compute lookahead for MANY_SEP5", function () {
+        let input = [new FiveTok()]
+        let parser = new ManySepImplicitLookAheadParser(input)
+        expect(parser.manySepRule().total).to.equal("5")
+    })
 
-        it("can accept lookahead function param for MANY4", function () {
-            let input = [new FourTok()]
-            let parser = new ManySepExplicitLookAheadParser(input)
-            expect(parser.manySepRule()).to.equal("4")
-        })
+    it("can accept lookahead function param for flow mixing several MANY_SEPs", function () {
+        let input = [new OneTok(), new Comma(), new OneTok(), new ThreeTok(), new Comma(),
+            new ThreeTok(), new Comma(), new ThreeTok(), new FiveTok()]
+        let parser = new ManySepImplicitLookAheadParser(input)
+        let result = parser.manySepRule()
+        expect(result.total).to.equal("113335")
+        expect(result.separators).to.have.length(3)
+        expect(result.separators).to.deep.equal([new Comma(), new Comma(), new Comma()])
+    })
 
-        it("can accept lookahead function param for MANY5", function () {
-            let input = [new FiveTok()]
-            let parser = new ManySepExplicitLookAheadParser(input)
-            expect(parser.manySepRule()).to.equal("5")
-        })
+    it("will cache the generatedLookAhead functions AFTER (check cache is filled)", function () {
+        let parser = new ManySepImplicitLookAheadParser()
+        let lookaheadCache = parser.getLookAheadCache()
+        expect(lookaheadCache.keys().length).to.equal(5)
+    })
+})
 
-        it("can accept lookahead function param for flow mixing several MANYs", function () {
-            let input = [new OneTok(), new Comma(), new OneTok(), new ThreeTok(), new Comma(),
-                new ThreeTok(), new Comma(), new ThreeTok(), new FiveTok()]
-            let parser = new ManySepExplicitLookAheadParser(input)
-            expect(parser.manySepRule()).to.equal("113335")
-        })
 
-        it("Will not cache any ImplicitLookahead functions when provided with explicit versions", function () {
-            let parser = new ManySepExplicitLookAheadParser()
-            let lookaheadCache = parser.getLookAheadCache()
-            expect(lookaheadCache.keys().length).to.equal(0)
-        })
+describe("The Explicit lookahead functionality of the Recognizer for MANY", function () {
+
+    it("can accept lookahead function param for MANY1", function () {
+        let input = [new OneTok()]
+        let parser = new ManySepExplicitLookAheadParser(input)
+        expect(parser.manySepRule()).to.equal("1")
     })
 
+    it("can accept lookahead function param for MANY2", function () {
+        let input = [new TwoTok()]
+        let parser = new ManySepExplicitLookAheadParser(input)
+        expect(parser.manySepRule()).to.equal("2")
+    })
 
-    class AtLeastOneImplicitLookAheadParser extends Parser {
+    it("can accept lookahead function param for MANY3", function () {
+        let input = [new ThreeTok()]
+        let parser = new ManySepExplicitLookAheadParser(input)
+        expect(parser.manySepRule()).to.equal("3")
+    })
 
-        public getLookAheadCache():lang.HashTable<Function> {
-            return cache.getLookaheadFuncsForClass(this.className)
-        }
+    it("can accept lookahead function param for MANY4", function () {
+        let input = [new FourTok()]
+        let parser = new ManySepExplicitLookAheadParser(input)
+        expect(parser.manySepRule()).to.equal("4")
+    })
 
-        constructor(input:Token[] = []) {
-            super(input, <any>chevrotain.recognizer.lookahead.spec)
-            Parser.performSelfAnalysis(this)
-        }
+    it("can accept lookahead function param for MANY5", function () {
+        let input = [new FiveTok()]
+        let parser = new ManySepExplicitLookAheadParser(input)
+        expect(parser.manySepRule()).to.equal("5")
+    })
+
+    it("can accept lookahead function param for flow mixing several MANYs", function () {
+        let input = [new OneTok(), new Comma(), new OneTok(), new ThreeTok(), new Comma(),
+            new ThreeTok(), new Comma(), new ThreeTok(), new FiveTok()]
+        let parser = new ManySepExplicitLookAheadParser(input)
+        expect(parser.manySepRule()).to.equal("113335")
+    })
+
+    it("Will not cache any ImplicitLookahead functions when provided with explicit versions", function () {
+        let parser = new ManySepExplicitLookAheadParser()
+        let lookaheadCache = parser.getLookAheadCache()
+        expect(lookaheadCache.keys().length).to.equal(0)
+    })
+})
 
-        public atLeastOneRule = this.RULE("atLeastOneRule", this.parseAtLeastOneRule, () => { return "-666" })
 
-        private parseAtLeastOneRule():string {
-            let total = ""
+class AtLeastOneImplicitLookAheadParser extends Parser {
 
-            this.AT_LEAST_ONE1(() => {
-                this.CONSUME1(OneTok)
-                total += "1"
-            }, "Ones")
+    public getLookAheadCache():HashTable<Function> {
+        return getLookaheadFuncsForClass(this.className)
+    }
 
-            this.AT_LEAST_ONE2(() => {
-                this.CONSUME1(TwoTok)
-                total += "2"
-            }, "Twos")
+    constructor(input:Token[] = []) {
+        super(input, ALL_TOKENS)
+        Parser.performSelfAnalysis(this)
+    }
 
-            this.AT_LEAST_ONE3(() => {
-                this.CONSUME1(ThreeTok)
-                total += "3"
-            }, "Threes")
+    public atLeastOneRule = this.RULE("atLeastOneRule", this.parseAtLeastOneRule, () => { return "-666" })
 
-            this.AT_LEAST_ONE4(() => {
-                this.CONSUME1(FourTok)
-                total += "4"
-            }, "Fours")
+    private parseAtLeastOneRule():string {
+        let total = ""
 
-            this.AT_LEAST_ONE5(() => {
-                this.CONSUME1(FiveTok)
-                total += "5"
-            }, "Fives")
+        this.AT_LEAST_ONE1(() => {
+            this.CONSUME1(OneTok)
+            total += "1"
+        }, "Ones")
 
-            return total
-        }
+        this.AT_LEAST_ONE2(() => {
+            this.CONSUME1(TwoTok)
+            total += "2"
+        }, "Twos")
+
+        this.AT_LEAST_ONE3(() => {
+            this.CONSUME1(ThreeTok)
+            total += "3"
+        }, "Threes")
+
+        this.AT_LEAST_ONE4(() => {
+            this.CONSUME1(FourTok)
+            total += "4"
+        }, "Fours")
+
+        this.AT_LEAST_ONE5(() => {
+            this.CONSUME1(FiveTok)
+            total += "5"
+        }, "Fives")
+
+        return total
     }
+}
 
-    class AtLeastOneExplicitLookAheadParser extends Parser {
+class AtLeastOneExplicitLookAheadParser extends Parser {
 
-        public getLookAheadCache():lang.HashTable<Function> {
-            return cache.getLookaheadFuncsForClass(this.className)
-        }
+    public getLookAheadCache():HashTable<Function> {
+        return getLookaheadFuncsForClass(this.className)
+    }
 
-        constructor(input:Token[] = []) {
-            super(input, <any>chevrotain.recognizer.lookahead.spec)
-            Parser.performSelfAnalysis(this)
-        }
+    constructor(input:Token[] = []) {
+        super(input, ALL_TOKENS)
+        Parser.performSelfAnalysis(this)
+    }
 
-        public atLeastOneRule = this.RULE("atLeastOneRule", this.parseAtLeastOneRule, () => { return "-666" })
+    public atLeastOneRule = this.RULE("atLeastOneRule", this.parseAtLeastOneRule, () => { return "-666" })
 
-        private parseAtLeastOneRule():string {
-            let total = ""
+    private parseAtLeastOneRule():string {
+        let total = ""
 
-            this.AT_LEAST_ONE1(isOneTok, () => {
-                this.CONSUME1(OneTok)
-                total += "1"
-            }, "Ones")
+        this.AT_LEAST_ONE1(isOneTok, () => {
+            this.CONSUME1(OneTok)
+            total += "1"
+        }, "Ones")
 
-            this.AT_LEAST_ONE2(isTwoTok, () => {
-                this.CONSUME1(TwoTok)
-                total += "2"
-            }, "Twos")
+        this.AT_LEAST_ONE2(isTwoTok, () => {
+            this.CONSUME1(TwoTok)
+            total += "2"
+        }, "Twos")
 
-            this.AT_LEAST_ONE3(isThreeTok, () => {
-                this.CONSUME1(ThreeTok)
-                total += "3"
-            }, "Threes")
+        this.AT_LEAST_ONE3(isThreeTok, () => {
+            this.CONSUME1(ThreeTok)
+            total += "3"
+        }, "Threes")
 
-            this.AT_LEAST_ONE4(isFourTok, () => {
-                this.CONSUME1(FourTok)
-                total += "4"
-            }, "Fours")
+        this.AT_LEAST_ONE4(isFourTok, () => {
+            this.CONSUME1(FourTok)
+            total += "4"
+        }, "Fours")
 
-            this.AT_LEAST_ONE5(isFiveTok, () => {
-                this.CONSUME1(FiveTok)
-                total += "5"
-            }, "Fives")
+        this.AT_LEAST_ONE5(isFiveTok, () => {
+            this.CONSUME1(FiveTok)
+            total += "5"
+        }, "Fives")
 
-            return total
-        }
+        return total
     }
+}
 
-    describe("The implicit lookahead calculation functionality of the Recognizer For AT_LEAST_ONE", function () {
+describe("The implicit lookahead calculation functionality of the Recognizer For AT_LEAST_ONE", function () {
 
-        it("will cache the generatedLookAhead functions BEFORE (check cache is clean)", function () {
-            let parser = new AtLeastOneImplicitLookAheadParser()
-            let lookaheadCache = parser.getLookAheadCache()
-            expect(lookaheadCache.keys().length).to.equal(0)
-        })
+    it("will cache the generatedLookAhead functions BEFORE (check cache is clean)", function () {
+        let parser = new AtLeastOneImplicitLookAheadParser()
+        let lookaheadCache = parser.getLookAheadCache()
+        expect(lookaheadCache.keys().length).to.equal(0)
+    })
 
-        it("can accept lookahead function param for AT_LEAST_ONE1-5", function () {
-            let input = [new OneTok(), new TwoTok(), new TwoTok(), new ThreeTok(),
-                new FourTok(), new FourTok(), new FiveTok()]
-            let parser = new AtLeastOneImplicitLookAheadParser(input)
-            expect(parser.atLeastOneRule()).to.equal("1223445")
-        })
+    it("can accept lookahead function param for AT_LEAST_ONE1-5", function () {
+        let input = [new OneTok(), new TwoTok(), new TwoTok(), new ThreeTok(),
+            new FourTok(), new FourTok(), new FiveTok()]
+        let parser = new AtLeastOneImplicitLookAheadParser(input)
+        expect(parser.atLeastOneRule()).to.equal("1223445")
+    })
 
-        it("will fail when zero occurrences of AT_LEAST_ONE in input", function () {
-            let input = [new OneTok(), new TwoTok(), /*new ThreeTok(),*/ new FourTok(), new FiveTok()]
-            let parser = new AtLeastOneImplicitLookAheadParser(input)
-            expect(parser.atLeastOneRule()).to.equal("-666")
-        })
+    it("will fail when zero occurrences of AT_LEAST_ONE in input", function () {
+        let input = [new OneTok(), new TwoTok(), /*new ThreeTok(),*/ new FourTok(), new FiveTok()]
+        let parser = new AtLeastOneImplicitLookAheadParser(input)
+        expect(parser.atLeastOneRule()).to.equal("-666")
+    })
 
-        it("will cache the generatedLookAhead functions AFTER (check cache is filled)", function () {
-            let parser = new AtLeastOneImplicitLookAheadParser()
-            let lookaheadCache = parser.getLookAheadCache()
-            expect(lookaheadCache.keys().length).to.equal(5)
-        })
+    it("will cache the generatedLookAhead functions AFTER (check cache is filled)", function () {
+        let parser = new AtLeastOneImplicitLookAheadParser()
+        let lookaheadCache = parser.getLookAheadCache()
+        expect(lookaheadCache.keys().length).to.equal(5)
     })
+})
 
-    describe("The Explicit lookahead functionality of the Recognizer for AT_LEAST_ONE", function () {
+describe("The Explicit lookahead functionality of the Recognizer for AT_LEAST_ONE", function () {
 
-        it("can accept lookahead function param for AT_LEAST_ONE1-5", function () {
-            let input = [new OneTok(), new TwoTok(), new TwoTok(), new ThreeTok(),
-                new FourTok(), new FourTok(), new FiveTok()]
-            let parser = new AtLeastOneExplicitLookAheadParser(input)
-            expect(parser.atLeastOneRule()).to.equal("1223445")
-        })
+    it("can accept lookahead function param for AT_LEAST_ONE1-5", function () {
+        let input = [new OneTok(), new TwoTok(), new TwoTok(), new ThreeTok(),
+            new FourTok(), new FourTok(), new FiveTok()]
+        let parser = new AtLeastOneExplicitLookAheadParser(input)
+        expect(parser.atLeastOneRule()).to.equal("1223445")
+    })
 
-        it("will fail when zero occurrences of AT_LEAST_ONE in input", function () {
-            let input = [new OneTok(), new TwoTok(), /*new ThreeTok(),*/ new FourTok(), new FiveTok()]
-            let parser = new AtLeastOneExplicitLookAheadParser(input)
-            expect(parser.atLeastOneRule()).to.equal("-666")
-        })
+    it("will fail when zero occurrences of AT_LEAST_ONE in input", function () {
+        let input = [new OneTok(), new TwoTok(), /*new ThreeTok(),*/ new FourTok(), new FiveTok()]
+        let parser = new AtLeastOneExplicitLookAheadParser(input)
+        expect(parser.atLeastOneRule()).to.equal("-666")
+    })
 
-        it("Will not cache any ImplicitLookahead functions when provided with explicit versions", function () {
-            let parser = new AtLeastOneExplicitLookAheadParser()
-            let lookaheadCache = parser.getLookAheadCache()
-            expect(lookaheadCache.keys().length).to.equal(0)
-        })
+    it("Will not cache any ImplicitLookahead functions when provided with explicit versions", function () {
+        let parser = new AtLeastOneExplicitLookAheadParser()
+        let lookaheadCache = parser.getLookAheadCache()
+        expect(lookaheadCache.keys().length).to.equal(0)
     })
+})
 
 
-    class AtLeastOneSepImplicitLookAheadParser extends Parser {
+class AtLeastOneSepImplicitLookAheadParser extends Parser {
 
-        public getLookAheadCache():lang.HashTable<Function> {
-            return cache.getLookaheadFuncsForClass(this.className)
-        }
+    public getLookAheadCache():HashTable<Function> {
+        return getLookaheadFuncsForClass(this.className)
+    }
 
-        constructor(input:Token[] = []) {
-            super(input, <any>chevrotain.recognizer.lookahead.spec)
-            Parser.performSelfAnalysis(this)
-        }
+    constructor(input:Token[] = []) {
+        super(input, ALL_TOKENS)
+        Parser.performSelfAnalysis(this)
+    }
 
-        public atLeastOneSepRule = this.RULE("atLeastOneSepRule", this.parseAtLeastOneRule, () => {
-            return {
-                total:      "-666",
-                separators: []
-            }
-        })
+    public atLeastOneSepRule = this.RULE("atLeastOneSepRule", this.parseAtLeastOneRule, () => {
+        return {
+            total:      "-666",
+            separators: []
+        }
+    })
 
-        private parseAtLeastOneRule():any {
-            let total = ""
-            let separators = []
+    private parseAtLeastOneRule():any {
+        let total = ""
+        let separators = []
 
-            separators = separators.concat(this.AT_LEAST_ONE_SEP1(Comma, () => {
-                this.CONSUME1(OneTok)
-                total += "1"
-            }, "Ones"))
+        separators = separators.concat(this.AT_LEAST_ONE_SEP1(Comma, () => {
+            this.CONSUME1(OneTok)
+            total += "1"
+        }, "Ones"))
 
-            separators = separators.concat(this.AT_LEAST_ONE_SEP2(Comma, () => {
-                this.CONSUME1(TwoTok)
-                total += "2"
-            }, "Twos"))
+        separators = separators.concat(this.AT_LEAST_ONE_SEP2(Comma, () => {
+            this.CONSUME1(TwoTok)
+            total += "2"
+        }, "Twos"))
 
-            separators = separators.concat(this.AT_LEAST_ONE_SEP3(Comma, () => {
-                this.CONSUME1(ThreeTok)
-                total += "3"
-            }, "Threes"))
+        separators = separators.concat(this.AT_LEAST_ONE_SEP3(Comma, () => {
+            this.CONSUME1(ThreeTok)
+            total += "3"
+        }, "Threes"))
 
-            separators = separators.concat(this.AT_LEAST_ONE_SEP4(Comma, () => {
-                this.CONSUME1(FourTok)
-                total += "4"
-            }, "Fours"))
+        separators = separators.concat(this.AT_LEAST_ONE_SEP4(Comma, () => {
+            this.CONSUME1(FourTok)
+            total += "4"
+        }, "Fours"))
 
-            separators = separators.concat(this.AT_LEAST_ONE_SEP5(Comma, () => {
-                this.CONSUME1(FiveTok)
-                total += "5"
-            }, "Fives"))
+        separators = separators.concat(this.AT_LEAST_ONE_SEP5(Comma, () => {
+            this.CONSUME1(FiveTok)
+            total += "5"
+        }, "Fives"))
 
-            return {total: total, separators: separators}
-        }
+        return {total: total, separators: separators}
     }
+}
 
-    class AtLeastOneSepExplicitLookAheadParser extends Parser {
+class AtLeastOneSepExplicitLookAheadParser extends Parser {
 
-        public getLookAheadCache():lang.HashTable<Function> {
-            return cache.getLookaheadFuncsForClass(this.className)
-        }
+    public getLookAheadCache():HashTable<Function> {
+        return getLookaheadFuncsForClass(this.className)
+    }
 
-        constructor(input:Token[] = []) {
-            super(input, <any>chevrotain.recognizer.lookahead.spec)
-            Parser.performSelfAnalysis(this)
-        }
+    constructor(input:Token[] = []) {
+        super(input, ALL_TOKENS)
+        Parser.performSelfAnalysis(this)
+    }
 
-        public atLeastOneSepRule = this.RULE("atLeastOneSepRule", this.parseAtLeastOneSepRule, () => { return "-666" })
+    public atLeastOneSepRule = this.RULE("atLeastOneSepRule", this.parseAtLeastOneSepRule, () => { return "-666" })
 
-        private parseAtLeastOneSepRule():string {
-            let total = ""
+    private parseAtLeastOneSepRule():string {
+        let total = ""
 
-            this.AT_LEAST_ONE_SEP1(Comma, isOneTok, () => {
-                this.CONSUME1(OneTok)
-                total += "1"
-            }, "Ones")
+        this.AT_LEAST_ONE_SEP1(Comma, isOneTok, () => {
+            this.CONSUME1(OneTok)
+            total += "1"
+        }, "Ones")
 
-            this.AT_LEAST_ONE_SEP2(Comma, isTwoTok, () => {
-                this.CONSUME1(TwoTok)
-                total += "2"
-            }, "Twos")
+        this.AT_LEAST_ONE_SEP2(Comma, isTwoTok, () => {
+            this.CONSUME1(TwoTok)
+            total += "2"
+        }, "Twos")
 
-            this.AT_LEAST_ONE_SEP3(Comma, isThreeTok, () => {
-                this.CONSUME1(ThreeTok)
-                total += "3"
-            }, "Threes")
+        this.AT_LEAST_ONE_SEP3(Comma, isThreeTok, () => {
+            this.CONSUME1(ThreeTok)
+            total += "3"
+        }, "Threes")
 
-            this.AT_LEAST_ONE_SEP4(Comma, isFourTok, () => {
-                this.CONSUME1(FourTok)
-                total += "4"
-            }, "Fours")
+        this.AT_LEAST_ONE_SEP4(Comma, isFourTok, () => {
+            this.CONSUME1(FourTok)
+            total += "4"
+        }, "Fours")
 
-            this.AT_LEAST_ONE_SEP5(Comma, isFiveTok, () => {
-                this.CONSUME1(FiveTok)
-                total += "5"
-            }, "Fives")
+        this.AT_LEAST_ONE_SEP5(Comma, isFiveTok, () => {
+            this.CONSUME1(FiveTok)
+            total += "5"
+        }, "Fives")
 
-            return total
-        }
+        return total
     }
+}
 
-    describe("The implicit lookahead calculation functionality of the Recognizer For AT_LEAST_ONE_SEP", function () {
+describe("The implicit lookahead calculation functionality of the Recognizer For AT_LEAST_ONE_SEP", function () {
 
-        it("will cache the generatedLookAhead functions BEFORE (check cache is clean)", function () {
-            let parser = new AtLeastOneSepImplicitLookAheadParser()
-            let lookaheadCache = parser.getLookAheadCache()
-            expect(lookaheadCache.keys().length).to.equal(0)
-        })
+    it("will cache the generatedLookAhead functions BEFORE (check cache is clean)", function () {
+        let parser = new AtLeastOneSepImplicitLookAheadParser()
+        let lookaheadCache = parser.getLookAheadCache()
+        expect(lookaheadCache.keys().length).to.equal(0)
+    })
 
-        it("can accept lookahead function param for AT_LEAST_ONE_SEP1-5", function () {
-            let input = [new OneTok(), new TwoTok(), new Comma(), new TwoTok(), new ThreeTok(),
-                new FourTok(), new Comma(), new FourTok(), new FiveTok()]
-            let parser = new AtLeastOneSepImplicitLookAheadParser(input)
-            let parseResult = parser.atLeastOneSepRule()
-            expect(parseResult.total).to.equal("1223445")
-            expect(parseResult.separators).to.deep.equal([new Comma(), new Comma()])
-        })
+    it("can accept lookahead function param for AT_LEAST_ONE_SEP1-5", function () {
+        let input = [new OneTok(), new TwoTok(), new Comma(), new TwoTok(), new ThreeTok(),
+            new FourTok(), new Comma(), new FourTok(), new FiveTok()]
+        let parser = new AtLeastOneSepImplicitLookAheadParser(input)
+        let parseResult = parser.atLeastOneSepRule()
+        expect(parseResult.total).to.equal("1223445")
+        expect(parseResult.separators).to.deep.equal([new Comma(), new Comma()])
+    })
 
-        it("will fail when zero occurrences of AT_LEAST_ONE_SEP in input", function () {
-            let input = [new OneTok(), new TwoTok(), /*new ThreeTok(),*/ new FourTok(), new FiveTok()]
-            let parser = new AtLeastOneSepImplicitLookAheadParser(input)
-            expect(parser.atLeastOneSepRule().total).to.equal("-666")
-        })
+    it("will fail when zero occurrences of AT_LEAST_ONE_SEP in input", function () {
+        let input = [new OneTok(), new TwoTok(), /*new ThreeTok(),*/ new FourTok(), new FiveTok()]
+        let parser = new AtLeastOneSepImplicitLookAheadParser(input)
+        expect(parser.atLeastOneSepRule().total).to.equal("-666")
+    })
 
-        it("will cache the generatedLookAhead functions AFTER (check cache is filled)", function () {
-            let parser = new AtLeastOneSepImplicitLookAheadParser()
-            let lookaheadCache = parser.getLookAheadCache()
-            expect(lookaheadCache.keys().length).to.equal(5)
-        })
+    it("will cache the generatedLookAhead functions AFTER (check cache is filled)", function () {
+        let parser = new AtLeastOneSepImplicitLookAheadParser()
+        let lookaheadCache = parser.getLookAheadCache()
+        expect(lookaheadCache.keys().length).to.equal(5)
     })
+})
 
-    describe("The Explicit lookahead functionality of the Recognizer for AT_LEAST_ONE_SEP", function () {
+describe("The Explicit lookahead functionality of the Recognizer for AT_LEAST_ONE_SEP", function () {
 
-        it("can accept lookahead function param for AT_LEAST_ONE_SEP1-5", function () {
-            let input = [new OneTok(), new TwoTok(), new Comma(), new TwoTok(), new ThreeTok(),
-                new FourTok(), new Comma(), new FourTok(), new FiveTok()]
-            let parser = new AtLeastOneSepExplicitLookAheadParser(input)
-            expect(parser.atLeastOneSepRule()).to.equal("1223445")
-        })
+    it("can accept lookahead function param for AT_LEAST_ONE_SEP1-5", function () {
+        let input = [new OneTok(), new TwoTok(), new Comma(), new TwoTok(), new ThreeTok(),
+            new FourTok(), new Comma(), new FourTok(), new FiveTok()]
+        let parser = new AtLeastOneSepExplicitLookAheadParser(input)
+        expect(parser.atLeastOneSepRule()).to.equal("1223445")
+    })
 
-        it("will fail when zero occurrences of AT_LEAST_ONE_SEP in input", function () {
-            let input = [new OneTok(), new TwoTok(), /*new ThreeTok(),*/ new FourTok(), new FiveTok()]
-            let parser = new AtLeastOneSepExplicitLookAheadParser(input)
-            expect(parser.atLeastOneSepRule()).to.equal("-666")
-        })
+    it("will fail when zero occurrences of AT_LEAST_ONE_SEP in input", function () {
+        let input = [new OneTok(), new TwoTok(), /*new ThreeTok(),*/ new FourTok(), new FiveTok()]
+        let parser = new AtLeastOneSepExplicitLookAheadParser(input)
+        expect(parser.atLeastOneSepRule()).to.equal("-666")
+    })
 
-        it("Will not cache any ImplicitLookahead functions when provided with explicit versions", function () {
-            let parser = new AtLeastOneSepExplicitLookAheadParser()
-            let lookaheadCache = parser.getLookAheadCache()
-            expect(lookaheadCache.keys().length).to.equal(0)
-        })
+    it("Will not cache any ImplicitLookahead functions when provided with explicit versions", function () {
+        let parser = new AtLeastOneSepExplicitLookAheadParser()
+        let lookaheadCache = parser.getLookAheadCache()
+        expect(lookaheadCache.keys().length).to.equal(0)
     })
+})
 
 
-    class OrImplicitLookAheadParser extends Parser {
+class OrImplicitLookAheadParser extends Parser {
 
-        public getLookAheadCache():lang.HashTable<Function> {
-            return cache.getLookaheadFuncsForClass(this.className)
-        }
+    public getLookAheadCache():HashTable<Function> {
+        return getLookaheadFuncsForClass(this.className)
+    }
 
-        constructor(input:Token[] = []) {
-            super(input, <any>chevrotain.recognizer.lookahead.spec)
-            Parser.performSelfAnalysis(this)
-        }
+    constructor(input:Token[] = []) {
+        super(input, ALL_TOKENS)
+        Parser.performSelfAnalysis(this)
+    }
 
-        public orRule = this.RULE("orRule", this.parseOrRule, () => { return "-666" })
+    public orRule = this.RULE("orRule", this.parseOrRule, () => { return "-666" })
 
-        private parseOrRule():string {
-            let total = ""
+    private parseOrRule():string {
+        let total = ""
 
-            // @formatter:off
+        // @formatter:off
             this.OR1([
                 {ALT: () => {
                     this.CONSUME1(OneTok)
@@ -1030,54 +1035,54 @@ namespace chevrotain.recognizer.lookahead.spec {
             ], "digits")
 
             // @formatter:on
-            return total
-        }
+        return total
     }
+}
 
-    describe("The implicit lookahead calculation functionality of the Recognizer For OR", function () {
+describe("The implicit lookahead calculation functionality of the Recognizer For OR", function () {
 
-        it("will cache the generatedLookAhead functions BEFORE (check cache is clean)", function () {
-            let parser = new OrImplicitLookAheadParser()
-            let lookaheadCache = parser.getLookAheadCache()
-            expect(lookaheadCache.keys().length).to.equal(0)
-        })
+    it("will cache the generatedLookAhead functions BEFORE (check cache is clean)", function () {
+        let parser = new OrImplicitLookAheadParser()
+        let lookaheadCache = parser.getLookAheadCache()
+        expect(lookaheadCache.keys().length).to.equal(0)
+    })
 
-        it("can compute the lookahead automatically for OR1-5", function () {
-            let input = [new OneTok(), new TwoTok(), new ThreeTok(), new FourTok(), new FiveTok()]
-            let parser = new OrImplicitLookAheadParser(input)
-            expect(parser.orRule()).to.equal("A1B2C3D4E5")
-        })
+    it("can compute the lookahead automatically for OR1-5", function () {
+        let input = [new OneTok(), new TwoTok(), new ThreeTok(), new FourTok(), new FiveTok()]
+        let parser = new OrImplicitLookAheadParser(input)
+        expect(parser.orRule()).to.equal("A1B2C3D4E5")
+    })
 
-        it("will fail when none of the alternatives match", function () {
-            let input = [new SixTok()]
-            let parser = new OrImplicitLookAheadParser(input)
-            expect(parser.orRule()).to.equal("-666")
-        })
+    it("will fail when none of the alternatives match", function () {
+        let input = [new SixTok()]
+        let parser = new OrImplicitLookAheadParser(input)
+        expect(parser.orRule()).to.equal("-666")
+    })
 
-        it("will cache the generatedLookAhead functions AFTER (check cache is filled)", function () {
-            let parser = new OrImplicitLookAheadParser()
-            let lookaheadCache = parser.getLookAheadCache()
-            expect(lookaheadCache.keys().length).to.equal(5)
-        })
+    it("will cache the generatedLookAhead functions AFTER (check cache is filled)", function () {
+        let parser = new OrImplicitLookAheadParser()
+        let lookaheadCache = parser.getLookAheadCache()
+        expect(lookaheadCache.keys().length).to.equal(5)
     })
+})
 
-    class OrExplicitLookAheadParser extends Parser {
+class OrExplicitLookAheadParser extends Parser {
 
-        public getLookAheadCache():lang.HashTable<Function> {
-            return cache.getLookaheadFuncsForClass(this.className)
-        }
+    public getLookAheadCache():HashTable<Function> {
+        return getLookaheadFuncsForClass(this.className)
+    }
 
-        constructor(input:Token[] = []) {
-            super(input, <any>chevrotain.recognizer.lookahead.spec)
-            Parser.performSelfAnalysis(this)
-        }
+    constructor(input:Token[] = []) {
+        super(input, ALL_TOKENS)
+        Parser.performSelfAnalysis(this)
+    }
 
-        public orRule = this.RULE("orRule", this.parseOrRule, () => { return "-666" })
+    public orRule = this.RULE("orRule", this.parseOrRule, () => { return "-666" })
 
-        private parseOrRule():string {
-            let total = ""
+    private parseOrRule():string {
+        let total = ""
 
-            // @formatter:off
+        // @formatter:off
             this.OR1([
                 {WHEN: isOneTok, THEN_DO: () => {
                     this.CONSUME1(OneTok)
@@ -1102,49 +1107,49 @@ namespace chevrotain.recognizer.lookahead.spec {
             ], "digits")
 
             // @formatter:on
-            return total
-        }
+        return total
     }
+}
 
-    describe("The Explicit lookahead functionality of the Recognizer for OR", function () {
+describe("The Explicit lookahead functionality of the Recognizer for OR", function () {
 
-        it("will cache the generatedLookAhead functions BEFORE (check cache is clean)", function () {
-            let parser = new OrExplicitLookAheadParser()
-            let lookaheadCache = parser.getLookAheadCache()
-            expect(lookaheadCache.keys().length).to.equal(0)
-        })
+    it("will cache the generatedLookAhead functions BEFORE (check cache is clean)", function () {
+        let parser = new OrExplicitLookAheadParser()
+        let lookaheadCache = parser.getLookAheadCache()
+        expect(lookaheadCache.keys().length).to.equal(0)
+    })
 
-        it("can accept the lookahead param explicitly for OR", function () {
-            let input = [new TwoTok()]
-            let parser = new OrExplicitLookAheadParser(input)
-            expect(parser.orRule()).to.equal("2")
-        })
+    it("can accept the lookahead param explicitly for OR", function () {
+        let input = [new TwoTok()]
+        let parser = new OrExplicitLookAheadParser(input)
+        expect(parser.orRule()).to.equal("2")
+    })
 
-        it("will fail when none of the alternatives match", function () {
-            let input = [new SixTok()]
-            let parser = new OrExplicitLookAheadParser(input)
-            expect(parser.orRule()).to.equal("-666")
-        })
+    it("will fail when none of the alternatives match", function () {
+        let input = [new SixTok()]
+        let parser = new OrExplicitLookAheadParser(input)
+        expect(parser.orRule()).to.equal("-666")
+    })
 
-        it("will NOT cache the generatedLookAhead functions in explicit mode", function () {
-            let parser = new OrExplicitLookAheadParser()
-            let lookaheadCache = parser.getLookAheadCache()
-            expect(lookaheadCache.keys().length).to.equal(0)
-        })
+    it("will NOT cache the generatedLookAhead functions in explicit mode", function () {
+        let parser = new OrExplicitLookAheadParser()
+        let lookaheadCache = parser.getLookAheadCache()
+        expect(lookaheadCache.keys().length).to.equal(0)
     })
+})
 
-    class OrAmbiguityLookAheadParser extends Parser {
+class OrAmbiguityLookAheadParser extends Parser {
 
-        constructor(input:Token[] = []) {
-            super(input, <any>chevrotain.recognizer.lookahead.spec)
-            Parser.performSelfAnalysis(this)
-        }
+    constructor(input:Token[] = []) {
+        super(input, ALL_TOKENS)
+        Parser.performSelfAnalysis(this)
+    }
 
-        public ambiguityRule = this.RULE("ambiguityRule", this.parseAmbiguityRule)
+    public ambiguityRule = this.RULE("ambiguityRule", this.parseAmbiguityRule)
 
-        private parseAmbiguityRule():void {
+    private parseAmbiguityRule():void {
 
-            // @formatter:off
+        // @formatter:off
             this.OR1([
                 {ALT: () => {
                     this.CONSUME1(OneTok)
@@ -1162,34 +1167,34 @@ namespace chevrotain.recognizer.lookahead.spec {
                 }}
             ], "digits")
             // @formatter:on
-        }
     }
+}
 
-    describe("OR production ambiguity detection when using implicit lookahead calculation", function () {
+describe("OR production ambiguity detection when using implicit lookahead calculation", function () {
 
-        it("will throw an error when two alternatives have the same single token (lookahead 1) prefix", function () {
-            let parser = new OrAmbiguityLookAheadParser()
-            expect(() => parser.ambiguityRule()).to.throw("Ambiguous alternatives")
-        })
+    it("will throw an error when two alternatives have the same single token (lookahead 1) prefix", function () {
+        let parser = new OrAmbiguityLookAheadParser()
+        expect(() => parser.ambiguityRule()).to.throw("Ambiguous alternatives")
     })
+})
 
-    class OrImplicitLookAheadParserIgnoreAmbiguities extends Parser {
+class OrImplicitLookAheadParserIgnoreAmbiguities extends Parser {
 
-        public getLookAheadCache():lang.HashTable<Function> {
-            return cache.getLookaheadFuncsForClass(this.className)
-        }
+    public getLookAheadCache():HashTable<Function> {
+        return getLookaheadFuncsForClass(this.className)
+    }
 
-        constructor(input:Token[] = []) {
-            super(input, <any>chevrotain.recognizer.lookahead.spec)
-            Parser.performSelfAnalysis(this)
-        }
+    constructor(input:Token[] = []) {
+        super(input, ALL_TOKENS)
+        Parser.performSelfAnalysis(this)
+    }
 
-        public orRule = this.RULE("orRule", this.parseOrRule, () => { return "-666" })
+    public orRule = this.RULE("orRule", this.parseOrRule, () => { return "-666" })
 
-        private parseOrRule():string {
-            let total = ""
+    private parseOrRule():string {
+        let total = ""
 
-            // @formatter:off
+        // @formatter:off
             this.OR([
                 {ALT: () => {
                     this.CONSUME1(OneTok)
@@ -1302,35 +1307,34 @@ namespace chevrotain.recognizer.lookahead.spec {
             ], "digits", Parser.IGNORE_AMBIGUITIES)
 
             // @formatter:on
-            return total
-        }
+        return total
     }
+}
 
-    describe("The implicit lookahead calculation functionality of the Recognizer For OR (with IGNORE_AMBIGUITIES)", function () {
+describe("The implicit lookahead calculation functionality of the Recognizer For OR (with IGNORE_AMBIGUITIES)", function () {
 
-        it("will cache the generatedLookAhead functions BEFORE (check cache is clean)", function () {
-            let parser = new OrImplicitLookAheadParserIgnoreAmbiguities()
-            let lookaheadCache = parser.getLookAheadCache()
-            expect(lookaheadCache.keys().length).to.equal(0)
-        })
+    it("will cache the generatedLookAhead functions BEFORE (check cache is clean)", function () {
+        let parser = new OrImplicitLookAheadParserIgnoreAmbiguities()
+        let lookaheadCache = parser.getLookAheadCache()
+        expect(lookaheadCache.keys().length).to.equal(0)
+    })
 
-        it("can compute the lookahead automatically for OR1-5", function () {
-            let input = [new OneTok(), new TwoTok(), new ThreeTok(), new FourTok(), new FiveTok()]
-            let parser = new OrImplicitLookAheadParserIgnoreAmbiguities(input)
-            expect(parser.orRule()).to.equal("A1B2C3D4E5")
-        })
+    it("can compute the lookahead automatically for OR1-5", function () {
+        let input = [new OneTok(), new TwoTok(), new ThreeTok(), new FourTok(), new FiveTok()]
+        let parser = new OrImplicitLookAheadParserIgnoreAmbiguities(input)
+        expect(parser.orRule()).to.equal("A1B2C3D4E5")
+    })
 
-        it("will fail when none of the alternatives match", function () {
-            let input = [new SixTok()]
-            let parser = new OrImplicitLookAheadParserIgnoreAmbiguities(input)
-            expect(parser.orRule()).to.equal("-666")
-        })
+    it("will fail when none of the alternatives match", function () {
+        let input = [new SixTok()]
+        let parser = new OrImplicitLookAheadParserIgnoreAmbiguities(input)
+        expect(parser.orRule()).to.equal("-666")
+    })
 
-        it("will cache the generatedLookAhead functions AFTER (check cache is filled)", function () {
-            let parser = new OrImplicitLookAheadParserIgnoreAmbiguities()
-            let lookaheadCache = parser.getLookAheadCache()
-            expect(lookaheadCache.keys().length).to.equal(5)
-        })
+    it("will cache the generatedLookAhead functions AFTER (check cache is filled)", function () {
+        let parser = new OrImplicitLookAheadParserIgnoreAmbiguities()
+        let lookaheadCache = parser.getLookAheadCache()
+        expect(lookaheadCache.keys().length).to.equal(5)
     })
+})
 
-}
diff --git a/test/parse/recognizer_spec.ts b/test/parse/recognizer_spec.ts
index 51dea8662..dd2566da6 100644
--- a/test/parse/recognizer_spec.ts
+++ b/test/parse/recognizer_spec.ts
@@ -1,304 +1,312 @@
-namespace chevrotain.recognizer.spec {
+import {Token, EOF} from "../../src/scan/tokens_public"
+import {Parser, EMPTY_ALT} from "../../src/parse/parser_public"
+import {HashTable} from "../../src/lang/lang_extensions"
+import {getLookaheadFuncsForClass} from "../../src/parse/cache"
+import {exceptions} from "../../src/parse/exceptions_public"
+import * as _ from "lodash"
 
-    export class PlusTok extends Token {
-        constructor() { super("+", 0, 1, 1) }
-    }
-
-    export class MinusTok extends Token {
-        constructor() { super("+", 0, 1, 1) }
-    }
 
-    export class IntToken extends Token {
-        constructor(image:string) { super(image, 0, 1, 1) }
-    }
+export class PlusTok extends Token {
+    constructor() { super("+", 0, 1, 1) }
+}
 
-    class ManyRepetitionRecovery extends Parser {
+export class MinusTok extends Token {
+    constructor() { super("+", 0, 1, 1) }
+}
 
-        constructor(input:Token[] = [], isErrorRecoveryEnabled = true) {
-            super(input, <any>chevrotain.recognizer.spec, isErrorRecoveryEnabled)
-            Parser.performSelfAnalysis(this)
-        }
+export class IntToken extends Token {
+    constructor(image:string) { super(image, 0, 1, 1) }
+}
 
-        public qualifiedName = this.RULE("qualifiedName", this.parseQualifiedName, () => { return ["666"] })
+export class IdentTok extends Token {
+    constructor(image:string) { super(image, 0, 1, 1) }
+}
 
-        private parseQualifiedName():string[] {
-            let idents = []
+export class DotTok extends Token {
+    constructor() { super(".", 0, 1, 1) }
+}
 
-            idents.push(this.CONSUME1(IdentTok).image)
-            this.MANY(isQualifiedNamePart, () => {
-                this.CONSUME1(DotTok)
-                idents.push(this.CONSUME2(IdentTok).image)
-            })
+const ALL_TOKENS = [PlusTok, MinusTok, IntToken, IdentTok, DotTok]
 
-            this.CONSUME1(EOF)
+class ManyRepetitionRecovery extends Parser {
 
-            return idents
-        }
+    constructor(input:Token[] = [], isErrorRecoveryEnabled = true) {
+        super(input, ALL_TOKENS, isErrorRecoveryEnabled)
+        Parser.performSelfAnalysis(this)
     }
 
-    class ManySepRepetitionRecovery extends Parser {
+    public qualifiedName = this.RULE("qualifiedName", this.parseQualifiedName, () => { return ["666"] })
 
-        constructor(input:Token[] = [], isErrorRecoveryEnabled = true) {
-            super(input, <any>chevrotain.recognizer.spec, isErrorRecoveryEnabled)
-            Parser.performSelfAnalysis(this)
-        }
-
-        public qualifiedName = this.RULE("qualifiedName", this.parseQualifiedName, () => { return ["333"] })
+    private parseQualifiedName():string[] {
+        let idents = []
 
-        private parseQualifiedName():string[] {
-            let idents = []
-
-            idents.push(this.CONSUME1(IdentTok).image)
+        idents.push(this.CONSUME1(IdentTok).image)
+        this.MANY(isQualifiedNamePart, () => {
             this.CONSUME1(DotTok)
+            idents.push(this.CONSUME2(IdentTok).image)
+        })
 
-            this.MANY_SEP(DotTok, () => {
-                idents.push(this.CONSUME2(IdentTok).image)
-            })
-
-            this.CONSUME1(EOF)
+        this.CONSUME1(EOF)
 
-            return idents
-        }
+        return idents
     }
+}
 
-    class ManySepSubRuleRepetitionRecovery extends Parser {
+class ManySepRepetitionRecovery extends Parser {
 
-        constructor(input:Token[] = []) {
-            super(input, <any>chevrotain.recognizer.spec)
-            Parser.performSelfAnalysis(this)
-        }
+    constructor(input:Token[] = [], isErrorRecoveryEnabled = true) {
+        super(input, ALL_TOKENS, isErrorRecoveryEnabled)
+        Parser.performSelfAnalysis(this)
+    }
 
-        public qualifiedName = this.RULE("qualifiedName", this.parseQualifiedName, () => { return undefined })
-        public identifier = this.RULE("identifier", this.parseIdentifier, () => { return undefined })
-        public idents = []
+    public qualifiedName = this.RULE("qualifiedName", this.parseQualifiedName, () => { return ["333"] })
 
-        private parseQualifiedName():string[] {
-            this.idents = []
+    private parseQualifiedName():string[] {
+        let idents = []
 
-            this.MANY_SEP(DotTok, () => {
-                this.SUBRULE(this.identifier)
-            })
+        idents.push(this.CONSUME1(IdentTok).image)
+        this.CONSUME1(DotTok)
 
-            this.CONSUME1(EOF)
+        this.MANY_SEP(DotTok, () => {
+            idents.push(this.CONSUME2(IdentTok).image)
+        })
 
-            return this.idents
-        }
+        this.CONSUME1(EOF)
 
-        private parseIdentifier():void {
-            this.idents.push(this.CONSUME1(IdentTok).image)
-        }
+        return idents
+    }
+}
 
-        protected canTokenTypeBeInsertedInRecovery(tokClass:Function) {
-            // this parser is meant to test a scenario with re-sync recovery and MANY_SEP --> disable TokenInsertion
-            return false
-        }
+class ManySepSubRuleRepetitionRecovery extends Parser {
+
+    constructor(input:Token[] = []) {
+        super(input, ALL_TOKENS)
+        Parser.performSelfAnalysis(this)
     }
 
-    class AtLeastOneRepetitionRecovery extends Parser {
+    public qualifiedName = this.RULE("qualifiedName", this.parseQualifiedName, () => { return undefined })
+    public identifier = this.RULE("identifier", this.parseIdentifier, () => { return undefined })
+    public idents = []
 
-        constructor(input:Token[] = [], isErrorRecoveryEnabled = true) {
-            super(input, <any>chevrotain.recognizer.spec, isErrorRecoveryEnabled)
-            Parser.performSelfAnalysis(this)
-        }
+    private parseQualifiedName():string[] {
+        this.idents = []
 
-        public qualifiedName = this.RULE("qualifiedName", this.parseQualifiedName, () => { return ["777"] })
+        this.MANY_SEP(DotTok, () => {
+            this.SUBRULE(this.identifier)
+        })
 
-        private parseQualifiedName():string[] {
-            let idents = []
+        this.CONSUME1(EOF)
 
-            idents.push(this.CONSUME1(IdentTok).image)
-            this.AT_LEAST_ONE(isQualifiedNamePart, () => {
-                this.CONSUME1(DotTok)
-                idents.push(this.CONSUME2(IdentTok).image)
-            })
+        return this.idents
+    }
 
-            this.CONSUME1(EOF)
+    private parseIdentifier():void {
+        this.idents.push(this.CONSUME1(IdentTok).image)
+    }
 
-            return idents
-        }
+    protected canTokenTypeBeInsertedInRecovery(tokClass:Function) {
+        // this parser is meant to test a scenario with re-sync recovery and MANY_SEP --> disable TokenInsertion
+        return false
     }
+}
 
-    class AtLeastOneSepRepetitionRecovery extends Parser {
+class AtLeastOneRepetitionRecovery extends Parser {
 
-        constructor(input:Token[] = [], isErrorRecoveryEnabled = true) {
-            super(input, <any>chevrotain.recognizer.spec, isErrorRecoveryEnabled)
-            Parser.performSelfAnalysis(this)
-        }
+    constructor(input:Token[] = [], isErrorRecoveryEnabled = true) {
+        super(input, ALL_TOKENS, isErrorRecoveryEnabled)
+        Parser.performSelfAnalysis(this)
+    }
 
-        public qualifiedName = this.RULE("qualifiedName", this.parseQualifiedName, () => { return ["999"] })
+    public qualifiedName = this.RULE("qualifiedName", this.parseQualifiedName, () => { return ["777"] })
 
-        private parseQualifiedName():string[] {
-            let idents = []
+    private parseQualifiedName():string[] {
+        let idents = []
 
-            this.AT_LEAST_ONE_SEP(DotTok, () => {
-                idents.push(this.CONSUME1(IdentTok).image)
-            }, "identifiers")
+        idents.push(this.CONSUME1(IdentTok).image)
+        this.AT_LEAST_ONE(isQualifiedNamePart, () => {
+            this.CONSUME1(DotTok)
+            idents.push(this.CONSUME2(IdentTok).image)
+        })
 
-            this.CONSUME1(EOF)
+        this.CONSUME1(EOF)
 
-            return idents
-        }
+        return idents
     }
+}
 
-    export class IdentTok extends Token {
-        constructor(image:string) { super(image, 0, 1, 1) }
-    }
+class AtLeastOneSepRepetitionRecovery extends Parser {
 
-    export class DotTok extends Token {
-        constructor() { super(".", 0, 1, 1) }
+    constructor(input:Token[] = [], isErrorRecoveryEnabled = true) {
+        super(input, ALL_TOKENS, isErrorRecoveryEnabled)
+        Parser.performSelfAnalysis(this)
     }
 
-    function isQualifiedNamePart():boolean {
-        return this.NEXT_TOKEN() instanceof DotTok
-    }
+    public qualifiedName = this.RULE("qualifiedName", this.parseQualifiedName, () => { return ["999"] })
 
-    class SubRuleTestParser extends Parser {
+    private parseQualifiedName():string[] {
+        let idents = []
 
-        private result = ""
-        private index = 1;
+        this.AT_LEAST_ONE_SEP(DotTok, () => {
+            idents.push(this.CONSUME1(IdentTok).image)
+        }, "identifiers")
 
-        constructor(input:Token[] = []) {
-            super(input, <any>chevrotain.recognizer.spec)
-            Parser.performSelfAnalysis(this)
-        }
+        this.CONSUME1(EOF)
 
-        public topRule = this.RULE("topRule", () => {
-            this.SUBRULE1(this.subRule)
-            this.SUBRULE2(this.subRule)
-            this.SUBRULE3(this.subRule)
-            this.SUBRULE4(this.subRule)
-            this.SUBRULE5(this.subRule)
-            return this.result
-        })
+        return idents
+    }
+}
 
-        public subRule = this.RULE("subRule", () => {
-            this.CONSUME(PlusTok)
-            this.result += this.index++
-        })
+function isQualifiedNamePart():boolean {
+    return this.NEXT_TOKEN() instanceof DotTok
+}
+
+class SubRuleTestParser extends Parser {
+
+    private result = ""
+    private index = 1;
+
+    constructor(input:Token[] = []) {
+        super(input, ALL_TOKENS)
+        Parser.performSelfAnalysis(this)
     }
 
-    class SubRuleArgsParser extends Parser {
+    public topRule = this.RULE("topRule", () => {
+        this.SUBRULE1(this.subRule)
+        this.SUBRULE2(this.subRule)
+        this.SUBRULE3(this.subRule)
+        this.SUBRULE4(this.subRule)
+        this.SUBRULE5(this.subRule)
+        return this.result
+    })
 
-        private numbers = ""
-        private letters = ""
+    public subRule = this.RULE("subRule", () => {
+        this.CONSUME(PlusTok)
+        this.result += this.index++
+    })
+}
 
-        constructor(input:Token[] = []) {
-            super(input, <any>chevrotain.recognizer.spec)
-            Parser.performSelfAnalysis(this)
-        }
+class SubRuleArgsParser extends Parser {
 
-        public topRule = this.RULE("topRule", () => {
-            this.SUBRULE(this.subRule, [5, "a"])
-            this.SUBRULE2(this.subRule, [4, "b"])
-            this.SUBRULE3(this.subRule, [3, "c"])
-            this.SUBRULE4(this.subRule, [2, "d"])
-            this.SUBRULE5(this.subRule, [1, "e"])
-            return {numbers: this.numbers, letters: this.letters}
-        })
+    private numbers = ""
+    private letters = ""
 
-        public subRule = this.RULE("subRule", (numFromCaller, charFromCaller) => {
-            this.CONSUME(PlusTok)
-            this.numbers += numFromCaller
-            this.letters += charFromCaller
-        })
+    constructor(input:Token[] = []) {
+        super(input, ALL_TOKENS)
+        Parser.performSelfAnalysis(this)
     }
 
-    class CustomLookaheadParser extends Parser {
+    public topRule = this.RULE("topRule", () => {
+        this.SUBRULE(this.subRule, [5, "a"])
+        this.SUBRULE2(this.subRule, [4, "b"])
+        this.SUBRULE3(this.subRule, [3, "c"])
+        this.SUBRULE4(this.subRule, [2, "d"])
+        this.SUBRULE5(this.subRule, [1, "e"])
+        return {numbers: this.numbers, letters: this.letters}
+    })
 
-        private result = ""
-        public plusAllowed = true
-        public minusAllowed = true
+    public subRule = this.RULE("subRule", (numFromCaller, charFromCaller) => {
+        this.CONSUME(PlusTok)
+        this.numbers += numFromCaller
+        this.letters += charFromCaller
+    })
+}
 
-        constructor(input:Token[] = []) {
-            super(input, <any>chevrotain.recognizer.spec)
-            Parser.performSelfAnalysis(this)
-        }
+class CustomLookaheadParser extends Parser {
 
-        private isPlus():boolean {
-            return this.isNextRule("plusRule") && this.plusAllowed
-        }
+    private result = ""
+    public plusAllowed = true
+    public minusAllowed = true
 
-        private isMinus():boolean {
-            return this.isNextRule("minusRule") && this.minusAllowed
-        }
+    constructor(input:Token[] = []) {
+        super(input, ALL_TOKENS)
+        Parser.performSelfAnalysis(this)
+    }
 
-        public topRule = this.RULE("topRule", () => {
-            this.OR([
-                {WHEN: this.isPlus, THEN_DO: () => { this.SUBRULE1(this.plusRule) }},
-                {WHEN: this.isMinus, THEN_DO: () => { this.SUBRULE1(this.minusRule) }}
-            ], "a unicorn")
+    private isPlus():boolean {
+        return this.isNextRule("plusRule") && this.plusAllowed
+    }
 
+    private isMinus():boolean {
+        return this.isNextRule("minusRule") && this.minusAllowed
+    }
 
-            return this.result
-        })
+    public topRule = this.RULE("topRule", () => {
+        this.OR([
+            {WHEN: this.isPlus, THEN_DO: () => { this.SUBRULE1(this.plusRule) }},
+            {WHEN: this.isMinus, THEN_DO: () => { this.SUBRULE1(this.minusRule) }}
+        ], "a unicorn")
 
-        public plusRule = this.RULE("plusRule", () => {
-            this.CONSUME(PlusTok)
-            this.result += "plus"
-        })
 
-        public minusRule = this.RULE("minusRule", () => {
-            this.CONSUME(MinusTok)
-            this.result += "minus"
-        })
-    }
+        return this.result
+    })
 
-    describe("The Parsing DSL", function () {
+    public plusRule = this.RULE("plusRule", () => {
+        this.CONSUME(PlusTok)
+        this.result += "plus"
+    })
 
-        it("provides a production SUBRULE1-5 that invokes another rule", function () {
-            let input = [new PlusTok(), new PlusTok(), new PlusTok(), new PlusTok(), new PlusTok()]
-            let parser = new SubRuleTestParser(input)
-            let result = parser.topRule()
-            expect(result).to.equal("12345")
-        })
+    public minusRule = this.RULE("minusRule", () => {
+        this.CONSUME(MinusTok)
+        this.result += "minus"
+    })
+}
 
-        it("provides a production SUBRULE1-5 that can accept arguments from its caller", function () {
-            let input = [new PlusTok(), new PlusTok(), new PlusTok(), new PlusTok(), new PlusTok()]
-            let parser = new SubRuleArgsParser(input)
-            let result = parser.topRule()
-            expect(result.letters).to.equal("abcde")
-            expect(result.numbers).to.equal("54321")
-        })
+describe("The Parsing DSL", function () {
+
+    it("provides a production SUBRULE1-5 that invokes another rule", function () {
+        let input = [new PlusTok(), new PlusTok(), new PlusTok(), new PlusTok(), new PlusTok()]
+        let parser = new SubRuleTestParser(input)
+        let result = parser.topRule()
+        expect(result).to.equal("12345")
+    })
 
-        it("allows using automatic lookahead even as part of custom lookahead functions valid", function () {
-            let input1 = [new PlusTok()]
-            let parser = new CustomLookaheadParser(input1)
-            let result = parser.topRule()
-            expect(result).to.equal("plus")
+    it("provides a production SUBRULE1-5 that can accept arguments from its caller", function () {
+        let input = [new PlusTok(), new PlusTok(), new PlusTok(), new PlusTok(), new PlusTok()]
+        let parser = new SubRuleArgsParser(input)
+        let result = parser.topRule()
+        expect(result.letters).to.equal("abcde")
+        expect(result.numbers).to.equal("54321")
+    })
 
-            let input2 = [new MinusTok()]
-            let parser2 = new CustomLookaheadParser(input2)
-            let result2 = parser2.topRule()
-            expect(result2).to.equal("minus")
-        })
+    it("allows using automatic lookahead even as part of custom lookahead functions valid", function () {
+        let input1 = [new PlusTok()]
+        let parser = new CustomLookaheadParser(input1)
+        let result = parser.topRule()
+        expect(result).to.equal("plus")
 
-        it("allows using automatic lookahead even as part of custom lookahead functions invalid", function () {
-            let input1 = [new PlusTok()]
-            let parser = new CustomLookaheadParser(input1)
-            parser.plusAllowed = false
-            let result = parser.topRule()
-            expect(result).to.equal(undefined)
-            expect(parser.errors.length).to.equal(1)
-            expect(_.contains(parser.errors[0].message, "unicorn")).to.equal(true)
-        })
+        let input2 = [new MinusTok()]
+        let parser2 = new CustomLookaheadParser(input2)
+        let result2 = parser2.topRule()
+        expect(result2).to.equal("minus")
+    })
+
+    it("allows using automatic lookahead even as part of custom lookahead functions invalid", function () {
+        let input1 = [new PlusTok()]
+        let parser = new CustomLookaheadParser(input1)
+        parser.plusAllowed = false
+        let result = parser.topRule()
+        expect(result).to.equal(undefined)
+        expect(parser.errors.length).to.equal(1)
+        expect(_.contains(parser.errors[0].message, "unicorn")).to.equal(true)
+    })
 
-        describe("supports EMPTY(...) alternative convenience function", () => {
+    describe("supports EMPTY(...) alternative convenience function", () => {
 
-            let EmptyAltParser = class EmptyAltParser extends Parser {
+        let EmptyAltParser = class EmptyAltParser extends Parser {
 
-                public getLookAheadCache():lang.HashTable<Function> {
-                    return cache.getLookaheadFuncsForClass(this.className)
-                }
+            public getLookAheadCache():HashTable<Function> {
+                return getLookaheadFuncsForClass(this.className)
+            }
 
-                constructor(input:Token[] = []) {
-                    super(input, <any>chevrotain.recognizer.spec)
-                    Parser.performSelfAnalysis(this)
-                }
+            constructor(input:Token[] = []) {
+                super(input, ALL_TOKENS)
+                Parser.performSelfAnalysis(this)
+            }
 
-                public orRule = this.RULE("orRule", this.parseOrRule, () => { return "-666" })
+            public orRule = this.RULE("orRule", this.parseOrRule, () => { return "-666" })
 
-                private parseOrRule():string {
-                    // @formatter:off
+            private parseOrRule():string {
+                // @formatter:off
                     return this.OR1([
                             {ALT: () => {
                                 this.CONSUME1(PlusTok)
@@ -308,234 +316,232 @@ namespace chevrotain.recognizer.spec {
                                 this.CONSUME1(MinusTok)
                                 return "-"
                             }},
-                            {ALT: chevrotain.EMPTY_ALT("EMPTY_ALT")}
+                            {ALT: EMPTY_ALT("EMPTY_ALT")}
                         ])
                      // @formatter:on
-                }
             }
+        }
 
-            it("can match an non-empty alternative in an OR with an empty alternative", function () {
-                let input = [new PlusTok()]
-                let parser = new EmptyAltParser(input)
-                expect(parser.orRule()).to.equal("+")
-            })
-
-            it("can match an empty alternative", () => {
-                let input = []
-                let parser = new EmptyAltParser(input)
-                expect(parser.orRule()).to.equal("EMPTY_ALT")
-            })
-
-            it("has a utility function for defining EMPTY ALTERNATIVES", () => {
-                let noArgsEmptyAlt = chevrotain.EMPTY_ALT()
-                expect(noArgsEmptyAlt()).to.be.undefined
-
-                let valueEmptyAlt = chevrotain.EMPTY_ALT(666)
-                expect(valueEmptyAlt()).to.equal(666)
-            })
-        })
-    })
-
-    describe("The Error Recovery functionality of the IntrospectionParser", function () {
-
-        it("can CONSUME tokens with an index specifying the occurrence for the specific token in the current rule", function () {
-            let parser:any = new Parser([], <any>chevrotain.gastBuilder.spec);
-            parser.reset()
-            let testInput = [new IntToken("1"), new PlusTok(),
-                new IntToken("2"), new PlusTok(), new IntToken("3")]
-
-            parser.input = testInput
-            expect(parser.CONSUME4(IntToken)).to.equal(testInput[0])
-            expect(parser.CONSUME2(PlusTok)).to.equal(testInput[1])
-            expect(parser.CONSUME1(IntToken)).to.equal(testInput[2])
-            expect(parser.CONSUME3(PlusTok)).to.equal(testInput[3])
-            expect(parser.CONSUME1(IntToken)).to.equal(testInput[4])
-            expect(parser.NEXT_TOKEN()).to.be.an.instanceof(EOF)
+        it("can match an non-empty alternative in an OR with an empty alternative", function () {
+            let input = [new PlusTok()]
+            let parser = new EmptyAltParser(input)
+            expect(parser.orRule()).to.equal("+")
         })
 
-        it("will not perform inRepetition recovery while in backtracking mode", function () {
-            let parser:any = new Parser([], {})
-            parser.isBackTrackingStack.push(1)
-            expect(parser.shouldInRepetitionRecoveryBeTried(MinusTok, 1)).to.equal(false)
+        it("can match an empty alternative", () => {
+            let input = []
+            let parser = new EmptyAltParser(input)
+            expect(parser.orRule()).to.equal("EMPTY_ALT")
         })
 
-        it("can perform in-repetition recovery for MANY grammar rule", function () {
-            // a.b+.c
-            let input = [new IdentTok("a"), new DotTok(), new IdentTok("b"),
-                new PlusTok(), new DotTok(), new IdentTok("c")]
-            let parser = new ManyRepetitionRecovery(input)
-            expect(parser.qualifiedName()).to.deep.equal(["a", "b", "c"])
-            expect(parser.errors.length).to.equal(1)
-        })
+        it("has a utility function for defining EMPTY ALTERNATIVES", () => {
+            let noArgsEmptyAlt = EMPTY_ALT()
+            expect(noArgsEmptyAlt()).to.be.undefined
 
-        it("can disable in-repetition recovery for MANY grammar rule", function () {
-            // a.b+.c
-            let input = [new IdentTok("a"), new DotTok(), new IdentTok("b"),
-                new PlusTok(), new DotTok(), new IdentTok("c")]
-            let parser = new ManyRepetitionRecovery(input, false)
-            expect(parser.qualifiedName()).to.deep.equal(["666"])
-            expect(parser.errors.length).to.equal(1)
+            let valueEmptyAlt = EMPTY_ALT(666)
+            expect(valueEmptyAlt()).to.equal(666)
         })
+    })
+})
+
+describe("The Error Recovery functionality of the IntrospectionParser", function () {
+
+    it("can CONSUME tokens with an index specifying the occurrence for the specific token in the current rule", function () {
+        let parser:any = new Parser([], ALL_TOKENS)
+        parser.reset()
+        let testInput = [new IntToken("1"), new PlusTok(),
+            new IntToken("2"), new PlusTok(), new IntToken("3")]
+
+        parser.input = testInput
+        expect(parser.CONSUME4(IntToken)).to.equal(testInput[0])
+        expect(parser.CONSUME2(PlusTok)).to.equal(testInput[1])
+        expect(parser.CONSUME1(IntToken)).to.equal(testInput[2])
+        expect(parser.CONSUME3(PlusTok)).to.equal(testInput[3])
+        expect(parser.CONSUME1(IntToken)).to.equal(testInput[4])
+        expect(parser.NEXT_TOKEN()).to.be.an.instanceof(EOF)
+    })
 
-        it("can perform in-repetition recovery for MANY_SEP grammar rule", function () {
-            // a.b+.c
-            let input = [new IdentTok("a"), new DotTok(), new IdentTok("b"),
-                new PlusTok(), new DotTok(), new IdentTok("c")]
-            let parser = new ManySepRepetitionRecovery(input)
-            expect(parser.qualifiedName()).to.deep.equal(["a", "b", "c"])
-            expect(parser.errors.length).to.equal(1)
-        })
+    it("will not perform inRepetition recovery while in backtracking mode", function () {
+        let parser:any = new Parser([], {})
+        parser.isBackTrackingStack.push(1)
+        expect(parser.shouldInRepetitionRecoveryBeTried(MinusTok, 1)).to.equal(false)
+    })
 
-        it("can disable in-repetition recovery for MANY_SEP grammar rule", function () {
-            // a.b+.c
-            let input = [new IdentTok("a"), new DotTok(), new IdentTok("b"),
-                new PlusTok(), new DotTok(), new IdentTok("c")]
-            let parser = new ManySepRepetitionRecovery(input, false)
-            expect(parser.qualifiedName()).to.deep.equal(["333"])
-            expect(parser.errors.length).to.equal(1)
-        })
+    it("can perform in-repetition recovery for MANY grammar rule", function () {
+        // a.b+.c
+        let input = [new IdentTok("a"), new DotTok(), new IdentTok("b"),
+            new PlusTok(), new DotTok(), new IdentTok("c")]
+        let parser = new ManyRepetitionRecovery(input)
+        expect(parser.qualifiedName()).to.deep.equal(["a", "b", "c"])
+        expect(parser.errors.length).to.equal(1)
+    })
 
-        it("can perform in-repetition recovery for MANY_SEP grammar rule #2", function () {
-            // a.b..c...d
-            let input = [new IdentTok("a"), new DotTok(), new DotTok(), new IdentTok("b"),
-                new DotTok(), new IdentTok("c"), new DotTok(), new DotTok(), new DotTok(), new IdentTok("d")]
-            let parser = new ManySepSubRuleRepetitionRecovery(input)
-            expect(parser.qualifiedName()).to.deep.equal(["a", "b", "c", "d"])
-            expect(parser.errors.length).to.equal(3)
-        })
+    it("can disable in-repetition recovery for MANY grammar rule", function () {
+        // a.b+.c
+        let input = [new IdentTok("a"), new DotTok(), new IdentTok("b"),
+            new PlusTok(), new DotTok(), new IdentTok("c")]
+        let parser = new ManyRepetitionRecovery(input, false)
+        expect(parser.qualifiedName()).to.deep.equal(["666"])
+        expect(parser.errors.length).to.equal(1)
+    })
 
-        it("can perform in-repetition recovery for AT_LEAST_ONE grammar rule", function () {
-            // a.b+.c
-            let input = [new IdentTok("a"), new DotTok(), new IdentTok("b"),
-                new PlusTok(), new DotTok(), new IdentTok("c")]
-            let parser = new AtLeastOneRepetitionRecovery(input)
-            expect(parser.qualifiedName()).to.deep.equal(["a", "b", "c"])
-            expect(parser.errors.length).to.equal(1)
-        })
+    it("can perform in-repetition recovery for MANY_SEP grammar rule", function () {
+        // a.b+.c
+        let input = [new IdentTok("a"), new DotTok(), new IdentTok("b"),
+            new PlusTok(), new DotTok(), new IdentTok("c")]
+        let parser = new ManySepRepetitionRecovery(input)
+        expect(parser.qualifiedName()).to.deep.equal(["a", "b", "c"])
+        expect(parser.errors.length).to.equal(1)
+    })
 
-        it("can disable in-repetition recovery for AT_LEAST_ONE grammar rule", function () {
-            // a.b+.c
-            let input = [new IdentTok("a"), new DotTok(), new IdentTok("b"),
-                new PlusTok(), new DotTok(), new IdentTok("c")]
-            let parser = new AtLeastOneRepetitionRecovery(input, false)
-            expect(parser.qualifiedName()).to.deep.equal(["777"])
-            expect(parser.errors.length).to.equal(1)
-        })
+    it("can disable in-repetition recovery for MANY_SEP grammar rule", function () {
+        // a.b+.c
+        let input = [new IdentTok("a"), new DotTok(), new IdentTok("b"),
+            new PlusTok(), new DotTok(), new IdentTok("c")]
+        let parser = new ManySepRepetitionRecovery(input, false)
+        expect(parser.qualifiedName()).to.deep.equal(["333"])
+        expect(parser.errors.length).to.equal(1)
+    })
 
-        it("can perform in-repetition recovery for AT_LEAST_ONE_SEP grammar rule", function () {
-            // a.b+.c
-            let input = [new IdentTok("a"), new DotTok(), new IdentTok("b"),
-                new PlusTok(), new DotTok(), new IdentTok("c")]
-            let parser = new AtLeastOneSepRepetitionRecovery(input)
-            expect(parser.qualifiedName()).to.deep.equal(["a", "b", "c"])
-            expect(parser.errors.length).to.equal(1)
-        })
+    it("can perform in-repetition recovery for MANY_SEP grammar rule #2", function () {
+        // a.b..c...d
+        let input = [new IdentTok("a"), new DotTok(), new DotTok(), new IdentTok("b"),
+            new DotTok(), new IdentTok("c"), new DotTok(), new DotTok(), new DotTok(), new IdentTok("d")]
+        let parser = new ManySepSubRuleRepetitionRecovery(input)
+        expect(parser.qualifiedName()).to.deep.equal(["a", "b", "c", "d"])
+        expect(parser.errors.length).to.equal(3)
+    })
 
-        it("can disable in-repetition recovery for AT_LEAST_ONE_SEP grammar rule", function () {
-            // a.b+.c
-            let input = [new IdentTok("a"), new DotTok(), new IdentTok("b"),
-                new PlusTok(), new DotTok(), new IdentTok("c")]
-            let parser = new AtLeastOneSepRepetitionRecovery(input, false)
-            expect(parser.qualifiedName()).to.deep.equal(["999"])
-            expect(parser.errors.length).to.equal(1)
-        })
+    it("can perform in-repetition recovery for AT_LEAST_ONE grammar rule", function () {
+        // a.b+.c
+        let input = [new IdentTok("a"), new DotTok(), new IdentTok("b"),
+            new PlusTok(), new DotTok(), new IdentTok("c")]
+        let parser = new AtLeastOneRepetitionRecovery(input)
+        expect(parser.qualifiedName()).to.deep.equal(["a", "b", "c"])
+        expect(parser.errors.length).to.equal(1)
     })
 
-    describe("The BaseRecognizer", function () {
+    it("can disable in-repetition recovery for AT_LEAST_ONE grammar rule", function () {
+        // a.b+.c
+        let input = [new IdentTok("a"), new DotTok(), new IdentTok("b"),
+            new PlusTok(), new DotTok(), new IdentTok("c")]
+        let parser = new AtLeastOneRepetitionRecovery(input, false)
+        expect(parser.qualifiedName()).to.deep.equal(["777"])
+        expect(parser.errors.length).to.equal(1)
+    })
 
-        it("can be initialized without supplying an input vector", function () {
-            let parser = new Parser([], [])
-            expect(parser.input).to.deep.equal([])
-            expect(parser.input).to.be.an.instanceof(Array)
-        })
+    it("can perform in-repetition recovery for AT_LEAST_ONE_SEP grammar rule", function () {
+        // a.b+.c
+        let input = [new IdentTok("a"), new DotTok(), new IdentTok("b"),
+            new PlusTok(), new DotTok(), new IdentTok("c")]
+        let parser = new AtLeastOneSepRepetitionRecovery(input)
+        expect(parser.qualifiedName()).to.deep.equal(["a", "b", "c"])
+        expect(parser.errors.length).to.equal(1)
+    })
 
-        it("can only SAVE_ERROR for recognition exceptions", function () {
-            let parser:any = new Parser([], [])
-            expect(() => parser.SAVE_ERROR(new Error("I am some random Error"))).
-            to.throw("trying to save an Error which is not a RecognitionException")
-            expect(parser.input).to.be.an.instanceof(Array)
-        })
+    it("can disable in-repetition recovery for AT_LEAST_ONE_SEP grammar rule", function () {
+        // a.b+.c
+        let input = [new IdentTok("a"), new DotTok(), new IdentTok("b"),
+            new PlusTok(), new DotTok(), new IdentTok("c")]
+        let parser = new AtLeastOneSepRepetitionRecovery(input, false)
+        expect(parser.qualifiedName()).to.deep.equal(["999"])
+        expect(parser.errors.length).to.equal(1)
+    })
+})
 
-        it("when it runs out of input EOF will be returned", function () {
-            let parser:any = new Parser([new IntToken("1"), new PlusTok()], [])
-            parser.CONSUME(IntToken)
-            parser.CONSUME(PlusTok)
-            expect(parser.NEXT_TOKEN()).to.be.an.instanceof(EOF)
-            expect(parser.NEXT_TOKEN()).to.be.an.instanceof(EOF)
-            expect(parser.SKIP_TOKEN()).to.be.an.instanceof(EOF)
-            expect(parser.SKIP_TOKEN()).to.be.an.instanceof(EOF)
-            // and we can go on and on and on... this avoid returning null/undefined
-            // see: http://en.wikipedia.org/wiki/Tony_Hoare#Apologies_and_retractions
-        })
+describe("The BaseRecognizer", function () {
 
-        it("invoking an OPTION will return true/false depending if it succeeded or not", function () {
-            let parser:any = new Parser([new IntToken("1"), new PlusTok()], {})
+    it("can be initialized without supplying an input vector", function () {
+        let parser = new Parser([], [])
+        expect(parser.input).to.deep.equal([])
+        expect(parser.input).to.be.an.instanceof(Array)
+    })
 
-            let successfulOption = parser.OPTION(function () { return this.NEXT_TOKEN() instanceof IntToken }, () => {
-                parser.CONSUME1(IntToken)
-            })
-            expect(successfulOption).to.equal(true)
+    it("can only SAVE_ERROR for recognition exceptions", function () {
+        let parser:any = new Parser([], [])
+        expect(() => parser.SAVE_ERROR(new Error("I am some random Error")))
+            .to.throw("trying to save an Error which is not a RecognitionException")
+        expect(parser.input).to.be.an.instanceof(Array)
+    })
 
-            let failedOption = parser.OPTION(function () {
-                // this lookahead should fail because the first token has been consumed and
-                // now the next one is a PlusTok
-                return this.NEXT_TOKEN() instanceof IntToken
-            }, () => { parser.CONSUME1(IntToken) })
-            expect(failedOption).to.equal(false)
-        })
+    it("when it runs out of input EOF will be returned", function () {
+        let parser:any = new Parser([new IntToken("1"), new PlusTok()], [])
+        parser.CONSUME(IntToken)
+        parser.CONSUME(PlusTok)
+        expect(parser.NEXT_TOKEN()).to.be.an.instanceof(EOF)
+        expect(parser.NEXT_TOKEN()).to.be.an.instanceof(EOF)
+        expect(parser.SKIP_TOKEN()).to.be.an.instanceof(EOF)
+        expect(parser.SKIP_TOKEN()).to.be.an.instanceof(EOF)
+        // and we can go on and on and on... this avoid returning null/undefined
+        // see: http://en.wikipedia.org/wiki/Tony_Hoare#Apologies_and_retractions
+    })
 
-        it("will return false if a RecognitionException is thrown during " +
-            "backtracking and rethrow any other kind of Exception", function () {
-            let parser:any = new Parser([], [])
-            let backTrackingThrows = parser.BACKTRACK(() => {throw new Error("division by zero, boom")}, () => { return true })
-            expect(() => backTrackingThrows()).to.throw("division by zero, boom")
+    it("invoking an OPTION will return true/false depending if it succeeded or not", function () {
+        let parser:any = new Parser([new IntToken("1"), new PlusTok()], {})
 
-            let throwExceptionFunc = () => { throw new exceptions.NotAllInputParsedException("sad sad panda", new PlusTok()) }
-            let backTrackingFalse = parser.BACKTRACK(() => { throwExceptionFunc() }, () => { return true })
-            expect(backTrackingFalse()).to.equal(false)
+        let successfulOption = parser.OPTION(function () { return this.NEXT_TOKEN() instanceof IntToken }, () => {
+            parser.CONSUME1(IntToken)
         })
-
+        expect(successfulOption).to.equal(true)
+
+        let failedOption = parser.OPTION(function () {
+            // this lookahead should fail because the first token has been consumed and
+            // now the next one is a PlusTok
+            return this.NEXT_TOKEN() instanceof IntToken
+        }, () => { parser.CONSUME1(IntToken) })
+        expect(failedOption).to.equal(false)
     })
 
-    describe("The BaseRecognizer", function () {
+    it("will return false if a RecognitionException is thrown during " +
+        "backtracking and rethrow any other kind of Exception", function () {
+        let parser:any = new Parser([], [])
+        let backTrackingThrows = parser.BACKTRACK(() => {throw new Error("division by zero, boom")}, () => { return true })
+        expect(() => backTrackingThrows()).to.throw("division by zero, boom")
 
-        it("can be initialized with a vector of Tokens", function () {
-            let parser:any = new Parser([], [PlusTok, MinusTok, IntToken])
-            let tokensMap = (<any>parser).tokensMap
-            expect(tokensMap.PlusTok).to.equal(PlusTok)
-            expect(tokensMap.MinusTok).to.equal(MinusTok)
-            expect(tokensMap.IntToken).to.equal(IntToken)
-        })
+        let throwExceptionFunc = () => { throw new exceptions.NotAllInputParsedException("sad sad panda", new PlusTok()) }
+        let backTrackingFalse = parser.BACKTRACK(() => { throwExceptionFunc() }, () => { return true })
+        expect(backTrackingFalse()).to.equal(false)
+    })
 
-        it("can be initialized with a Dictionary of Tokens", function () {
-            let initTokenDictionary = {PlusTok: PlusTok, MinusTok: MinusTok, IntToken: IntToken}
-            let parser:any = new Parser([], {
-                PlusTok:  PlusTok,
-                MinusTok: MinusTok,
-                IntToken: IntToken
-            })
-            let tokensMap = (<any>parser).tokensMap
-            // the implementation should clone the dictionary to avoid bugs caused by mutability
-            expect(tokensMap).not.to.equal(initTokenDictionary)
-            expect(tokensMap.PlusTok).to.equal(PlusTok)
-            expect(tokensMap.MinusTok).to.equal(MinusTok)
-            expect(tokensMap.IntToken).to.equal(IntToken)
-        })
+})
 
-        it("cannot be initialized with other parameters", function () {
-            expect(() => {
-                return new Parser([], null)
-            }).to.throw()
+describe("The BaseRecognizer", function () {
 
-            expect(() => {
-                return new Parser([], <any>666)
-            }).to.throw()
+    it("can be initialized with a vector of Tokens", function () {
+        let parser:any = new Parser([], [PlusTok, MinusTok, IntToken])
+        let tokensMap = (<any>parser).tokensMap
+        expect(tokensMap.PlusTok).to.equal(PlusTok)
+        expect(tokensMap.MinusTok).to.equal(MinusTok)
+        expect(tokensMap.IntToken).to.equal(IntToken)
+    })
 
-            expect(() => {
-                return new Parser([], <any>"woof woof")
-            }).to.throw()
+    it("can be initialized with a Dictionary of Tokens", function () {
+        let initTokenDictionary = {PlusTok: PlusTok, MinusTok: MinusTok, IntToken: IntToken}
+        let parser:any = new Parser([], {
+            PlusTok:  PlusTok,
+            MinusTok: MinusTok,
+            IntToken: IntToken
         })
+        let tokensMap = (<any>parser).tokensMap
+        // the implementation should clone the dictionary to avoid bugs caused by mutability
+        expect(tokensMap).not.to.equal(initTokenDictionary)
+        expect(tokensMap.PlusTok).to.equal(PlusTok)
+        expect(tokensMap.MinusTok).to.equal(MinusTok)
+        expect(tokensMap.IntToken).to.equal(IntToken)
+    })
+
+    it("cannot be initialized with other parameters", function () {
+        expect(() => {
+            return new Parser([], null)
+        }).to.throw()
 
+        expect(() => {
+            return new Parser([], <any>666)
+        }).to.throw()
+
+        expect(() => {
+            return new Parser([], <any>"woof woof")
+        }).to.throw()
     })
 
-}
+})
diff --git a/test/requirejs_test_main.js b/test/requirejs_test_main.js
deleted file mode 100644
index 06a155c21..000000000
--- a/test/requirejs_test_main.js
+++ /dev/null
@@ -1,12 +0,0 @@
-require.config({
-    // Karma serves files under /base, which is the basePath from your config file
-    baseUrl: '/base',
-
-    paths: {
-        'lodash':     'bower_components/lodash/lodash'
-    },
-
-    deps: ['bin/chevrotainSpecs'],
-
-    callback: window.__karma__.start
-});
diff --git a/test/scan/lexer_spec.ts b/test/scan/lexer_spec.ts
index d01892be8..112bb365b 100644
--- a/test/scan/lexer_spec.ts
+++ b/test/scan/lexer_spec.ts
@@ -1,442 +1,449 @@
-namespace chevrotain.lexer.spec {
-
-    import matchers = specs.matchers
-    let NA = Lexer.NA
-    let SKIPPED = Lexer.SKIPPED
-
-
-    export class IntegerTok extends Token { static PATTERN = /^[1-9]\d*/ }
-    export class IdentifierTok extends Token { static PATTERN = /^[A-Za-z_]\w*/ }
-    export class BambaTok extends Token {
-        static PATTERN = /^bamba/
-        static LONGER_ALT = IdentifierTok
-    }
-
-    let patternsToClass = {}
-    patternsToClass[BambaTok.PATTERN.toString()] = BambaTok
-    patternsToClass[IntegerTok.PATTERN.toString()] = IntegerTok
-    patternsToClass[IdentifierTok.PATTERN.toString()] = IdentifierTok
-    let patterns:RegExp[] = <any>_.collect(_.values(patternsToClass), "PATTERN")
-
-    let testLexer = new Lexer([BambaTok, IntegerTok, IdentifierTok])
-
-    describe("The Chevrotain Simple Lexer", function () {
-
-        it("can create a token from a string with priority to the First Token class with the longest match #1", function () {
-            // this can match either IdentifierTok or BambaTok but should match BambaTok has its pattern is defined before IdentifierTok
-            let input = "bamba"
-            let result = testLexer.tokenize(input)
-            expect(result.tokens[0]).to.be.an.instanceof(BambaTok)
-            expect(result.tokens[0].image).to.equal("bamba")
-            expect(result.tokens[0].startLine).to.equal(1)
-            expect(result.tokens[0].startColumn).to.equal(1)
-        })
+import {Token} from "../../src/scan/tokens_public"
+import {Lexer, LexerDefinitionErrorType} from "../../src/scan/lexer_public"
+import {
+    findMissingPatterns,
+    countLineTerminators,
+    analyzeTokenClasses,
+    addStartOfInput,
+    findInvalidGroupType,
+    findEndOfInputAnchor,
+    findDuplicatePatterns,
+    findUnsupportedFlags,
+    findInvalidPatterns
+} from "../../src/scan/lexer"
+import {setEquality} from "../utils/matchers"
+import * as _ from "lodash"
+
+
+export class IntegerTok extends Token { static PATTERN = /^[1-9]\d*/ }
+export class IdentifierTok extends Token { static PATTERN = /^[A-Za-z_]\w*/ }
+export class BambaTok extends Token {
+    static PATTERN = /^bamba/
+    static LONGER_ALT = IdentifierTok
+}
 
-        it("can create a token from a string with priority to the First Token class with the longest match #2", function () {
-            let input = "bambaMIA"
-            let result = testLexer.tokenize(input)
-            expect(result.tokens[0]).to.be.an.instanceof(IdentifierTok)
-            expect(result.tokens[0].image).to.equal("bambaMIA")
-            expect(result.tokens[0].startLine).to.equal(1)
-            expect(result.tokens[0].startColumn).to.equal(1)
-        })
+let patternsToClass = {}
+patternsToClass[BambaTok.PATTERN.toString()] = BambaTok
+patternsToClass[IntegerTok.PATTERN.toString()] = IntegerTok
+patternsToClass[IdentifierTok.PATTERN.toString()] = IdentifierTok
+let patterns:RegExp[] = <any>_.collect(_.values(patternsToClass), "PATTERN")
 
-        it("can create a token from a string", function () {
-            let input = "6666543221231"
-            let result = testLexer.tokenize(input)
-            expect(result.tokens[0]).to.be.an.instanceof(IntegerTok)
-            expect(result.tokens[0].image).to.equal("6666543221231")
-            expect(result.tokens[0].startLine).to.equal(1)
-            expect(result.tokens[0].startColumn).to.equal(1)
-        })
-    })
+let testLexer = new Lexer([BambaTok, IntegerTok, IdentifierTok])
 
+describe("The Chevrotain Simple Lexer", function () {
 
-    class ValidNaPattern extends Token {
-        static PATTERN = NA
-    }
+    it("can create a token from a string with priority to the First Token class with the longest match #1", function () {
+        // this can match either IdentifierTok or BambaTok but should match BambaTok has its pattern is defined before IdentifierTok
+        let input = "bamba"
+        let result = testLexer.tokenize(input)
+        expect(result.tokens[0]).to.be.an.instanceof(BambaTok)
+        expect(result.tokens[0].image).to.equal("bamba")
+        expect(result.tokens[0].startLine).to.equal(1)
+        expect(result.tokens[0].startColumn).to.equal(1)
+    })
 
-    class ValidNaPattern2 extends Token {
-        static PATTERN = NA
-    }
+    it("can create a token from a string with priority to the First Token class with the longest match #2", function () {
+        let input = "bambaMIA"
+        let result = testLexer.tokenize(input)
+        expect(result.tokens[0]).to.be.an.instanceof(IdentifierTok)
+        expect(result.tokens[0].image).to.equal("bambaMIA")
+        expect(result.tokens[0].startLine).to.equal(1)
+        expect(result.tokens[0].startColumn).to.equal(1)
+    })
 
-    class InvalidPattern extends Token {
-        static PATTERN = "BAMBA"
-    }
+    it("can create a token from a string", function () {
+        let input = "6666543221231"
+        let result = testLexer.tokenize(input)
+        expect(result.tokens[0]).to.be.an.instanceof(IntegerTok)
+        expect(result.tokens[0].image).to.equal("6666543221231")
+        expect(result.tokens[0].startLine).to.equal(1)
+        expect(result.tokens[0].startColumn).to.equal(1)
+    })
+})
 
-    class MissingPattern extends Token {}
 
-    class MultiLinePattern extends Token {
-        static PATTERN = /bamba/m
-    }
+class ValidNaPattern extends Token {
+    static PATTERN = Lexer.NA
+}
 
-    class EndOfInputAnchor extends Token {
-        static PATTERN = /BAMBA$/
-    }
+class ValidNaPattern2 extends Token {
+    static PATTERN = Lexer.NA
+}
 
-    class GlobalPattern extends Token {
-        static PATTERN = /bamba/g
-    }
+class InvalidPattern extends Token {
+    static PATTERN = "BAMBA"
+}
 
-    class CaseInsensitivePattern extends Token {
-        static PATTERN = /bamba/i
-    }
+class MissingPattern extends Token {}
 
-    class IntegerValid extends Token {
-        static PATTERN = /0\d*/
-    }
+class MultiLinePattern extends Token {
+    static PATTERN = /bamba/m
+}
 
-    class DecimalInvalid extends Token {
-        static PATTERN = /0\d*/ // oops we did copy paste and forgot to change the pattern same as Integer
-    }
+class EndOfInputAnchor extends Token {
+    static PATTERN = /BAMBA$/
+}
 
-    class Skipped extends Token {
-        static GROUP = SKIPPED
-    }
+class GlobalPattern extends Token {
+    static PATTERN = /bamba/g
+}
 
-    class Special extends Token {
-        static GROUP = "Strange"
-    }
+class CaseInsensitivePattern extends Token {
+    static PATTERN = /bamba/i
+}
 
-    class InvalidGroupNumber extends Token {
-        static PATTERN = /\d\d\d/
-        static GROUP = 666
-    }
+class IntegerValid extends Token {
+    static PATTERN = /0\d*/
+}
 
-    describe("The Simple Lexer Validations", function () {
+class DecimalInvalid extends Token {
+    static PATTERN = /0\d*/ // oops we did copy paste and forgot to change the pattern same as Integer
+}
 
-        it("won't detect valid patterns as missing", function () {
-            let result = findMissingPatterns([BambaTok, IntegerTok, IdentifierTok])
-            //noinspection BadExpressionStatementJS
-            expect(result.errors).to.be.empty
-            expect(result.validTokenClasses).to.deep.equal([BambaTok, IntegerTok, IdentifierTok])
-        })
+class Skipped extends Token {
+    static GROUP = Lexer.SKIPPED
+}
 
-        it("will detect missing patterns", function () {
-            let tokenClasses = [ValidNaPattern, MissingPattern]
-            let result = findMissingPatterns(tokenClasses)
-            expect(result.errors.length).to.equal(1)
-            expect(result.errors[0].tokenClasses).to.deep.equal([MissingPattern])
-            expect(result.errors[0].type).to.equal(LexerDefinitionErrorType.MISSING_PATTERN)
-            expect(result.errors[0].message).to.contain("MissingPattern")
-            expect(result.validTokenClasses).to.deep.equal([ValidNaPattern])
-        })
+class Special extends Token {
+    static GROUP = "Strange"
+}
 
-        it("won't detect valid patterns as invalid", function () {
-            let result = findInvalidPatterns([BambaTok, IntegerTok, IdentifierTok, ValidNaPattern])
-            //noinspection BadExpressionStatementJS
-            expect(result.errors).to.be.empty
-            expect(result.validTokenClasses).to.deep.equal([BambaTok, IntegerTok, IdentifierTok, ValidNaPattern])
-        })
+class InvalidGroupNumber extends Token {
+    static PATTERN = /\d\d\d/
+    static GROUP = 666
+}
 
-        it("will detect invalid patterns as invalid", function () {
-            let tokenClasses = [ValidNaPattern, InvalidPattern]
-            let result = findInvalidPatterns(tokenClasses)
-            expect(result.errors.length).to.equal(1)
-            expect(result.errors[0].tokenClasses).to.deep.equal([InvalidPattern])
-            expect(result.errors[0].type).to.equal(LexerDefinitionErrorType.INVALID_PATTERN)
-            expect(result.errors[0].message).to.contain("InvalidPattern")
-            expect(result.validTokenClasses).to.deep.equal([ValidNaPattern])
-        })
+describe("The Simple Lexer Validations", function () {
 
-        it("won't detect valid patterns as using unsupported flags", function () {
-            let errors = findUnsupportedFlags([BambaTok, IntegerTok, IdentifierTok, CaseInsensitivePattern])
-            //noinspection BadExpressionStatementJS
-            expect(errors).to.be.empty
-        })
+    it("won't detect valid patterns as missing", function () {
+        let result = findMissingPatterns([BambaTok, IntegerTok, IdentifierTok])
+        //noinspection BadExpressionStatementJS
+        expect(result.errors).to.be.empty
+        expect(result.validTokenClasses).to.deep.equal([BambaTok, IntegerTok, IdentifierTok])
+    })
 
-        it("will detect patterns using unsupported multiline flag", function () {
-            let tokenClasses = [ValidNaPattern, MultiLinePattern]
-            let errors = findUnsupportedFlags(tokenClasses)
-            expect(errors.length).to.equal(1)
-            expect(errors[0].tokenClasses).to.deep.equal([MultiLinePattern])
-            expect(errors[0].type).to.equal(LexerDefinitionErrorType.UNSUPPORTED_FLAGS_FOUND)
-            expect(errors[0].message).to.contain("MultiLinePattern")
-        })
+    it("will detect missing patterns", function () {
+        let tokenClasses = [ValidNaPattern, MissingPattern]
+        let result = findMissingPatterns(tokenClasses)
+        expect(result.errors.length).to.equal(1)
+        expect(result.errors[0].tokenClasses).to.deep.equal([MissingPattern])
+        expect(result.errors[0].type).to.equal(LexerDefinitionErrorType.MISSING_PATTERN)
+        expect(result.errors[0].message).to.contain("MissingPattern")
+        expect(result.validTokenClasses).to.deep.equal([ValidNaPattern])
+    })
 
-        it("will detect patterns using unsupported global flag", function () {
-            let tokenClasses = [ValidNaPattern, GlobalPattern]
-            let errors = findUnsupportedFlags(tokenClasses)
-            expect(errors.length).to.equal(1)
-            expect(errors[0].tokenClasses).to.deep.equal([GlobalPattern])
-            expect(errors[0].type).to.equal(LexerDefinitionErrorType.UNSUPPORTED_FLAGS_FOUND)
-            expect(errors[0].message).to.contain("GlobalPattern")
-        })
+    it("won't detect valid patterns as invalid", function () {
+        let result = findInvalidPatterns([BambaTok, IntegerTok, IdentifierTok, ValidNaPattern])
+        //noinspection BadExpressionStatementJS
+        expect(result.errors).to.be.empty
+        expect(result.validTokenClasses).to.deep.equal([BambaTok, IntegerTok, IdentifierTok, ValidNaPattern])
+    })
 
-        it("won't detect valid patterns as duplicates", function () {
-            let errors = findDuplicatePatterns([MultiLinePattern, IntegerValid])
-            //noinspection BadExpressionStatementJS
-            expect(errors).to.be.empty
-        })
+    it("will detect invalid patterns as invalid", function () {
+        let tokenClasses = [ValidNaPattern, InvalidPattern]
+        let result = findInvalidPatterns(tokenClasses)
+        expect(result.errors.length).to.equal(1)
+        expect(result.errors[0].tokenClasses).to.deep.equal([InvalidPattern])
+        expect(result.errors[0].type).to.equal(LexerDefinitionErrorType.INVALID_PATTERN)
+        expect(result.errors[0].message).to.contain("InvalidPattern")
+        expect(result.validTokenClasses).to.deep.equal([ValidNaPattern])
+    })
 
-        it("won't detect NA patterns as duplicates", function () {
-            let errors = findDuplicatePatterns([ValidNaPattern, ValidNaPattern2])
-            //noinspection BadExpressionStatementJS
-            expect(errors).to.be.empty
-        })
+    it("won't detect valid patterns as using unsupported flags", function () {
+        let errors = findUnsupportedFlags([BambaTok, IntegerTok, IdentifierTok, CaseInsensitivePattern])
+        //noinspection BadExpressionStatementJS
+        expect(errors).to.be.empty
+    })
 
-        it("will detect patterns using unsupported end of input anchor", function () {
-            let tokenClasses = [ValidNaPattern, EndOfInputAnchor]
-            let errors = findEndOfInputAnchor(tokenClasses)
-            expect(errors.length).to.equal(1)
-            expect(errors[0].tokenClasses).to.deep.equal([EndOfInputAnchor])
-            expect(errors[0].type).to.equal(LexerDefinitionErrorType.EOI_ANCHOR_FOUND)
-            expect(errors[0].message).to.contain("EndOfInputAnchor")
-        })
+    it("will detect patterns using unsupported multiline flag", function () {
+        let tokenClasses = [ValidNaPattern, MultiLinePattern]
+        let errors = findUnsupportedFlags(tokenClasses)
+        expect(errors.length).to.equal(1)
+        expect(errors[0].tokenClasses).to.deep.equal([MultiLinePattern])
+        expect(errors[0].type).to.equal(LexerDefinitionErrorType.UNSUPPORTED_FLAGS_FOUND)
+        expect(errors[0].message).to.contain("MultiLinePattern")
+    })
 
-        it("won't detect valid patterns as using unsupported end of input anchor", function () {
-            let errors = findEndOfInputAnchor([IntegerTok, IntegerValid])
-            //noinspection BadExpressionStatementJS
-            expect(errors).to.be.empty
-        })
+    it("will detect patterns using unsupported global flag", function () {
+        let tokenClasses = [ValidNaPattern, GlobalPattern]
+        let errors = findUnsupportedFlags(tokenClasses)
+        expect(errors.length).to.equal(1)
+        expect(errors[0].tokenClasses).to.deep.equal([GlobalPattern])
+        expect(errors[0].type).to.equal(LexerDefinitionErrorType.UNSUPPORTED_FLAGS_FOUND)
+        expect(errors[0].message).to.contain("GlobalPattern")
+    })
 
-        it("will detect identical patterns for different classes", function () {
-            let tokenClasses = [DecimalInvalid, IntegerValid]
-            let errors = findDuplicatePatterns(tokenClasses)
-            expect(errors.length).to.equal(1)
-            expect(errors[0].tokenClasses).to.deep.equal([DecimalInvalid, IntegerValid])
-            expect(errors[0].type).to.equal(LexerDefinitionErrorType.DUPLICATE_PATTERNS_FOUND)
-            expect(errors[0].message).to.contain("IntegerValid")
-            expect(errors[0].message).to.contain("DecimalInvalid")
-        })
+    it("won't detect valid patterns as duplicates", function () {
+        let errors = findDuplicatePatterns([MultiLinePattern, IntegerValid])
+        //noinspection BadExpressionStatementJS
+        expect(errors).to.be.empty
+    })
 
-        it("won't detect valid groups as unsupported", function () {
-            let errors = findInvalidGroupType([IntegerTok, Skipped, Special])
-            //noinspection BadExpressionStatementJS
-            expect(errors).to.be.empty
-        })
+    it("won't detect NA patterns as duplicates", function () {
+        let errors = findDuplicatePatterns([ValidNaPattern, ValidNaPattern2])
+        //noinspection BadExpressionStatementJS
+        expect(errors).to.be.empty
+    })
 
-        it("will detect unsupported group types", function () {
-            let tokenClasses = [InvalidGroupNumber]
-            let errors = findInvalidGroupType(tokenClasses)
-            expect(errors.length).to.equal(1)
-            expect(errors[0].tokenClasses).to.deep.equal([InvalidGroupNumber])
-            expect(errors[0].type).to.equal(LexerDefinitionErrorType.INVALID_GROUP_TYPE_FOUND)
-            expect(errors[0].message).to.contain("InvalidGroupNumber")
-        })
+    it("will detect patterns using unsupported end of input anchor", function () {
+        let tokenClasses = [ValidNaPattern, EndOfInputAnchor]
+        let errors = findEndOfInputAnchor(tokenClasses)
+        expect(errors.length).to.equal(1)
+        expect(errors[0].tokenClasses).to.deep.equal([EndOfInputAnchor])
+        expect(errors[0].type).to.equal(LexerDefinitionErrorType.EOI_ANCHOR_FOUND)
+        expect(errors[0].message).to.contain("EndOfInputAnchor")
     })
 
-    class PatternNoStart extends Token { static PATTERN = /bamba/i }
+    it("won't detect valid patterns as using unsupported end of input anchor", function () {
+        let errors = findEndOfInputAnchor([IntegerTok, IntegerValid])
+        //noinspection BadExpressionStatementJS
+        expect(errors).to.be.empty
+    })
 
-    class Keyword extends Token { static PATTERN = NA }
-    class If extends Keyword { static PATTERN = /if/ }
-    class Else extends Keyword { static PATTERN = /else/ }
-    class Return extends Keyword { static PATTERN = /return/ }
-    class Integer extends Token { static PATTERN = /[1-9]\d*/ }
-    class Punctuation extends Token { static PATTERN = NA }
-    class LParen extends Punctuation { static PATTERN = /\(/ }
-    class RParen extends Punctuation { static PATTERN = /\)/ }
+    it("will detect identical patterns for different classes", function () {
+        let tokenClasses = [DecimalInvalid, IntegerValid]
+        let errors = findDuplicatePatterns(tokenClasses)
+        expect(errors.length).to.equal(1)
+        expect(errors[0].tokenClasses).to.deep.equal([DecimalInvalid, IntegerValid])
+        expect(errors[0].type).to.equal(LexerDefinitionErrorType.DUPLICATE_PATTERNS_FOUND)
+        expect(errors[0].message).to.contain("IntegerValid")
+        expect(errors[0].message).to.contain("DecimalInvalid")
+    })
 
-    class Whitespace extends Token {
-        static PATTERN = /(\t| )/
-        static GROUP = SKIPPED
-    }
+    it("won't detect valid groups as unsupported", function () {
+        let errors = findInvalidGroupType([IntegerTok, Skipped, Special])
+        //noinspection BadExpressionStatementJS
+        expect(errors).to.be.empty
+    })
 
-    class NewLine extends Token {
-        static PATTERN = /(\n|\r|\r\n)/
-        static GROUP = SKIPPED
-    }
+    it("will detect unsupported group types", function () {
+        let tokenClasses = [InvalidGroupNumber]
+        let errors = findInvalidGroupType(tokenClasses)
+        expect(errors.length).to.equal(1)
+        expect(errors[0].tokenClasses).to.deep.equal([InvalidGroupNumber])
+        expect(errors[0].type).to.equal(LexerDefinitionErrorType.INVALID_GROUP_TYPE_FOUND)
+        expect(errors[0].message).to.contain("InvalidGroupNumber")
+    })
+})
+
+class PatternNoStart extends Token { static PATTERN = /bamba/i }
+
+class Keyword extends Token { static PATTERN = Lexer.NA }
+class If extends Keyword { static PATTERN = /if/ }
+class Else extends Keyword { static PATTERN = /else/ }
+class Return extends Keyword { static PATTERN = /return/ }
+class Integer extends Token { static PATTERN = /[1-9]\d*/ }
+class Punctuation extends Token { static PATTERN = Lexer.NA }
+class LParen extends Punctuation { static PATTERN = /\(/ }
+class RParen extends Punctuation { static PATTERN = /\)/ }
+
+class Whitespace extends Token {
+    static PATTERN = /(\t| )/
+    static GROUP = Lexer.SKIPPED
+}
 
-    class WhitespaceNotSkipped extends Token {
-        static PATTERN = /\s+/
-    }
+class NewLine extends Token {
+    static PATTERN = /(\n|\r|\r\n)/
+    static GROUP = Lexer.SKIPPED
+}
 
-    class Comment extends Token {
-        static PATTERN = /\/\/.+/
-        static GROUP = "comments"
-    }
+class WhitespaceNotSkipped extends Token {
+    static PATTERN = /\s+/
+}
 
-    class WhitespaceOrAmp extends Token {
-        static PATTERN = /\s+|&/
-    }
+class Comment extends Token {
+    static PATTERN = /\/\/.+/
+    static GROUP = "comments"
+}
 
+class WhitespaceOrAmp extends Token {
+    static PATTERN = /\s+|&/
+}
 
-    describe("The Simple Lexer transformations", function () {
 
-        it("can transform a pattern to one with startOfInput mark ('^') #1 (NO OP)", function () {
-            let orgSource = BambaTok.PATTERN.source
-            let transPattern = addStartOfInput(BambaTok.PATTERN)
-            expect(transPattern.source).to.equal("^(?:" + orgSource + ")")
-            expect(_.startsWith(transPattern.source, "^")).to.equal(true)
-        })
+describe("The Simple Lexer transformations", function () {
 
-        it("can transform a pattern to one with startOfInput mark ('^') #2", function () {
-            let orgSource = PatternNoStart.PATTERN.source
-            let transPattern = addStartOfInput(PatternNoStart.PATTERN)
-            expect(transPattern.source).to.equal("^(?:" + orgSource + ")")
-            expect(_.startsWith(transPattern.source, "^")).to.equal(true)
-        })
+    it("can transform a pattern to one with startOfInput mark ('^') #1 (NO OP)", function () {
+        let orgSource = BambaTok.PATTERN.source
+        let transPattern = addStartOfInput(BambaTok.PATTERN)
+        expect(transPattern.source).to.equal("^(?:" + orgSource + ")")
+        expect(_.startsWith(transPattern.source, "^")).to.equal(true)
+    })
 
-        it("can transform/analyze an array of Token Classes into matched/ignored/patternToClass", function () {
-            let tokenClasses = [Keyword, If, Else, Return, Integer, Punctuation, LParen, RParen, Whitespace, NewLine]
-            let analyzeResult = analyzeTokenClasses(tokenClasses)
-            expect(analyzeResult.allPatterns.length).to.equal(8)
-            let allPatternsString = _.map(analyzeResult.allPatterns, (pattern) => {
-                return pattern.source
-            })
-            matchers.setEquality(allPatternsString, ["^(?:(\\t| ))", "^(?:(\\n|\\r|\\r\\n))",
-                "^(?:\\()", "^(?:\\))", "^(?:[1-9]\\d*)", "^(?:if)", "^(?:else)", "^(?:return)"])
-
-            let patternIdxToClass = analyzeResult.patternIdxToClass
-            expect(_.keys(patternIdxToClass).length).to.equal(8)
-            expect(patternIdxToClass[0]).to.equal(If);
-            expect(patternIdxToClass[1]).to.equal(Else);
-            expect(patternIdxToClass[2]).to.equal(Return);
-            expect(patternIdxToClass[3]).to.equal(Integer);
-            expect(patternIdxToClass[4]).to.equal(LParen);
-            expect(patternIdxToClass[5]).to.equal(RParen);
-            expect(patternIdxToClass[6]).to.equal(Whitespace);
-            expect(patternIdxToClass[7]).to.equal(NewLine);
-        })
+    it("can transform a pattern to one with startOfInput mark ('^') #2", function () {
+        let orgSource = PatternNoStart.PATTERN.source
+        let transPattern = addStartOfInput(PatternNoStart.PATTERN)
+        expect(transPattern.source).to.equal("^(?:" + orgSource + ")")
+        expect(_.startsWith(transPattern.source, "^")).to.equal(true)
+    })
 
-        it("can count the number of line terminators in a string", function () {
-            expect(countLineTerminators("bamba\r\nbisli\r")).to.equal(2)
-            expect(countLineTerminators("\r\r\r1234\r\n")).to.equal(4)
-            expect(countLineTerminators("aaaa\raaa\n\r1234\n")).to.equal(4)
+    it("can transform/analyze an array of Token Classes into matched/ignored/patternToClass", function () {
+        let tokenClasses = [Keyword, If, Else, Return, Integer, Punctuation, LParen, RParen, Whitespace, NewLine]
+        let analyzeResult = analyzeTokenClasses(tokenClasses)
+        expect(analyzeResult.allPatterns.length).to.equal(8)
+        let allPatternsString = _.map(analyzeResult.allPatterns, (pattern) => {
+            return pattern.source
         })
+        setEquality(allPatternsString, ["^(?:(\\t| ))", "^(?:(\\n|\\r|\\r\\n))",
+            "^(?:\\()", "^(?:\\))", "^(?:[1-9]\\d*)", "^(?:if)", "^(?:else)", "^(?:return)"])
+
+        let patternIdxToClass = analyzeResult.patternIdxToClass
+        expect(_.keys(patternIdxToClass).length).to.equal(8)
+        expect(patternIdxToClass[0]).to.equal(If);
+        expect(patternIdxToClass[1]).to.equal(Else);
+        expect(patternIdxToClass[2]).to.equal(Return);
+        expect(patternIdxToClass[3]).to.equal(Integer);
+        expect(patternIdxToClass[4]).to.equal(LParen);
+        expect(patternIdxToClass[5]).to.equal(RParen);
+        expect(patternIdxToClass[6]).to.equal(Whitespace);
+        expect(patternIdxToClass[7]).to.equal(NewLine);
     })
 
-    describe("The Simple Lexer Full flow", function () {
-
-        it("can create a simple Lexer from a List of Token Classes", function () {
-            let ifElseLexer = new Lexer([Keyword, If, Else, Return, Integer, Punctuation, LParen, RParen, Whitespace, NewLine])
-            //noinspection BadExpressionStatementJS
-            expect(ifElseLexer.lexerDefinitionErrors).to.be.empty
-
-            let input = "if (666) return 1\n" +
-                "\telse return 2"
-
-            let lexResult = ifElseLexer.tokenize(input)
-            expect(lexResult.tokens).to.deep.equal([new If("if", 0, 1, 1), new LParen("(", 3, 1, 4), new Integer("666", 4, 1, 5),
-                new RParen(")", 7, 1, 8), new Return("return", 9, 1, 10), new Integer("1", 16, 1, 17), new Else("else", 19, 2, 2),
-                new Return("return", 24, 2, 7), new Integer("2", 31, 2, 14)
-            ])
-            // TODO: support returning skipped tokens under certain conditions (token groups)
-            //expect(lexResult.skipped).to.deep.equal([new Whitespace(1, 3, " "), new Whitespace(1, 9, " "), new Whitespace(1, 16, " "),
-            //    new NewLine(1, 18, "\n"), new Whitespace(2, 1, "\t"), new Whitespace(2, 6, " "), new Whitespace(2, 13, " ")])
-        })
+    it("can count the number of line terminators in a string", function () {
+        expect(countLineTerminators("bamba\r\nbisli\r")).to.equal(2)
+        expect(countLineTerminators("\r\r\r1234\r\n")).to.equal(4)
+        expect(countLineTerminators("aaaa\raaa\n\r1234\n")).to.equal(4)
+    })
+})
+
+describe("The Simple Lexer Full flow", function () {
+
+    it("can create a simple Lexer from a List of Token Classes", function () {
+        let ifElseLexer = new Lexer([Keyword, If, Else, Return, Integer, Punctuation, LParen, RParen, Whitespace, NewLine])
+        //noinspection BadExpressionStatementJS
+        expect(ifElseLexer.lexerDefinitionErrors).to.be.empty
+
+        let input = "if (666) return 1\n" +
+            "\telse return 2"
+
+        let lexResult = ifElseLexer.tokenize(input)
+        expect(lexResult.tokens).to.deep.equal([new If("if", 0, 1, 1), new LParen("(", 3, 1, 4), new Integer("666", 4, 1, 5),
+            new RParen(")", 7, 1, 8), new Return("return", 9, 1, 10), new Integer("1", 16, 1, 17), new Else("else", 19, 2, 2),
+            new Return("return", 24, 2, 7), new Integer("2", 31, 2, 14)
+        ])
+        // TODO: support returning skipped tokens under certain conditions (token groups)
+        //expect(lexResult.skipped).to.deep.equal([new Whitespace(1, 3, " "), new Whitespace(1, 9, " "), new Whitespace(1, 16, " "),
+        //    new NewLine(1, 18, "\n"), new Whitespace(2, 1, "\t"), new Whitespace(2, 6, " "), new Whitespace(2, 13, " ")])
+    })
 
-        it("Will throw an error during the creation of a Lexer if the Lexer's definition is invalid", function () {
-            expect(() => new Lexer([EndOfInputAnchor, If, Else])).to.throw(/Errors detected in definition of Lexer/)
-            expect(() => new Lexer([EndOfInputAnchor, If, Else])).to.throw(/EndOfInputAnchor/)
-        })
+    it("Will throw an error during the creation of a Lexer if the Lexer's definition is invalid", function () {
+        expect(() => new Lexer([EndOfInputAnchor, If, Else])).to.throw(/Errors detected in definition of Lexer/)
+        expect(() => new Lexer([EndOfInputAnchor, If, Else])).to.throw(/EndOfInputAnchor/)
+    })
 
-        it("can defer the throwing of errors during the creation of a Lexer if the Lexer's definition is invalid", function () {
-            expect(() => new Lexer([EndOfInputAnchor, If, Else], true)).to.not.throw(/Errors detected in definition of Lexer/)
-            expect(() => new Lexer([EndOfInputAnchor, If, Else], true)).to.not.throw(/EndOfInputAnchor/)
+    it("can defer the throwing of errors during the creation of a Lexer if the Lexer's definition is invalid", function () {
+        expect(() => new Lexer([EndOfInputAnchor, If, Else], true)).to.not.throw(/Errors detected in definition of Lexer/)
+        expect(() => new Lexer([EndOfInputAnchor, If, Else], true)).to.not.throw(/EndOfInputAnchor/)
 
-            let lexerWithErrs = new Lexer([EndOfInputAnchor, If, Else], true)
-            //noinspection BadExpressionStatementJS
-            expect(lexerWithErrs.lexerDefinitionErrors).to.not.be.empty
-            // even when the Error handling is deferred, actual usage of an invalid lexer is not permitted!
-            expect(() => lexerWithErrs.tokenize("else")).to.throw(/Unable to Tokenize because Errors detected in definition of Lexer/)
-            expect(() => lexerWithErrs.tokenize("else")).to.throw(/EndOfInputAnchor/)
-        })
+        let lexerWithErrs = new Lexer([EndOfInputAnchor, If, Else], true)
+        //noinspection BadExpressionStatementJS
+        expect(lexerWithErrs.lexerDefinitionErrors).to.not.be.empty
+        // even when the Error handling is deferred, actual usage of an invalid lexer is not permitted!
+        expect(() => lexerWithErrs.tokenize("else")).to.throw(/Unable to Tokenize because Errors detected in definition of Lexer/)
+        expect(() => lexerWithErrs.tokenize("else")).to.throw(/EndOfInputAnchor/)
+    })
 
-        it("can skip invalid character inputs and only report one error per sequence of characters skipped", function () {
-            let ifElseLexer = new Lexer([Keyword, If, Else, Return, Integer, Punctuation, LParen, RParen, Whitespace, NewLine])
-
-
-            let input = "if (666) return 1@#$@#$\n" +
-                "\telse return 2"
-
-            let lexResult = ifElseLexer.tokenize(input)
-            expect(lexResult.errors.length).to.equal(1)
-            expect(lexResult.errors[0].message).to.contain("@")
-            expect(lexResult.errors[0].line).to.equal(1)
-            expect(lexResult.errors[0].column).to.equal(18)
-            expect(lexResult.errors[0].length).to.equal(6)
-            expect(lexResult.tokens).to.deep.equal([new If("if", 0, 1, 1), new LParen("(", 3, 1, 4), new Integer("666", 4, 1, 5),
-                new RParen(")", 7, 1, 8), new Return("return", 9, 1, 10), new Integer("1", 16, 1, 17), new Else("else", 25, 2, 2),
-                new Return("return", 30, 2, 7), new Integer("2", 37, 2, 14)
-            ])
-            // TODO: support returning skipped tokens under certain conditions (token groups)
-            //expect(lexResult.skipped).to.deep.equal([new Whitespace(1, 3, " "), new Whitespace(1, 9, " "), new Whitespace(1, 16, " "),
-            //    new NewLine(1, 24, "\n"), new Whitespace(2, 1, "\t"), new Whitespace(2, 6, " "), new Whitespace(2, 13, " ")])
-        })
+    it("can skip invalid character inputs and only report one error per sequence of characters skipped", function () {
+        let ifElseLexer = new Lexer([Keyword, If, Else, Return, Integer, Punctuation, LParen, RParen, Whitespace, NewLine])
+
+
+        let input = "if (666) return 1@#$@#$\n" +
+            "\telse return 2"
+
+        let lexResult = ifElseLexer.tokenize(input)
+        expect(lexResult.errors.length).to.equal(1)
+        expect(lexResult.errors[0].message).to.contain("@")
+        expect(lexResult.errors[0].line).to.equal(1)
+        expect(lexResult.errors[0].column).to.equal(18)
+        expect(lexResult.errors[0].length).to.equal(6)
+        expect(lexResult.tokens).to.deep.equal([new If("if", 0, 1, 1), new LParen("(", 3, 1, 4), new Integer("666", 4, 1, 5),
+            new RParen(")", 7, 1, 8), new Return("return", 9, 1, 10), new Integer("1", 16, 1, 17), new Else("else", 25, 2, 2),
+            new Return("return", 30, 2, 7), new Integer("2", 37, 2, 14)
+        ])
+        // TODO: support returning skipped tokens under certain conditions (token groups)
+        //expect(lexResult.skipped).to.deep.equal([new Whitespace(1, 3, " "), new Whitespace(1, 9, " "), new Whitespace(1, 16, " "),
+        //    new NewLine(1, 24, "\n"), new Whitespace(2, 1, "\t"), new Whitespace(2, 6, " "), new Whitespace(2, 13, " ")])
+    })
 
-        it("won't go into infinite loops when skipping at end of input", function () {
-            let ifElseLexer = new Lexer([Keyword, If, Else, Return, Integer, Punctuation, LParen, RParen, Whitespace, NewLine])
-
-            let input = "if&&&&&&&&&&&&&&&&&&&&&&&&&&&&"
-            let lexResult = ifElseLexer.tokenize(input)
-            expect(lexResult.errors.length).to.equal(1)
-            expect(lexResult.errors[0].message).to.contain("&")
-            expect(lexResult.errors[0].line).to.equal(1)
-            expect(lexResult.errors[0].column).to.equal(3)
-            expect(lexResult.errors[0].length).to.equal(28)
-            expect(lexResult.tokens).to.deep.equal([new If("if", 0, 1, 1)])
-        })
+    it("won't go into infinite loops when skipping at end of input", function () {
+        let ifElseLexer = new Lexer([Keyword, If, Else, Return, Integer, Punctuation, LParen, RParen, Whitespace, NewLine])
+
+        let input = "if&&&&&&&&&&&&&&&&&&&&&&&&&&&&"
+        let lexResult = ifElseLexer.tokenize(input)
+        expect(lexResult.errors.length).to.equal(1)
+        expect(lexResult.errors[0].message).to.contain("&")
+        expect(lexResult.errors[0].line).to.equal(1)
+        expect(lexResult.errors[0].column).to.equal(3)
+        expect(lexResult.errors[0].length).to.equal(28)
+        expect(lexResult.tokens).to.deep.equal([new If("if", 0, 1, 1)])
+    })
 
-        it("can deal with line terminators during resync", function () {
-            let ifElseLexer = new Lexer([If, Else]) // no newLine tokens those will be resynced
-
-            let input = "if\r\nelse\rif\r"
-            let lexResult = ifElseLexer.tokenize(input)
-            expect(lexResult.errors.length).to.equal(3)
-            expect(lexResult.errors[0].message).to.contain("\r")
-            expect(lexResult.errors[0].line).to.equal(1)
-            expect(lexResult.errors[0].column).to.equal(3)
-            expect(lexResult.errors[0].length).to.equal(2)
-
-            expect(lexResult.errors[1].message).to.contain("\r")
-            expect(lexResult.errors[1].line).to.equal(2)
-            expect(lexResult.errors[1].column).to.equal(5)
-            expect(lexResult.errors[1].length).to.equal(1)
-
-            expect(lexResult.errors[2].message).to.contain("\r")
-            expect(lexResult.errors[2].line).to.equal(3)
-            expect(lexResult.errors[2].column).to.equal(3)
-            expect(lexResult.errors[2].length).to.equal(1)
-            expect(lexResult.tokens).to.deep.equal([new If("if", 0, 1, 1), new Else("else", 4, 2, 1), new If("if", 9, 3, 1)])
-        })
+    it("can deal with line terminators during resync", function () {
+        let ifElseLexer = new Lexer([If, Else]) // no newLine tokens those will be resynced
+
+        let input = "if\r\nelse\rif\r"
+        let lexResult = ifElseLexer.tokenize(input)
+        expect(lexResult.errors.length).to.equal(3)
+        expect(lexResult.errors[0].message).to.contain("\r")
+        expect(lexResult.errors[0].line).to.equal(1)
+        expect(lexResult.errors[0].column).to.equal(3)
+        expect(lexResult.errors[0].length).to.equal(2)
+
+        expect(lexResult.errors[1].message).to.contain("\r")
+        expect(lexResult.errors[1].line).to.equal(2)
+        expect(lexResult.errors[1].column).to.equal(5)
+        expect(lexResult.errors[1].length).to.equal(1)
+
+        expect(lexResult.errors[2].message).to.contain("\r")
+        expect(lexResult.errors[2].line).to.equal(3)
+        expect(lexResult.errors[2].column).to.equal(3)
+        expect(lexResult.errors[2].length).to.equal(1)
+        expect(lexResult.tokens).to.deep.equal([new If("if", 0, 1, 1), new Else("else", 4, 2, 1), new If("if", 9, 3, 1)])
+    })
 
-        it("can deal with line terminators inside multi-line Tokens", function () {
-            let ifElseLexer = new Lexer([If, Else, WhitespaceNotSkipped])
+    it("can deal with line terminators inside multi-line Tokens", function () {
+        let ifElseLexer = new Lexer([If, Else, WhitespaceNotSkipped])
 
-            let input = "if\r\r\telse\rif\n"
-            let lexResult = ifElseLexer.tokenize(input)
+        let input = "if\r\r\telse\rif\n"
+        let lexResult = ifElseLexer.tokenize(input)
 
-            expect(lexResult.tokens).to.deep.equal([
-                new If("if", 0, 1, 1, 1, 2),
-                new WhitespaceNotSkipped("\r\r\t", 2, 1, 3, 3, 1),
-                new Else("else", 5, 3, 2, 3, 5),
-                new WhitespaceNotSkipped("\r", 9, 3, 6, 3, 6),
-                new If("if", 10, 4, 1, 4, 2),
-                new WhitespaceNotSkipped("\n", 12, 4, 3, 4, 3),
-            ])
-        })
+        expect(lexResult.tokens).to.deep.equal([
+            new If("if", 0, 1, 1, 1, 2),
+            new WhitespaceNotSkipped("\r\r\t", 2, 1, 3, 3, 1),
+            new Else("else", 5, 3, 2, 3, 5),
+            new WhitespaceNotSkipped("\r", 9, 3, 6, 3, 6),
+            new If("if", 10, 4, 1, 4, 2),
+            new WhitespaceNotSkipped("\n", 12, 4, 3, 4, 3),
+        ])
+    })
 
-        it("can deal with Tokens which may or may not be a lineTerminator", function () {
-            let ifElseLexer = new Lexer([If, Else, WhitespaceOrAmp])
+    it("can deal with Tokens which may or may not be a lineTerminator", function () {
+        let ifElseLexer = new Lexer([If, Else, WhitespaceOrAmp])
 
-            let input = "if\r\r\telse&if"
-            let lexResult = ifElseLexer.tokenize(input)
+        let input = "if\r\r\telse&if"
+        let lexResult = ifElseLexer.tokenize(input)
 
-            expect(lexResult.tokens).to.deep.equal([
-                new If("if", 0, 1, 1, 1, 2),
-                new WhitespaceOrAmp("\r\r\t", 2, 1, 3, 3, 1),
-                new Else("else", 5, 3, 2, 3, 5),
-                new WhitespaceOrAmp("&", 9, 3, 6, 3, 6),
-                new If("if", 10, 3, 7, 3, 8),
-            ])
-        })
+        expect(lexResult.tokens).to.deep.equal([
+            new If("if", 0, 1, 1, 1, 2),
+            new WhitespaceOrAmp("\r\r\t", 2, 1, 3, 3, 1),
+            new Else("else", 5, 3, 2, 3, 5),
+            new WhitespaceOrAmp("&", 9, 3, 6, 3, 6),
+            new If("if", 10, 3, 7, 3, 8),
+        ])
+    })
 
-        it("supports Token groups", function () {
+    it("supports Token groups", function () {
 
-            let ifElseLexer = new Lexer([If, Else, Comment])
-            let input = "if//else"
-            let lexResult = ifElseLexer.tokenize(input)
+        let ifElseLexer = new Lexer([If, Else, Comment])
+        let input = "if//else"
+        let lexResult = ifElseLexer.tokenize(input)
 
-            expect(lexResult.tokens).to.deep.equal([
-                new If("if", 0, 1, 1, 1, 2),
-            ])
+        expect(lexResult.tokens).to.deep.equal([
+            new If("if", 0, 1, 1, 1, 2),
+        ])
 
-            expect((<any>lexResult.groups).comments).to.deep.equal([
-                new Comment("//else", 2, 1, 3, 1, 8),
-            ])
-        })
+        expect((<any>lexResult.groups).comments).to.deep.equal([
+            new Comment("//else", 2, 1, 3, 1, 8),
+        ])
     })
-}
-
-
+})
diff --git a/test/scan/token_spec.ts b/test/scan/token_spec.ts
index b0208027a..6bdf1822b 100644
--- a/test/scan/token_spec.ts
+++ b/test/scan/token_spec.ts
@@ -1,65 +1,61 @@
+import {extendToken, tokenName, Token} from "../../src/scan/tokens_public"
 
-namespace chevrotain.tokens.spec {
+let TrueLiteral = extendToken("TrueLiteral")
+class FalseLiteral extends Token {}
 
-    import tok = chevrotain.tokens
+describe("The Chevrotain Tokens namespace", function () {
+    "use strict"
 
-    let TrueLiteral = extendToken("TrueLiteral")
-    class FalseLiteral extends Token {}
-
-    describe("The Chevrotain Tokens namespace", function () {
-        "use strict"
-
-        it("exports a utility function that returns a token's name", function () {
-            // FalseLiteral was created with an anonymous function as its constructor yet tokenName(...)
-            // should still work correctly on it if the 'tokenName' property has been set on its constructor.
-            expect(tokenName(FalseLiteral)).to.equal("FalseLiteral")
-            expect(tokenName(TrueLiteral)).to.equal("TrueLiteral")
-        })
-
-        let A = extendToken("A")
-        let B = extendToken("B", A)
-        B.GROUP = "Special"
-
-        let C = extendToken("C", /\d+/, B)
-        let D = extendToken("D", /\w+/, B)
+    it("exports a utility function that returns a token's name", function () {
+        // FalseLiteral was created with an anonymous function as its constructor yet tokenName(...)
+        // should still work correctly on it if the 'tokenName' property has been set on its constructor.
+        expect(tokenName(FalseLiteral)).to.equal("FalseLiteral")
+        expect(tokenName(TrueLiteral)).to.equal("TrueLiteral")
+    })
 
-        it("provides an extendToken utility - creating an instance", function () {
-            let aInstance = new A("Hello", 0, 1, 1)
-            expect(aInstance.image).to.equal("Hello")
-            expect(aInstance.offset).to.equal(0)
-            expect(aInstance.startLine).to.equal(1)
-            expect(aInstance.endLine).to.equal(1)
-            expect(aInstance.startColumn).to.equal(1)
-            expect(aInstance.endColumn).to.equal(5)
-        })
+    let A = extendToken("A")
+    let B = extendToken("B", A)
+    B.GROUP = "Special"
+
+    let C = extendToken("C", /\d+/, B)
+    let D = extendToken("D", /\w+/, B)
+
+    it("provides an extendToken utility - creating an instance", function () {
+        let aInstance = new A("Hello", 0, 1, 1)
+        expect(aInstance.image).to.equal("Hello")
+        expect(aInstance.offset).to.equal(0)
+        expect(aInstance.startLine).to.equal(1)
+        expect(aInstance.endLine).to.equal(1)
+        expect(aInstance.startColumn).to.equal(1)
+        expect(aInstance.endColumn).to.equal(5)
+    })
 
-        it("provides an extendToken utility - creating a subclass instance", function () {
-            let aInstance = new C("world", 0, 1, 1)
-            expect(aInstance.image).to.equal("world")
-            expect(aInstance.offset).to.equal(0)
-            expect(aInstance.startLine).to.equal(1)
-            expect(aInstance.endLine).to.equal(1)
-            expect(aInstance.startColumn).to.equal(1)
-            expect(aInstance.endColumn).to.equal(5)
-        })
+    it("provides an extendToken utility - creating a subclass instance", function () {
+        let aInstance = new C("world", 0, 1, 1)
+        expect(aInstance.image).to.equal("world")
+        expect(aInstance.offset).to.equal(0)
+        expect(aInstance.startLine).to.equal(1)
+        expect(aInstance.endLine).to.equal(1)
+        expect(aInstance.startColumn).to.equal(1)
+        expect(aInstance.endColumn).to.equal(5)
+    })
 
-        it("provides an extendToken utility - inheritance chain", function () {
-            let dInstance = new D("world", 0, 1, 1)
-            expect(dInstance).to.be.an.instanceof(A)
-            expect(dInstance).to.be.an.instanceof(B)
-            expect(dInstance).not.to.be.an.instanceof(C)
+    it("provides an extendToken utility - inheritance chain", function () {
+        let dInstance = new D("world", 0, 1, 1)
+        expect(dInstance).to.be.an.instanceof(A)
+        expect(dInstance).to.be.an.instanceof(B)
+        expect(dInstance).not.to.be.an.instanceof(C)
 
-            let cInstance = new C("666", 0, 1, 1)
-            expect(cInstance).to.be.an.instanceof(A)
-            expect(cInstance).to.be.an.instanceof(B)
+        let cInstance = new C("666", 0, 1, 1)
+        expect(cInstance).to.be.an.instanceof(A)
+        expect(cInstance).to.be.an.instanceof(B)
 
-            let bInstance = new B("666", 0, 1, 1)
-            expect(bInstance).to.be.an.instanceof(A)
-        })
+        let bInstance = new B("666", 0, 1, 1)
+        expect(bInstance).to.be.an.instanceof(A)
+    })
 
-        it("provides an extendToken utility - static properties inheritance", function () {
-            expect(D.GROUP).to.equal("Special")
-            expect(C.GROUP).to.equal("Special")
-        })
+    it("provides an extendToken utility - static properties inheritance", function () {
+        expect(D.GROUP).to.equal("Special")
+        expect(C.GROUP).to.equal("Special")
     })
-}
+})
diff --git a/test/test.config.js b/test/test.config.js
index 561d62662..a1973ea4a 100644
--- a/test/test.config.js
+++ b/test/test.config.js
@@ -1,14 +1,7 @@
-// CHEV_TEST_MODE will cause the WHOLE 'chevrotain' namespace object to be exported
-// normally during production this flag is undefined (false), and only a small part
-// of Chevrotain is exposed as a public API.
-
 if (typeof global === "object") {
-    console.log("CHEV_TEST_MODE flag enabled")
-    global.CHEV_TEST_MODE = true
     global.expect = require("chai").expect
 }
 
 else if (typeof window === "object") {
-    console.log("CHEV_TEST_MODE flag enabled")
-    window.CHEV_TEST_MODE = true
-}
\ No newline at end of file
+    window.expect = chai.expect
+}
diff --git a/test/text/range_spec.ts b/test/text/range_spec.ts
index 48b05308b..1a0031359 100644
--- a/test/text/range_spec.ts
+++ b/test/text/range_spec.ts
@@ -1,64 +1,60 @@
+import {Range} from "../../src/text/range"
 
-namespace chevrotain.range.spec {
+describe("The Chevrotain Range namespace", function () {
 
+    it("an invalid range can not be created", function () {
+        expect(() => { return new Range(5, 1)}).to.throw("INVALID RANGE")
+        expect(() => { return new Range(-1, 2)}).to.throw("INVALID RANGE")
+    })
 
-    describe("The Chevrotain Range namespace", function () {
-
-        it("an invalid range can not be created", function () {
-            expect(() => { return new Range(5, 1)}).to.throw("INVALID RANGE")
-            expect(() => { return new Range(-1, 2)}).to.throw("INVALID RANGE")
-        })
-
-        it("can check if a number is contained in a give range", function () {
-            let r = new Range(90, 110)
-            expect(r.contains(-4)).to.equal(false)
-            expect(r.contains(30)).to.equal(false)
-            expect(r.contains(89)).to.equal(false)
-            expect(r.contains(90)).to.equal(true)
-            expect(r.contains(99)).to.equal(true)
-            expect(r.contains(105)).to.equal(true)
-            expect(r.contains(110)).to.equal(true)
-            expect(r.contains(111)).to.equal(false)
-            expect(r.contains(999)).to.equal(false)
-        })
-
-        it("can check if it is contained in another range", function () {
-            let _10_50 = new Range(10, 50)
-            let _1_6 = new Range(1, 6)
-            let _5_15 = new Range(5, 15)
-            let _20_35 = new Range(20, 35)
-            let _45_55 = new Range(45, 55)
-            let _51_100 = new Range(51, 100)
-
-            expect(_1_6.isContainedInRange(_10_50)).to.equal(false)
-            expect(_5_15.isContainedInRange(_10_50)).to.equal(false)
-            expect(_20_35.isContainedInRange(_10_50)).to.equal(true)
-            expect(_10_50.isContainedInRange(_10_50)).to.equal(true)
-            expect(_45_55.isContainedInRange(_10_50)).to.equal(false)
-            expect(_51_100.isContainedInRange(_10_50)).to.equal(false)
-        })
-
-        it("can check if it is strictly contained in another range", function () {
-            let _10_50 = new Range(10, 50)
-
-            let _1_6 = new Range(1, 6)
-            let _10_11 = new Range(10, 11)
-            let _5_15 = new Range(5, 15)
-            let _20_35 = new Range(20, 35)
-            let _45_55 = new Range(45, 55)
-            let _49_50 = new Range(49, 50)
-            let _51_100 = new Range(51, 100)
-
-            expect(_1_6.isStrictlyContainedInRange(_10_50)).to.equal(false)
-            expect(_10_11.isStrictlyContainedInRange(_10_50)).to.equal(false)
-            expect(_5_15.isStrictlyContainedInRange(_10_50)).to.equal(false)
-            expect(_20_35.isStrictlyContainedInRange(_10_50)).to.equal(true)
-            expect(_10_50.isStrictlyContainedInRange(_10_50)).to.equal(false)
-            expect(_45_55.isStrictlyContainedInRange(_10_50)).to.equal(false)
-            expect(_49_50.isStrictlyContainedInRange(_10_50)).to.equal(false)
-            expect(_51_100.isStrictlyContainedInRange(_10_50)).to.equal(false)
-        })
+    it("can check if a number is contained in a give range", function () {
+        let r = new Range(90, 110)
+        expect(r.contains(-4)).to.equal(false)
+        expect(r.contains(30)).to.equal(false)
+        expect(r.contains(89)).to.equal(false)
+        expect(r.contains(90)).to.equal(true)
+        expect(r.contains(99)).to.equal(true)
+        expect(r.contains(105)).to.equal(true)
+        expect(r.contains(110)).to.equal(true)
+        expect(r.contains(111)).to.equal(false)
+        expect(r.contains(999)).to.equal(false)
+    })
 
+    it("can check if it is contained in another range", function () {
+        let _10_50 = new Range(10, 50)
+        let _1_6 = new Range(1, 6)
+        let _5_15 = new Range(5, 15)
+        let _20_35 = new Range(20, 35)
+        let _45_55 = new Range(45, 55)
+        let _51_100 = new Range(51, 100)
+
+        expect(_1_6.isContainedInRange(_10_50)).to.equal(false)
+        expect(_5_15.isContainedInRange(_10_50)).to.equal(false)
+        expect(_20_35.isContainedInRange(_10_50)).to.equal(true)
+        expect(_10_50.isContainedInRange(_10_50)).to.equal(true)
+        expect(_45_55.isContainedInRange(_10_50)).to.equal(false)
+        expect(_51_100.isContainedInRange(_10_50)).to.equal(false)
+    })
 
+    it("can check if it is strictly contained in another range", function () {
+        let _10_50 = new Range(10, 50)
+
+        let _1_6 = new Range(1, 6)
+        let _10_11 = new Range(10, 11)
+        let _5_15 = new Range(5, 15)
+        let _20_35 = new Range(20, 35)
+        let _45_55 = new Range(45, 55)
+        let _49_50 = new Range(49, 50)
+        let _51_100 = new Range(51, 100)
+
+        expect(_1_6.isStrictlyContainedInRange(_10_50)).to.equal(false)
+        expect(_10_11.isStrictlyContainedInRange(_10_50)).to.equal(false)
+        expect(_5_15.isStrictlyContainedInRange(_10_50)).to.equal(false)
+        expect(_20_35.isStrictlyContainedInRange(_10_50)).to.equal(true)
+        expect(_10_50.isStrictlyContainedInRange(_10_50)).to.equal(false)
+        expect(_45_55.isStrictlyContainedInRange(_10_50)).to.equal(false)
+        expect(_49_50.isStrictlyContainedInRange(_10_50)).to.equal(false)
+        expect(_51_100.isStrictlyContainedInRange(_10_50)).to.equal(false)
     })
-}
+
+})
diff --git a/test/utils/matchers.ts b/test/utils/matchers.ts
index c61b15f46..c6ae4fe56 100644
--- a/test/utils/matchers.ts
+++ b/test/utils/matchers.ts
@@ -1,9 +1,6 @@
-namespace specs.matchers {
-
-    export function setEquality<T>(actual:T[], expected:T[]):void {
-        expect(actual).to.contain.members(expected)
-        expect(expected).to.contain.members(actual)
-        expect(expected).to.have.lengthOf(actual.length)
-    }
-
+export function setEquality<T>(actual:T[], expected:T[]):void {
+    expect(actual).to.contain.members(expected)
+    expect(expected).to.contain.members(actual)
+    expect(expected).to.have.lengthOf(actual.length)
 }
+
diff --git a/test/utils/utils_spec.ts b/test/utils/utils_spec.ts
index fff048038..791bf6b79 100644
--- a/test/utils/utils_spec.ts
+++ b/test/utils/utils_spec.ts
@@ -1,188 +1,213 @@
-namespace chevrotain.utils.spec {
-
-    describe("The Utils functions namespace", () => {
+import {
+    last,
+    forEach,
+    isString,
+    drop,
+    dropRight,
+    filter,
+    reject,
+    has,
+    contains,
+    cloneArr,
+    cloneObj,
+    find,
+    reduce,
+    compact,
+    uniq,
+    pick,
+    partial,
+    difference,
+    some,
+    every,
+    indexOf,
+    sortBy,
+    zipObject,
+    assign,
+    groupBy
+} from "../../src/utils/utils"
+
+describe("The Utils functions namespace", () => {
+
+    it("exports a last utility", () => {
+        expect(last([1, 2, 3])).to.equal(3)
+        expect(last([])).to.equal(undefined)
+        expect(last(null)).to.equal(undefined)
+    })
 
-        it("exports a last utility", () => {
-            expect(last([1, 2, 3])).to.equal(3)
-            expect(last([])).to.equal(undefined)
-            expect(last(null)).to.equal(undefined)
+    it("exports a forEach utility", () => {
+        forEach([1, 2, 3], (item, idx) => {
+            expect(item).to.equal(idx + 1)
         })
 
-        it("exports a forEach utility", () => {
-            forEach([1, 2, 3], (item, idx) => {
-                expect(item).to.equal(idx + 1)
-            })
-
-            forEach(null, (item) => {
-                throw Error("call back should not be invoked for none array")
-            })
-
-            forEach([], (item) => {
-                throw Error("call back should not be invoked for empty array")
-            })
+        forEach(null, (item) => {
+            throw Error("call back should not be invoked for none array")
         })
 
-        it("exports a isString utility", () => {
-            expect(isString("")).to.be.true
-            expect(isString("bamba")).to.be.true
-            expect(isString(66)).to.be.false
-            expect(isString(null)).to.be.false
+        forEach([], (item) => {
+            throw Error("call back should not be invoked for empty array")
         })
+    })
 
-        it("exports a drop utility", () => {
-            expect(drop([])).to.deep.equal([])
-            expect(drop([1, 2, 3])).to.deep.equal([2, 3])
-            expect(drop([1, 2, 3], 2)).to.deep.equal([3])
-            expect(drop([1, 2, 3], 3)).to.deep.equal([])
-        })
+    it("exports a isString utility", () => {
+        expect(isString("")).to.be.true
+        expect(isString("bamba")).to.be.true
+        expect(isString(66)).to.be.false
+        expect(isString(null)).to.be.false
+    })
 
-        it("exports a dropRight utility", () => {
-            expect(dropRight([])).to.deep.equal([])
-            expect(dropRight([1, 2, 3])).to.deep.equal([1, 2])
-            expect(dropRight([1, 2, 3], 2)).to.deep.equal([1])
-            expect(dropRight([1, 2, 3], 3)).to.deep.equal([])
-        })
+    it("exports a drop utility", () => {
+        expect(drop([])).to.deep.equal([])
+        expect(drop([1, 2, 3])).to.deep.equal([2, 3])
+        expect(drop([1, 2, 3], 2)).to.deep.equal([3])
+        expect(drop([1, 2, 3], 3)).to.deep.equal([])
+    })
 
-        it("exports a filter utility", () => {
-            expect(filter([], (item) => {return true})).to.deep.equal([])
-            expect(filter([1, 2, 3], (item) => {return true})).to.deep.equal([1, 2, 3])
-            expect(filter([1, 2, 3], (item) => {return false})).to.deep.equal([])
-            expect(filter([1, 2, 3], (item) => {return item % 2 === 0})).to.deep.equal([2])
-            expect(filter([1, 2, 3], (item) => {return item % 2 === 1})).to.deep.equal([1, 3])
-            expect(filter(null, (item) => {return item % 2 === 1})).to.deep.equal([])
-        })
+    it("exports a dropRight utility", () => {
+        expect(dropRight([])).to.deep.equal([])
+        expect(dropRight([1, 2, 3])).to.deep.equal([1, 2])
+        expect(dropRight([1, 2, 3], 2)).to.deep.equal([1])
+        expect(dropRight([1, 2, 3], 3)).to.deep.equal([])
+    })
 
-        it("exports a reject utility", () => {
-            expect(reject([], (item) => {return true})).to.deep.equal([])
-            expect(reject([1, 2, 3], (item) => {return false})).to.deep.equal([1, 2, 3])
-            expect(reject([1, 2, 3], (item) => {return true})).to.deep.equal([])
-            expect(reject([1, 2, 3], (item) => {return item % 2 === 0})).to.deep.equal([1, 3])
-            expect(reject([1, 2, 3], (item) => {return item % 2 === 1})).to.deep.equal([2])
-            expect(reject(null, (item) => {return item % 2 === 1})).to.deep.equal([])
-        })
+    it("exports a filter utility", () => {
+        expect(filter([], (item) => {return true})).to.deep.equal([])
+        expect(filter([1, 2, 3], (item) => {return true})).to.deep.equal([1, 2, 3])
+        expect(filter([1, 2, 3], (item) => {return false})).to.deep.equal([])
+        expect(filter([1, 2, 3], (item) => {return item % 2 === 0})).to.deep.equal([2])
+        expect(filter([1, 2, 3], (item) => {return item % 2 === 1})).to.deep.equal([1, 3])
+        expect(filter(null, (item) => {return item % 2 === 1})).to.deep.equal([])
+    })
 
-        it("exports a has utility", () => {
-            expect(has([1, 2, 3], "0")).to.be.true
-            expect(has([1, 2, 3], "5")).to.be.false
-            expect(has({}, "bamba")).to.be.false
-            expect(has({bamba: 666}, "bamba")).to.be.true
-        })
+    it("exports a reject utility", () => {
+        expect(reject([], (item) => {return true})).to.deep.equal([])
+        expect(reject([1, 2, 3], (item) => {return false})).to.deep.equal([1, 2, 3])
+        expect(reject([1, 2, 3], (item) => {return true})).to.deep.equal([])
+        expect(reject([1, 2, 3], (item) => {return item % 2 === 0})).to.deep.equal([1, 3])
+        expect(reject([1, 2, 3], (item) => {return item % 2 === 1})).to.deep.equal([2])
+        expect(reject(null, (item) => {return item % 2 === 1})).to.deep.equal([])
+    })
 
-        it("exports a contains utility", () => {
-            expect(contains([1, 2, 3], 4)).to.be.false
-            expect(contains([1, 2, 3], 2)).to.be.true
-            expect(contains([], 2)).to.be.false
-        })
+    it("exports a has utility", () => {
+        expect(has([1, 2, 3], "0")).to.be.true
+        expect(has([1, 2, 3], "5")).to.be.false
+        expect(has({}, "bamba")).to.be.false
+        expect(has({bamba: 666}, "bamba")).to.be.true
+    })
 
-        it("exports a cloneArr utility", () => {
-            expect(cloneArr([1, 2, 3])).to.deep.equal([1, 2, 3])
-            expect(cloneArr([])).to.deep.equal([])
-            let arr = []
-            expect(cloneArr(arr)).to.not.equal(arr)
-        })
+    it("exports a contains utility", () => {
+        expect(contains([1, 2, 3], 4)).to.be.false
+        expect(contains([1, 2, 3], 2)).to.be.true
+        expect(contains([], 2)).to.be.false
+    })
 
-        it("exports a cloneObj utility", () => {
-            expect(cloneObj({bamba: 666, bisli: 777})).to.deep.equal({bamba: 666, bisli: 777})
-            let obj = {bamba: 666, bisli: 777}
-            expect(cloneObj(obj)).to.not.equal(obj)
-            expect(cloneObj(["bamba"])).to.not.have.property("length")
-            expect(cloneObj(["bamba"])).to.deep.equal({"0": "bamba"})
-        })
+    it("exports a cloneArr utility", () => {
+        expect(cloneArr([1, 2, 3])).to.deep.equal([1, 2, 3])
+        expect(cloneArr([])).to.deep.equal([])
+        let arr = []
+        expect(cloneArr(arr)).to.not.equal(arr)
+    })
 
-        it("exports a find utility", () => {
-            expect(find([1, 2, 3], (item) => item === 2)).to.equal(2)
-            expect(find([], (item) => item === 2)).to.be.undefined
-            let a = {}
-            let b = {}
-            expect(find([a, b], (item) => item === b)).to.equal(b)
-        })
+    it("exports a cloneObj utility", () => {
+        expect(cloneObj({bamba: 666, bisli: 777})).to.deep.equal({bamba: 666, bisli: 777})
+        let obj = {bamba: 666, bisli: 777}
+        expect(cloneObj(obj)).to.not.equal(obj)
+        expect(cloneObj(["bamba"])).to.not.have.property("length")
+        expect(cloneObj(["bamba"])).to.deep.equal({"0": "bamba"})
+    })
 
-        it("exports a reduce utility", () => {
-            expect(reduce([1, 2, 3], (result, item) => {
-                return result.concat([item * 2])
-            }, [])).to.deep.equal([2, 4, 6])
+    it("exports a find utility", () => {
+        expect(find([1, 2, 3], (item) => item === 2)).to.equal(2)
+        expect(find([], (item) => item === 2)).to.be.undefined
+        let a = {}
+        let b = {}
+        expect(find([a, b], (item) => item === b)).to.equal(b)
+    })
 
-            expect(reduce({one: 1, two: 2, three: 3}, (result, item) => {
-                return result.concat([item * 2])
-            }, [])).to.deep.equal([2, 4, 6])
-        })
+    it("exports a reduce utility", () => {
+        expect(reduce([1, 2, 3], (result, item) => {
+            return result.concat([item * 2])
+        }, [])).to.deep.equal([2, 4, 6])
 
-        it("exports a compact utility", () => {
-            expect(compact([1, 2, null, 3])).to.deep.equal([1, 2, 3])
-            expect(compact([1, undefined, 2, 3])).to.deep.equal([1, 2, 3])
-            expect(compact([])).to.deep.equal([])
-            expect(compact([1, 2, 3])).to.deep.equal([1, 2, 3])
-        })
+        expect(reduce({one: 1, two: 2, three: 3}, (result, item) => {
+            return result.concat([item * 2])
+        }, [])).to.deep.equal([2, 4, 6])
+    })
 
-        it("exports a uniq utility", () => {
-            expect(uniq([1, 2, 3, 2])).to.contain.members([1, 2, 3])
-            expect(uniq([2, 2, 4, 2], (item) => { return 666 })).to.have.length(1)
-            expect(uniq([])).to.deep.equal([])
-        })
+    it("exports a compact utility", () => {
+        expect(compact([1, 2, null, 3])).to.deep.equal([1, 2, 3])
+        expect(compact([1, undefined, 2, 3])).to.deep.equal([1, 2, 3])
+        expect(compact([])).to.deep.equal([])
+        expect(compact([1, 2, 3])).to.deep.equal([1, 2, 3])
+    })
 
-        it("exports a pick utility", () => {
-            expect(pick({bamba: true, bisli: false}, (item) => item)).to.deep.equal({bamba: true})
-            expect(pick({}, (item) => item)).to.be.empty
-        })
+    it("exports a uniq utility", () => {
+        expect(uniq([1, 2, 3, 2])).to.contain.members([1, 2, 3])
+        expect(uniq([2, 2, 4, 2], (item) => { return 666 })).to.have.length(1)
+        expect(uniq([])).to.deep.equal([])
+    })
 
-        it("exports a partial utility", () => {
-            let add = function (x, y) {
-                return x + y
-            }
-            expect(partial(add)(2, 3)).to.equal(5)
-            expect(partial(add, 2)(3)).to.equal(5)
-            expect(partial(add, 2, 3)()).to.equal(5)
-        })
+    it("exports a pick utility", () => {
+        expect(pick({bamba: true, bisli: false}, (item) => item)).to.deep.equal({bamba: true})
+        expect(pick({}, (item) => item)).to.be.empty
+    })
 
-        it("exports an every utility", () => {
-            expect(every([], (item) => {return true})).to.be.true
-            // empty set always true...
-            expect(every([], (item) => {return false})).to.be.true
-            expect(every([1, 2, 3], (item) => {return item % 2 === 0})).to.be.false
-            expect(every([2, 4, 6], (item) => {return item % 2 === 0})).to.be.true
-        })
+    it("exports a partial utility", () => {
+        let add = function (x, y) {
+            return x + y
+        }
+        expect(partial(add)(2, 3)).to.equal(5)
+        expect(partial(add, 2)(3)).to.equal(5)
+        expect(partial(add, 2, 3)()).to.equal(5)
+    })
 
-        it("exports an difference utility", () => {
-            expect(difference([1, 2, 3], [2])).to.deep.equal([1, 3])
-            expect(difference([1, 2, 3], [1, 3])).to.deep.equal([2])
-            expect(difference([1, 2, 3], [])).to.deep.equal([1, 2, 3])
-            expect(difference([], [1, 2])).to.deep.equal([])
-        })
+    it("exports an every utility", () => {
+        expect(every([], (item) => {return true})).to.be.true
+        // empty set always true...
+        expect(every([], (item) => {return false})).to.be.true
+        expect(every([1, 2, 3], (item) => {return item % 2 === 0})).to.be.false
+        expect(every([2, 4, 6], (item) => {return item % 2 === 0})).to.be.true
+    })
 
-        it("exports an some utility", () => {
-            expect(some([], (item) => {return true})).to.be.false
-            expect(some([], (item) => {return false})).to.be.false
-            expect(some([1, 2, 3], (item) => {return item % 2 === 0})).to.be.true
-            expect(some([1, 3, 5], (item) => {return item % 2 === 0})).to.be.false
-        })
+    it("exports an difference utility", () => {
+        expect(difference([1, 2, 3], [2])).to.deep.equal([1, 3])
+        expect(difference([1, 2, 3], [1, 3])).to.deep.equal([2])
+        expect(difference([1, 2, 3], [])).to.deep.equal([1, 2, 3])
+        expect(difference([], [1, 2])).to.deep.equal([])
+    })
 
-        it("exports an indexOf utility", () => {
-            expect(indexOf([1, 2, 3], 2)).to.equal(1)
-            expect(indexOf([1, 2, 3], 3)).to.equal(2)
-            expect(indexOf([1, 2, 3], 0)).to.equal(-1)
-            expect(indexOf([], -2)).to.equal(-1)
-        })
+    it("exports an some utility", () => {
+        expect(some([], (item) => {return true})).to.be.false
+        expect(some([], (item) => {return false})).to.be.false
+        expect(some([1, 2, 3], (item) => {return item % 2 === 0})).to.be.true
+        expect(some([1, 3, 5], (item) => {return item % 2 === 0})).to.be.false
+    })
 
-        it("exports a sortBy utility", () => {
-            expect(sortBy([1, 2, 3], (num) => num)).to.deep.equal([1, 2, 3])
-            expect(sortBy([3, 2, 1], (num) => num)).to.deep.equal([1, 2, 3])
-        })
+    it("exports an indexOf utility", () => {
+        expect(indexOf([1, 2, 3], 2)).to.equal(1)
+        expect(indexOf([1, 2, 3], 3)).to.equal(2)
+        expect(indexOf([1, 2, 3], 0)).to.equal(-1)
+        expect(indexOf([], -2)).to.equal(-1)
+    })
 
-        it("exports a zipObject utility", () => {
-            expect(zipObject(["ima", "aba", "bamba"], [1, 2, 3])).to.deep.equal({"ima": 1, "aba": 2, "bamba": 3})
-            expect(() => zipObject(["ima", "aba"], [1, 2, 3])).to.throw("can't zipObject")
-            expect(zipObject([], [])).to.deep.equal({})
-        })
+    it("exports a sortBy utility", () => {
+        expect(sortBy([1, 2, 3], (num) => num)).to.deep.equal([1, 2, 3])
+        expect(sortBy([3, 2, 1], (num) => num)).to.deep.equal([1, 2, 3])
+    })
 
-        it("exports an assign utility", () => {
-            expect(assign(["ima", "aba", "bamba"], [1, 2, 3])).to.deep.equal([1, 2, 3])
-            expect(assign({}, {"ima": 666}, {"aba": 333})).to.deep.equal({"ima": 666, "aba": 333})
-            expect(assign({}, {"ima": 666}, {"aba": 333}, {"ima": 999})).to.deep.equal({"ima": 999, "aba": 333})
-        })
+    it("exports a zipObject utility", () => {
+        expect(zipObject(["ima", "aba", "bamba"], [1, 2, 3])).to.deep.equal({"ima": 1, "aba": 2, "bamba": 3})
+        expect(() => zipObject(["ima", "aba"], [1, 2, 3])).to.throw("can't zipObject")
+        expect(zipObject([], [])).to.deep.equal({})
+    })
 
-        it("exports a groupBy utility", () => {
-            expect(groupBy([1, 2, 3, 4], (num) => "" + num % 2)).to.deep.equal({0: [2, 4], 1: [1, 3]})
-            expect(groupBy([1, 2, 3, 4], (num) => "" + num)).to.deep.equal({1: [1], 2: [2], 3: [3], 4: [4]})
-        })
+    it("exports an assign utility", () => {
+        expect(assign(["ima", "aba", "bamba"], [1, 2, 3])).to.deep.equal([1, 2, 3])
+        expect(assign({}, {"ima": 666}, {"aba": 333})).to.deep.equal({"ima": 666, "aba": 333})
+        expect(assign({}, {"ima": 666}, {"aba": 333}, {"ima": 999})).to.deep.equal({"ima": 999, "aba": 333})
+    })
+
+    it("exports a groupBy utility", () => {
+        expect(groupBy([1, 2, 3, 4], (num) => "" + num % 2)).to.deep.equal({0: [2, 4], 1: [1, 3]})
+        expect(groupBy([1, 2, 3, 4], (num) => "" + num)).to.deep.equal({1: [1], 2: [2], 3: [3], 4: [4]})
     })
-}
+})
diff --git a/tests_integration/definitions/es6_modules.ts b/tests_integration/definitions/es6_modules.ts
new file mode 100644
index 000000000..2d52a5af3
--- /dev/null
+++ b/tests_integration/definitions/es6_modules.ts
@@ -0,0 +1,7 @@
+/// <reference path="../../bin/chevrotain.d.ts" />
+import {Parser, Lexer, gast} from "chevrotain"
+
+/**
+ * This File will be compiled using TSC to verify that the custom build chevrotain.d.ts
+ * is compatible with Typescript's ES6 module syntax (import/export)
+ */
diff --git a/tests_integration/definitions/namespaces.ts b/tests_integration/definitions/namespaces.ts
new file mode 100644
index 000000000..b74668275
--- /dev/null
+++ b/tests_integration/definitions/namespaces.ts
@@ -0,0 +1,8 @@
+/// <reference path="../../bin/chevrotain.d.ts" />
+import Lexer = chevrotain.Lexer
+import Parser = chevrotain.Parser
+
+/**
+* This File will be compiled using TSC to verify that the custom build chevrotain.d.ts
+* is compatible with Typescript's old style module/namespaces (global)
+*/
diff --git a/watch.bat b/watch.bat
index 6c9767f8e..b03d12d50 100644
--- a/watch.bat
+++ b/watch.bat
@@ -1 +1 @@
-"C:\Program Files (x86)\Git\bin\sh.exe" --login -i -c "find $(pwd)/src/ $(pwd)/test/ $(pwd)/libs/ -name "*.ts" | xargs node_modules/.bin/tsc -w -t ES5 --sourcemap --outDir bin/gen"
\ No newline at end of file
+"C:\Program Files (x86)\Git\bin\sh.exe" --login -i -c "find $(pwd)/src/ $(pwd)/test/ $(pwd)/libs/ -name "*.ts" | xargs node_modules/.bin/tsc -w -t ES5 --diagnostics --sourcemap --module commonjs --outDir bin"
\ No newline at end of file