@@ -20,30 +20,6 @@ More detailed documentation and info on writing declarations can be found [on th
 
 `tstl -p path/to/tsconfig.json`
 
-**Usage**
-```
-tstl [options] [files...]
-
-In addition to the options listed below you can also pass options for the
-typescript compiler (For a list of options use tsc -h).
-
-NOTES:
-- The tsc options might have no effect.
-- Options in tsconfig.json are prioritized.
-
-Options:
-  --lt, --luaTarget  Specify Lua target version.
-                               [string] [choices: "JIT", "5.3"] [default: "JIT"]
-  --ah, --addHeader  Specify if a header will be added to compiled files.
-                                                      [boolean] [default: false]
-  -h, --help         Show help                                         [boolean]
-  -v, --version      Show version number                               [boolean]
-
-Examples:
-  tstl path/to/file.ts [...]     Compile files
-  tstl -p path/to/tsconfig.json  Compile project
-```
-
 **Example tsconfig.json**
 ```
 {
 
@@ -16,43 +16,43 @@ export interface ParsedCommandLine extends ts.ParsedCommandLine {
 }
 
 const optionDeclarations: { [key: string]: yargs.Options } = {
-    'lt': {
-        alias: 'luaTarget',
+    'luaTarget': {
+        alias: 'lt',
         choices: ['JIT', '5.3'],
         default: 'JIT',
         describe: 'Specify Lua target version.',
         type: 'string'
     },
-    'ah': {
-        alias: 'addHeader',
+    'addHeader': {
+        alias: 'ah',
         describe: 'Specify if a header will be added to compiled files.',
         default: false,
         type: 'boolean'
     },
-    'h': {
-        alias: 'help'
+    'dontRequireLuaLib': {
+        describe: 'Dont require lua library that enables advanced Typescipt/JS functionality.',
+        default: false,
+        type: 'boolean'
     },
-    'v': {
-        alias: 'version'
-    }
 };
 
 
 /**
  * Pares the supplied arguments.
  * The result will include arguments supplied via CLI and arguments from tsconfig.
  */
-export function parseCommandLine(args: ReadonlyArray<string>) : ParsedCommandLine {
-    const argv = yargs
-        .usage(dedent(`tstl [options] [files...]
+export function parseCommandLine(args: ReadonlyArray<string>): ParsedCommandLine {
+    const parsedArgs = yargs
+        .usage(dedent(`Syntax: tstl [options] [files...]
 
             In addition to the options listed below you can also pass options for the typescript compiler (For a list of options use tsc -h).
 
-            NOTES:
-            - The tsc options might have no effect.
-            - Options in tsconfig.json are prioritized.`))
+            Notes:
+              - The tsc options might have no effect.
+              - Options in tsconfig.json are prioritized.`))
         .example('tstl path/to/file.ts [...]', 'Compile files')
         .example('tstl -p path/to/tsconfig.json', 'Compile project')
+        .wrap(yargs.terminalWidth())
         .options(optionDeclarations)
         .argv;
 
@@ -61,6 +61,10 @@ export function parseCommandLine(args: ReadonlyArray<string>) : ParsedCommandLin
     // Run diagnostics to check for invalid tsc/tstl options
     runDiagnostics(commandLine);
 
+    // Add TSTL options from CLI
+    addTSTLOptions(commandLine, parsedArgs);
+
+    // Load config
     if (commandLine.options.project) {
         findConfigFile(commandLine);
         let configPath = commandLine.options.project;
@@ -69,13 +73,11 @@ export function parseCommandLine(args: ReadonlyArray<string>) : ParsedCommandLin
         commandLine = ts.parseJsonConfigFileContent(configJson.config, ts.sys, path.dirname(configPath), commandLine.options);
     }
 
-    // Add compiler options that are ignored by TS parsers
-    for (const arg in commandLine.raw) {
-        // we dont have to check if the options is vlaid becuase we already validated at this point.
-        if (getOptionNameMap()[arg]) {
-            commandLine.options[arg] = commandLine.raw[arg];
-        }
-    }
+    // Add TSTL options from tsconfig
+    addTSTLOptions(commandLine);
+
+    // Run diagnostics again to check for errors in tsconfig
+    runDiagnostics(commandLine);
 
     if (commandLine.options.project && !commandLine.options.rootDir) {
         commandLine.options.rootDir = path.dirname(commandLine.options.project);
@@ -89,9 +91,6 @@ export function parseCommandLine(args: ReadonlyArray<string>) : ParsedCommandLin
         commandLine.options.outDir = commandLine.options.rootDir;
     }
 
-    // Run diagnostics again to check for errors in tsconfig
-    runDiagnostics(commandLine);
-
     return commandLine;
 }
 
@@ -101,53 +100,55 @@ interface OptionNameMap {
 
 let optionNameMapCache: OptionNameMap;
 
-/**
- * Gets a list of valid tstl options including aliases
- * That can be used for arguemtn checking.
- */
-function getOptionNameMap(): OptionNameMap{
-    if (optionNameMapCache) {
-        return optionNameMapCache;
-    }
-    let optNameMap: OptionNameMap = {};
-    for (let key in optionDeclarations) {
-        optNameMap[key] = true
-        let alias = optionDeclarations[key].alias;
-        if (typeof alias === "string") {
-            optNameMap[alias] = true;
-        } else {
-            alias.forEach((val) => optNameMap[val] = true);
+function addTSTLOptions(commandLine: ts.ParsedCommandLine, additionalArgs?: yargs.Arguments) {
+    additionalArgs = additionalArgs ? additionalArgs : commandLine.raw
+    // Add compiler options that are ignored by TS parsers
+    for (const arg in additionalArgs) {
+        // we dont have to check if the options is vlaid becuase we already validated at this point.
+        if (optionDeclarations[arg]) {
+            commandLine.options[arg] = additionalArgs[arg];
         }
     }
-    optionNameMapCache = optNameMap;
-    return optNameMap;
 }
 
 /** Check the current state of the ParsedCommandLine for errors */
 function runDiagnostics(commandLine: ts.ParsedCommandLine) {
     const tsInvalidCompilerOptionErrorCode = 5023;
 
     if (commandLine.errors.length !== 0) {
+        // Generate a list of valid option names and aliases
+        let optionNames = [];
+        for (let key in optionDeclarations) {
+            optionNames.push(key);
+            let alias = optionDeclarations[key].alias;
+            if (alias) {
+                if (typeof alias === "string") {
+                    optionNames.push(alias);
+                } else {
+                    optionNames.push(...alias);
+                }
+            }
+        }
+
         commandLine.errors.forEach((err) => {
             let ignore = false;
             // Ignore errors caused by tstl specific compiler options
             if (err.code == tsInvalidCompilerOptionErrorCode) {
-                for (const key in getOptionNameMap()) {
-                    if (err.messageText.toString().indexOf(key) !== -1) {
+                for (const optionName of optionNames) {
+                    if (err.messageText.toString().indexOf(optionName) !== -1) {
                         ignore = true;
                     }
                 }
-            }
-
-            if (!ignore) {
-                console.log(`error TS${err.code}: ${err.messageText}`);
-                process.exit(1);
+                if (!ignore) {
+                    console.log(`error TS${err.code}: ${err.messageText}`);
+                    process.exit(1);
+                }
             }
         });
     }
 }
 
-/** Find configFile, function form ts api seems to be broken? */
+/** Find configFile, function from ts api seems to be broken? */
 function findConfigFile(commandLine: ts.ParsedCommandLine) {
     let configPath = path.isAbsolute(commandLine.options.project) ? commandLine.options.project : path.join(process.cwd(), commandLine.options.project);
     if (fs.statSync(configPath).isDirectory()) {