From 0caf3f6169954a7270b9131f431b8b48dc93a5cf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=94=90=E6=96=8C?= <1987.tangbin@gmail.com>
Date: Sun, 1 Jun 2014 01:28:48 +0800
Subject: [PATCH] bug fix

---
 LICENSE                                       |    0
 README.md                                     |   84 +-
 bin/node2bat                                  |    2 +-
 demo/includeHTML/README.md                    |   39 +
 .../test => demo/includeHTML/demo}/about.html |   14 +-
 .../test => demo/includeHTML/demo}/index.html |   14 +-
 .../test => demo/includeHTML/demo}/news.html  |   14 +-
 demo/includeHTML/demo/public/footer.html      |    3 +
 .../includeHTML/demo}/public/header.html      |    1 +
 demo/includeHTML/includeHTML.bat              | 2484 ++++++++++++++++
 demo/includeHTML/includeHTML.js               |   87 +
 demo/includeHTML/package.json                 |   13 +
 lib/node2bat.runtime.js                       | 1328 ---------
 package.json                                  |   13 +-
 node2bat.js => src/node2bat.js                |    8 +-
 src/runtime.js                                | 2400 +++++++++++++++
 test/README.md                                |   43 -
 test/Thumbs.db                                |  Bin 7168 -> 0 bytes
 test/banner.jpg                               |  Bin 31947 -> 0 bytes
 test/includeHTML.bat                          | 1402 ---------
 test/includeHTML.js                           |   77 -
 test/test.bat                                 | 2567 +++++++++++++++++
 test/test.js                                  |  171 ++
 test/test/public/footer.html                  |    3 -
 24 files changed, 7860 insertions(+), 2907 deletions(-)
 mode change 100644 => 100755 LICENSE
 create mode 100755 demo/includeHTML/README.md
 rename {test/test => demo/includeHTML/demo}/about.html (65%)
 rename {test/test => demo/includeHTML/demo}/index.html (65%)
 rename {test/test => demo/includeHTML/demo}/news.html (65%)
 create mode 100755 demo/includeHTML/demo/public/footer.html
 rename {test/test => demo/includeHTML/demo}/public/header.html (85%)
 create mode 100644 demo/includeHTML/includeHTML.bat
 create mode 100644 demo/includeHTML/includeHTML.js
 create mode 100644 demo/includeHTML/package.json
 delete mode 100755 lib/node2bat.runtime.js
 rename node2bat.js => src/node2bat.js (68%)
 create mode 100755 src/runtime.js
 delete mode 100644 test/README.md
 delete mode 100755 test/Thumbs.db
 delete mode 100644 test/banner.jpg
 delete mode 100644 test/includeHTML.bat
 delete mode 100755 test/includeHTML.js
 create mode 100644 test/test.bat
 create mode 100644 test/test.js
 delete mode 100755 test/test/public/footer.html

diff --git a/LICENSE b/LICENSE
old mode 100644
new mode 100755
diff --git a/README.md b/README.md
index 3efa1e3..69e5a2a 100755
--- a/README.md
+++ b/README.md
@@ -2,11 +2,15 @@
 
 ##	简介
 
-node2bat 是一个可以将 NodeJS 脚本编译为 Windows 批处理脚本的工具。编译后的批处理不再依赖 NodeJS，双击可直接运行。你可以使用 NodeJS 的 API 来编写一些轻量级的自动化 Windows 批处理脚本。
+node2bat 是一个可以将 NodeJS 脚本编译为 Windows 批处理脚本的工具。编译后的批处理不再依赖 NodeJS，双击可直接运行。你可以使用 NodeJS 的 API 来编写 Windows 批处理脚本发布给其他人使用，而不需要安装 NodeJS 的环境。借助 js 强大的语法支持，你的批处理将异常强大。
+
+##	原理
+
+windows 中自带了 javascript 引擎支持 jscript，所以 node2bat 便是使用 jscript 封装了一层 nodejs 的 api，然后巧妙地将 js 包含在 bat 文件中。
 
 ##	安装
 
-先安装 NodeJS 与 npm，然后执行：
+先安装 NodeJS，然后执行：
 
 	$ npm install node2bat -g
 	
@@ -18,52 +22,54 @@ node2bat 是一个可以将 NodeJS 脚本编译为 Windows 批处理脚本的工
 
 ##	运行示例
 
-源码 test 目录是一个演示例子，其中 includeHTML.js 是基于 NodeJS 编写的自动化脚本，它的用途是给页面制作人员批量更新局部模板的。
+源码 demo 目录是一个演示例子，其中 includeHTML.js 是基于 NodeJS 编写的自动化脚本，它的用途是给页面制作人员批量更新局部模板的。
 
 这个脚本里面用到了 NodeJS 的文件与路径处理，我们可以编译 includeHTML.js 为 bat 文件，这样用户拿到我们的 bat 文件就可以直接双击运行了，无需安装 NodeJS 与学习命令行。
 
 切换到源码目录，运行：
 
-	$ node2bat test/includeHTML.js
+	$ node2bat demo/includeHTML/includeHTML.js
 
 运行完毕后会立刻生成独立的 includeHTML.bat，你也可以双击打开它试用一下。
 
 ##	JS API
 
-node2bat v0.0.1 支持的 JS API 是 NodeJS API 的子集，包含基本的文件与路径操作：
+node2bat 支持 NodeJS API 的核心 API，并且支持大多数 ECMA5 的 API，这些足可以满足绝大多数任务。
 
 ###	全局变量
 
-*	[require(id)](http://nodejs.org/api/globals.html#globals_require)``（注意：不支持外部模块）``
-*	[process.argv](http://nodejs.org/api/process.html#process_process_argv)
-*	[process.env](http://nodejs.org/api/process.html#process_process_env)
-*	[process.exit([code])](http://nodejs.org/api/process.html#process_process_env)
-*	[process.cwd()](http://nodejs.org/api/process.html#process_process_cwd)
-*	[process.stdout.write(message)](http://nodejs.org/api/process.html#process_process_stdout)
-*	[console.log(message)](http://nodejs.org/api/console.html#console_console_log_data)
 *	[__filename](http://nodejs.org/api/globals.html#globals_filename)
 *	[__dirname](http://nodejs.org/api/globals.html#globals_dirname)
-
->	注：使用 process.argv.slice(2) 可返回拖拽到批处理程序图标上后所有的文件列表
+*	[require(id)](http://nodejs.org/api/globals.html#globals_require)``（注意：仅支持 node2bat 内置的系统模块或外部 json 文件）``	
+*	process
+	*	[process.argv](http://nodejs.org/api/process.html#process_process_argv)
+	*	[process.env](http://nodejs.org/api/process.html#process_process_env)
+	*	[process.exit([code])](http://nodejs.org/api/process.html#process_process_env)
+	*	[process.cwd()](http://nodejs.org/api/process.html#process_process_cwd)
+	*	[process.stdout.write(message)](http://nodejs.org/api/process.html#process_process_stdout)
+	*	[process.stderr.write(message)](http://nodejs.org/api/process.html#process_process_stderr)
+*	console
+	*	[console.log([data], [...])](http://nodejs.org/api/console.html#console_console_log_data)
+	*	[console.info([data], [...])](http://nodejs.org/api/console.html#console_console_info_data)
+	*	[console.error([data], [...])](http://nodejs.org/api/console.html#console_console_error_data)
+	*	[console.warn([data], [...])](http://nodejs.org/api/console.html#console_console_warn_data)
+	*	[console.dir(obj)](http://nodejs.org/api/console.html#console_console_dir_obj)
+	*	[console.time(label)](http://nodejs.org/api/console.html#console_console_time_label)
+	*	[console.timeEnd(label)](http://nodejs.org/api/console.html#console_console_timeend_label)
+	*	[console.assert(expression, [message])](http://nodejs.org/api/console.html#console_console_assert_expression_message)
+
+>	注：如果拖拽文件到 bat 图标上执行，process.argv.slice(2) 可以获取这些文件的列表
 
 ###	内置模块
 
 *   File System
-    *   [fs.rename(oldPath, newPath, callback)](http://nodejs.org/api/fs.html#fs_fs_rename_oldpath_newpath_callback)
     *   [fs.renameSync(oldPath, newPath)](http://nodejs.org/api/fs.html#fs_fs_renamesync_oldpath_newpath)
-    *   [fs.stat(path, callback)](http://nodejs.org/api/fs.html#fs_fs_stat_path_callback)
-    *   [fs.statSync(path)](http://nodejs.org/api/fs.html#fs_fs_statsync_path)
-    *   [fs.unlink(path, callback)](http://nodejs.org/api/fs.html#fs_fs_unlink_path_callback)
+    *   [fs.statSync(path)](http://nodejs.org/api/fs.html#fs_fs_statsync_path)``只支 isFile()、isDirectory()、size、atime、mtime、ctime``
     *   [fs.unlinkSync(path)](http://nodejs.org/api/fs.html#fs_fs_unlinksync_path)
-    *   [fs.rmdir(path, callback)](http://nodejs.org/api/fs.html#fs_fs_rmdir_path_callback)
     *   [fs.rmdirSync(path)](http://nodejs.org/api/fs.html#fs_fs_rmdirsync_path)
-    *   [fs.mkdir(path, [mode], callback)](http://nodejs.org/api/fs.html#fs_fs_mkdir_path_mode_callback)
     *   [fs.mkdirSync(path, [mode])](http://nodejs.org/api/fs.html#fs_fs_mkdirsync_path_mode)
-    *   [fs.readFile(filename, [options], callback)](http://nodejs.org/api/fs.html#fs_fs_readfile_filename_options_callback)
     *   [fs.readFileSync(filename, [options])](http://nodejs.org/api/fs.html#fs_fs_readfilesync_filename_options)
-    *   [fs.writeFile(filename, data, [options], callback)](http://nodejs.org/api/fs.html#fs_fs_writefile_filename_data_options_callback)
     *   [fs.writeFileSync(filename, data, [options])](http://nodejs.org/api/fs.html#fs_fs_writefilesync_filename_data_options)
-    *   [fs.exists(path, callback)](http://nodejs.org/api/fs.html#fs_fs_exists_path_callback)
     *   [fs.existsSync(path)](http://nodejs.org/api/fs.html#fs_fs_existssync_path)
 *   Path
     *   [path.normalize(p)](http://nodejs.org/api/path.html#path_path_normalize_p)
@@ -75,8 +81,36 @@ node2bat v0.0.1 支持的 JS API 是 NodeJS API 的子集，包含基本的文
     *   [path.extname(p)](http://nodejs.org/api/path.html#path_path_extname_p)
     *   [path.sep](http://nodejs.org/api/path.html#path_path_sep)
     *   [path.delimiter](http://nodejs.org/api/path.html#path_path_delimiter)
+    
+##	测试用例
+
+	node2bat test/test.js
+	start test/test.bat
+    
+##	更新日志
+
+v0.0.3
+
+*	修复``fs.writeFileSync()``写入``utf-8``文件会插入 bom 的问题
+*	修复``this``指向为``global``对象的问题
+*	``require()``方法支持载入 json 文件
+*	``fs.statSync()``支持``size``、``atime``、``mtime``、``ctime``
+*	``require(id)``支持读取外部 json 文件
+*	完善``console``模块
+*	完善``process.env``模块，完全与 NodeJS 保持一致
+*	鉴于使用场景为批处理，所以取消异步方法的支持
+*	提供测试用例
+
+v0.0.2
+
+*	修正``process.argv``的 BUG
+*	``console.log``方法可以友好的显示``Object``数据结构
+
+v0.0.1
+
+*	支持 NodeJS 文件与路径操作等基础 API
 
-##	开源节流
+## License
 
-正如您若见，这是一个奇葩的项目，如果有兴趣可参与进来将更多的 NodeJS 特性在 node2bat 上实现。
+MIT
 
diff --git a/bin/node2bat b/bin/node2bat
index 648a386..3885d70 100755
--- a/bin/node2bat
+++ b/bin/node2bat
@@ -2,7 +2,7 @@
 
 'use strict';
 
-var node2bat = require('../node2bat.js');
+var node2bat = require('../src/node2bat.js');
 var fs = require('fs');
 
 
diff --git a/demo/includeHTML/README.md b/demo/includeHTML/README.md
new file mode 100755
index 0000000..e79147e
--- /dev/null
+++ b/demo/includeHTML/README.md
@@ -0,0 +1,39 @@
+#	HTML 局部模板更新工具
+
+##	工具介绍
+
+includeHTML 是一个简单易用的 HTML 静态文件局部模板批量更新工具，它通过注释的方式给 HTML 添加类似服务端模板``include``标签的功能，可用来分离页面的头部与底部模板。
+
+###	特性
+
+1. 无需 js 支持不会破坏 SEO
+2. 无需服务端环境运行
+3. 页面可被反复更新
+4. 语法与普通注释无异 
+5. 绿色单文件，双击即可运行
+
+本工具适用于 web 设计师或者 web 重构工程师。
+
+##	include 语句
+
+编写页面的时候，在需要动态更新的地方按固定格式写好注释即可，例如：
+
+```
+ <!--[include './public/header.html']-->
+    <div id="header">
+        <ul class="nav">
+            <li><a href="./index.html">Home</a></li>
+            <li><a href="./news.html">News</a></li>
+            <li><a href="./about.html">about</a></li>
+        </ul>
+    </div>
+ <!--[/include]-->
+```
+
+运行本工具后则会将内容替换为外部模板。
+	
+##	工具使用
+	
+将工具放在模板目录，双击 includeHTML.bat 即可。
+
+> 处理单个页面拖拽到 includeHTML.bat 图标上运行即可。
diff --git a/test/test/about.html b/demo/includeHTML/demo/about.html
similarity index 65%
rename from test/test/about.html
rename to demo/includeHTML/demo/about.html
index dcf9158..ff62b07 100755
--- a/test/test/about.html
+++ b/demo/includeHTML/demo/about.html
@@ -1,29 +1,29 @@
-<!doctype html>
+<!doctype html>
 <html lang="en">
 <head>
 	<meta charset="UTF-8">
 	<title>About</title>
 </head>
 <body>
-	<!--[include './public/header.html']-->
+	<!--[include "./public/header.html"]-->
 	<div id="header">
+		<h1>Site</h1>
 		<ul class="nav">
 			<li><a href="./index.html">Home</a></li>
 			<li><a href="./news.html">News</a></li>
 			<li><a href="./about.html">about</a></li>
 		</ul>
-	</div>
+	</div>
 	<!--[/include]-->
 	
 	<div id="content">
 		<h2>About</h2>
 	</div>
 	
-	<!--[include './public/footer.html']-->
+	<!--[include "./public/footer.html"]-->
 	<div id="footer">
-		(c) 2013 <a href="https://github.com/aui">github.com/aui</a>
-	</div>
-	
+		(c) 2014 <a href="https://github.com/aui">github.com/aui</a>
+	</div>
 	<!--[/include]-->
 </body>
 </html>
\ No newline at end of file
diff --git a/test/test/index.html b/demo/includeHTML/demo/index.html
similarity index 65%
rename from test/test/index.html
rename to demo/includeHTML/demo/index.html
index d796d6c..255a346 100755
--- a/test/test/index.html
+++ b/demo/includeHTML/demo/index.html
@@ -1,29 +1,29 @@
-<!doctype html>
+<!doctype html>
 <html lang="en">
 <head>
 	<meta charset="UTF-8">
 	<title>Home</title>
 </head>
 <body>
-	<!--[include './public/header.html']-->
+	<!--[include "./public/header.html"]-->
 	<div id="header">
+		<h1>Site</h1>
 		<ul class="nav">
 			<li><a href="./index.html">Home</a></li>
 			<li><a href="./news.html">News</a></li>
 			<li><a href="./about.html">about</a></li>
 		</ul>
-	</div>
+	</div>
 	<!--[/include]-->
 	
 	<div id="content">
 		<h2>Home</h2>
 	</div>
 	
-	<!--[include './public/footer.html']-->
+	<!--[include "./public/footer.html"]-->
 	<div id="footer">
-		(c) 2013 <a href="https://github.com/aui">github.com/aui</a>
-	</div>
-	
+		(c) 2014 <a href="https://github.com/aui">github.com/aui</a>
+	</div>
 	<!--[/include]-->
 </body>
 </html>
\ No newline at end of file
diff --git a/test/test/news.html b/demo/includeHTML/demo/news.html
similarity index 65%
rename from test/test/news.html
rename to demo/includeHTML/demo/news.html
index ad0af84..ea90d28 100755
--- a/test/test/news.html
+++ b/demo/includeHTML/demo/news.html
@@ -1,29 +1,29 @@
-<!doctype html>
+<!doctype html>
 <html lang="en">
 <head>
 	<meta charset="UTF-8">
 	<title>News</title>
 </head>
 <body>
-	<!--[include './public/header.html']-->
+	<!--[include "./public/header.html"]-->
 	<div id="header">
+		<h1>Site</h1>
 		<ul class="nav">
 			<li><a href="./index.html">Home</a></li>
 			<li><a href="./news.html">News</a></li>
 			<li><a href="./about.html">about</a></li>
 		</ul>
-	</div>
+	</div>
 	<!--[/include]-->
 	
 	<div id="content">
 		<h2>News</h2>
 	</div>
 	
-	<!--[include './public/footer.html']-->
+	<!--[include "./public/footer.html"]-->
 	<div id="footer">
-		(c) 2013 <a href="https://github.com/aui">github.com/aui</a>
-	</div>
-	
+		(c) 2014 <a href="https://github.com/aui">github.com/aui</a>
+	</div>
 	<!--[/include]-->
 </body>
 </html>
\ No newline at end of file
diff --git a/demo/includeHTML/demo/public/footer.html b/demo/includeHTML/demo/public/footer.html
new file mode 100755
index 0000000..09a7406
--- /dev/null
+++ b/demo/includeHTML/demo/public/footer.html
@@ -0,0 +1,3 @@
+	<div id="footer">
+		(c) 2014 <a href="https://github.com/aui">github.com/aui</a>
+	</div>
\ No newline at end of file
diff --git a/test/test/public/header.html b/demo/includeHTML/demo/public/header.html
similarity index 85%
rename from test/test/public/header.html
rename to demo/includeHTML/demo/public/header.html
index 0072f24..cea8ba7 100755
--- a/test/test/public/header.html
+++ b/demo/includeHTML/demo/public/header.html
@@ -1,4 +1,5 @@
 	<div id="header">
+		<h1>Site</h1>
 		<ul class="nav">
 			<li><a href="./index.html">Home</a></li>
 			<li><a href="./news.html">News</a></li>
diff --git a/demo/includeHTML/includeHTML.bat b/demo/includeHTML/includeHTML.bat
new file mode 100644
index 0000000..ce1fb5a
--- /dev/null
+++ b/demo/includeHTML/includeHTML.bat
@@ -0,0 +1,2484 @@
+@if (0===0) @end/*
+@echo off
+title node
+cd %~dp0
+call CScript.EXE "%~dpnx0" //Nologo //e:jscript %*
+goto cmd
+-------------------------------------------------------
+Build       1401553234841
+Compiler    node2bat.js@0.0.2 | https://github.com/aui/node2bat
+-------------------------------------------------------
+*/(function () {
+
+try {
+var fs = require('fs');
+var path = require('path');
+var extnames = ['.html', '.htm'];
+var args = process.argv.slice(2);
+var base = '.' + path.sep;
+
+var charset = 'utf-8';
+var INCLUDE_RE = /([\u0009\u000B\u000C\u0020\u00A0\u1680\u180E\u2000-\u200A\u200B\u2028\u2029\u202F\u205F\u3000]*?)<!--\s*\[include\s*['"]*(.*?)['"]*\]\s*-->([\w\W]*?)<!--\s*\[\/include\]\s*-->/ig;
+var TEMPLATE = '{{blank}}<!--[include "{{id}}"]-->\n{{content}}\n{{blank}}<!--[/include]-->';
+var TEMPLATE_RE = /\{\{(.*?)\}\}/g;
+
+
+var compile = function (base, file) {
+	var html = fs.readFileSync(file, charset);
+	var count = 0;
+	var stdout = file.replace(base + path.sep, '');
+
+	html = html.replace(INCLUDE_RE, function ($1, blank, id, content) {
+
+		var dirname = path.dirname(file);
+		var target = path.resolve(dirname, id.split('/').join(path.sep));
+		var fileContent = '';
+
+		if (fs.existsSync(target)) {
+			fileContent = fs.readFileSync(target, charset);
+			if (content.trim() === fileContent.trim()) {
+				return $1;
+			}
+		} else {
+			throw new Error('File not found: ' + target);
+		}
+
+		count ++;
+		return template(TEMPLATE, {
+			id: id,
+			blank: blank,
+			content: fileContent
+		});
+	});
+	
+	
+	if (count) {
+
+		stdout += ' [ok]'
+		fs.writeFileSync(file, html, charset);
+	}
+	
+	console.log(stdout);
+};
+
+
+var template = function (string, data) {
+	return string.replace(TEMPLATE_RE, function ($1, $2) {
+		return data[$2] || '';
+	});
+};
+
+
+var walk = function (dir) {
+	var dirList = fs.readdirSync(dir);
+
+	dirList.forEach(function (item) {
+		var target = path.join(dir, item);
+		
+		if (fs.statSync(target).isDirectory()) {
+			walk(target);
+		} else if (extnames.indexOf(path.extname(target)) === 0) {
+			compile(base, target);
+		}
+	});
+};
+
+
+if (args[0]) {
+	base = path.resolve(args[0]);
+}
+
+
+if (fs.statSync(base).isDirectory()) {
+	walk(base);
+} else if (extnames.indexOf(path.extname(base)) === 0) {
+	var file = base;
+	base = path.dirname(base);
+	compile(base, file);
+}
+} catch (e) {
+    console.error(e);
+    WScript.Quit(1);
+}
+
+}).call({
+    node2bat: "0.0.2"
+}, function (global, exports) {
+    // NodeJS Runtime
+    global.global = global;
+
+    global.process = {
+
+        title: 'node',
+
+        argv: function () {
+            var Arguments = WScript.Arguments;
+            var length = Arguments.length;
+            var argv = ['node', WScript.ScriptFullName];
+
+            if (length) {
+                for (var i = 0; i < length; i++) {
+                    argv.push(Arguments(i));
+                }
+            }
+
+            return argv;
+        }(),
+
+
+        cwd: function () {
+            return WScript
+                .ScriptFullName
+                .replace(WScript.ScriptName, '')
+                .replace(/\\+$/, '');
+        },
+
+        // @see http://technet.microsoft.com/en-us/library/ee156595.aspx
+        env: (function () {
+            var wsh = new ActiveXObject("WScript.Shell");
+            var processObject = wsh.Environment("Process");
+            var list = [
+                'ALLUSERSPROFILE',
+                'APPDATA',
+                'CommonProgramFiles',
+                'COMPUTERNAME',
+                'ComSpec',
+                'configsetroot',
+                'FP_NO_HOST_CHECK',
+                'HOMEDRIVE',
+                'HOMEPATH',
+                'LOCALAPPDATA',
+                'LOGONSERVER',
+                'NUMBER_OF_PROCESSORS',
+                'OS',
+                'Path',
+                'PATHEXT',
+                'PROCESSOR_ARCHITECTURE',
+                'PROCESSOR_IDENTIFIER',
+                'PROCESSOR_LEVEL',
+                'PROCESSOR_REVISION',
+                'ProgramData',
+                'ProgramFiles',
+                'PROMPT',
+                'PSModulePath',
+                'PUBLIC',
+                'SESSIONNAME',
+                'SystemDrive',
+                'SystemRoot',
+                'TEMP',
+                'TMP',
+                'USERDOMAIN',
+                'USERNAME',
+                'USERPROFILE',
+                'windir'
+            ];
+
+
+            var Env = function () {
+                for (var name, info, i = 0; i < list.length; i++) {
+                    name = list[i];
+                    info = processObject.Item(name);
+                    info = wsh.ExpandEnvironmentStrings(info);
+                    this[name] = info;
+                    Env.prototype[name.toUpperCase()] = info;
+                }
+            };
+
+            return new Env();
+        })(),
+
+
+        exit: function (code) {
+            WScript.Quit(code);
+        },
+
+
+        stdout: {
+            write: function (message) {
+                WScript.StdOut.Write(message);
+            }
+        },
+
+        stderr: {
+            write: function (message) {
+                WScript.StdOut.Write(message);
+            }
+        }
+    };
+
+
+    // CommonJS require()
+    global.require = function require (id) {
+        
+        var path = require.resolve(id);
+        var mod = require._modules[path];
+
+        if (!mod) {
+            if (/\.json$/i.test(id)) {
+                var fs = require('fs');
+                var text = fs.readFileSync(id, 'utf-8');
+                var json = JSON.parse(text);
+                return json;
+            } else {
+                throw new Error('failed to require "' + id + '"');
+            } 
+        }
+
+        if (!mod.exports) {
+            mod.exports = {};
+            mod.call(mod.exports, require.relative(path), mod.exports, mod);
+        }
+
+        return mod.exports;
+    }
+
+    // fn: function (require, exports, module) {}
+    function define (path, fn) {
+        require._modules[path] = fn;
+    };
+
+    require._modules = {};
+
+    require.resolve = function (path) {
+        var orig = path,
+            reg = path + '.js',
+            index = path + '/index.js';
+        return require._modules[reg] && reg || require._modules[index] && index || orig;
+    };
+
+
+    require.relative = function (parent) {
+        return function (p) {
+            if ('.' != p.substr(0, 1)) return require(p);
+
+            var path = parent.split('/'),
+                segs = p.split('/');
+            path.pop();
+
+            for (var i = 0; i < segs.length; i++) {
+                var seg = segs[i];
+                if ('..' == seg) path.pop();
+                else if ('.' != seg) path.push(seg);
+            }
+
+            return require(path.join('/'));
+        };
+    };
+
+
+    global.__filename = WScript.ScriptFullName;
+
+    global.__dirname = global.process.cwd();
+
+
+    /*global.setTimeout = function (fn, time) {
+        WScript.Sleep(time);
+        if (typeof fn === 'function') {
+            fn();
+        } else {
+            eval(fn);
+        }
+    };
+
+
+    global.setInterval = function (fn, time) {
+        var interval = function () {
+
+            WScript.Sleep(time);
+
+            if (typeof fn === 'function') {
+                fn();
+            } else {
+                eval(fn);
+            }
+
+            interval();
+        };
+
+        interval();
+    };*/
+
+
+    define('util', function (require, exports, module) {
+        // 2014-04-04 02:39:42
+        var formatRegExp = /%[sdj%]/g;
+        exports.format = function (f) {
+            if (!isString(f)) {
+                var objects = [];
+                for (var i = 0; i < arguments.length; i++) {
+                    objects.push(inspect(arguments[i]));
+                }
+                return objects.join(' ');
+            }
+
+            var i = 1;
+            var args = arguments;
+            var len = args.length;
+            var str = String(f).replace(formatRegExp, function (x) {
+                if (x === '%%') return '%';
+                if (i >= len) return x;
+                switch (x) {
+                case '%s':
+                    return String(args[i++]);
+                case '%d':
+                    return Number(args[i++]);
+                case '%j':
+                    try {
+                        return JSON.stringify(args[i++]);
+                    } catch (_) {
+                        return '[Circular]';
+                    }
+                default:
+                    return x;
+                }
+            });
+            for (var x = args[i]; i < len; x = args[++i]) {
+                if (isNull(x) || !isObject(x)) {
+                    str += ' ' + x;
+                } else {
+                    str += ' ' + inspect(x);
+                }
+            }
+            return str;
+        };
+
+
+         // Mark that a method should not be used.
+         // Returns a modified function which warns once by default.
+         // If --no-deprecation is set, then it is a no-op.
+        exports.deprecate = function (fn, msg) {
+            // Allow for deprecating things in the process of starting up.
+            if (isUndefined(global.process)) {
+                return function () {
+                    return exports.deprecate(fn, msg).apply(this, arguments);
+                };
+            }
+
+            if (process.noDeprecation === true) {
+                return fn;
+            }
+
+            var warned = false;
+
+            function deprecated() {
+                if (!warned) {
+                    if (process.throwDeprecation) {
+                        throw new Error(msg);
+                    } else if (process.traceDeprecation) {
+                        console.trace(msg);
+                    } else {
+                        console.error(msg);
+                    }
+                    warned = true;
+                }
+                return fn.apply(this, arguments);
+            }
+
+            return deprecated;
+        };
+
+
+        var debugs = {};
+        var debugEnviron;
+        exports.debuglog = function (set) {
+            if (isUndefined(debugEnviron))
+                debugEnviron = process.env.NODE_DEBUG || '';
+            set = set.toUpperCase();
+            if (!debugs[set]) {
+                if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
+                    var pid = process.pid;
+                    debugs[set] = function () {
+                        var msg = exports.format.apply(exports, arguments);
+                        console.error('%s %d: %s', set, pid, msg);
+                    };
+                } else {
+                    debugs[set] = function () {};
+                }
+            }
+            return debugs[set];
+        };
+
+
+        /**
+         * Echos the value of a value. Trys to print the value out
+         * in the best way possible given the different types.
+         *
+         * @param {Object} obj The object to print out.
+         * @param {Object} opts Optional options object that alters the output.
+         */
+        /* legacy: obj, showHidden, depth, colors*/
+        function inspect(obj, opts) {
+            // default options
+            var ctx = {
+                seen: [],
+                stylize: stylizeNoColor
+            };
+            // legacy...
+            if (arguments.length >= 3) ctx.depth = arguments[2];
+            if (arguments.length >= 4) ctx.colors = arguments[3];
+            if (isBoolean(opts)) {
+                // legacy...
+                ctx.showHidden = opts;
+            } else if (opts) {
+                // got an "options" object
+                exports._extend(ctx, opts);
+            }
+            // set default options
+            if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
+            if (isUndefined(ctx.depth)) ctx.depth = 2;
+            if (isUndefined(ctx.colors)) ctx.colors = false;
+            if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
+            if (ctx.colors) ctx.stylize = stylizeWithColor;
+            return formatValue(ctx, obj, ctx.depth);
+        }
+        exports.inspect = inspect;
+
+
+         // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
+        inspect.colors = {
+            'bold': [1, 22],
+            'italic': [3, 23],
+            'underline': [4, 24],
+            'inverse': [7, 27],
+            'white': [37, 39],
+            'grey': [90, 39],
+            'black': [30, 39],
+            'blue': [34, 39],
+            'cyan': [36, 39],
+            'green': [32, 39],
+            'magenta': [35, 39],
+            'red': [31, 39],
+            'yellow': [33, 39]
+        };
+
+         // Don't use 'blue' not visible on cmd.exe
+        inspect.styles = {
+            'special': 'cyan',
+            'number': 'yellow',
+            'boolean': 'yellow',
+            'undefined': 'grey',
+            'null': 'bold',
+            'string': 'green',
+            'date': 'magenta',
+            // "name": intentionally not styling
+            'regexp': 'red'
+        };
+
+
+        function stylizeWithColor(str, styleType) {
+            var style = inspect.styles[styleType];
+
+            if (style) {
+                return '\u001b[' + inspect.colors[style][0] + 'm' + str +
+                    '\u001b[' + inspect.colors[style][1] + 'm';
+            } else {
+                return str;
+            }
+        }
+
+
+        function stylizeNoColor(str, styleType) {
+            return str;
+        }
+
+
+        function arrayToHash(array) {
+            var hash = {};
+
+            array.forEach(function (val, idx) {
+                hash[val] = true;
+            });
+
+            return hash;
+        }
+
+
+        function formatValue(ctx, value, recurseTimes) {
+            // Provide a hook for user-specified inspect functions.
+            // Check that value is an object with an inspect function on it
+            if (ctx.customInspect &&
+                value &&
+                isFunction(value.inspect) &&
+                // Filter out the util module, it's inspect function is special
+                value.inspect !== exports.inspect &&
+                // Also filter out any prototype objects using the circular check.
+                !(value.constructor && value.constructor.prototype === value)) {
+                var ret = value.inspect(recurseTimes, ctx);
+                if (!isString(ret)) {
+                    ret = formatValue(ctx, ret, recurseTimes);
+                }
+                return ret;
+            }
+
+            // Primitive types cannot have properties
+            var primitive = formatPrimitive(ctx, value);
+            if (primitive) {
+                return primitive;
+            }
+
+            // Look up the keys of the object.
+            var keys = Object.keys(value);
+            var visibleKeys = arrayToHash(keys);
+
+            if (ctx.showHidden) {
+                keys = Object.getOwnPropertyNames(value);
+            }
+
+            // This could be a boxed primitive (new String(), etc.), check valueOf()
+            // NOTE: Avoid calling `valueOf` on `Date` instance because it will return
+            // a number which, when object has some additional user-stored `keys`,
+            // will be printed out.
+            var formatted;
+            var raw = value;
+            try {
+                // the .valueOf() call can fail for a multitude of reasons
+                if (!isDate(value))
+                    raw = value.valueOf();
+            } catch (e) {
+                // ignore...
+            }
+
+            if (isString(raw)) {
+                // for boxed Strings, we have to remove the 0-n indexed entries,
+                // since they just noisey up the output and are redundant
+                keys = keys.filter(function (key) {
+                    return !(key >= 0 && key < raw.length);
+                });
+            }
+
+            // Some type of object without properties can be shortcutted.
+            if (keys.length === 0) {
+                if (isFunction(value)) {
+                    var name = value.name ? ': ' + value.name : '';
+                    return ctx.stylize('[Function' + name + ']', 'special');
+                }
+                if (isRegExp(value)) {
+                    return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+                }
+                if (isDate(value)) {
+                    return ctx.stylize(Date.prototype.toString.call(value), 'date');
+                }
+                if (isError(value)) {
+                    return formatError(value);
+                }
+                // now check the `raw` value to handle boxed primitives
+                if (isString(raw)) {
+                    formatted = formatPrimitiveNoColor(ctx, raw);
+                    return ctx.stylize('[String: ' + formatted + ']', 'string');
+                }
+                if (isNumber(raw)) {
+                    formatted = formatPrimitiveNoColor(ctx, raw);
+                    return ctx.stylize('[Number: ' + formatted + ']', 'number');
+                }
+                if (isBoolean(raw)) {
+                    formatted = formatPrimitiveNoColor(ctx, raw);
+                    return ctx.stylize('[Boolean: ' + formatted + ']', 'boolean');
+                }
+            }
+
+            var base = '',
+                array = false,
+                braces = ['{', '}'];
+
+            // Make Array say that they are Array
+            if (isArray(value)) {
+                array = true;
+                braces = ['[', ']'];
+            }
+
+            // Make functions say that they are functions
+            if (isFunction(value)) {
+                var n = value.name ? ': ' + value.name : '';
+                base = ' [Function' + n + ']';
+            }
+
+            // Make RegExps say that they are RegExps
+            if (isRegExp(value)) {
+                base = ' ' + RegExp.prototype.toString.call(value);
+            }
+
+            // Make dates with properties first say the date
+            if (isDate(value)) {
+                base = ' ' + Date.prototype.toUTCString.call(value);
+            }
+
+            // Make error with message first say the error
+            if (isError(value)) {
+                base = ' ' + formatError(value);
+            }
+
+            // Make boxed primitive Strings look like such
+            if (isString(raw)) {
+                formatted = formatPrimitiveNoColor(ctx, raw);
+                base = ' ' + '[String: ' + formatted + ']';
+            }
+
+            // Make boxed primitive Numbers look like such
+            if (isNumber(raw)) {
+                formatted = formatPrimitiveNoColor(ctx, raw);
+                base = ' ' + '[Number: ' + formatted + ']';
+            }
+
+            // Make boxed primitive Booleans look like such
+            if (isBoolean(raw)) {
+                formatted = formatPrimitiveNoColor(ctx, raw);
+                base = ' ' + '[Boolean: ' + formatted + ']';
+            }
+
+            if (keys.length === 0 && (!array || value.length === 0)) {
+                return braces[0] + base + braces[1];
+            }
+
+            if (recurseTimes < 0) {
+                if (isRegExp(value)) {
+                    return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+                } else {
+                    return ctx.stylize('[Object]', 'special');
+                }
+            }
+
+            ctx.seen.push(value);
+
+            var output;
+            if (array) {
+                output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
+            } else {
+                output = keys.map(function (key) {
+                    return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
+                });
+            }
+
+            ctx.seen.pop();
+
+            return reduceToSingleString(output, base, braces);
+        }
+
+
+        function formatPrimitive(ctx, value) {
+            if (isUndefined(value))
+                return ctx.stylize('undefined', 'undefined');
+            if (isString(value)) {
+                var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
+                    .replace(/'/g, "\\'")
+                    .replace(/\\"/g, '"') + '\'';
+                return ctx.stylize(simple, 'string');
+            }
+            if (isNumber(value)) {
+                // Format -0 as '-0'. Strict equality won't distinguish 0 from -0,
+                // so instead we use the fact that 1 / -0 < 0 whereas 1 / 0 > 0 .
+                if (value === 0 && 1 / value < 0)
+                    return ctx.stylize('-0', 'number');
+                return ctx.stylize('' + value, 'number');
+            }
+            if (isBoolean(value))
+                return ctx.stylize('' + value, 'boolean');
+            // For some reason typeof null is "object", so special case here.
+            if (isNull(value))
+                return ctx.stylize('null', 'null');
+        }
+
+
+        function formatPrimitiveNoColor(ctx, value) {
+            var stylize = ctx.stylize;
+            ctx.stylize = stylizeNoColor;
+            var str = formatPrimitive(ctx, value);
+            ctx.stylize = stylize;
+            return str;
+        }
+
+
+        function formatError(value) {
+            return '[' + Error.prototype.toString.call(value) + ']';
+        }
+
+
+        function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
+            var output = [];
+            for (var i = 0, l = value.length; i < l; ++i) {
+                if (hasOwnProperty(value, String(i))) {
+                    output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+                        String(i), true));
+                } else {
+                    output.push('');
+                }
+            }
+            keys.forEach(function (key) {
+                if (!key.match(/^\d+$/)) {
+                    output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+                        key, true));
+                }
+            });
+            return output;
+        }
+
+
+        function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
+            var name, str, desc;
+            desc = /*Object.getOwnPropertyDescriptor(value, key) ||*/ {
+                value: value[key]
+            };
+            if (desc.get) {
+                if (desc.set) {
+                    str = ctx.stylize('[Getter/Setter]', 'special');
+                } else {
+                    str = ctx.stylize('[Getter]', 'special');
+                }
+            } else {
+                if (desc.set) {
+                    str = ctx.stylize('[Setter]', 'special');
+                }
+            }
+            if (!hasOwnProperty(visibleKeys, key)) {
+                name = '[' + key + ']';
+            }
+            if (!str) {
+                if (ctx.seen.indexOf(desc.value) < 0) {
+                    if (isNull(recurseTimes)) {
+                        str = formatValue(ctx, desc.value, null);
+                    } else {
+                        str = formatValue(ctx, desc.value, recurseTimes - 1);
+                    }
+                    if (str.indexOf('\n') > -1) {
+                        if (array) {
+                            str = str.split('\n').map(function (line) {
+                                return '  ' + line;
+                            }).join('\n').substr(2);
+                        } else {
+                            str = '\n' + str.split('\n').map(function (line) {
+                                return '   ' + line;
+                            }).join('\n');
+                        }
+                    }
+                } else {
+                    str = ctx.stylize('[Circular]', 'special');
+                }
+            }
+            if (isUndefined(name)) {
+                if (array && key.match(/^\d+$/)) {
+                    return str;
+                }
+                name = JSON.stringify('' + key);
+                if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+                    name = name.substr(1, name.length - 2);
+                    name = ctx.stylize(name, 'name');
+                } else {
+                    name = name.replace(/'/g, "\\'")
+                        .replace(/\\"/g, '"')
+                        .replace(/(^"|"$)/g, "'")
+                        .replace(/\\\\/g, '\\');
+                    name = ctx.stylize(name, 'string');
+                }
+            }
+
+            return name + ': ' + str;
+        }
+
+
+        function reduceToSingleString(output, base, braces) {
+            var length = output.reduce(function (prev, cur) {
+                return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
+            }, 0);
+
+            if (length > 60) {
+                return braces[0] +
+                    (base === '' ? '' : base + '\n ') +
+                    ' ' +
+                    output.join(',\n  ') +
+                    ' ' +
+                    braces[1];
+            }
+
+            return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
+        }
+
+
+         // NOTE: These type checking functions intentionally don't use `instanceof`
+         // because it is fragile and can be easily faked with `Object.create()`.
+        var isArray = exports.isArray = Array.isArray;
+
+        function isBoolean(arg) {
+            return typeof arg === 'boolean';
+        }
+        exports.isBoolean = isBoolean;
+
+        function isNull(arg) {
+            return arg === null;
+        }
+        exports.isNull = isNull;
+
+        function isNullOrUndefined(arg) {
+            return arg == null;
+        }
+        exports.isNullOrUndefined = isNullOrUndefined;
+
+        function isNumber(arg) {
+            return typeof arg === 'number';
+        }
+        exports.isNumber = isNumber;
+
+        function isString(arg) {
+            return typeof arg === 'string';
+        }
+        exports.isString = isString;
+
+        function isSymbol(arg) {
+            return typeof arg === 'symbol';
+        }
+        exports.isSymbol = isSymbol;
+
+        function isUndefined(arg) {
+            return arg === void 0;
+        }
+        exports.isUndefined = isUndefined;
+
+        function isRegExp(re) {
+            return isObject(re) && objectToString(re) === '[object RegExp]';
+        }
+        exports.isRegExp = isRegExp;
+
+        function isObject(arg) {
+            return typeof arg === 'object' && arg !== null;
+        }
+        exports.isObject = isObject;
+
+        function isDate(d) {
+            return isObject(d) && objectToString(d) === '[object Date]';
+        }
+        exports.isDate = isDate;
+
+        function isError(e) {
+            return isObject(e) &&
+                (objectToString(e) === '[object Error]' || e instanceof Error);
+        }
+        exports.isError = isError;
+
+        function isFunction(arg) {
+            return typeof arg === 'function';
+        }
+        exports.isFunction = isFunction;
+
+        function isPrimitive(arg) {
+            return arg === null ||
+                typeof arg === 'boolean' ||
+                typeof arg === 'number' ||
+                typeof arg === 'string' ||
+                typeof arg === 'symbol' || // ES6 symbol
+                typeof arg === 'undefined';
+        }
+        exports.isPrimitive = isPrimitive;
+
+        function objectToString(o) {
+            return Object.prototype.toString.call(o);
+        }
+
+
+        function pad(n) {
+            return n < 10 ? '0' + n.toString(10) : n.toString(10);
+        }
+
+
+        var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
+            'Oct', 'Nov', 'Dec'
+        ];
+
+         // 26 Feb 16:19:34
+        function timestamp() {
+            var d = new Date();
+            var time = [pad(d.getHours()),
+                pad(d.getMinutes()),
+                pad(d.getSeconds())
+            ].join(':');
+            return [d.getDate(), months[d.getMonth()], time].join(' ');
+        }
+
+
+         // log is just a thin wrapper to console.log that prepends a timestamp
+        exports.log = function () {
+            console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
+        };
+
+
+        exports._extend = function (origin, add) {
+            // Don't do anything if add isn't an object
+            if (!add || !isObject(add)) return origin;
+
+            var keys = Object.keys(add);
+            var i = keys.length;
+            while (i--) {
+                origin[keys[i]] = add[keys[i]];
+            }
+            return origin;
+        };
+
+        function hasOwnProperty(obj, prop) {
+            return Object.prototype.hasOwnProperty.call(obj, prop);
+        }
+
+
+        var uv;
+        exports._errnoException = function (err, syscall, original) {
+            if (isUndefined(uv)) uv = process.binding('uv');
+            var errname = uv.errname(err);
+            var message = syscall + ' ' + errname;
+            if (original)
+                message += ' ' + original;
+            var e = new Error(message);
+            e.code = errname;
+            e.errno = errname;
+            e.syscall = syscall;
+            return e;
+        };
+    });
+
+
+    define('console', function (require, exports, module) {
+        // 2013-08-02 06:08:01 
+        var util = require('util');
+
+        function Console(stdout, stderr) {
+            if (!(this instanceof Console)) {
+                return new Console(stdout, stderr);
+            }
+            if (!stdout || !util.isFunction(stdout.write)) {
+                throw new TypeError('Console expects a writable stream instance');
+            }
+            if (!stderr) {
+                stderr = stdout;
+            }
+
+            this._stdout = stdout;
+            this._stderr = stderr;
+            this._times = {};
+
+            // bind the prototype functions to this Console instance
+            Object.keys(Console.prototype).forEach(function (k) {
+                this[k] = this[k].bind(this);
+            }, this);
+        }
+
+        Console.prototype.log = function () {
+            this._stdout.write(util.format.apply(this, arguments) + '\n');
+        };
+
+
+        Console.prototype.info = Console.prototype.log;
+
+
+        Console.prototype.warn = function () {
+            this._stderr.write(util.format.apply(this, arguments) + '\n');
+        };
+
+
+        Console.prototype.error = Console.prototype.warn;
+
+
+        Console.prototype.dir = function (object) {
+            this._stdout.write(util.inspect(object, {
+                customInspect: false
+            }) + '\n');
+        };
+
+
+        Console.prototype.time = function (label) {
+            this._times[label] = Date.now();
+        };
+
+
+        Console.prototype.timeEnd = function (label) {
+            var time = this._times[label];
+            if (!time) {
+                throw new Error('No such label: ' + label);
+            }
+            var duration = Date.now() - time;
+            this.log('%s: %dms', label, duration);
+        };
+
+
+        Console.prototype.assert = function (expression) {
+            if (!expression) {
+                var arr = Array.prototype.slice.call(arguments, 1);
+                require('assert').ok(false, util.format.apply(this, arr));
+            }
+        };
+
+
+        module.exports = new Console(process.stdout, process.stderr);
+        module.exports.Console = Console;
+    });
+
+
+    define('fs', function (require, exports, module) {
+
+        var fso = new ActiveXObject('Scripting.FileSystemObject');
+
+        var Stat = function (path) {
+            var info;
+            this._path = path;
+
+            if (this.isFile()) {
+                info = fso.GetFile(path);
+            } else if (this.isDirectory()) {
+                info = fso.GetFolder(path);
+            } else {
+                throw new Error('ENOENT, no such file or directory ' + JSON.stringify(path));
+            }
+
+            this.size = info.Size; // TODO: 读取目录不准确
+            this.atime = new Date(info.DateLastAccessed);
+            this.mtime = new Date(info.DateLastModified);
+            this.ctime = new Date(info.DateCreated);
+        };
+
+        Stat.prototype = {
+            isFile: function () {
+                return fso.FileExists(this._path);
+            },
+            isDirectory: function () {
+                return fso.FolderExists(this._path);
+            }
+        };
+
+        exports.renameSync = function (oldPath, newPath) {
+            var statSync = exports.statSync(oldPath);
+            var file = fso[statSync.isFile() ? 'GetFile' : 'GetFolder'](oldPath);
+            if (exports.existsSync(newPath)) {
+                exports.unlinkSync(newPath);
+            }
+            file.Move(newPath);
+        };
+
+        exports.mkdirSync = function (path) {
+            // TODO: Error Info
+            fso.CreateFolder(path);
+        };
+
+        exports.mkdirSync = function (path) {
+            fso.CreateFolder(path);
+        };
+
+        exports.rmdirSync = function (path) {
+            fso.DeleteFolder(path, true);
+        };
+
+        exports.unlinkSync = function (path) {
+            fso.DeleteFile(path, true);
+        };
+
+        exports.existsSync = function (path) {
+            try {
+                var statSync = exports.statSync(path);
+                return statSync.isFile() || statSync.isDirectory();
+            } catch (e) {
+                return false;
+            }  
+        };
+
+        exports.statSync = function (path) {
+            return new Stat(path);
+        };
+
+        exports.readdirSync = function (path) {
+
+            var listall = function (path) {
+
+                var fd = fso.GetFolder(path + '\\');
+                var fe = new Enumerator(fd.files);
+                var list = [];
+                var item;
+
+                while (!fe.atEnd()) {
+                    item = fe.item() + '';
+                    item = item.replace(/^.*\\([^\\]*)$/, '$1');
+                    list.push(item);
+                    fe.moveNext();
+                }
+
+                var folderList = new Enumerator(fd.SubFolders);
+                for (; !folderList.atEnd(); folderList.moveNext()) {
+                    item = folderList.item() + '';
+                    item = item.replace(/^.*\\([^\\]*)$/, '$1');
+                    list.push(item);
+                }
+
+                return list;
+            };
+
+            return listall(path);
+        };
+
+        exports.readFileSync = function (file, charset) {
+            var stream = new ActiveXObject('adodb.stream');
+            var fileContent;
+
+            stream.Type = charset ? 2 : 1;
+            stream.Open();
+
+            if (charset) {
+                stream.Charset = charset;
+            } else {
+                throw new TypeError('Bad arguments');
+            }
+
+            try {
+                stream.LoadFromFile(file);
+            } catch (e) {
+                throw e;
+            }
+
+            fileContent = new String(stream.ReadText());
+            fileContent.Charset = charset;
+            stream.Close();
+
+            return fileContent.toString();
+        };
+
+        // @see http://bathome.l3.wuyou.com/redirect.php?goto=findpost&ptid=10300&pid=66972
+        // @see http://www.clockworksoftware.com/asp/Products/vbs2js.asp
+        exports.writeFileSync = function (file, data, charset) {
+            var binData;
+            var stream = new ActiveXObject("adodb.Stream");
+
+            stream.Open();
+
+            try {
+                
+                if (charset) {
+
+
+                    stream.Position = 0;
+                    stream.CharSet = charset;
+                    stream.WriteText(data);
+                    stream.SetEOS();
+
+                    stream.Position = 0;
+                    stream.Type = 1;
+
+                    // TODO: test BOM
+                    // /^0xEF0xBB0xBF/
+                    if (charset !== 'ascii') {
+                        stream.Position = 3;
+                    }
+                    
+                    binData = stream.Read(-1); 
+
+                    stream.Position = 0;
+                    stream.Write(binData);
+                    stream.SetEOS();
+                    
+
+                    stream.SaveToFile(file, 2);
+                } else {
+                    
+                    //stream.Type = 1;
+                    //stream.Write(data);
+                    //stream.SaveToFile(file, 2);
+                    throw new TypeError('Bad arguments');
+                }
+
+            } catch (e) {
+                throw e;
+            } finally {
+                stream.close();
+            }
+        };
+    });
+
+
+    define('path', function (require, exports, module) {
+
+        // resolves . and .. elements in a path array with directory names there
+        // must be no slashes, empty elements, or device names (c:\) in the array
+        // (so also no leading and trailing slashes - it does not distinguish
+        // relative and absolute paths)
+        function normalizeArray(parts, allowAboveRoot) {
+            // if the path tries to go above the root, `up` ends up > 0
+            var up = 0;
+            for (var i = parts.length - 1; i >= 0; i--) {
+                var last = parts[i];
+                if (last === '.') {
+                    parts.splice(i, 1);
+                } else if (last === '..') {
+                    parts.splice(i, 1);
+                    up++;
+                } else if (up) {
+                    parts.splice(i, 1);
+                    up--;
+                }
+            }
+
+            // if the path is allowed to go above the root, restore leading ..s
+            if (allowAboveRoot) {
+                for (; up--; up) {
+                    parts.unshift('..');
+                }
+            }
+
+            return parts;
+        }
+        // Regex to split a windows path into three parts: [*, device, slash,
+        // tail] windows-only
+        var splitDeviceRe =
+            /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
+
+        // Regex to split the tail part of the above into [*, dir, basename, ext]
+        var splitTailRe =
+            /^([\s\S]*?)((?:\.{1,2}|[^\\\/]+?|)(\.[^.\/\\]*|))(?:[\\\/]*)$/;
+
+        // Function to split a filename into [root, dir, basename, ext]
+        // windows version
+        var splitPath = function (filename) {
+            // Separate device+slash from tail
+            var result = splitDeviceRe.exec(filename),
+                device = (result[1] || '') + (result[2] || ''),
+                tail = result[3] || '';
+            // Split the tail into dir, basename and extension
+            var result2 = splitTailRe.exec(tail),
+                dir = result2[1],
+                basename = result2[2],
+                ext = result2[3];
+            return [device, dir, basename, ext];
+        };
+
+        var normalizeUNCRoot = function (device) {
+            return '\\\\' + device.replace(/^[\\\/]+/, '').replace(/[\\\/]+/g, '\\');
+        };
+
+        // path.resolve([from ...], to)
+        // windows version
+        exports.resolve = function () {
+            var resolvedDevice = '',
+                resolvedTail = '',
+                resolvedAbsolute = false;
+
+            for (var i = arguments.length - 1; i >= -1; i--) {
+                var path;
+                if (i >= 0) {
+                    path = arguments[i];
+                } else if (!resolvedDevice) {
+                    path = process.cwd();
+                } else {
+                    // Windows has the concept of drive-specific current working
+                    // directories. If we've resolved a drive letter but not yet an
+                    // absolute path, get cwd for that drive. We're sure the device is not
+                    // an unc path at this points, because unc paths are always absolute.
+                    path = process.env['=' + resolvedDevice];
+                    // Verify that a drive-local cwd was found and that it actually points
+                    // to our drive. If not, default to the drive's root.
+                    if (!path || path.substr(0, 3).toLowerCase() !==
+                        resolvedDevice.toLowerCase() + '\\') {
+                        path = resolvedDevice + '\\';
+                    }
+                }
+
+                // Skip empty and invalid entries
+                if (typeof path !== 'string') {
+                    throw new TypeError('Arguments to path.resolve must be strings');
+                } else if (!path) {
+                    continue;
+                }
+
+                var result = splitDeviceRe.exec(path),
+                    device = result[1] || '',
+                    isUnc = device && device.charAt(1) !== ':',
+                    isAbsolute = exports.isAbsolute(path),
+                    tail = result[3];
+
+                if (device &&
+                    resolvedDevice &&
+                    device.toLowerCase() !== resolvedDevice.toLowerCase()) {
+                    // This path points to another device so it is not applicable
+                    continue;
+                }
+
+                if (!resolvedDevice) {
+                    resolvedDevice = device;
+                }
+                if (!resolvedAbsolute) {
+                    resolvedTail = tail + '\\' + resolvedTail;
+                    resolvedAbsolute = isAbsolute;
+                }
+
+                if (resolvedDevice && resolvedAbsolute) {
+                    break;
+                }
+            }
+
+            // Convert slashes to backslashes when `resolvedDevice` points to an UNC
+            // root. Also squash multiple slashes into a single one where appropriate.
+            if (isUnc) {
+                resolvedDevice = normalizeUNCRoot(resolvedDevice);
+            }
+
+            // At this point the path should be resolved to a full absolute path,
+            // but handle relative paths to be safe (might happen when process.cwd()
+            // fails)
+
+            // Normalize the tail path
+
+            function f(p) {
+                return !!p;
+            }
+
+            resolvedTail = normalizeArray(resolvedTail.split(/[\\\/]+/).filter(f), !resolvedAbsolute).join('\\');
+
+            return (resolvedDevice + (resolvedAbsolute ? '\\' : '') + resolvedTail) ||
+                '.';
+        };
+
+        // windows version
+        exports.normalize = function (path) {
+            var result = splitDeviceRe.exec(path),
+                device = result[1] || '',
+                isUnc = device && device.charAt(1) !== ':',
+                isAbsolute = exports.isAbsolute(path),
+                tail = result[3],
+                trailingSlash = /[\\\/]$/.test(tail);
+
+            // If device is a drive letter, we'll normalize to lower case.
+            if (device && device.charAt(1) === ':') {
+                device = device[0].toLowerCase() + device.substr(1);
+            }
+
+            // Normalize the tail path
+            tail = normalizeArray(tail.split(/[\\\/]+/).filter(function (p) {
+                return !!p;
+            }), !isAbsolute).join('\\');
+
+            if (!tail && !isAbsolute) {
+                tail = '.';
+            }
+            if (tail && trailingSlash) {
+                tail += '\\';
+            }
+
+            // Convert slashes to backslashes when `device` points to an UNC root.
+            // Also squash multiple slashes into a single one where appropriate.
+            if (isUnc) {
+                device = normalizeUNCRoot(device);
+            }
+
+            return device + (isAbsolute ? '\\' : '') + tail;
+        };
+
+        // windows version
+        exports.isAbsolute = function (path) {
+            var result = splitDeviceRe.exec(path),
+                device = result[1] || '',
+                isUnc = device && device.charAt(1) !== ':';
+            // UNC paths are always absolute
+            return !!result[2] || isUnc;
+        };
+
+        // windows version
+        exports.join = function () {
+            function f(p) {
+                if (typeof p !== 'string') {
+                    throw new TypeError('Arguments to path.join must be strings');
+                }
+                return p;
+            }
+
+            var paths = Array.prototype.filter.call(arguments, f);
+            var joined = paths.join('\\');
+
+            // Make sure that the joined path doesn't start with two slashes, because
+            // normalize() will mistake it for an UNC path then.
+            //
+            // This step is skipped when it is very clear that the user actually
+            // intended to point at an UNC path. This is assumed when the first
+            // non-empty string arguments starts with exactly two slashes followed by
+            // at least one more non-slash character.
+            //
+            // Note that for normalize() to treat a path as an UNC path it needs to
+            // have at least 2 components, so we don't filter for that here.
+            // This means that the user can use join to construct UNC paths from
+            // a server name and a share name; for example:
+            //   path.join('//server', 'share') -> '\\\\server\\share\')
+            if (!/^[\\\/]{2}[^\\\/]/.test(paths[0])) {
+                joined = joined.replace(/^[\\\/]{2,}/, '\\');
+            }
+
+            return exports.normalize(joined);
+        };
+
+        // path.relative(from, to)
+        // it will solve the relative path from 'from' to 'to', for instance:
+        // from = 'C:\\orandea\\test\\aaa'
+        // to = 'C:\\orandea\\impl\\bbb'
+        // The output of the function should be: '..\\..\\impl\\bbb'
+        // windows version
+        exports.relative = function (from, to) {
+            from = exports.resolve(from);
+            to = exports.resolve(to);
+
+            // windows is not case sensitive
+            var lowerFrom = from.toLowerCase();
+            var lowerTo = to.toLowerCase();
+
+            function trim(arr) {
+                var start = 0;
+                for (; start < arr.length; start++) {
+                    if (arr[start] !== '') break;
+                }
+
+                var end = arr.length - 1;
+                for (; end >= 0; end--) {
+                    if (arr[end] !== '') break;
+                }
+
+                if (start > end) return [];
+                return arr.slice(start, end - start + 1);
+            }
+
+            var toParts = trim(to.split('\\'));
+
+            var lowerFromParts = trim(lowerFrom.split('\\'));
+            var lowerToParts = trim(lowerTo.split('\\'));
+
+            var length = Math.min(lowerFromParts.length, lowerToParts.length);
+            var samePartsLength = length;
+            for (var i = 0; i < length; i++) {
+                if (lowerFromParts[i] !== lowerToParts[i]) {
+                    samePartsLength = i;
+                    break;
+                }
+            }
+
+            if (samePartsLength == 0) {
+                return to;
+            }
+
+            var outputParts = [];
+            for (var i = samePartsLength; i < lowerFromParts.length; i++) {
+                outputParts.push('..');
+            }
+
+            outputParts = outputParts.concat(toParts.slice(samePartsLength));
+
+            return outputParts.join('\\');
+        };
+
+        exports.sep = '\\';
+        exports.delimiter = ';';
+
+        exports.dirname = function (path) {
+            var result = splitPath(path),
+                root = result[0],
+                dir = result[1];
+
+            if (!root && !dir) {
+                // No dirname whatsoever
+                return '.';
+            }
+
+            if (dir) {
+                // It has a dirname, strip trailing slash
+                dir = dir.substr(0, dir.length - 1);
+            }
+
+            return root + dir;
+        };
+
+
+        exports.basename = function (path, ext) {
+            var f = splitPath(path)[2];
+            // TODO: make this comparison case-insensitive on windows?
+            if (ext && f.substr(-1 * ext.length) === ext) {
+                f = f.substr(0, f.length - ext.length);
+            }
+            return f;
+        };
+
+
+        exports.extname = function (path) {
+            return splitPath(path)[3];
+        };
+    });
+
+    
+    define('assert', function (require, exports, module) {
+        // 2014-03-03 03:54:19 
+        var util = require('util');
+        var pSlice = Array.prototype.slice;
+
+        // 1. The assert module provides functions that throw
+        // AssertionError's when particular conditions are not met. The
+        // assert module must conform to the following interface.
+
+        var assert = module.exports = ok;
+
+        // 2. The AssertionError is defined in assert.
+        // new assert.AssertionError({ message: message,
+        //                             actual: actual,
+        //                             expected: expected })
+
+        assert.AssertionError = function AssertionError(options) {
+            this.name = 'AssertionError';
+            this.actual = options.actual;
+            this.expected = options.expected;
+            this.operator = options.operator;
+            if (options.message) {
+                this.message = options.message;
+                this.generatedMessage = false;
+            } else {
+                this.message = getMessage(this);
+                this.generatedMessage = true;
+            }
+            //var stackStartFunction = options.stackStartFunction || fail;
+            //Error.captureStackTrace(this, stackStartFunction);
+        };
+
+        // assert.AssertionError instanceof Error
+        //util.inherits(assert.AssertionError, Error);
+        assert.AssertionError.prototype = Error.prototype;
+
+        function replacer(key, value) {
+            if (util.isUndefined(value)) {
+                return '' + value;
+            }
+            if (util.isNumber(value) && (isNaN(value) || !isFinite(value))) {
+                return value.toString();
+            }
+            if (util.isFunction(value) || util.isRegExp(value)) {
+                return value.toString();
+            }
+            return value;
+        }
+
+        function truncate(s, n) {
+            if (util.isString(s)) {
+                return s.length < n ? s : s.slice(0, n);
+            } else {
+                return s;
+            }
+        }
+
+        function getMessage(self) {
+            return truncate(JSON.stringify(self.actual, replacer), 128) + ' ' +
+                self.operator + ' ' +
+                truncate(JSON.stringify(self.expected, replacer), 128);
+        }
+
+        // At present only the three keys mentioned above are used and
+        // understood by the spec. Implementations or sub modules can pass
+        // other keys to the AssertionError's constructor - they will be
+        // ignored.
+
+        // 3. All of the following functions must throw an AssertionError
+        // when a corresponding condition is not met, with a message that
+        // may be undefined if not provided.  All assertion methods provide
+        // both the actual and expected values to the assertion error for
+        // display purposes.
+
+        function fail(actual, expected, message, operator, stackStartFunction) {
+            throw new assert.AssertionError({
+                message: message,
+                actual: actual,
+                expected: expected,
+                operator: operator,
+                stackStartFunction: stackStartFunction
+            });
+        }
+
+        // EXTENSION! allows for well behaved errors defined elsewhere.
+        assert.fail = fail;
+
+        // 4. Pure assertion tests whether a value is truthy, as determined
+        // by !!guard.
+        // assert.ok(guard, message_opt);
+        // This statement is equivalent to assert.equal(true, !!guard,
+        // message_opt);. To test strictly for the value true, use
+        // assert.strictEqual(true, guard, message_opt);.
+
+        function ok(value, message) {
+            if (!value) fail(value, true, message, '==', assert.ok);
+        }
+        assert.ok = ok;
+
+        // 5. The equality assertion tests shallow, coercive equality with
+        // ==.
+        // assert.equal(actual, expected, message_opt);
+
+        assert.equal = function equal(actual, expected, message) {
+            if (actual != expected) fail(actual, expected, message, '==', assert.equal);
+        };
+
+        // 6. The non-equality assertion tests for whether two objects are not equal
+        // with != assert.notEqual(actual, expected, message_opt);
+
+        assert.notEqual = function notEqual(actual, expected, message) {
+            if (actual == expected) {
+                fail(actual, expected, message, '!=', assert.notEqual);
+            }
+        };
+
+        // 7. The equivalence assertion tests a deep equality relation.
+        // assert.deepEqual(actual, expected, message_opt);
+
+        assert.deepEqual = function deepEqual(actual, expected, message) {
+            if (!_deepEqual(actual, expected)) {
+                fail(actual, expected, message, 'deepEqual', assert.deepEqual);
+            }
+        };
+
+        function _deepEqual(actual, expected) {
+            // 7.1. All identical values are equivalent, as determined by ===.
+            if (actual === expected) {
+                return true;
+
+            } else if (util.isDate(actual) && util.isDate(expected)) {
+                return actual.getTime() === expected.getTime();
+
+                // 7.3 If the expected value is a RegExp object, the actual value is
+                // equivalent if it is also a RegExp object with the same source and
+                // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).
+            } else if (util.isRegExp(actual) && util.isRegExp(expected)) {
+                return actual.source === expected.source &&
+                    actual.global === expected.global &&
+                    actual.multiline === expected.multiline &&
+                    actual.lastIndex === expected.lastIndex &&
+                    actual.ignoreCase === expected.ignoreCase;
+
+                // 7.4. Other pairs that do not both pass typeof value == 'object',
+                // equivalence is determined by ==.
+            } else if (!util.isObject(actual) && !util.isObject(expected)) {
+                return actual == expected;
+
+                // 7.5 For all other Object pairs, including Array objects, equivalence is
+                // determined by having the same number of owned properties (as verified
+                // with Object.prototype.hasOwnProperty.call), the same set of keys
+                // (although not necessarily the same order), equivalent values for every
+                // corresponding key, and an identical 'prototype' property. Note: this
+                // accounts for both named and indexed properties on Arrays.
+            } else {
+                return objEquiv(actual, expected);
+            }
+        }
+
+        function isArguments(object) {
+            return Object.prototype.toString.call(object) == '[object Arguments]';
+        }
+
+        function objEquiv(a, b) {
+            if (util.isNullOrUndefined(a) || util.isNullOrUndefined(b))
+                return false;
+            // an identical 'prototype' property.
+            if (a.prototype !== b.prototype) return false;
+            //~~~I've managed to break Object.keys through screwy arguments passing.
+            //   Converting to array solves the problem.
+            var aIsArgs = isArguments(a),
+                bIsArgs = isArguments(b);
+            if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))
+                return false;
+            if (aIsArgs) {
+                a = pSlice.call(a);
+                b = pSlice.call(b);
+                return _deepEqual(a, b);
+            }
+            try {
+                var ka = Object.keys(a),
+                    kb = Object.keys(b),
+                    key, i;
+            } catch (e) { //happens when one is a string literal and the other isn't
+                return false;
+            }
+            // having the same number of owned properties (keys incorporates
+            // hasOwnProperty)
+            if (ka.length != kb.length)
+                return false;
+            //the same set of keys (although not necessarily the same order),
+            ka.sort();
+            kb.sort();
+            //~~~cheap key test
+            for (i = ka.length - 1; i >= 0; i--) {
+                if (ka[i] != kb[i])
+                    return false;
+            }
+            //equivalent values for every corresponding key, and
+            //~~~possibly expensive deep test
+            for (i = ka.length - 1; i >= 0; i--) {
+                key = ka[i];
+                if (!_deepEqual(a[key], b[key])) return false;
+            }
+            return true;
+        }
+
+        // 8. The non-equivalence assertion tests for any deep inequality.
+        // assert.notDeepEqual(actual, expected, message_opt);
+
+        assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
+            if (_deepEqual(actual, expected)) {
+                fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);
+            }
+        };
+
+        // 9. The strict equality assertion tests strict equality, as determined by ===.
+        // assert.strictEqual(actual, expected, message_opt);
+
+        assert.strictEqual = function strictEqual(actual, expected, message) {
+            if (actual !== expected) {
+                fail(actual, expected, message, '===', assert.strictEqual);
+            }
+        };
+
+        // 10. The strict non-equality assertion tests for strict inequality, as
+        // determined by !==.  assert.notStrictEqual(actual, expected, message_opt);
+
+        assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
+            if (actual === expected) {
+                fail(actual, expected, message, '!==', assert.notStrictEqual);
+            }
+        };
+
+        function expectedException(actual, expected) {
+            if (!actual || !expected) {
+                return false;
+            }
+
+            if (Object.prototype.toString.call(expected) == '[object RegExp]') {
+                return expected.test(actual);
+            } else if (actual instanceof expected) {
+                return true;
+            } else if (expected.call({}, actual) === true) {
+                return true;
+            }
+
+            return false;
+        }
+
+        function _throws(shouldThrow, block, expected, message) {
+            var actual;
+
+            if (util.isString(expected)) {
+                message = expected;
+                expected = null;
+            }
+
+            try {
+                block();
+            } catch (e) {
+                actual = e;
+            }
+
+            message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +
+                (message ? ' ' + message : '.');
+
+            if (shouldThrow && !actual) {
+                fail(actual, expected, 'Missing expected exception' + message);
+            }
+
+            if (!shouldThrow && expectedException(actual, expected)) {
+                fail(actual, expected, 'Got unwanted exception' + message);
+            }
+
+            if ((shouldThrow && actual && expected &&
+                !expectedException(actual, expected)) || (!shouldThrow && actual)) {
+                throw actual;
+            }
+        }
+
+        // 11. Expected to throw an error:
+        // assert.throws(block, Error_opt, message_opt);
+
+        assert.throws = function (block, /*optional*/ error, /*optional*/ message) {
+            _throws.apply(this, [true].concat(pSlice.call(arguments)));
+        };
+
+        // EXTENSION! This is annoying to write outside this module.
+        assert.doesNotThrow = function (block, /*optional*/ message) {
+            _throws.apply(this, [false].concat(pSlice.call(arguments)));
+        };
+
+        assert.ifError = function (err) {
+            if (err) {
+                throw err;
+            }
+        };
+    });
+    
+
+    (function () {
+
+        // es5-safe
+        // ----------------
+        // Provides compatibility shims so that legacy JavaScript engines behave as
+        // closely as possible to ES5.
+        //
+        // Thanks to:
+        //  - http://es5.github.com/
+        //  - http://kangax.github.com/es5-compat-table/
+        //  - https://github.com/kriskowal/es5-shim
+        //  - http://perfectionkills.com/extending-built-in-native-objects-evil-or-not/
+        //  - https://gist.github.com/1120592
+        //  - https://code.google.com/p/v8/
+
+
+        var OP = Object.prototype;
+        var AP = Array.prototype;
+        var FP = Function.prototype;
+        var SP = String.prototype;
+        var hasOwnProperty = OP.hasOwnProperty;
+        var slice = AP.slice;
+
+
+        /*---------------------------------------*
+         * Function
+         *---------------------------------------*/
+
+        // ES-5 15.3.4.5
+        // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Function/bind
+        FP.bind || (FP.bind = function (that) {
+            var target = this;
+
+            // If IsCallable(func) is false, throw a TypeError exception.
+            if (typeof target !== 'function') {
+                throw new TypeError('Bind must be called on a function');
+            }
+
+            var boundArgs = slice.call(arguments, 1);
+
+            function bound() {
+                // Called as a constructor.
+                if (this instanceof bound) {
+                    var self = createObject(target.prototype);
+                    var result = target.apply(
+                        self,
+                        boundArgs.concat(slice.call(arguments))
+                    );
+                    return Object(result) === result ? result : self;
+                }
+                // Called as a function.
+                else {
+                    return target.apply(
+                        that,
+                        boundArgs.concat(slice.call(arguments))
+                    );
+                }
+            }
+
+            // NOTICE: The function.length is not writable.
+            //bound.length = Math.max(target.length - boundArgs.length, 0);
+
+            return bound;
+        });
+
+
+        // Helpers
+
+        function createObject(proto) {
+            var o;
+
+            if (Object.create) {
+                o = Object.create(proto);
+            } else {
+                /** @constructor */
+
+                function F() {}
+
+                F.prototype = proto;
+                o = new F();
+            }
+
+            return o;
+        }
+
+
+        /*---------------------------------------*
+         * Object
+         *---------------------------------------*/
+        // http://ejohn.org/blog/ecmascript-5-objects-and-properties/
+
+        // ES5 15.2.3.14
+        // http://whattheheadsaid.com/2010/10/a-safer-object-keys-compatibility-implementation
+        // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Object/keys
+        // https://developer.mozilla.org/en/ECMAScript_DontEnum_attribute
+        // http://msdn.microsoft.com/en-us/library/adebfyya(v=vs.94).aspx
+        Object.keys || (Object.keys = (function () {
+            var hasDontEnumBug = !{
+                toString: ''
+            }.propertyIsEnumerable('toString');
+            var DontEnums = [
+                'toString',
+                'toLocaleString',
+                'valueOf',
+                'hasOwnProperty',
+                'isPrototypeOf',
+                'propertyIsEnumerable',
+                'constructor'
+            ];
+            var DontEnumsLength = DontEnums.length;
+
+            return function (o) {
+                if (o !== Object(o)) {
+                    throw new TypeError(o + ' is not an object');
+                }
+
+                var result = [];
+
+                for (var name in o) {
+                    if (hasOwnProperty.call(o, name)) {
+                        result.push(name);
+                    }
+                }
+
+                if (hasDontEnumBug) {
+                    for (var i = 0; i < DontEnumsLength; i++) {
+                        if (hasOwnProperty.call(o, DontEnums[i])) {
+                            result.push(DontEnums[i]);
+                        }
+                    }
+                }
+
+                return result;
+            };
+
+        })());
+
+
+        // ES5 1.8.5
+        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames
+        Object.getOwnPropertyNames || (Object.getOwnPropertyNames = function (obj) {
+            var keys = [];
+
+            // Only iterate the keys if we were given an object, and
+            // a special check for null, as typeof null == "object"
+            if (typeof obj === "object" && obj !== null) {
+                // Use a standard for in loop
+                for (var x in obj) {
+                    // A for in will iterate over members on the prototype
+                    // chain as well, but Object.getOwnPropertyNames returns
+                    // only those directly on the object, so use hasOwnProperty.
+                    if (obj.hasOwnProperty(x)) {
+                        keys.push(x);
+                    }
+                }
+            }
+
+            return keys;
+        });
+
+
+
+        /*---------------------------------------*
+         * Array
+         *---------------------------------------*/
+        // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array
+        // https://github.com/kangax/fabric.js/blob/gh-pages/src/util/lang_array.js
+
+        // ES5 15.4.3.2
+        // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/isArray
+        Array.isArray || (Array.isArray = function (obj) {
+            return OP.toString.call(obj) === '[object Array]';
+        });
+
+
+        // ES5 15.4.4.18
+        // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/array/foreach
+        AP.forEach || (AP.forEach = function (fn, context) {
+            for (var i = 0, len = this.length >>> 0; i < len; i++) {
+                if (i in this) {
+                    fn.call(context, this[i], i, this);
+                }
+            }
+        });
+
+
+        // ES5 15.4.4.19
+        // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map
+        AP.map || (AP.map = function (fn, context) {
+            var len = this.length >>> 0;
+            var result = new Array(len);
+
+            for (var i = 0; i < len; i++) {
+                if (i in this) {
+                    result[i] = fn.call(context, this[i], i, this);
+                }
+            }
+
+            return result;
+        });
+
+
+        // ES5 15.4.4.20
+        // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/filter
+        AP.filter || (AP.filter = function (fn, context) {
+            var result = [],
+                val;
+
+            for (var i = 0, len = this.length >>> 0; i < len; i++) {
+                if (i in this) {
+                    val = this[i]; // in case fn mutates this
+                    if (fn.call(context, val, i, this)) {
+                        result.push(val);
+                    }
+                }
+            }
+
+            return result;
+        });
+
+
+        // ES5 15.4.4.16
+        // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/every
+        AP.every || (AP.every = function (fn, context) {
+            for (var i = 0, len = this.length >>> 0; i < len; i++) {
+                if (i in this && !fn.call(context, this[i], i, this)) {
+                    return false;
+                }
+            }
+            return true;
+        });
+
+
+        // ES5 15.4.4.17
+        // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/some
+        AP.some || (AP.some = function (fn, context) {
+            for (var i = 0, len = this.length >>> 0; i < len; i++) {
+                if (i in this && fn.call(context, this[i], i, this)) {
+                    return true;
+                }
+            }
+            return false;
+        });
+
+
+        // ES5 15.4.4.21
+        // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/reduce
+        AP.reduce || (AP.reduce = function (fn /*, initial*/ ) {
+            if (typeof fn !== 'function') {
+                throw new TypeError(fn + ' is not an function');
+            }
+
+            var len = this.length >>> 0,
+                i = 0,
+                result;
+
+            if (arguments.length > 1) {
+                result = arguments[1];
+            } else {
+                do {
+                    if (i in this) {
+                        result = this[i++];
+                        break;
+                    }
+                    // if array contains no values, no initial value to return
+                    if (++i >= len) {
+                        throw new TypeError('reduce of empty array with on initial value');
+                    }
+                }
+                while (true);
+            }
+
+            for (; i < len; i++) {
+                if (i in this) {
+                    result = fn.call(null, result, this[i], i, this);
+                }
+            }
+
+            return result;
+        });
+
+
+        // ES5 15.4.4.22
+        // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/reduceRight
+        AP.reduceRight || (AP.reduceRight = function (fn /*, initial*/ ) {
+            if (typeof fn !== 'function') {
+                throw new TypeError(fn + ' is not an function');
+            }
+
+            var len = this.length >>> 0,
+                i = len - 1,
+                result;
+
+            if (arguments.length > 1) {
+                result = arguments[1];
+            } else {
+                do {
+                    if (i in this) {
+                        result = this[i--];
+                        break;
+                    }
+                    // if array contains no values, no initial value to return
+                    if (--i < 0)
+                        throw new TypeError('reduce of empty array with on initial value');
+                }
+                while (true);
+            }
+
+            for (; i >= 0; i--) {
+                if (i in this) {
+                    result = fn.call(null, result, this[i], i, this);
+                }
+            }
+
+            return result;
+        });
+
+
+        // ES5 15.4.4.14
+        // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/indexOf
+        AP.indexOf || (AP.indexOf = function (value, from) {
+            var len = this.length >>> 0;
+
+            from = Number(from) || 0;
+            from = Math[from < 0 ? 'ceil' : 'floor'](from);
+            if (from < 0) {
+                from = Math.max(from + len, 0);
+            }
+
+            for (; from < len; from++) {
+                if (from in this && this[from] === value) {
+                    return from;
+                }
+            }
+
+            return -1;
+        });
+
+
+        // ES5 15.4.4.15
+        // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/indexOf
+        AP.lastIndexOf || (AP.lastIndexOf = function (value, from) {
+            var len = this.length >>> 0;
+
+            from = Number(from) || len - 1;
+            from = Math[from < 0 ? 'ceil' : 'floor'](from);
+            if (from < 0) {
+                from += len;
+            }
+            from = Math.min(from, len - 1);
+
+            for (; from >= 0; from--) {
+                if (from in this && this[from] === value) {
+                    return from;
+                }
+            }
+
+            return -1;
+        });
+
+
+        /*---------------------------------------*
+         * String
+         *---------------------------------------*/
+
+        // ES5 15.5.4.20
+        // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/String/trim
+        // http://blog.stevenlevithan.com/archives/faster-trim-javascript
+        // http://jsperf.com/mega-trim-test
+        SP.trim || (SP.trim = (function () {
+
+            // http://perfectionkills.com/whitespace-deviations/
+            var whiteSpaces = [
+
+                '\\s',
+                //'0009', // 'HORIZONTAL TAB'
+                //'000A', // 'LINE FEED OR NEW LINE'
+                //'000B', // 'VERTICAL TAB'
+                //'000C', // 'FORM FEED'
+                //'000D', // 'CARRIAGE RETURN'
+                //'0020', // 'SPACE'
+
+                '00A0', // 'NO-BREAK SPACE'
+                '1680', // 'OGHAM SPACE MARK'
+                '180E', // 'MONGOLIAN VOWEL SEPARATOR'
+
+                '2000-\\u200A',
+                //'2000', // 'EN QUAD'
+                //'2001', // 'EM QUAD'
+                //'2002', // 'EN SPACE'
+                //'2003', // 'EM SPACE'
+                //'2004', // 'THREE-PER-EM SPACE'
+                //'2005', // 'FOUR-PER-EM SPACE'
+                //'2006', // 'SIX-PER-EM SPACE'
+                //'2007', // 'FIGURE SPACE'
+                //'2008', // 'PUNCTUATION SPACE'
+                //'2009', // 'THIN SPACE'
+                //'200A', // 'HAIR SPACE'
+
+                '200B', // 'ZERO WIDTH SPACE (category Cf)
+                '2028', // 'LINE SEPARATOR'
+                '2029', // 'PARAGRAPH SEPARATOR'
+                '202F', // 'NARROW NO-BREAK SPACE'
+                '205F', // 'MEDIUM MATHEMATICAL SPACE'
+                '3000' //  'IDEOGRAPHIC SPACE'
+
+            ].join('\\u');
+
+            var trimLeftReg = new RegExp('^[' + whiteSpaces + ']+');
+            var trimRightReg = new RegExp('[' + whiteSpaces + ']+$');
+
+            return function () {
+                return String(this).replace(trimLeftReg, '').replace(trimRightReg, '');
+            }
+
+        })());
+
+
+        /*---------------------------------------*
+         * Date
+         *---------------------------------------*/
+
+        // ES5 15.9.4.4
+        // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Date/now
+        Date.now || (Date.now = function () {
+            return +new Date;
+        });
+
+    })();
+
+
+    /*
+    json2.js
+    2013-05-26
+
+    Public Domain.
+
+    NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
+
+    See http://www.JSON.org/js.html
+
+
+    This code should be minified before deployment.
+    See http://javascript.crockford.com/jsmin.html
+    */
+
+
+    if (typeof JSON !== 'object') {
+        JSON = {};
+    }
+
+    (function () {
+        'use strict';
+
+        function f(n) {
+            return n < 10 ? '0' + n : n;
+        }
+
+        if (typeof Date.prototype.toJSON !== 'function') {
+
+            Date.prototype.toJSON = function () {
+
+                return isFinite(this.valueOf()) ? this.getUTCFullYear() + '-' +
+                    f(this.getUTCMonth() + 1) + '-' +
+                    f(this.getUTCDate()) + 'T' +
+                    f(this.getUTCHours()) + ':' +
+                    f(this.getUTCMinutes()) + ':' +
+                    f(this.getUTCSeconds()) + 'Z' : null;
+            };
+
+            String.prototype.toJSON =
+                Number.prototype.toJSON =
+                Boolean.prototype.toJSON = function () {
+                    return this.valueOf();
+            };
+        }
+
+        var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
+            escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
+            gap,
+            indent,
+            meta = {
+                '\b': '\\b',
+                '\t': '\\t',
+                '\n': '\\n',
+                '\f': '\\f',
+                '\r': '\\r',
+                '"': '\\"',
+                '\\': '\\\\'
+            },
+            rep;
+
+
+        function quote(string) {
+
+            escapable.lastIndex = 0;
+            return escapable.test(string) ? '"' + string.replace(escapable, function (a) {
+                var c = meta[a];
+                return typeof c === 'string' ? c : '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+            }) + '"' : '"' + string + '"';
+        }
+
+
+        function str(key, holder) {
+
+            var i,
+                k,
+                v,
+                length,
+                mind = gap,
+                partial,
+                value = holder[key];
+
+            if (value && typeof value === 'object' &&
+                typeof value.toJSON === 'function') {
+                value = value.toJSON(key);
+            }
+
+            if (typeof rep === 'function') {
+                value = rep.call(holder, key, value);
+            }
+
+            switch (typeof value) {
+            case 'string':
+                return quote(value);
+
+            case 'number':
+
+                return isFinite(value) ? String(value) : 'null';
+
+            case 'boolean':
+            case 'null':
+
+                return String(value);
+
+
+            case 'object':
+
+
+                if (!value) {
+                    return 'null';
+                }
+
+
+                gap += indent;
+                partial = [];
+
+
+                if (Object.prototype.toString.apply(value) === '[object Array]') {
+
+
+                    length = value.length;
+                    for (i = 0; i < length; i += 1) {
+                        partial[i] = str(i, value) || 'null';
+                    }
+
+
+                    v = partial.length === 0 ? '[]' : gap ? '[\n' + gap + partial.join(',\n' + gap) + '\n' + mind + ']' : '[' + partial.join(',') + ']';
+                    gap = mind;
+                    return v;
+                }
+
+
+                if (rep && typeof rep === 'object') {
+                    length = rep.length;
+                    for (i = 0; i < length; i += 1) {
+                        if (typeof rep[i] === 'string') {
+                            k = rep[i];
+                            v = str(k, value);
+                            if (v) {
+                                partial.push(quote(k) + (gap ? ': ' : ':') + v);
+                            }
+                        }
+                    }
+                } else {
+
+                    for (k in value) {
+                        if (Object.prototype.hasOwnProperty.call(value, k)) {
+                            v = str(k, value);
+                            if (v) {
+                                partial.push(quote(k) + (gap ? ': ' : ':') + v);
+                            }
+                        }
+                    }
+                }
+
+                v = partial.length === 0 ? '{}' : gap ? '{\n' + gap + partial.join(',\n' + gap) + '\n' + mind + '}' : '{' + partial.join(',') + '}';
+                gap = mind;
+                return v;
+            }
+        }
+
+        if (typeof JSON.stringify !== 'function') {
+            JSON.stringify = function (value, replacer, space) {
+
+                var i;
+                gap = '';
+                indent = '';
+
+
+                if (typeof space === 'number') {
+                    for (i = 0; i < space; i += 1) {
+                        indent += ' ';
+                    }
+
+
+                } else if (typeof space === 'string') {
+                    indent = space;
+                }
+
+
+                rep = replacer;
+                if (replacer && typeof replacer !== 'function' &&
+                    (typeof replacer !== 'object' ||
+                        typeof replacer.length !== 'number')) {
+                    throw new Error('JSON.stringify');
+                }
+
+                return str('', {
+                    '': value
+                });
+            };
+        }
+
+        if (typeof JSON.parse !== 'function') {
+            JSON.parse = function (text, reviver) {
+
+                var j;
+
+                function walk(holder, key) {
+
+                    var k, v, value = holder[key];
+                    if (value && typeof value === 'object') {
+                        for (k in value) {
+                            if (Object.prototype.hasOwnProperty.call(value, k)) {
+                                v = walk(value, k);
+                                if (v !== undefined) {
+                                    value[k] = v;
+                                } else {
+                                    delete value[k];
+                                }
+                            }
+                        }
+                    }
+                    return reviver.call(holder, key, value);
+                }
+
+                text = String(text);
+                cx.lastIndex = 0;
+                if (cx.test(text)) {
+                    text = text.replace(cx, function (a) {
+                        return '\\u' +
+                            ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+                    });
+                }
+
+                if (/^[\],:{}\s]*$/
+                    .test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@')
+                        .replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']')
+                        .replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
+
+                    j = eval('(' + text + ')');
+
+                    return typeof reviver === 'function' ? walk({
+                        '': j
+                    }, '') : j;
+                }
+
+                throw new SyntaxError('JSON.parse');
+            };
+        }
+    }());
+
+
+    global.console = require('console');
+
+}(this, {}));
+
+WScript.Sleep(500);
+
+/*
+:cmd
+::if %errorlevel% == 0 exit
+pause>nul
+::*/
\ No newline at end of file
diff --git a/demo/includeHTML/includeHTML.js b/demo/includeHTML/includeHTML.js
new file mode 100644
index 0000000..477febf
--- /dev/null
+++ b/demo/includeHTML/includeHTML.js
@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+
+var fs = require('fs');
+var path = require('path');
+var extnames = ['.html', '.htm'];
+var args = process.argv.slice(2);
+var base = '.' + path.sep;
+
+var charset = 'utf-8';
+var INCLUDE_RE = /([\u0009\u000B\u000C\u0020\u00A0\u1680\u180E\u2000-\u200A\u200B\u2028\u2029\u202F\u205F\u3000]*?)<!--\s*\[include\s*['"]*(.*?)['"]*\]\s*-->([\w\W]*?)<!--\s*\[\/include\]\s*-->/ig;
+var TEMPLATE = '{{blank}}<!--[include "{{id}}"]-->\n{{content}}\n{{blank}}<!--[/include]-->';
+var TEMPLATE_RE = /\{\{(.*?)\}\}/g;
+
+
+var compile = function (base, file) {
+	var html = fs.readFileSync(file, charset);
+	var count = 0;
+	var stdout = file.replace(base + path.sep, '');
+
+	html = html.replace(INCLUDE_RE, function ($1, blank, id, content) {
+
+		var dirname = path.dirname(file);
+		var target = path.resolve(dirname, id.split('/').join(path.sep));
+		var fileContent = '';
+
+		if (fs.existsSync(target)) {
+			fileContent = fs.readFileSync(target, charset);
+			if (content.trim() === fileContent.trim()) {
+				return $1;
+			}
+		} else {
+			throw new Error('File not found: ' + target);
+		}
+
+		count ++;
+		return template(TEMPLATE, {
+			id: id,
+			blank: blank,
+			content: fileContent
+		});
+	});
+	
+	
+	if (count) {
+
+		stdout += ' [ok]'
+		fs.writeFileSync(file, html, charset);
+	}
+	
+	console.log(stdout);
+};
+
+
+var template = function (string, data) {
+	return string.replace(TEMPLATE_RE, function ($1, $2) {
+		return data[$2] || '';
+	});
+};
+
+
+var walk = function (dir) {
+	var dirList = fs.readdirSync(dir);
+
+	dirList.forEach(function (item) {
+		var target = path.join(dir, item);
+		
+		if (fs.statSync(target).isDirectory()) {
+			walk(target);
+		} else if (extnames.indexOf(path.extname(target)) === 0) {
+			compile(base, target);
+		}
+	});
+};
+
+
+if (args[0]) {
+	base = path.resolve(args[0]);
+}
+
+
+if (fs.statSync(base).isDirectory()) {
+	walk(base);
+} else if (extnames.indexOf(path.extname(base)) === 0) {
+	var file = base;
+	base = path.dirname(base);
+	compile(base, file);
+}
diff --git a/demo/includeHTML/package.json b/demo/includeHTML/package.json
new file mode 100644
index 0000000..1ff05f4
--- /dev/null
+++ b/demo/includeHTML/package.json
@@ -0,0 +1,13 @@
+{
+    "name": "includeHTML",
+    "version": "0.0.2",
+    "description": "Template",
+    "author": "bingzitang@tencent.com",
+    "bin": {
+        "inc": "./includeHTML.js"
+    },
+    "scripts": {
+        "test": "inc ./demo"
+    },
+    "license": "BSD"
+}
\ No newline at end of file
diff --git a/lib/node2bat.runtime.js b/lib/node2bat.runtime.js
deleted file mode 100755
index 40e1fbc..0000000
--- a/lib/node2bat.runtime.js
+++ /dev/null
@@ -1,1328 +0,0 @@
-@if (0===0) @end/*!node2bat | https://github.com/aui/node2bat | sugarpie.tang@gmail.com
-@echo off
-title loading..
-cd %~dp0
-call CScript.EXE "%~dpnx0" //Nologo //e:jscript %*
-title node
-goto cmd
--------------------------------*/
-(function () {
-
-'<:node_code>'
-
-})// NodeJS Basic API
-(function (global, exports) {
-
-global.global = global;
-
-global.console = {
-	log: function (message) {
-		if (typeof message !== 'string') {
-			message = this.__toSource(message);
-		}
-		
-		WScript.Echo(message);
-	},
-	__toSource: (function () {
-		var getType = function (obj) {
-			var toString = Object.prototype.toString;
-			return obj === null
-			? "Null" : obj === undefined
-			? "Undefined" : toString.call(obj).slice(8, -1);
-		};
-
-		return function toSource (obj) {
-			var type = getType(obj);
-			var string = '';
-			var temp;
-
-			switch (type) {
-				case 'Object':
-
-					temp = [];
-
-					for (var name in obj) {
-						temp.push(
-							JSON.stringify(name) + ':' + toSource(obj[name])
-						);
-					}
-
-					string =  '{' + temp.join(',') + '}';
-
-					break;
-				case 'Array':
-					temp = [];
-					var length = obj.length;
-
-					while (length) {
-						temp[--length] = toSource(obj[length]);
-					}
-
-					string = '[' + temp.join(',') + ']';
-
-					break;
-				case 'String':
-					string = JSON.stringify(obj);
-					break;
-				case 'Undefined':
-					string = 'undefined';
-					break;
-				case 'Boolean':
-				case 'Number':
-				case 'Null':
-					string = obj + '';
-					break;
-				case 'Function':
-
-					temp = obj
-					.toString()
-					.match(/^function\s*(\w+)\s*\(\)\s*\{\s*\[native\s*code\]\s*\}$/);
-
-					if (temp) {
-						string = temp[1];
-					} else {
-						string = obj + '';
-					}
-
-					break;
-				// Namespace
-				default:
-					string = type;
-			}
-
-			return string;
-		};
-	})()
-};
-
-global.process = {
-
-    argv: function () {
-        var Arguments = WScript.Arguments;
-        var length = Arguments.length;
-        var argv = ['node'];
-        
-        if (length) {
-            for (var i = 0; i < length; i ++) {
-                argv.push(Arguments(i));
-            }
-        }
-        
-        return argv;
-    }(),
-	
-	
-    cwd: function () {
-        return WScript
-        .ScriptFullName
-        .replace(WScript.ScriptName, '')
-        .replace(/\\+$/, '');
-    },
-	
-	
-	env: (function () {
-		var env = {};
-		var wsh = new ActiveXObject("WScript.Shell"); 
-		var user = wsh.Environment("User"); 
-		var system = wsh.Environment("System");
-		var list = [
-			'ALLUSERSPROFILE',
-			'APPDATA',
-			'CommonProgramFiles',
-			'COMPUTERNAME',
-			'ComSpec',
-			'configsetroot',
-			'FP_NO_HOST_CHECK',
-			'HOMEDRIVE',
-			'HOMEPATH',
-			'LOCALAPPDATA',
-			'LOGONSERVER',
-			'NUMBER_OF_PROCESSORS',
-			'OS',
-			'Path',
-			'PATHEXT',
-			'PROCESSOR_ARCHITECTURE',
-			'PROCESSOR_IDENTIFIER',
-			'PROCESSOR_LEVEL',
-			'PROCESSOR_REVISION',
-			'ProgramData',
-			'ProgramFiles',
-			'PROMPT',
-			'PSModulePath',
-			'PUBLIC',
-			'SESSIONNAME',
-			'SystemDrive',
-			'SystemRoot',
-			'TEMP',
-			'TMP',
-			'USERDOMAIN',
-			'USERNAME',
-			'USERPROFILE',
-			'windir'
-		];
-		
-		for (var name, info, i = 0; i < list.length; i ++) {
-			name = list[i];
-			info = user.Item(name);
-			if (!info && info !== 0) {
-				info = system.Item(name);
-			}
-			env[name] = info;
-		}
-		
-		return env;
-	})(),
-	
-	
-    exit: function (code) {
-        WScript.Quit(code);
-    },
-	
-	
-    stdout: {
-        write: function (message) {
-            WScript.Echo(message);
-        }
-    }
-};
-
-global.require = function (id) {
-    if (!exports[id]) {
-        throw new Error('Cannot find module \'' + id + '\'');
-    }
-    return exports[id];
-};
-
-
-global.__filename = WScript.ScriptFullName;
-
-global.__dirname = global.process.cwd();
-
-
-exports.fs = {};
-
-(function (exports) {
-
-	var fso = new ActiveXObject('Scripting.FileSystemObject');
-	
-	var fs = {
-
-		renameSync: function (oldPath, newPath) {
-			var statSync = fs.statSync(oldPath);
-			var file = fso[statSync.isFile() ? 'GetFile' : 'GetFolder'](oldPath);
-			file.Move(newPath); 
-		},
-
-		mkdirSync: function (path) {
-			fso.CreateFolder(path);
-		},
-
-		rmdirSync: function (path) {
-			fso.DeleteFolder(path, true);
-		},
-
-		unlinkSync: function (path) {
-			fso.DeleteFile(path, true); 
-		},
-
-		existsSync: function (path) {
-			var statSync = fs.statSync(path);
-			return statSync.isFile() || statSync.isDirectory();
-		},
-
-		statSync: function (path) {
-			return {
-				isFile: function () {
-					return fso.FileExists(path);
-				},
-				isDirectory: function () {
-					return fso.FolderExists(path);
-				}
-			};
-		},
-
-		readdirSync: function (path) {
-
-			var listall = function (path) {
-			
-				var fd = fso.GetFolder(path + '\\');
-				var fe = new Enumerator(fd.files);
-				var list = [];
-				var item;
-				
-				while(!fe.atEnd()) {
-					item = fe.item() + '';
-					item = item.replace(/^.*\\([^\\]*)$/, '$1');
-					list.push(item);
-					fe.moveNext();
-				}
-				
-				var folderList = new Enumerator(fd.SubFolders);
-				for (; !folderList.atEnd(); folderList.moveNext()) {
-					item = folderList.item() + '';
-					item = item.replace(/^.*\\([^\\]*)$/, '$1');
-					list.push(item);
-				}
-				
-				return list;
-			};
-
-			return listall(path);
-		},
-
-		readFileSync: function (file, charset) {
-			var stream = new ActiveXObject('adodb.stream');
-			var fileContent;
-
-			stream.type = charset ? 2 : 1;
-			stream.mode = 3;
-			stream.open();
-
-			if (charset) {
-				stream.charset = charset;
-			}
-			
-			try {
-				stream.loadFromFile(file);
-			} catch (e) {
-				throw e;
-			}
-
-			fileContent = new String(stream.readText());
-			fileContent.charset = charset;
-			stream.close();
-			return fileContent.toString();
-		},
-
-		writeFileSync: function (file, data, charset) {
-			var stream = new ActiveXObject('adodb.stream');
-			
-			stream.type = charset ? 2 : 1;
-
-			if (charset) {
-				stream.charset = charset;
-			}
-			
-			try {
-				stream.open();
-				if (charset) {
-					stream.writeText(data);
-				} else {
-					stream.write(data);
-				}
-				stream.saveToFile(file, 2);
-
-				return true;
-			} catch (e) {
-				throw e;
-			} finally {
-				stream.close();
-			}
-
-			return true;
-		}
-	};
-	
-	for (var name in fs) {
-		exports[name] = fs[name];
-		if (/Sync$/.test(name)) {
-			exports[name.replace(/Sync$/, '')] = (function (main) {
-				return function () {
-					var args = arguments;
-					var error = null;
-					var data = {};
-					var callback = args[args.length - 1];
-					if (typeof callback !== 'function') {
-						callback = function () {};
-					}
-					
-					try {
-						main.apply(global, args);
-					} catch (e) {
-						error = e;
-					}
-					
-					callback(error, data);
-				};
-			})(fs[name]);
-		}
-	}
-
-})(exports.fs);
-
-exports.path = {};
-
-(function (exports) {
-
-	// resolves . and .. elements in a path array with directory names there
-	// must be no slashes, empty elements, or device names (c:\) in the array
-	// (so also no leading and trailing slashes - it does not distinguish
-	// relative and absolute paths)
-	function normalizeArray(parts, allowAboveRoot) {
-	  // if the path tries to go above the root, `up` ends up > 0
-	  var up = 0;
-	  for (var i = parts.length - 1; i >= 0; i--) {
-		var last = parts[i];
-		if (last === '.') {
-		  parts.splice(i, 1);
-		} else if (last === '..') {
-		  parts.splice(i, 1);
-		  up++;
-		} else if (up) {
-		  parts.splice(i, 1);
-		  up--;
-		}
-	  }
-
-	  // if the path is allowed to go above the root, restore leading ..s
-	  if (allowAboveRoot) {
-		for (; up--; up) {
-		  parts.unshift('..');
-		}
-	  }
-
-	  return parts;
-	}
-  // Regex to split a windows path into three parts: [*, device, slash,
-  // tail] windows-only
-  var splitDeviceRe =
-      /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
-
-  // Regex to split the tail part of the above into [*, dir, basename, ext]
-  var splitTailRe =
-      /^([\s\S]*?)((?:\.{1,2}|[^\\\/]+?|)(\.[^.\/\\]*|))(?:[\\\/]*)$/;
-
-  // Function to split a filename into [root, dir, basename, ext]
-  // windows version
-  var splitPath = function(filename) {
-    // Separate device+slash from tail
-    var result = splitDeviceRe.exec(filename),
-        device = (result[1] || '') + (result[2] || ''),
-        tail = result[3] || '';
-    // Split the tail into dir, basename and extension
-    var result2 = splitTailRe.exec(tail),
-        dir = result2[1],
-        basename = result2[2],
-        ext = result2[3];
-    return [device, dir, basename, ext];
-  };
-
-  var normalizeUNCRoot = function(device) {
-    return '\\\\' + device.replace(/^[\\\/]+/, '').replace(/[\\\/]+/g, '\\');
-  };
-
-  // path.resolve([from ...], to)
-  // windows version
-  exports.resolve = function() {
-    var resolvedDevice = '',
-        resolvedTail = '',
-        resolvedAbsolute = false;
-
-    for (var i = arguments.length - 1; i >= -1; i--) {
-      var path;
-      if (i >= 0) {
-        path = arguments[i];
-      } else if (!resolvedDevice) {
-        path = process.cwd();
-      } else {
-        // Windows has the concept of drive-specific current working
-        // directories. If we've resolved a drive letter but not yet an
-        // absolute path, get cwd for that drive. We're sure the device is not
-        // an unc path at this points, because unc paths are always absolute.
-        path = process.env['=' + resolvedDevice];
-        // Verify that a drive-local cwd was found and that it actually points
-        // to our drive. If not, default to the drive's root.
-        if (!path || path.substr(0, 3).toLowerCase() !==
-            resolvedDevice.toLowerCase() + '\\') {
-          path = resolvedDevice + '\\';
-        }
-      }
-
-      // Skip empty and invalid entries
-      if (typeof path !== 'string') {
-        throw new TypeError('Arguments to path.resolve must be strings');
-      } else if (!path) {
-        continue;
-      }
-
-      var result = splitDeviceRe.exec(path),
-          device = result[1] || '',
-          isUnc = device && device.charAt(1) !== ':',
-          isAbsolute = exports.isAbsolute(path),
-          tail = result[3];
-
-      if (device &&
-          resolvedDevice &&
-          device.toLowerCase() !== resolvedDevice.toLowerCase()) {
-        // This path points to another device so it is not applicable
-        continue;
-      }
-
-      if (!resolvedDevice) {
-        resolvedDevice = device;
-      }
-      if (!resolvedAbsolute) {
-        resolvedTail = tail + '\\' + resolvedTail;
-        resolvedAbsolute = isAbsolute;
-      }
-
-      if (resolvedDevice && resolvedAbsolute) {
-        break;
-      }
-    }
-
-    // Convert slashes to backslashes when `resolvedDevice` points to an UNC
-    // root. Also squash multiple slashes into a single one where appropriate.
-    if (isUnc) {
-      resolvedDevice = normalizeUNCRoot(resolvedDevice);
-    }
-
-    // At this point the path should be resolved to a full absolute path,
-    // but handle relative paths to be safe (might happen when process.cwd()
-    // fails)
-
-    // Normalize the tail path
-
-    function f(p) {
-      return !!p;
-    }
-
-    resolvedTail = normalizeArray(resolvedTail.split(/[\\\/]+/).filter(f),
-                                  !resolvedAbsolute).join('\\');
-
-    return (resolvedDevice + (resolvedAbsolute ? '\\' : '') + resolvedTail) ||
-           '.';
-  };
-
-  // windows version
-  exports.normalize = function(path) {
-    var result = splitDeviceRe.exec(path),
-        device = result[1] || '',
-        isUnc = device && device.charAt(1) !== ':',
-        isAbsolute = exports.isAbsolute(path),
-        tail = result[3],
-        trailingSlash = /[\\\/]$/.test(tail);
-
-    // If device is a drive letter, we'll normalize to lower case.
-    if (device && device.charAt(1) === ':') {
-      device = device[0].toLowerCase() + device.substr(1);
-    }
-
-    // Normalize the tail path
-    tail = normalizeArray(tail.split(/[\\\/]+/).filter(function(p) {
-      return !!p;
-    }), !isAbsolute).join('\\');
-
-    if (!tail && !isAbsolute) {
-      tail = '.';
-    }
-    if (tail && trailingSlash) {
-      tail += '\\';
-    }
-
-    // Convert slashes to backslashes when `device` points to an UNC root.
-    // Also squash multiple slashes into a single one where appropriate.
-    if (isUnc) {
-      device = normalizeUNCRoot(device);
-    }
-
-    return device + (isAbsolute ? '\\' : '') + tail;
-  };
-
-  // windows version
-  exports.isAbsolute = function(path) {
-    var result = splitDeviceRe.exec(path),
-        device = result[1] || '',
-        isUnc = device && device.charAt(1) !== ':';
-    // UNC paths are always absolute
-    return !!result[2] || isUnc;
-  };
-
-  // windows version
-  exports.join = function() {
-    function f(p) {
-      if (typeof p !== 'string') {
-        throw new TypeError('Arguments to path.join must be strings');
-      }
-      return p;
-    }
-
-    var paths = Array.prototype.filter.call(arguments, f);
-    var joined = paths.join('\\');
-
-    // Make sure that the joined path doesn't start with two slashes, because
-    // normalize() will mistake it for an UNC path then.
-    //
-    // This step is skipped when it is very clear that the user actually
-    // intended to point at an UNC path. This is assumed when the first
-    // non-empty string arguments starts with exactly two slashes followed by
-    // at least one more non-slash character.
-    //
-    // Note that for normalize() to treat a path as an UNC path it needs to
-    // have at least 2 components, so we don't filter for that here.
-    // This means that the user can use join to construct UNC paths from
-    // a server name and a share name; for example:
-    //   path.join('//server', 'share') -> '\\\\server\\share\')
-    if (!/^[\\\/]{2}[^\\\/]/.test(paths[0])) {
-      joined = joined.replace(/^[\\\/]{2,}/, '\\');
-    }
-
-    return exports.normalize(joined);
-  };
-
-  // path.relative(from, to)
-  // it will solve the relative path from 'from' to 'to', for instance:
-  // from = 'C:\\orandea\\test\\aaa'
-  // to = 'C:\\orandea\\impl\\bbb'
-  // The output of the function should be: '..\\..\\impl\\bbb'
-  // windows version
-  exports.relative = function(from, to) {
-    from = exports.resolve(from);
-    to = exports.resolve(to);
-
-    // windows is not case sensitive
-    var lowerFrom = from.toLowerCase();
-    var lowerTo = to.toLowerCase();
-
-    function trim(arr) {
-      var start = 0;
-      for (; start < arr.length; start++) {
-        if (arr[start] !== '') break;
-      }
-
-      var end = arr.length - 1;
-      for (; end >= 0; end--) {
-        if (arr[end] !== '') break;
-      }
-
-      if (start > end) return [];
-      return arr.slice(start, end - start + 1);
-    }
-
-    var toParts = trim(to.split('\\'));
-
-    var lowerFromParts = trim(lowerFrom.split('\\'));
-    var lowerToParts = trim(lowerTo.split('\\'));
-
-    var length = Math.min(lowerFromParts.length, lowerToParts.length);
-    var samePartsLength = length;
-    for (var i = 0; i < length; i++) {
-      if (lowerFromParts[i] !== lowerToParts[i]) {
-        samePartsLength = i;
-        break;
-      }
-    }
-
-    if (samePartsLength == 0) {
-      return to;
-    }
-
-    var outputParts = [];
-    for (var i = samePartsLength; i < lowerFromParts.length; i++) {
-      outputParts.push('..');
-    }
-
-    outputParts = outputParts.concat(toParts.slice(samePartsLength));
-
-    return outputParts.join('\\');
-  };
-
-  exports.sep = '\\';
-  exports.delimiter = ';';
-
-  exports.dirname = function(path) {
-      var result = splitPath(path),
-          root = result[0],
-          dir = result[1];
-
-      if (!root && !dir) {
-        // No dirname whatsoever
-        return '.';
-      }
-
-      if (dir) {
-        // It has a dirname, strip trailing slash
-        dir = dir.substr(0, dir.length - 1);
-      }
-
-      return root + dir;
-  };
-
-
-  exports.basename = function(path, ext) {
-      var f = splitPath(path)[2];
-      // TODO: make this comparison case-insensitive on windows?
-      if (ext && f.substr(-1 * ext.length) === ext) {
-        f = f.substr(0, f.length - ext.length);
-      }
-      return f;
-  };
-
-
-  exports.extname = function(path) {
-      return splitPath(path)[3];
-  };
-
-
-})(exports.path);
-
-
-(function() {
-
-  // es5-safe
-  // ----------------
-  // Provides compatibility shims so that legacy JavaScript engines behave as
-  // closely as possible to ES5.
-  //
-  // Thanks to:
-  //  - http://es5.github.com/
-  //  - http://kangax.github.com/es5-compat-table/
-  //  - https://github.com/kriskowal/es5-shim
-  //  - http://perfectionkills.com/extending-built-in-native-objects-evil-or-not/
-  //  - https://gist.github.com/1120592
-  //  - https://code.google.com/p/v8/
-
-
-  var OP = Object.prototype;
-  var AP = Array.prototype;
-  var FP = Function.prototype;
-  var SP = String.prototype;
-  var hasOwnProperty = OP.hasOwnProperty;
-  var slice = AP.slice;
-
-
-  /*---------------------------------------*
-   * Function
-   *---------------------------------------*/
-
-  // ES-5 15.3.4.5
-  // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Function/bind
-  FP.bind || (FP.bind = function(that) {
-    var target = this;
-
-    // If IsCallable(func) is false, throw a TypeError exception.
-    if (typeof target !== 'function') {
-      throw new TypeError('Bind must be called on a function');
-    }
-
-    var boundArgs = slice.call(arguments, 1);
-
-    function bound() {
-      // Called as a constructor.
-      if (this instanceof bound) {
-        var self = createObject(target.prototype);
-        var result = target.apply(
-            self,
-            boundArgs.concat(slice.call(arguments))
-        );
-        return Object(result) === result ? result : self;
-      }
-      // Called as a function.
-      else {
-        return target.apply(
-            that,
-            boundArgs.concat(slice.call(arguments))
-        );
-      }
-    }
-
-    // NOTICE: The function.length is not writable.
-    //bound.length = Math.max(target.length - boundArgs.length, 0);
-
-    return bound;
-  });
-
-
-  // Helpers
-  function createObject(proto) {
-    var o;
-
-    if (Object.create) {
-      o = Object.create(proto);
-    }
-    else {
-      /** @constructor */
-      function F() {
-      }
-
-      F.prototype = proto;
-      o = new F();
-    }
-
-    return o;
-  }
-
-
-  /*---------------------------------------*
-   * Object
-   *---------------------------------------*/
-  // http://ejohn.org/blog/ecmascript-5-objects-and-properties/
-
-  // ES5 15.2.3.14
-  // http://whattheheadsaid.com/2010/10/a-safer-object-keys-compatibility-implementation
-  // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Object/keys
-  // https://developer.mozilla.org/en/ECMAScript_DontEnum_attribute
-  // http://msdn.microsoft.com/en-us/library/adebfyya(v=vs.94).aspx
-  Object.keys || (Object.keys = (function() {
-    var hasDontEnumBug = !{toString: ''}.propertyIsEnumerable('toString');
-    var DontEnums = [
-      'toString',
-      'toLocaleString',
-      'valueOf',
-      'hasOwnProperty',
-      'isPrototypeOf',
-      'propertyIsEnumerable',
-      'constructor'
-    ];
-    var DontEnumsLength = DontEnums.length;
-
-    return function(o) {
-      if (o !== Object(o)) {
-        throw new TypeError(o + ' is not an object');
-      }
-
-      var result = [];
-
-      for (var name in o) {
-        if (hasOwnProperty.call(o, name)) {
-          result.push(name);
-        }
-      }
-
-      if (hasDontEnumBug) {
-        for (var i = 0; i < DontEnumsLength; i++) {
-          if (hasOwnProperty.call(o, DontEnums[i])) {
-            result.push(DontEnums[i]);
-          }
-        }
-      }
-
-      return result;
-    };
-
-  })());
-
-
-  /*---------------------------------------*
-   * Array
-   *---------------------------------------*/
-  // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array
-  // https://github.com/kangax/fabric.js/blob/gh-pages/src/util/lang_array.js
-
-  // ES5 15.4.3.2
-  // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/isArray
-  Array.isArray || (Array.isArray = function(obj) {
-    return OP.toString.call(obj) === '[object Array]';
-  });
-
-
-  // ES5 15.4.4.18
-  // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/array/foreach
-  AP.forEach || (AP.forEach = function(fn, context) {
-    for (var i = 0, len = this.length >>> 0; i < len; i++) {
-      if (i in this) {
-        fn.call(context, this[i], i, this);
-      }
-    }
-  });
-
-
-  // ES5 15.4.4.19
-  // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map
-  AP.map || (AP.map = function(fn, context) {
-    var len = this.length >>> 0;
-    var result = new Array(len);
-
-    for (var i = 0; i < len; i++) {
-      if (i in this) {
-        result[i] = fn.call(context, this[i], i, this);
-      }
-    }
-
-    return result;
-  });
-
-
-  // ES5 15.4.4.20
-  // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/filter
-  AP.filter || (AP.filter = function(fn, context) {
-    var result = [], val;
-
-    for (var i = 0, len = this.length >>> 0; i < len; i++) {
-      if (i in this) {
-        val = this[i]; // in case fn mutates this
-        if (fn.call(context, val, i, this)) {
-          result.push(val);
-        }
-      }
-    }
-
-    return result;
-  });
-
-
-  // ES5 15.4.4.16
-  // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/every
-  AP.every || (AP.every = function(fn, context) {
-    for (var i = 0, len = this.length >>> 0; i < len; i++) {
-      if (i in this && !fn.call(context, this[i], i, this)) {
-        return false;
-      }
-    }
-    return true;
-  });
-
-
-  // ES5 15.4.4.17
-  // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/some
-  AP.some || (AP.some = function(fn, context) {
-    for (var i = 0, len = this.length >>> 0; i < len; i++) {
-      if (i in this && fn.call(context, this[i], i, this)) {
-        return true;
-      }
-    }
-    return false;
-  });
-
-
-  // ES5 15.4.4.21
-  // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/reduce
-  AP.reduce || (AP.reduce = function(fn /*, initial*/) {
-    if (typeof fn !== 'function') {
-      throw new TypeError(fn + ' is not an function');
-    }
-
-    var len = this.length >>> 0, i = 0, result;
-
-    if (arguments.length > 1) {
-      result = arguments[1];
-    }
-    else {
-      do {
-        if (i in this) {
-          result = this[i++];
-          break;
-        }
-        // if array contains no values, no initial value to return
-        if (++i >= len) {
-          throw new TypeError('reduce of empty array with on initial value');
-        }
-      }
-      while (true);
-    }
-
-    for (; i < len; i++) {
-      if (i in this) {
-        result = fn.call(null, result, this[i], i, this);
-      }
-    }
-
-    return result;
-  });
-
-
-  // ES5 15.4.4.22
-  // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/reduceRight
-  AP.reduceRight || (AP.reduceRight = function(fn /*, initial*/) {
-    if (typeof fn !== 'function') {
-      throw new TypeError(fn + ' is not an function');
-    }
-
-    var len = this.length >>> 0, i = len - 1, result;
-
-    if (arguments.length > 1) {
-      result = arguments[1];
-    }
-    else {
-      do {
-        if (i in this) {
-          result = this[i--];
-          break;
-        }
-        // if array contains no values, no initial value to return
-        if (--i < 0)
-          throw new TypeError('reduce of empty array with on initial value');
-      }
-      while (true);
-    }
-
-    for (; i >= 0; i--) {
-      if (i in this) {
-        result = fn.call(null, result, this[i], i, this);
-      }
-    }
-
-    return result;
-  });
-
-
-  // ES5 15.4.4.14
-  // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/indexOf
-  AP.indexOf || (AP.indexOf = function(value, from) {
-    var len = this.length >>> 0;
-
-    from = Number(from) || 0;
-    from = Math[from < 0 ? 'ceil' : 'floor'](from);
-    if (from < 0) {
-      from = Math.max(from + len, 0);
-    }
-
-    for (; from < len; from++) {
-      if (from in this && this[from] === value) {
-        return from;
-      }
-    }
-
-    return -1;
-  });
-
-
-  // ES5 15.4.4.15
-  // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/indexOf
-  AP.lastIndexOf || (AP.lastIndexOf = function(value, from) {
-    var len = this.length >>> 0;
-
-    from = Number(from) || len - 1;
-    from = Math[from < 0 ? 'ceil' : 'floor'](from);
-    if (from < 0) {
-      from += len;
-    }
-    from = Math.min(from, len - 1);
-
-    for (; from >= 0; from--) {
-      if (from in this && this[from] === value) {
-        return from;
-      }
-    }
-
-    return -1;
-  });
-
-
-  /*---------------------------------------*
-   * String
-   *---------------------------------------*/
-
-  // ES5 15.5.4.20
-  // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/String/trim
-  // http://blog.stevenlevithan.com/archives/faster-trim-javascript
-  // http://jsperf.com/mega-trim-test
-  SP.trim || (SP.trim = (function() {
-
-    // http://perfectionkills.com/whitespace-deviations/
-    var whiteSpaces = [
-
-      '\\s',
-      //'0009', // 'HORIZONTAL TAB'
-      //'000A', // 'LINE FEED OR NEW LINE'
-      //'000B', // 'VERTICAL TAB'
-      //'000C', // 'FORM FEED'
-      //'000D', // 'CARRIAGE RETURN'
-      //'0020', // 'SPACE'
-
-      '00A0', // 'NO-BREAK SPACE'
-      '1680', // 'OGHAM SPACE MARK'
-      '180E', // 'MONGOLIAN VOWEL SEPARATOR'
-
-      '2000-\\u200A',
-      //'2000', // 'EN QUAD'
-      //'2001', // 'EM QUAD'
-      //'2002', // 'EN SPACE'
-      //'2003', // 'EM SPACE'
-      //'2004', // 'THREE-PER-EM SPACE'
-      //'2005', // 'FOUR-PER-EM SPACE'
-      //'2006', // 'SIX-PER-EM SPACE'
-      //'2007', // 'FIGURE SPACE'
-      //'2008', // 'PUNCTUATION SPACE'
-      //'2009', // 'THIN SPACE'
-      //'200A', // 'HAIR SPACE'
-
-      '200B', // 'ZERO WIDTH SPACE (category Cf)
-      '2028', // 'LINE SEPARATOR'
-      '2029', // 'PARAGRAPH SEPARATOR'
-      '202F', // 'NARROW NO-BREAK SPACE'
-      '205F', // 'MEDIUM MATHEMATICAL SPACE'
-      '3000' //  'IDEOGRAPHIC SPACE'
-
-    ].join('\\u');
-
-    var trimLeftReg = new RegExp('^[' + whiteSpaces + ']+');
-    var trimRightReg = new RegExp('[' + whiteSpaces + ']+$');
-
-    return function() {
-      return String(this).replace(trimLeftReg, '').replace(trimRightReg, '');
-    }
-
-  })());
-
-
-  /*---------------------------------------*
-   * Date
-   *---------------------------------------*/
-
-  // ES5 15.9.4.4
-  // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Date/now
-  Date.now || (Date.now = function() {
-    return +new Date;
-  });
-
-})();
-
-/*
-    json2.js
-    2013-05-26
-
-    Public Domain.
-
-    NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
-
-    See http://www.JSON.org/js.html
-
-
-    This code should be minified before deployment.
-    See http://javascript.crockford.com/jsmin.html
-*/
-
-
-if (typeof JSON !== 'object') {
-    JSON = {};
-}
-
-(function () {
-    'use strict';
-
-    function f(n) {
-        return n < 10 ? '0' + n : n;
-    }
-
-    if (typeof Date.prototype.toJSON !== 'function') {
-
-        Date.prototype.toJSON = function () {
-
-            return isFinite(this.valueOf())
-                ? this.getUTCFullYear()     + '-' +
-                    f(this.getUTCMonth() + 1) + '-' +
-                    f(this.getUTCDate())      + 'T' +
-                    f(this.getUTCHours())     + ':' +
-                    f(this.getUTCMinutes())   + ':' +
-                    f(this.getUTCSeconds())   + 'Z'
-                : null;
-        };
-
-        String.prototype.toJSON      =
-            Number.prototype.toJSON  =
-            Boolean.prototype.toJSON = function () {
-                return this.valueOf();
-            };
-    }
-
-    var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
-        escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
-        gap,
-        indent,
-        meta = {
-            '\b': '\\b',
-            '\t': '\\t',
-            '\n': '\\n',
-            '\f': '\\f',
-            '\r': '\\r',
-            '"' : '\\"',
-            '\\': '\\\\'
-        },
-        rep;
-
-
-    function quote(string) {
-
-        escapable.lastIndex = 0;
-        return escapable.test(string) ? '"' + string.replace(escapable, function (a) {
-            var c = meta[a];
-            return typeof c === 'string'
-                ? c
-                : '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
-        }) + '"' : '"' + string + '"';
-    }
-
-
-    function str(key, holder) {
-
-        var i,
-            k,
-            v,
-            length,
-            mind = gap,
-            partial,
-            value = holder[key];
-
-        if (value && typeof value === 'object' &&
-                typeof value.toJSON === 'function') {
-            value = value.toJSON(key);
-        }
-
-        if (typeof rep === 'function') {
-            value = rep.call(holder, key, value);
-        }
-
-        switch (typeof value) {
-        case 'string':
-            return quote(value);
-
-        case 'number':
-
-            return isFinite(value) ? String(value) : 'null';
-
-        case 'boolean':
-        case 'null':
-
-            return String(value);
-
-
-        case 'object':
-
-
-            if (!value) {
-                return 'null';
-            }
-
-
-            gap += indent;
-            partial = [];
-
-
-            if (Object.prototype.toString.apply(value) === '[object Array]') {
-
-
-                length = value.length;
-                for (i = 0; i < length; i += 1) {
-                    partial[i] = str(i, value) || 'null';
-                }
-
-
-                v = partial.length === 0
-                    ? '[]'
-                    : gap
-                    ? '[\n' + gap + partial.join(',\n' + gap) + '\n' + mind + ']'
-                    : '[' + partial.join(',') + ']';
-                gap = mind;
-                return v;
-            }
-
-
-            if (rep && typeof rep === 'object') {
-                length = rep.length;
-                for (i = 0; i < length; i += 1) {
-                    if (typeof rep[i] === 'string') {
-                        k = rep[i];
-                        v = str(k, value);
-                        if (v) {
-                            partial.push(quote(k) + (gap ? ': ' : ':') + v);
-                        }
-                    }
-                }
-            } else {
-
-                for (k in value) {
-                    if (Object.prototype.hasOwnProperty.call(value, k)) {
-                        v = str(k, value);
-                        if (v) {
-                            partial.push(quote(k) + (gap ? ': ' : ':') + v);
-                        }
-                    }
-                }
-            }
-
-            v = partial.length === 0
-                ? '{}'
-                : gap
-                ? '{\n' + gap + partial.join(',\n' + gap) + '\n' + mind + '}'
-                : '{' + partial.join(',') + '}';
-            gap = mind;
-            return v;
-        }
-    }
-
-    if (typeof JSON.stringify !== 'function') {
-        JSON.stringify = function (value, replacer, space) {
-
-            var i;
-            gap = '';
-            indent = '';
-
-
-            if (typeof space === 'number') {
-                for (i = 0; i < space; i += 1) {
-                    indent += ' ';
-                }
-
-
-            } else if (typeof space === 'string') {
-                indent = space;
-            }
-
-
-            rep = replacer;
-            if (replacer && typeof replacer !== 'function' &&
-                    (typeof replacer !== 'object' ||
-                    typeof replacer.length !== 'number')) {
-                throw new Error('JSON.stringify');
-            }
-
-            return str('', {'': value});
-        };
-    }
-
-    if (typeof JSON.parse !== 'function') {
-        JSON.parse = function (text, reviver) {
-
-            var j;
-
-            function walk(holder, key) {
-
-                var k, v, value = holder[key];
-                if (value && typeof value === 'object') {
-                    for (k in value) {
-                        if (Object.prototype.hasOwnProperty.call(value, k)) {
-                            v = walk(value, k);
-                            if (v !== undefined) {
-                                value[k] = v;
-                            } else {
-                                delete value[k];
-                            }
-                        }
-                    }
-                }
-                return reviver.call(holder, key, value);
-            }
-
-            text = String(text);
-            cx.lastIndex = 0;
-            if (cx.test(text)) {
-                text = text.replace(cx, function (a) {
-                    return '\\u' +
-                        ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
-                });
-            }
-
-            if (/^[\],:{}\s]*$/
-                    .test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@')
-                        .replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']')
-                        .replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
-
-                j = eval('(' + text + ')');
-
-                return typeof reviver === 'function'
-                    ? walk({'': j}, '')
-                    : j;
-            }
-
-            throw new SyntaxError('JSON.parse');
-        };
-    }
-}());
-
-}(this, {}));
-/*-------------------------------
-:cmd
-::if %errorlevel% == 0 exit
-pause>nul
-*/
\ No newline at end of file
diff --git a/package.json b/package.json
index 2b64bcc..9b9b490 100755
--- a/package.json
+++ b/package.json
@@ -1,21 +1,24 @@
 {
   "name": "node2bat",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "readmeFilename": "README.md",
   "description": "node2bat",
   "homepage": "https://github.com/aui/node2bat",
-  "keywords": [],
+  "keywords": ["bat", "nodejs", "cmd", "batch"],
   "author": "aui",
   "repository": {
     "type": "git",
     "url": "https://github.com/node2bat/node2bat.git"
   },
-  "main": "./node2bat.js",
+  "main": "./src/node2bat.js",
   "bin": {
     "node2bat": "./bin/node2bat"
   },
   "dependencies": {},
-  "devDependencies": {},
+  "devDependencies": {
+    "mocha": "*"
+  },
   "optionalDependencies": {},
   "license": "MIT"
-}
\ No newline at end of file
+}
+        
\ No newline at end of file
diff --git a/node2bat.js b/src/node2bat.js
similarity index 68%
rename from node2bat.js
rename to src/node2bat.js
index c82bb92..80a3e4f 100755
--- a/node2bat.js
+++ b/src/node2bat.js
@@ -2,8 +2,9 @@
 
 var fs = require('fs');
 var path = require('path');
+var version = require('../package.json').version;
 
-var runtime = fs.readFileSync(path.join(__dirname, 'lib/node2bat.runtime.js'), 'utf-8');
+var runtime = fs.readFileSync(path.join(__dirname, 'runtime.js'), 'utf-8');
 
 var toAnsi = function (code) {
 	var unicode = [], ansi;
@@ -21,7 +22,10 @@ var toAnsi = function (code) {
 var compile = function (code) {
 	code = code.replace(/^\#\!.*/, '');
 	code = toAnsi(code);
-	return runtime.replace(/'<\:node_code>'/, code);
+	return runtime
+	.replace(/'<\:build_time>'/g, Date.now())
+	.replace(/'<\:node_code>'/g, code)
+	.replace(/'<\:compiler_version>'/g, version);
 };
 
 exports.compile = function (file) {
diff --git a/src/runtime.js b/src/runtime.js
new file mode 100755
index 0000000..7e92e8c
--- /dev/null
+++ b/src/runtime.js
@@ -0,0 +1,2400 @@
+@if (0===0) @end/*
+@echo off
+title node
+cd %~dp0
+call CScript.EXE "%~dpnx0" //Nologo //e:jscript %*
+goto cmd
+-------------------------------------------------------
+Build       '<:build_time>'
+Compiler    node2bat.js@'<:compiler_version>' | https://github.com/aui/node2bat
+-------------------------------------------------------
+*/(function () {
+
+try {
+'<:node_code>'
+} catch (e) {
+    console.error(e);
+    WScript.Quit(1);
+}
+
+}).call({
+    node2bat: "'<:compiler_version>'"
+}, function (global, exports) {
+    // NodeJS Runtime
+    global.global = global;
+
+
+    global.__filename = WScript.ScriptFullName;
+
+    global.__dirname = WScript
+                .ScriptFullName
+                .replace(WScript.ScriptName, '')
+                .replace(/\\+$/, '');
+
+    global.process = {
+
+        title: 'node',
+
+        argv: function () {
+            var Arguments = WScript.Arguments;
+            var length = Arguments.length;
+            var argv = ['node', WScript.ScriptFullName];
+
+            if (length) {
+                for (var i = 0; i < length; i++) {
+                    argv.push(Arguments(i));
+                }
+            }
+
+            return argv;
+        }(),
+
+
+        cwd: function () {
+            return global.__dirname;
+        },
+
+        // @see http://technet.microsoft.com/en-us/library/ee156595.aspx
+        env: (function () {
+            var wsh = new ActiveXObject("WScript.Shell");
+            var processObject = wsh.Environment("Process");
+            var list = [
+                'ALLUSERSPROFILE',
+                'APPDATA',
+                'CommonProgramFiles',
+                'COMPUTERNAME',
+                'ComSpec',
+                'configsetroot',
+                'FP_NO_HOST_CHECK',
+                'HOMEDRIVE',
+                'HOMEPATH',
+                'LOCALAPPDATA',
+                'LOGONSERVER',
+                'NUMBER_OF_PROCESSORS',
+                'OS',
+                'Path',
+                'PATHEXT',
+                'PROCESSOR_ARCHITECTURE',
+                'PROCESSOR_IDENTIFIER',
+                'PROCESSOR_LEVEL',
+                'PROCESSOR_REVISION',
+                'ProgramData',
+                'ProgramFiles',
+                'PROMPT',
+                'PSModulePath',
+                'PUBLIC',
+                'SESSIONNAME',
+                'SystemDrive',
+                'SystemRoot',
+                'TEMP',
+                'TMP',
+                'USERDOMAIN',
+                'USERNAME',
+                'USERPROFILE',
+                'windir'
+            ];
+
+
+            var Env = function () {
+                for (var name, info, i = 0; i < list.length; i++) {
+                    name = list[i];
+                    info = processObject.Item(name);
+                    info = wsh.ExpandEnvironmentStrings(info);
+                    this[name] = info;
+                    Env.prototype[name.toUpperCase()] = info;
+                }
+            };
+
+            return new Env();
+        })(),
+
+
+        exit: function (code) {
+            WScript.Quit(code);
+        },
+
+
+        stdout: {
+            write: function (message) {
+                WScript.StdOut.Write(message);
+            }
+        },
+
+        stderr: {
+            write: function (message) {
+                WScript.StdOut.Write(message);
+            }
+        }
+    };
+
+
+    // CommonJS require()
+    global.require = function require (id) {
+        
+        var path = require.resolve(id);
+        var mod = require._modules[path];
+
+        if (!mod) {
+            if (/\.json$/i.test(id)) {
+                var fs = require('fs');
+                var text = fs.readFileSync(id, 'utf-8');
+                var json = JSON.parse(text);
+                return json;
+            } else {
+                throw new Error('failed to require "' + id + '"');
+            } 
+        }
+
+        if (!mod.exports) {
+            mod.exports = {};
+            mod.call(mod.exports, require.relative(path), mod.exports, mod);
+        }
+
+        return mod.exports;
+    }
+
+    // fn: function (require, exports, module) {}
+    function define (path, fn) {
+        require._modules[path] = fn;
+    };
+
+    require._modules = {};
+
+    require.resolve = function (path) {
+        var orig = path,
+            reg = path + '.js',
+            index = path + '/index.js';
+        return require._modules[reg] && reg || require._modules[index] && index || orig;
+    };
+
+
+    require.relative = function (parent) {
+        return function (p) {
+            if ('.' != p.substr(0, 1)) return require(p);
+
+            var path = parent.split('/'),
+                segs = p.split('/');
+            path.pop();
+
+            for (var i = 0; i < segs.length; i++) {
+                var seg = segs[i];
+                if ('..' == seg) path.pop();
+                else if ('.' != seg) path.push(seg);
+            }
+
+            return require(path.join('/'));
+        };
+    };
+
+
+    /*global.setTimeout = function (fn, time) {
+        WScript.Sleep(time);
+        if (typeof fn === 'function') {
+            fn();
+        } else {
+            eval(fn);
+        }
+    };
+
+
+    global.setInterval = function (fn, time) {
+        var interval = function () {
+
+            WScript.Sleep(time);
+
+            if (typeof fn === 'function') {
+                fn();
+            } else {
+                eval(fn);
+            }
+
+            interval();
+        };
+
+        interval();
+    };*/
+
+
+    define('util', function (require, exports, module) {
+        // 2014-04-04 02:39:42
+        var formatRegExp = /%[sdj%]/g;
+        exports.format = function (f) {
+            if (!isString(f)) {
+                var objects = [];
+                for (var i = 0; i < arguments.length; i++) {
+                    objects.push(inspect(arguments[i]));
+                }
+                return objects.join(' ');
+            }
+
+            var i = 1;
+            var args = arguments;
+            var len = args.length;
+            var str = String(f).replace(formatRegExp, function (x) {
+                if (x === '%%') return '%';
+                if (i >= len) return x;
+                switch (x) {
+                case '%s':
+                    return String(args[i++]);
+                case '%d':
+                    return Number(args[i++]);
+                case '%j':
+                    try {
+                        return JSON.stringify(args[i++]);
+                    } catch (_) {
+                        return '[Circular]';
+                    }
+                default:
+                    return x;
+                }
+            });
+            for (var x = args[i]; i < len; x = args[++i]) {
+                if (isNull(x) || !isObject(x)) {
+                    str += ' ' + x;
+                } else {
+                    str += ' ' + inspect(x);
+                }
+            }
+            return str;
+        };
+
+
+         // Mark that a method should not be used.
+         // Returns a modified function which warns once by default.
+         // If --no-deprecation is set, then it is a no-op.
+        exports.deprecate = function (fn, msg) {
+            // Allow for deprecating things in the process of starting up.
+            if (isUndefined(global.process)) {
+                return function () {
+                    return exports.deprecate(fn, msg).apply(this, arguments);
+                };
+            }
+
+            if (process.noDeprecation === true) {
+                return fn;
+            }
+
+            var warned = false;
+
+            function deprecated() {
+                if (!warned) {
+                    if (process.throwDeprecation) {
+                        throw new Error(msg);
+                    } else if (process.traceDeprecation) {
+                        console.trace(msg);
+                    } else {
+                        console.error(msg);
+                    }
+                    warned = true;
+                }
+                return fn.apply(this, arguments);
+            }
+
+            return deprecated;
+        };
+
+
+        var debugs = {};
+        var debugEnviron;
+        exports.debuglog = function (set) {
+            if (isUndefined(debugEnviron))
+                debugEnviron = process.env.NODE_DEBUG || '';
+            set = set.toUpperCase();
+            if (!debugs[set]) {
+                if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
+                    var pid = process.pid;
+                    debugs[set] = function () {
+                        var msg = exports.format.apply(exports, arguments);
+                        console.error('%s %d: %s', set, pid, msg);
+                    };
+                } else {
+                    debugs[set] = function () {};
+                }
+            }
+            return debugs[set];
+        };
+
+
+        /**
+         * Echos the value of a value. Trys to print the value out
+         * in the best way possible given the different types.
+         *
+         * @param {Object} obj The object to print out.
+         * @param {Object} opts Optional options object that alters the output.
+         */
+        /* legacy: obj, showHidden, depth, colors*/
+        function inspect(obj, opts) {
+            // default options
+            var ctx = {
+                seen: [],
+                stylize: stylizeNoColor
+            };
+            // legacy...
+            if (arguments.length >= 3) ctx.depth = arguments[2];
+            if (arguments.length >= 4) ctx.colors = arguments[3];
+            if (isBoolean(opts)) {
+                // legacy...
+                ctx.showHidden = opts;
+            } else if (opts) {
+                // got an "options" object
+                exports._extend(ctx, opts);
+            }
+            // set default options
+            if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
+            if (isUndefined(ctx.depth)) ctx.depth = 2;
+            if (isUndefined(ctx.colors)) ctx.colors = false;
+            if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
+            if (ctx.colors) ctx.stylize = stylizeWithColor;
+            return formatValue(ctx, obj, ctx.depth);
+        }
+        exports.inspect = inspect;
+
+
+         // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
+        inspect.colors = {
+            'bold': [1, 22],
+            'italic': [3, 23],
+            'underline': [4, 24],
+            'inverse': [7, 27],
+            'white': [37, 39],
+            'grey': [90, 39],
+            'black': [30, 39],
+            'blue': [34, 39],
+            'cyan': [36, 39],
+            'green': [32, 39],
+            'magenta': [35, 39],
+            'red': [31, 39],
+            'yellow': [33, 39]
+        };
+
+         // Don't use 'blue' not visible on cmd.exe
+        inspect.styles = {
+            'special': 'cyan',
+            'number': 'yellow',
+            'boolean': 'yellow',
+            'undefined': 'grey',
+            'null': 'bold',
+            'string': 'green',
+            'date': 'magenta',
+            // "name": intentionally not styling
+            'regexp': 'red'
+        };
+
+
+        function stylizeWithColor(str, styleType) {
+            var style = inspect.styles[styleType];
+
+            if (style) {
+                return '\u001b[' + inspect.colors[style][0] + 'm' + str +
+                    '\u001b[' + inspect.colors[style][1] + 'm';
+            } else {
+                return str;
+            }
+        }
+
+
+        function stylizeNoColor(str, styleType) {
+            return str;
+        }
+
+
+        function arrayToHash(array) {
+            var hash = {};
+
+            array.forEach(function (val, idx) {
+                hash[val] = true;
+            });
+
+            return hash;
+        }
+
+
+        function formatValue(ctx, value, recurseTimes) {
+            // Provide a hook for user-specified inspect functions.
+            // Check that value is an object with an inspect function on it
+            if (ctx.customInspect &&
+                value &&
+                isFunction(value.inspect) &&
+                // Filter out the util module, it's inspect function is special
+                value.inspect !== exports.inspect &&
+                // Also filter out any prototype objects using the circular check.
+                !(value.constructor && value.constructor.prototype === value)) {
+                var ret = value.inspect(recurseTimes, ctx);
+                if (!isString(ret)) {
+                    ret = formatValue(ctx, ret, recurseTimes);
+                }
+                return ret;
+            }
+
+            // Primitive types cannot have properties
+            var primitive = formatPrimitive(ctx, value);
+            if (primitive) {
+                return primitive;
+            }
+
+            // Look up the keys of the object.
+            var keys = Object.keys(value);
+            var visibleKeys = arrayToHash(keys);
+
+            if (ctx.showHidden) {
+                keys = Object.getOwnPropertyNames(value);
+            }
+
+            // This could be a boxed primitive (new String(), etc.), check valueOf()
+            // NOTE: Avoid calling `valueOf` on `Date` instance because it will return
+            // a number which, when object has some additional user-stored `keys`,
+            // will be printed out.
+            var formatted;
+            var raw = value;
+            try {
+                // the .valueOf() call can fail for a multitude of reasons
+                if (!isDate(value))
+                    raw = value.valueOf();
+            } catch (e) {
+                // ignore...
+            }
+
+            if (isString(raw)) {
+                // for boxed Strings, we have to remove the 0-n indexed entries,
+                // since they just noisey up the output and are redundant
+                keys = keys.filter(function (key) {
+                    return !(key >= 0 && key < raw.length);
+                });
+            }
+
+            // Some type of object without properties can be shortcutted.
+            if (keys.length === 0) {
+                if (isFunction(value)) {
+                    var name = value.name ? ': ' + value.name : '';
+                    return ctx.stylize('[Function' + name + ']', 'special');
+                }
+                if (isRegExp(value)) {
+                    return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+                }
+                if (isDate(value)) {
+                    return ctx.stylize(Date.prototype.toString.call(value), 'date');
+                }
+                if (isError(value)) {
+                    return formatError(value);
+                }
+                // now check the `raw` value to handle boxed primitives
+                if (isString(raw)) {
+                    formatted = formatPrimitiveNoColor(ctx, raw);
+                    return ctx.stylize('[String: ' + formatted + ']', 'string');
+                }
+                if (isNumber(raw)) {
+                    formatted = formatPrimitiveNoColor(ctx, raw);
+                    return ctx.stylize('[Number: ' + formatted + ']', 'number');
+                }
+                if (isBoolean(raw)) {
+                    formatted = formatPrimitiveNoColor(ctx, raw);
+                    return ctx.stylize('[Boolean: ' + formatted + ']', 'boolean');
+                }
+            }
+
+            var base = '',
+                array = false,
+                braces = ['{', '}'];
+
+            // Make Array say that they are Array
+            if (isArray(value)) {
+                array = true;
+                braces = ['[', ']'];
+            }
+
+            // Make functions say that they are functions
+            if (isFunction(value)) {
+                var n = value.name ? ': ' + value.name : '';
+                base = ' [Function' + n + ']';
+            }
+
+            // Make RegExps say that they are RegExps
+            if (isRegExp(value)) {
+                base = ' ' + RegExp.prototype.toString.call(value);
+            }
+
+            // Make dates with properties first say the date
+            if (isDate(value)) {
+                base = ' ' + Date.prototype.toUTCString.call(value);
+            }
+
+            // Make error with message first say the error
+            if (isError(value)) {
+                base = ' ' + formatError(value);
+            }
+
+            // Make boxed primitive Strings look like such
+            if (isString(raw)) {
+                formatted = formatPrimitiveNoColor(ctx, raw);
+                base = ' ' + '[String: ' + formatted + ']';
+            }
+
+            // Make boxed primitive Numbers look like such
+            if (isNumber(raw)) {
+                formatted = formatPrimitiveNoColor(ctx, raw);
+                base = ' ' + '[Number: ' + formatted + ']';
+            }
+
+            // Make boxed primitive Booleans look like such
+            if (isBoolean(raw)) {
+                formatted = formatPrimitiveNoColor(ctx, raw);
+                base = ' ' + '[Boolean: ' + formatted + ']';
+            }
+
+            if (keys.length === 0 && (!array || value.length === 0)) {
+                return braces[0] + base + braces[1];
+            }
+
+            if (recurseTimes < 0) {
+                if (isRegExp(value)) {
+                    return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+                } else {
+                    return ctx.stylize('[Object]', 'special');
+                }
+            }
+
+            ctx.seen.push(value);
+
+            var output;
+            if (array) {
+                output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
+            } else {
+                output = keys.map(function (key) {
+                    return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
+                });
+            }
+
+            ctx.seen.pop();
+
+            return reduceToSingleString(output, base, braces);
+        }
+
+
+        function formatPrimitive(ctx, value) {
+            if (isUndefined(value))
+                return ctx.stylize('undefined', 'undefined');
+            if (isString(value)) {
+                var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
+                    .replace(/'/g, "\\'")
+                    .replace(/\\"/g, '"') + '\'';
+                return ctx.stylize(simple, 'string');
+            }
+            if (isNumber(value)) {
+                // Format -0 as '-0'. Strict equality won't distinguish 0 from -0,
+                // so instead we use the fact that 1 / -0 < 0 whereas 1 / 0 > 0 .
+                if (value === 0 && 1 / value < 0)
+                    return ctx.stylize('-0', 'number');
+                return ctx.stylize('' + value, 'number');
+            }
+            if (isBoolean(value))
+                return ctx.stylize('' + value, 'boolean');
+            // For some reason typeof null is "object", so special case here.
+            if (isNull(value))
+                return ctx.stylize('null', 'null');
+        }
+
+
+        function formatPrimitiveNoColor(ctx, value) {
+            var stylize = ctx.stylize;
+            ctx.stylize = stylizeNoColor;
+            var str = formatPrimitive(ctx, value);
+            ctx.stylize = stylize;
+            return str;
+        }
+
+
+        function formatError(value) {
+            return '[' + Error.prototype.toString.call(value) + ']';
+        }
+
+
+        function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
+            var output = [];
+            for (var i = 0, l = value.length; i < l; ++i) {
+                if (hasOwnProperty(value, String(i))) {
+                    output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+                        String(i), true));
+                } else {
+                    output.push('');
+                }
+            }
+            keys.forEach(function (key) {
+                if (!key.match(/^\d+$/)) {
+                    output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+                        key, true));
+                }
+            });
+            return output;
+        }
+
+
+        function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
+            var name, str, desc;
+            desc = /*Object.getOwnPropertyDescriptor(value, key) ||*/ {
+                value: value[key]
+            };
+            if (desc.get) {
+                if (desc.set) {
+                    str = ctx.stylize('[Getter/Setter]', 'special');
+                } else {
+                    str = ctx.stylize('[Getter]', 'special');
+                }
+            } else {
+                if (desc.set) {
+                    str = ctx.stylize('[Setter]', 'special');
+                }
+            }
+            if (!hasOwnProperty(visibleKeys, key)) {
+                name = '[' + key + ']';
+            }
+            if (!str) {
+                if (ctx.seen.indexOf(desc.value) < 0) {
+                    if (isNull(recurseTimes)) {
+                        str = formatValue(ctx, desc.value, null);
+                    } else {
+                        str = formatValue(ctx, desc.value, recurseTimes - 1);
+                    }
+                    if (str.indexOf('\n') > -1) {
+                        if (array) {
+                            str = str.split('\n').map(function (line) {
+                                return '  ' + line;
+                            }).join('\n').substr(2);
+                        } else {
+                            str = '\n' + str.split('\n').map(function (line) {
+                                return '   ' + line;
+                            }).join('\n');
+                        }
+                    }
+                } else {
+                    str = ctx.stylize('[Circular]', 'special');
+                }
+            }
+            if (isUndefined(name)) {
+                if (array && key.match(/^\d+$/)) {
+                    return str;
+                }
+                name = JSON.stringify('' + key);
+                if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+                    name = name.substr(1, name.length - 2);
+                    name = ctx.stylize(name, 'name');
+                } else {
+                    name = name.replace(/'/g, "\\'")
+                        .replace(/\\"/g, '"')
+                        .replace(/(^"|"$)/g, "'")
+                        .replace(/\\\\/g, '\\');
+                    name = ctx.stylize(name, 'string');
+                }
+            }
+
+            return name + ': ' + str;
+        }
+
+
+        function reduceToSingleString(output, base, braces) {
+            var length = output.reduce(function (prev, cur) {
+                return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
+            }, 0);
+
+            if (length > 60) {
+                return braces[0] +
+                    (base === '' ? '' : base + '\n ') +
+                    ' ' +
+                    output.join(',\n  ') +
+                    ' ' +
+                    braces[1];
+            }
+
+            return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
+        }
+
+
+         // NOTE: These type checking functions intentionally don't use `instanceof`
+         // because it is fragile and can be easily faked with `Object.create()`.
+        var isArray = exports.isArray = Array.isArray;
+
+        function isBoolean(arg) {
+            return typeof arg === 'boolean';
+        }
+        exports.isBoolean = isBoolean;
+
+        function isNull(arg) {
+            return arg === null;
+        }
+        exports.isNull = isNull;
+
+        function isNullOrUndefined(arg) {
+            return arg == null;
+        }
+        exports.isNullOrUndefined = isNullOrUndefined;
+
+        function isNumber(arg) {
+            return typeof arg === 'number';
+        }
+        exports.isNumber = isNumber;
+
+        function isString(arg) {
+            return typeof arg === 'string';
+        }
+        exports.isString = isString;
+
+        function isSymbol(arg) {
+            return typeof arg === 'symbol';
+        }
+        exports.isSymbol = isSymbol;
+
+        function isUndefined(arg) {
+            return arg === void 0;
+        }
+        exports.isUndefined = isUndefined;
+
+        function isRegExp(re) {
+            return isObject(re) && objectToString(re) === '[object RegExp]';
+        }
+        exports.isRegExp = isRegExp;
+
+        function isObject(arg) {
+            return typeof arg === 'object' && arg !== null;
+        }
+        exports.isObject = isObject;
+
+        function isDate(d) {
+            return isObject(d) && objectToString(d) === '[object Date]';
+        }
+        exports.isDate = isDate;
+
+        function isError(e) {
+            return isObject(e) &&
+                (objectToString(e) === '[object Error]' || e instanceof Error);
+        }
+        exports.isError = isError;
+
+        function isFunction(arg) {
+            return typeof arg === 'function';
+        }
+        exports.isFunction = isFunction;
+
+        function isPrimitive(arg) {
+            return arg === null ||
+                typeof arg === 'boolean' ||
+                typeof arg === 'number' ||
+                typeof arg === 'string' ||
+                typeof arg === 'symbol' || // ES6 symbol
+                typeof arg === 'undefined';
+        }
+        exports.isPrimitive = isPrimitive;
+
+        function objectToString(o) {
+            return Object.prototype.toString.call(o);
+        }
+
+
+        function pad(n) {
+            return n < 10 ? '0' + n.toString(10) : n.toString(10);
+        }
+
+
+        var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
+            'Oct', 'Nov', 'Dec'
+        ];
+
+         // 26 Feb 16:19:34
+        function timestamp() {
+            var d = new Date();
+            var time = [pad(d.getHours()),
+                pad(d.getMinutes()),
+                pad(d.getSeconds())
+            ].join(':');
+            return [d.getDate(), months[d.getMonth()], time].join(' ');
+        }
+
+
+         // log is just a thin wrapper to console.log that prepends a timestamp
+        exports.log = function () {
+            console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
+        };
+
+
+        exports._extend = function (origin, add) {
+            // Don't do anything if add isn't an object
+            if (!add || !isObject(add)) return origin;
+
+            var keys = Object.keys(add);
+            var i = keys.length;
+            while (i--) {
+                origin[keys[i]] = add[keys[i]];
+            }
+            return origin;
+        };
+
+        function hasOwnProperty(obj, prop) {
+            return Object.prototype.hasOwnProperty.call(obj, prop);
+        }
+
+
+        var uv;
+        exports._errnoException = function (err, syscall, original) {
+            if (isUndefined(uv)) uv = process.binding('uv');
+            var errname = uv.errname(err);
+            var message = syscall + ' ' + errname;
+            if (original)
+                message += ' ' + original;
+            var e = new Error(message);
+            e.code = errname;
+            e.errno = errname;
+            e.syscall = syscall;
+            return e;
+        };
+    });
+
+
+    define('console', function (require, exports, module) {
+        // 2013-08-02 06:08:01 
+        var util = require('util');
+
+        function Console(stdout, stderr) {
+            if (!(this instanceof Console)) {
+                return new Console(stdout, stderr);
+            }
+            if (!stdout || !util.isFunction(stdout.write)) {
+                throw new TypeError('Console expects a writable stream instance');
+            }
+            if (!stderr) {
+                stderr = stdout;
+            }
+
+            this._stdout = stdout;
+            this._stderr = stderr;
+            this._times = {};
+
+            // bind the prototype functions to this Console instance
+            Object.keys(Console.prototype).forEach(function (k) {
+                this[k] = this[k].bind(this);
+            }, this);
+        }
+
+        Console.prototype.log = function () {
+            this._stdout.write(util.format.apply(this, arguments) + '\n');
+        };
+
+
+        Console.prototype.info = Console.prototype.log;
+
+
+        Console.prototype.warn = function () {
+            this._stderr.write(util.format.apply(this, arguments) + '\n');
+        };
+
+
+        Console.prototype.error = Console.prototype.warn;
+
+
+        Console.prototype.dir = function (object) {
+            this._stdout.write(util.inspect(object, {
+                customInspect: false
+            }) + '\n');
+        };
+
+
+        Console.prototype.time = function (label) {
+            this._times[label] = Date.now();
+        };
+
+
+        Console.prototype.timeEnd = function (label) {
+            var time = this._times[label];
+            if (!time) {
+                throw new Error('No such label: ' + label);
+            }
+            var duration = Date.now() - time;
+            this.log('%s: %dms', label, duration);
+        };
+
+
+        Console.prototype.assert = function (expression) {
+            if (!expression) {
+                var arr = Array.prototype.slice.call(arguments, 1);
+                require('assert').ok(false, util.format.apply(this, arr));
+            }
+        };
+
+
+        module.exports = new Console(process.stdout, process.stderr);
+        module.exports.Console = Console;
+    });
+
+
+    define('fs', function (require, exports, module) {
+
+        var fso = new ActiveXObject('Scripting.FileSystemObject');
+
+        var Stat = function (path) {
+            var info;
+            this._path = path;
+
+            if (this.isFile()) {
+                info = fso.GetFile(path);
+            } else if (this.isDirectory()) {
+                info = fso.GetFolder(path);
+            } else {
+                throw new Error('ENOENT, no such file or directory ' + JSON.stringify(path));
+            }
+
+            this.size = info.Size; // TODO: 读取目录不准确
+            this.atime = new Date(info.DateLastAccessed);
+            this.mtime = new Date(info.DateLastModified);
+            this.ctime = new Date(info.DateCreated);
+        };
+
+        Stat.prototype = {
+            isFile: function () {
+                return fso.FileExists(this._path);
+            },
+            isDirectory: function () {
+                return fso.FolderExists(this._path);
+            }
+        };
+
+        exports.renameSync = function (oldPath, newPath) {
+            var statSync = exports.statSync(oldPath);
+            var file = fso[statSync.isFile() ? 'GetFile' : 'GetFolder'](oldPath);
+            if (exports.existsSync(newPath)) {
+                exports.unlinkSync(newPath);
+            }
+            file.Move(newPath);
+        };
+
+        exports.mkdirSync = function (path) {
+            // TODO: Error Info
+            fso.CreateFolder(path);
+        };
+
+        exports.mkdirSync = function (path) {
+            fso.CreateFolder(path);
+        };
+
+        exports.rmdirSync = function (path) {
+            fso.DeleteFolder(path, true);
+        };
+
+        exports.unlinkSync = function (path) {
+            fso.DeleteFile(path, true);
+        };
+
+        exports.existsSync = function (path) {
+            try {
+                var statSync = exports.statSync(path);
+                return statSync.isFile() || statSync.isDirectory();
+            } catch (e) {
+                return false;
+            }  
+        };
+
+        exports.statSync = function (path) {
+            return new Stat(path);
+        };
+
+        exports.readdirSync = function (path) {
+
+            var listall = function (path) {
+
+                var fd = fso.GetFolder(path + '\\');
+                var fe = new Enumerator(fd.files);
+                var list = [];
+                var item;
+
+                while (!fe.atEnd()) {
+                    item = fe.item() + '';
+                    item = item.replace(/^.*\\([^\\]*)$/, '$1');
+                    list.push(item);
+                    fe.moveNext();
+                }
+
+                var folderList = new Enumerator(fd.SubFolders);
+                for (; !folderList.atEnd(); folderList.moveNext()) {
+                    item = folderList.item() + '';
+                    item = item.replace(/^.*\\([^\\]*)$/, '$1');
+                    list.push(item);
+                }
+
+                return list;
+            };
+
+            return listall(path);
+        };
+
+        exports.readFileSync = function (file, charset) {
+            var stream = new ActiveXObject('adodb.stream');
+            var fileContent;
+
+            stream.Type = charset ? 2 : 1;
+            stream.Open();
+
+            if (charset) {
+                stream.Charset = charset;
+            } else {
+                throw new TypeError('Bad arguments');
+            }
+
+            try {
+                stream.LoadFromFile(file);
+            } catch (e) {
+                throw e;
+            }
+
+            fileContent = new String(stream.ReadText());
+            fileContent.Charset = charset;
+            stream.Close();
+
+            return fileContent.toString();
+        };
+
+        // @see http://bathome.l3.wuyou.com/redirect.php?goto=findpost&ptid=10300&pid=66972
+        // @see http://www.clockworksoftware.com/asp/Products/vbs2js.asp
+        exports.writeFileSync = function (file, data, charset) {
+            var binData;
+            var stream = new ActiveXObject("adodb.Stream");
+
+            stream.Open();
+
+            try {
+                
+                if (charset) {
+
+
+                    stream.Position = 0;
+                    stream.CharSet = charset;
+                    stream.WriteText(data);
+                    stream.SetEOS();
+
+                    stream.Position = 0;
+                    stream.Type = 1;
+
+                    // TODO: test BOM
+                    // /^0xEF0xBB0xBF/
+                    if (charset !== 'ascii') {
+                        stream.Position = 3;
+                    }
+                    
+                    binData = stream.Read(-1); 
+
+                    stream.Position = 0;
+                    stream.Write(binData);
+                    stream.SetEOS();
+                    
+
+                    stream.SaveToFile(file, 2);
+                } else {
+                    
+                    //stream.Type = 1;
+                    //stream.Write(data);
+                    //stream.SaveToFile(file, 2);
+                    throw new TypeError('Bad arguments');
+                }
+
+            } catch (e) {
+                throw e;
+            } finally {
+                stream.close();
+            }
+        };
+    });
+
+
+    define('path', function (require, exports, module) {
+
+        // resolves . and .. elements in a path array with directory names there
+        // must be no slashes, empty elements, or device names (c:\) in the array
+        // (so also no leading and trailing slashes - it does not distinguish
+        // relative and absolute paths)
+        function normalizeArray(parts, allowAboveRoot) {
+            // if the path tries to go above the root, `up` ends up > 0
+            var up = 0;
+            for (var i = parts.length - 1; i >= 0; i--) {
+                var last = parts[i];
+                if (last === '.') {
+                    parts.splice(i, 1);
+                } else if (last === '..') {
+                    parts.splice(i, 1);
+                    up++;
+                } else if (up) {
+                    parts.splice(i, 1);
+                    up--;
+                }
+            }
+
+            // if the path is allowed to go above the root, restore leading ..s
+            if (allowAboveRoot) {
+                for (; up--; up) {
+                    parts.unshift('..');
+                }
+            }
+
+            return parts;
+        }
+        // Regex to split a windows path into three parts: [*, device, slash,
+        // tail] windows-only
+        var splitDeviceRe =
+            /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
+
+        // Regex to split the tail part of the above into [*, dir, basename, ext]
+        var splitTailRe =
+            /^([\s\S]*?)((?:\.{1,2}|[^\\\/]+?|)(\.[^.\/\\]*|))(?:[\\\/]*)$/;
+
+        // Function to split a filename into [root, dir, basename, ext]
+        // windows version
+        var splitPath = function (filename) {
+            // Separate device+slash from tail
+            var result = splitDeviceRe.exec(filename),
+                device = (result[1] || '') + (result[2] || ''),
+                tail = result[3] || '';
+            // Split the tail into dir, basename and extension
+            var result2 = splitTailRe.exec(tail),
+                dir = result2[1],
+                basename = result2[2],
+                ext = result2[3];
+            return [device, dir, basename, ext];
+        };
+
+        var normalizeUNCRoot = function (device) {
+            return '\\\\' + device.replace(/^[\\\/]+/, '').replace(/[\\\/]+/g, '\\');
+        };
+
+        // path.resolve([from ...], to)
+        // windows version
+        exports.resolve = function () {
+            var resolvedDevice = '',
+                resolvedTail = '',
+                resolvedAbsolute = false;
+
+            for (var i = arguments.length - 1; i >= -1; i--) {
+                var path;
+                if (i >= 0) {
+                    path = arguments[i];
+                } else if (!resolvedDevice) {
+                    path = process.cwd();
+                } else {
+                    // Windows has the concept of drive-specific current working
+                    // directories. If we've resolved a drive letter but not yet an
+                    // absolute path, get cwd for that drive. We're sure the device is not
+                    // an unc path at this points, because unc paths are always absolute.
+                    path = process.env['=' + resolvedDevice];
+                    // Verify that a drive-local cwd was found and that it actually points
+                    // to our drive. If not, default to the drive's root.
+                    if (!path || path.substr(0, 3).toLowerCase() !==
+                        resolvedDevice.toLowerCase() + '\\') {
+                        path = resolvedDevice + '\\';
+                    }
+                }
+
+                // Skip empty and invalid entries
+                if (typeof path !== 'string') {
+                    throw new TypeError('Arguments to path.resolve must be strings');
+                } else if (!path) {
+                    continue;
+                }
+
+                var result = splitDeviceRe.exec(path),
+                    device = result[1] || '',
+                    isUnc = device && device.charAt(1) !== ':',
+                    isAbsolute = exports.isAbsolute(path),
+                    tail = result[3];
+
+                if (device &&
+                    resolvedDevice &&
+                    device.toLowerCase() !== resolvedDevice.toLowerCase()) {
+                    // This path points to another device so it is not applicable
+                    continue;
+                }
+
+                if (!resolvedDevice) {
+                    resolvedDevice = device;
+                }
+                if (!resolvedAbsolute) {
+                    resolvedTail = tail + '\\' + resolvedTail;
+                    resolvedAbsolute = isAbsolute;
+                }
+
+                if (resolvedDevice && resolvedAbsolute) {
+                    break;
+                }
+            }
+
+            // Convert slashes to backslashes when `resolvedDevice` points to an UNC
+            // root. Also squash multiple slashes into a single one where appropriate.
+            if (isUnc) {
+                resolvedDevice = normalizeUNCRoot(resolvedDevice);
+            }
+
+            // At this point the path should be resolved to a full absolute path,
+            // but handle relative paths to be safe (might happen when process.cwd()
+            // fails)
+
+            // Normalize the tail path
+
+            function f(p) {
+                return !!p;
+            }
+
+            resolvedTail = normalizeArray(resolvedTail.split(/[\\\/]+/).filter(f), !resolvedAbsolute).join('\\');
+
+            return (resolvedDevice + (resolvedAbsolute ? '\\' : '') + resolvedTail) ||
+                '.';
+        };
+
+        // windows version
+        exports.normalize = function (path) {
+            var result = splitDeviceRe.exec(path),
+                device = result[1] || '',
+                isUnc = device && device.charAt(1) !== ':',
+                isAbsolute = exports.isAbsolute(path),
+                tail = result[3],
+                trailingSlash = /[\\\/]$/.test(tail);
+
+            // If device is a drive letter, we'll normalize to lower case.
+            if (device && device.charAt(1) === ':') {
+                device = device[0].toLowerCase() + device.substr(1);
+            }
+
+            // Normalize the tail path
+            tail = normalizeArray(tail.split(/[\\\/]+/).filter(function (p) {
+                return !!p;
+            }), !isAbsolute).join('\\');
+
+            if (!tail && !isAbsolute) {
+                tail = '.';
+            }
+            if (tail && trailingSlash) {
+                tail += '\\';
+            }
+
+            // Convert slashes to backslashes when `device` points to an UNC root.
+            // Also squash multiple slashes into a single one where appropriate.
+            if (isUnc) {
+                device = normalizeUNCRoot(device);
+            }
+
+            return device + (isAbsolute ? '\\' : '') + tail;
+        };
+
+        // windows version
+        exports.isAbsolute = function (path) {
+            var result = splitDeviceRe.exec(path),
+                device = result[1] || '',
+                isUnc = device && device.charAt(1) !== ':';
+            // UNC paths are always absolute
+            return !!result[2] || isUnc;
+        };
+
+        // windows version
+        exports.join = function () {
+            function f(p) {
+                if (typeof p !== 'string') {
+                    throw new TypeError('Arguments to path.join must be strings');
+                }
+                return p;
+            }
+
+            var paths = Array.prototype.filter.call(arguments, f);
+            var joined = paths.join('\\');
+
+            // Make sure that the joined path doesn't start with two slashes, because
+            // normalize() will mistake it for an UNC path then.
+            //
+            // This step is skipped when it is very clear that the user actually
+            // intended to point at an UNC path. This is assumed when the first
+            // non-empty string arguments starts with exactly two slashes followed by
+            // at least one more non-slash character.
+            //
+            // Note that for normalize() to treat a path as an UNC path it needs to
+            // have at least 2 components, so we don't filter for that here.
+            // This means that the user can use join to construct UNC paths from
+            // a server name and a share name; for example:
+            //   path.join('//server', 'share') -> '\\\\server\\share\')
+            if (!/^[\\\/]{2}[^\\\/]/.test(paths[0])) {
+                joined = joined.replace(/^[\\\/]{2,}/, '\\');
+            }
+
+            return exports.normalize(joined);
+        };
+
+        // path.relative(from, to)
+        // it will solve the relative path from 'from' to 'to', for instance:
+        // from = 'C:\\orandea\\test\\aaa'
+        // to = 'C:\\orandea\\impl\\bbb'
+        // The output of the function should be: '..\\..\\impl\\bbb'
+        // windows version
+        exports.relative = function (from, to) {
+            from = exports.resolve(from);
+            to = exports.resolve(to);
+
+            // windows is not case sensitive
+            var lowerFrom = from.toLowerCase();
+            var lowerTo = to.toLowerCase();
+
+            function trim(arr) {
+                var start = 0;
+                for (; start < arr.length; start++) {
+                    if (arr[start] !== '') break;
+                }
+
+                var end = arr.length - 1;
+                for (; end >= 0; end--) {
+                    if (arr[end] !== '') break;
+                }
+
+                if (start > end) return [];
+                return arr.slice(start, end - start + 1);
+            }
+
+            var toParts = trim(to.split('\\'));
+
+            var lowerFromParts = trim(lowerFrom.split('\\'));
+            var lowerToParts = trim(lowerTo.split('\\'));
+
+            var length = Math.min(lowerFromParts.length, lowerToParts.length);
+            var samePartsLength = length;
+            for (var i = 0; i < length; i++) {
+                if (lowerFromParts[i] !== lowerToParts[i]) {
+                    samePartsLength = i;
+                    break;
+                }
+            }
+
+            if (samePartsLength == 0) {
+                return to;
+            }
+
+            var outputParts = [];
+            for (var i = samePartsLength; i < lowerFromParts.length; i++) {
+                outputParts.push('..');
+            }
+
+            outputParts = outputParts.concat(toParts.slice(samePartsLength));
+
+            return outputParts.join('\\');
+        };
+
+        exports.sep = '\\';
+        exports.delimiter = ';';
+
+        exports.dirname = function (path) {
+            var result = splitPath(path),
+                root = result[0],
+                dir = result[1];
+
+            if (!root && !dir) {
+                // No dirname whatsoever
+                return '.';
+            }
+
+            if (dir) {
+                // It has a dirname, strip trailing slash
+                dir = dir.substr(0, dir.length - 1);
+            }
+
+            return root + dir;
+        };
+
+
+        exports.basename = function (path, ext) {
+            var f = splitPath(path)[2];
+            // TODO: make this comparison case-insensitive on windows?
+            if (ext && f.substr(-1 * ext.length) === ext) {
+                f = f.substr(0, f.length - ext.length);
+            }
+            return f;
+        };
+
+
+        exports.extname = function (path) {
+            return splitPath(path)[3];
+        };
+    });
+
+    
+    define('assert', function (require, exports, module) {
+        // 2014-03-03 03:54:19 
+        var util = require('util');
+        var pSlice = Array.prototype.slice;
+
+        // 1. The assert module provides functions that throw
+        // AssertionError's when particular conditions are not met. The
+        // assert module must conform to the following interface.
+
+        var assert = module.exports = ok;
+
+        // 2. The AssertionError is defined in assert.
+        // new assert.AssertionError({ message: message,
+        //                             actual: actual,
+        //                             expected: expected })
+
+        assert.AssertionError = function AssertionError(options) {
+            this.name = 'AssertionError';
+            this.actual = options.actual;
+            this.expected = options.expected;
+            this.operator = options.operator;
+            if (options.message) {
+                this.message = options.message;
+                this.generatedMessage = false;
+            } else {
+                this.message = getMessage(this);
+                this.generatedMessage = true;
+            }
+            //var stackStartFunction = options.stackStartFunction || fail;
+            //Error.captureStackTrace(this, stackStartFunction);
+        };
+
+        // assert.AssertionError instanceof Error
+        //util.inherits(assert.AssertionError, Error);
+        assert.AssertionError.prototype = Error.prototype;
+
+        function replacer(key, value) {
+            if (util.isUndefined(value)) {
+                return '' + value;
+            }
+            if (util.isNumber(value) && (isNaN(value) || !isFinite(value))) {
+                return value.toString();
+            }
+            if (util.isFunction(value) || util.isRegExp(value)) {
+                return value.toString();
+            }
+            return value;
+        }
+
+        function truncate(s, n) {
+            if (util.isString(s)) {
+                return s.length < n ? s : s.slice(0, n);
+            } else {
+                return s;
+            }
+        }
+
+        function getMessage(self) {
+            return truncate(JSON.stringify(self.actual, replacer), 128) + ' ' +
+                self.operator + ' ' +
+                truncate(JSON.stringify(self.expected, replacer), 128);
+        }
+
+        // At present only the three keys mentioned above are used and
+        // understood by the spec. Implementations or sub modules can pass
+        // other keys to the AssertionError's constructor - they will be
+        // ignored.
+
+        // 3. All of the following functions must throw an AssertionError
+        // when a corresponding condition is not met, with a message that
+        // may be undefined if not provided.  All assertion methods provide
+        // both the actual and expected values to the assertion error for
+        // display purposes.
+
+        function fail(actual, expected, message, operator, stackStartFunction) {
+            throw new assert.AssertionError({
+                message: message,
+                actual: actual,
+                expected: expected,
+                operator: operator,
+                stackStartFunction: stackStartFunction
+            });
+        }
+
+        // EXTENSION! allows for well behaved errors defined elsewhere.
+        assert.fail = fail;
+
+        // 4. Pure assertion tests whether a value is truthy, as determined
+        // by !!guard.
+        // assert.ok(guard, message_opt);
+        // This statement is equivalent to assert.equal(true, !!guard,
+        // message_opt);. To test strictly for the value true, use
+        // assert.strictEqual(true, guard, message_opt);.
+
+        function ok(value, message) {
+            if (!value) fail(value, true, message, '==', assert.ok);
+        }
+        assert.ok = ok;
+
+        // 5. The equality assertion tests shallow, coercive equality with
+        // ==.
+        // assert.equal(actual, expected, message_opt);
+
+        assert.equal = function equal(actual, expected, message) {
+            if (actual != expected) fail(actual, expected, message, '==', assert.equal);
+        };
+
+        // 6. The non-equality assertion tests for whether two objects are not equal
+        // with != assert.notEqual(actual, expected, message_opt);
+
+        assert.notEqual = function notEqual(actual, expected, message) {
+            if (actual == expected) {
+                fail(actual, expected, message, '!=', assert.notEqual);
+            }
+        };
+
+        // 7. The equivalence assertion tests a deep equality relation.
+        // assert.deepEqual(actual, expected, message_opt);
+
+        assert.deepEqual = function deepEqual(actual, expected, message) {
+            if (!_deepEqual(actual, expected)) {
+                fail(actual, expected, message, 'deepEqual', assert.deepEqual);
+            }
+        };
+
+        function _deepEqual(actual, expected) {
+            // 7.1. All identical values are equivalent, as determined by ===.
+            if (actual === expected) {
+                return true;
+
+            } else if (util.isDate(actual) && util.isDate(expected)) {
+                return actual.getTime() === expected.getTime();
+
+                // 7.3 If the expected value is a RegExp object, the actual value is
+                // equivalent if it is also a RegExp object with the same source and
+                // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).
+            } else if (util.isRegExp(actual) && util.isRegExp(expected)) {
+                return actual.source === expected.source &&
+                    actual.global === expected.global &&
+                    actual.multiline === expected.multiline &&
+                    actual.lastIndex === expected.lastIndex &&
+                    actual.ignoreCase === expected.ignoreCase;
+
+                // 7.4. Other pairs that do not both pass typeof value == 'object',
+                // equivalence is determined by ==.
+            } else if (!util.isObject(actual) && !util.isObject(expected)) {
+                return actual == expected;
+
+                // 7.5 For all other Object pairs, including Array objects, equivalence is
+                // determined by having the same number of owned properties (as verified
+                // with Object.prototype.hasOwnProperty.call), the same set of keys
+                // (although not necessarily the same order), equivalent values for every
+                // corresponding key, and an identical 'prototype' property. Note: this
+                // accounts for both named and indexed properties on Arrays.
+            } else {
+                return objEquiv(actual, expected);
+            }
+        }
+
+        function isArguments(object) {
+            return Object.prototype.toString.call(object) == '[object Arguments]';
+        }
+
+        function objEquiv(a, b) {
+            if (util.isNullOrUndefined(a) || util.isNullOrUndefined(b))
+                return false;
+            // an identical 'prototype' property.
+            if (a.prototype !== b.prototype) return false;
+            //~~~I've managed to break Object.keys through screwy arguments passing.
+            //   Converting to array solves the problem.
+            var aIsArgs = isArguments(a),
+                bIsArgs = isArguments(b);
+            if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))
+                return false;
+            if (aIsArgs) {
+                a = pSlice.call(a);
+                b = pSlice.call(b);
+                return _deepEqual(a, b);
+            }
+            try {
+                var ka = Object.keys(a),
+                    kb = Object.keys(b),
+                    key, i;
+            } catch (e) { //happens when one is a string literal and the other isn't
+                return false;
+            }
+            // having the same number of owned properties (keys incorporates
+            // hasOwnProperty)
+            if (ka.length != kb.length)
+                return false;
+            //the same set of keys (although not necessarily the same order),
+            ka.sort();
+            kb.sort();
+            //~~~cheap key test
+            for (i = ka.length - 1; i >= 0; i--) {
+                if (ka[i] != kb[i])
+                    return false;
+            }
+            //equivalent values for every corresponding key, and
+            //~~~possibly expensive deep test
+            for (i = ka.length - 1; i >= 0; i--) {
+                key = ka[i];
+                if (!_deepEqual(a[key], b[key])) return false;
+            }
+            return true;
+        }
+
+        // 8. The non-equivalence assertion tests for any deep inequality.
+        // assert.notDeepEqual(actual, expected, message_opt);
+
+        assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
+            if (_deepEqual(actual, expected)) {
+                fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);
+            }
+        };
+
+        // 9. The strict equality assertion tests strict equality, as determined by ===.
+        // assert.strictEqual(actual, expected, message_opt);
+
+        assert.strictEqual = function strictEqual(actual, expected, message) {
+            if (actual !== expected) {
+                fail(actual, expected, message, '===', assert.strictEqual);
+            }
+        };
+
+        // 10. The strict non-equality assertion tests for strict inequality, as
+        // determined by !==.  assert.notStrictEqual(actual, expected, message_opt);
+
+        assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
+            if (actual === expected) {
+                fail(actual, expected, message, '!==', assert.notStrictEqual);
+            }
+        };
+
+        function expectedException(actual, expected) {
+            if (!actual || !expected) {
+                return false;
+            }
+
+            if (Object.prototype.toString.call(expected) == '[object RegExp]') {
+                return expected.test(actual);
+            } else if (actual instanceof expected) {
+                return true;
+            } else if (expected.call({}, actual) === true) {
+                return true;
+            }
+
+            return false;
+        }
+
+        function _throws(shouldThrow, block, expected, message) {
+            var actual;
+
+            if (util.isString(expected)) {
+                message = expected;
+                expected = null;
+            }
+
+            try {
+                block();
+            } catch (e) {
+                actual = e;
+            }
+
+            message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +
+                (message ? ' ' + message : '.');
+
+            if (shouldThrow && !actual) {
+                fail(actual, expected, 'Missing expected exception' + message);
+            }
+
+            if (!shouldThrow && expectedException(actual, expected)) {
+                fail(actual, expected, 'Got unwanted exception' + message);
+            }
+
+            if ((shouldThrow && actual && expected &&
+                !expectedException(actual, expected)) || (!shouldThrow && actual)) {
+                throw actual;
+            }
+        }
+
+        // 11. Expected to throw an error:
+        // assert.throws(block, Error_opt, message_opt);
+
+        assert.throws = function (block, /*optional*/ error, /*optional*/ message) {
+            _throws.apply(this, [true].concat(pSlice.call(arguments)));
+        };
+
+        // EXTENSION! This is annoying to write outside this module.
+        assert.doesNotThrow = function (block, /*optional*/ message) {
+            _throws.apply(this, [false].concat(pSlice.call(arguments)));
+        };
+
+        assert.ifError = function (err) {
+            if (err) {
+                throw err;
+            }
+        };
+    });
+    
+
+    (function () {
+
+        // es5-safe
+        // ----------------
+        // Provides compatibility shims so that legacy JavaScript engines behave as
+        // closely as possible to ES5.
+        //
+        // Thanks to:
+        //  - http://es5.github.com/
+        //  - http://kangax.github.com/es5-compat-table/
+        //  - https://github.com/kriskowal/es5-shim
+        //  - http://perfectionkills.com/extending-built-in-native-objects-evil-or-not/
+        //  - https://gist.github.com/1120592
+        //  - https://code.google.com/p/v8/
+
+
+        var OP = Object.prototype;
+        var AP = Array.prototype;
+        var FP = Function.prototype;
+        var SP = String.prototype;
+        var hasOwnProperty = OP.hasOwnProperty;
+        var slice = AP.slice;
+
+
+        /*---------------------------------------*
+         * Function
+         *---------------------------------------*/
+
+        // ES-5 15.3.4.5
+        // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Function/bind
+        FP.bind || (FP.bind = function (that) {
+            var target = this;
+
+            // If IsCallable(func) is false, throw a TypeError exception.
+            if (typeof target !== 'function') {
+                throw new TypeError('Bind must be called on a function');
+            }
+
+            var boundArgs = slice.call(arguments, 1);
+
+            function bound() {
+                // Called as a constructor.
+                if (this instanceof bound) {
+                    var self = createObject(target.prototype);
+                    var result = target.apply(
+                        self,
+                        boundArgs.concat(slice.call(arguments))
+                    );
+                    return Object(result) === result ? result : self;
+                }
+                // Called as a function.
+                else {
+                    return target.apply(
+                        that,
+                        boundArgs.concat(slice.call(arguments))
+                    );
+                }
+            }
+
+            // NOTICE: The function.length is not writable.
+            //bound.length = Math.max(target.length - boundArgs.length, 0);
+
+            return bound;
+        });
+
+
+        // Helpers
+
+        function createObject(proto) {
+            var o;
+
+            if (Object.create) {
+                o = Object.create(proto);
+            } else {
+                /** @constructor */
+
+                function F() {}
+
+                F.prototype = proto;
+                o = new F();
+            }
+
+            return o;
+        }
+
+
+        /*---------------------------------------*
+         * Object
+         *---------------------------------------*/
+        // http://ejohn.org/blog/ecmascript-5-objects-and-properties/
+
+        // ES5 15.2.3.14
+        // http://whattheheadsaid.com/2010/10/a-safer-object-keys-compatibility-implementation
+        // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Object/keys
+        // https://developer.mozilla.org/en/ECMAScript_DontEnum_attribute
+        // http://msdn.microsoft.com/en-us/library/adebfyya(v=vs.94).aspx
+        Object.keys || (Object.keys = (function () {
+            var hasDontEnumBug = !{
+                toString: ''
+            }.propertyIsEnumerable('toString');
+            var DontEnums = [
+                'toString',
+                'toLocaleString',
+                'valueOf',
+                'hasOwnProperty',
+                'isPrototypeOf',
+                'propertyIsEnumerable',
+                'constructor'
+            ];
+            var DontEnumsLength = DontEnums.length;
+
+            return function (o) {
+                if (o !== Object(o)) {
+                    throw new TypeError(o + ' is not an object');
+                }
+
+                var result = [];
+
+                for (var name in o) {
+                    if (hasOwnProperty.call(o, name)) {
+                        result.push(name);
+                    }
+                }
+
+                if (hasDontEnumBug) {
+                    for (var i = 0; i < DontEnumsLength; i++) {
+                        if (hasOwnProperty.call(o, DontEnums[i])) {
+                            result.push(DontEnums[i]);
+                        }
+                    }
+                }
+
+                return result;
+            };
+
+        })());
+
+
+        // ES5 1.8.5
+        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames
+        Object.getOwnPropertyNames || (Object.getOwnPropertyNames = function (obj) {
+            var keys = [];
+
+            // Only iterate the keys if we were given an object, and
+            // a special check for null, as typeof null == "object"
+            if (typeof obj === "object" && obj !== null) {
+                // Use a standard for in loop
+                for (var x in obj) {
+                    // A for in will iterate over members on the prototype
+                    // chain as well, but Object.getOwnPropertyNames returns
+                    // only those directly on the object, so use hasOwnProperty.
+                    if (obj.hasOwnProperty(x)) {
+                        keys.push(x);
+                    }
+                }
+            }
+
+            return keys;
+        });
+
+
+
+        /*---------------------------------------*
+         * Array
+         *---------------------------------------*/
+        // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array
+        // https://github.com/kangax/fabric.js/blob/gh-pages/src/util/lang_array.js
+
+        // ES5 15.4.3.2
+        // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/isArray
+        Array.isArray || (Array.isArray = function (obj) {
+            return OP.toString.call(obj) === '[object Array]';
+        });
+
+
+        // ES5 15.4.4.18
+        // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/array/foreach
+        AP.forEach || (AP.forEach = function (fn, context) {
+            for (var i = 0, len = this.length >>> 0; i < len; i++) {
+                if (i in this) {
+                    fn.call(context, this[i], i, this);
+                }
+            }
+        });
+
+
+        // ES5 15.4.4.19
+        // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map
+        AP.map || (AP.map = function (fn, context) {
+            var len = this.length >>> 0;
+            var result = new Array(len);
+
+            for (var i = 0; i < len; i++) {
+                if (i in this) {
+                    result[i] = fn.call(context, this[i], i, this);
+                }
+            }
+
+            return result;
+        });
+
+
+        // ES5 15.4.4.20
+        // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/filter
+        AP.filter || (AP.filter = function (fn, context) {
+            var result = [],
+                val;
+
+            for (var i = 0, len = this.length >>> 0; i < len; i++) {
+                if (i in this) {
+                    val = this[i]; // in case fn mutates this
+                    if (fn.call(context, val, i, this)) {
+                        result.push(val);
+                    }
+                }
+            }
+
+            return result;
+        });
+
+
+        // ES5 15.4.4.16
+        // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/every
+        AP.every || (AP.every = function (fn, context) {
+            for (var i = 0, len = this.length >>> 0; i < len; i++) {
+                if (i in this && !fn.call(context, this[i], i, this)) {
+                    return false;
+                }
+            }
+            return true;
+        });
+
+
+        // ES5 15.4.4.17
+        // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/some
+        AP.some || (AP.some = function (fn, context) {
+            for (var i = 0, len = this.length >>> 0; i < len; i++) {
+                if (i in this && fn.call(context, this[i], i, this)) {
+                    return true;
+                }
+            }
+            return false;
+        });
+
+
+        // ES5 15.4.4.21
+        // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/reduce
+        AP.reduce || (AP.reduce = function (fn /*, initial*/ ) {
+            if (typeof fn !== 'function') {
+                throw new TypeError(fn + ' is not an function');
+            }
+
+            var len = this.length >>> 0,
+                i = 0,
+                result;
+
+            if (arguments.length > 1) {
+                result = arguments[1];
+            } else {
+                do {
+                    if (i in this) {
+                        result = this[i++];
+                        break;
+                    }
+                    // if array contains no values, no initial value to return
+                    if (++i >= len) {
+                        throw new TypeError('reduce of empty array with on initial value');
+                    }
+                }
+                while (true);
+            }
+
+            for (; i < len; i++) {
+                if (i in this) {
+                    result = fn.call(null, result, this[i], i, this);
+                }
+            }
+
+            return result;
+        });
+
+
+        // ES5 15.4.4.22
+        // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/reduceRight
+        AP.reduceRight || (AP.reduceRight = function (fn /*, initial*/ ) {
+            if (typeof fn !== 'function') {
+                throw new TypeError(fn + ' is not an function');
+            }
+
+            var len = this.length >>> 0,
+                i = len - 1,
+                result;
+
+            if (arguments.length > 1) {
+                result = arguments[1];
+            } else {
+                do {
+                    if (i in this) {
+                        result = this[i--];
+                        break;
+                    }
+                    // if array contains no values, no initial value to return
+                    if (--i < 0)
+                        throw new TypeError('reduce of empty array with on initial value');
+                }
+                while (true);
+            }
+
+            for (; i >= 0; i--) {
+                if (i in this) {
+                    result = fn.call(null, result, this[i], i, this);
+                }
+            }
+
+            return result;
+        });
+
+
+        // ES5 15.4.4.14
+        // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/indexOf
+        AP.indexOf || (AP.indexOf = function (value, from) {
+            var len = this.length >>> 0;
+
+            from = Number(from) || 0;
+            from = Math[from < 0 ? 'ceil' : 'floor'](from);
+            if (from < 0) {
+                from = Math.max(from + len, 0);
+            }
+
+            for (; from < len; from++) {
+                if (from in this && this[from] === value) {
+                    return from;
+                }
+            }
+
+            return -1;
+        });
+
+
+        // ES5 15.4.4.15
+        // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/indexOf
+        AP.lastIndexOf || (AP.lastIndexOf = function (value, from) {
+            var len = this.length >>> 0;
+
+            from = Number(from) || len - 1;
+            from = Math[from < 0 ? 'ceil' : 'floor'](from);
+            if (from < 0) {
+                from += len;
+            }
+            from = Math.min(from, len - 1);
+
+            for (; from >= 0; from--) {
+                if (from in this && this[from] === value) {
+                    return from;
+                }
+            }
+
+            return -1;
+        });
+
+
+        /*---------------------------------------*
+         * String
+         *---------------------------------------*/
+
+        // ES5 15.5.4.20
+        // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/String/trim
+        // http://blog.stevenlevithan.com/archives/faster-trim-javascript
+        // http://jsperf.com/mega-trim-test
+        SP.trim || (SP.trim = (function () {
+
+            // http://perfectionkills.com/whitespace-deviations/
+            var whiteSpaces = [
+
+                '\\s',
+                //'0009', // 'HORIZONTAL TAB'
+                //'000A', // 'LINE FEED OR NEW LINE'
+                //'000B', // 'VERTICAL TAB'
+                //'000C', // 'FORM FEED'
+                //'000D', // 'CARRIAGE RETURN'
+                //'0020', // 'SPACE'
+
+                '00A0', // 'NO-BREAK SPACE'
+                '1680', // 'OGHAM SPACE MARK'
+                '180E', // 'MONGOLIAN VOWEL SEPARATOR'
+
+                '2000-\\u200A',
+                //'2000', // 'EN QUAD'
+                //'2001', // 'EM QUAD'
+                //'2002', // 'EN SPACE'
+                //'2003', // 'EM SPACE'
+                //'2004', // 'THREE-PER-EM SPACE'
+                //'2005', // 'FOUR-PER-EM SPACE'
+                //'2006', // 'SIX-PER-EM SPACE'
+                //'2007', // 'FIGURE SPACE'
+                //'2008', // 'PUNCTUATION SPACE'
+                //'2009', // 'THIN SPACE'
+                //'200A', // 'HAIR SPACE'
+
+                '200B', // 'ZERO WIDTH SPACE (category Cf)
+                '2028', // 'LINE SEPARATOR'
+                '2029', // 'PARAGRAPH SEPARATOR'
+                '202F', // 'NARROW NO-BREAK SPACE'
+                '205F', // 'MEDIUM MATHEMATICAL SPACE'
+                '3000' //  'IDEOGRAPHIC SPACE'
+
+            ].join('\\u');
+
+            var trimLeftReg = new RegExp('^[' + whiteSpaces + ']+');
+            var trimRightReg = new RegExp('[' + whiteSpaces + ']+$');
+
+            return function () {
+                return String(this).replace(trimLeftReg, '').replace(trimRightReg, '');
+            }
+
+        })());
+
+
+        /*---------------------------------------*
+         * Date
+         *---------------------------------------*/
+
+        // ES5 15.9.4.4
+        // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Date/now
+        Date.now || (Date.now = function () {
+            return +new Date;
+        });
+
+    })();
+
+
+    /*
+    json2.js
+    2013-05-26
+
+    Public Domain.
+
+    NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
+
+    See http://www.JSON.org/js.html
+
+
+    This code should be minified before deployment.
+    See http://javascript.crockford.com/jsmin.html
+    */
+
+
+    if (typeof JSON !== 'object') {
+        JSON = {};
+    }
+
+    (function () {
+        'use strict';
+
+        function f(n) {
+            return n < 10 ? '0' + n : n;
+        }
+
+        if (typeof Date.prototype.toJSON !== 'function') {
+
+            Date.prototype.toJSON = function () {
+
+                return isFinite(this.valueOf()) ? this.getUTCFullYear() + '-' +
+                    f(this.getUTCMonth() + 1) + '-' +
+                    f(this.getUTCDate()) + 'T' +
+                    f(this.getUTCHours()) + ':' +
+                    f(this.getUTCMinutes()) + ':' +
+                    f(this.getUTCSeconds()) + 'Z' : null;
+            };
+
+            String.prototype.toJSON =
+                Number.prototype.toJSON =
+                Boolean.prototype.toJSON = function () {
+                    return this.valueOf();
+            };
+        }
+
+        var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
+            escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
+            gap,
+            indent,
+            meta = {
+                '\b': '\\b',
+                '\t': '\\t',
+                '\n': '\\n',
+                '\f': '\\f',
+                '\r': '\\r',
+                '"': '\\"',
+                '\\': '\\\\'
+            },
+            rep;
+
+
+        function quote(string) {
+
+            escapable.lastIndex = 0;
+            return escapable.test(string) ? '"' + string.replace(escapable, function (a) {
+                var c = meta[a];
+                return typeof c === 'string' ? c : '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+            }) + '"' : '"' + string + '"';
+        }
+
+
+        function str(key, holder) {
+
+            var i,
+                k,
+                v,
+                length,
+                mind = gap,
+                partial,
+                value = holder[key];
+
+            if (value && typeof value === 'object' &&
+                typeof value.toJSON === 'function') {
+                value = value.toJSON(key);
+            }
+
+            if (typeof rep === 'function') {
+                value = rep.call(holder, key, value);
+            }
+
+            switch (typeof value) {
+            case 'string':
+                return quote(value);
+
+            case 'number':
+
+                return isFinite(value) ? String(value) : 'null';
+
+            case 'boolean':
+            case 'null':
+
+                return String(value);
+
+
+            case 'object':
+
+
+                if (!value) {
+                    return 'null';
+                }
+
+
+                gap += indent;
+                partial = [];
+
+
+                if (Object.prototype.toString.apply(value) === '[object Array]') {
+
+
+                    length = value.length;
+                    for (i = 0; i < length; i += 1) {
+                        partial[i] = str(i, value) || 'null';
+                    }
+
+
+                    v = partial.length === 0 ? '[]' : gap ? '[\n' + gap + partial.join(',\n' + gap) + '\n' + mind + ']' : '[' + partial.join(',') + ']';
+                    gap = mind;
+                    return v;
+                }
+
+
+                if (rep && typeof rep === 'object') {
+                    length = rep.length;
+                    for (i = 0; i < length; i += 1) {
+                        if (typeof rep[i] === 'string') {
+                            k = rep[i];
+                            v = str(k, value);
+                            if (v) {
+                                partial.push(quote(k) + (gap ? ': ' : ':') + v);
+                            }
+                        }
+                    }
+                } else {
+
+                    for (k in value) {
+                        if (Object.prototype.hasOwnProperty.call(value, k)) {
+                            v = str(k, value);
+                            if (v) {
+                                partial.push(quote(k) + (gap ? ': ' : ':') + v);
+                            }
+                        }
+                    }
+                }
+
+                v = partial.length === 0 ? '{}' : gap ? '{\n' + gap + partial.join(',\n' + gap) + '\n' + mind + '}' : '{' + partial.join(',') + '}';
+                gap = mind;
+                return v;
+            }
+        }
+
+        if (typeof JSON.stringify !== 'function') {
+            JSON.stringify = function (value, replacer, space) {
+
+                var i;
+                gap = '';
+                indent = '';
+
+
+                if (typeof space === 'number') {
+                    for (i = 0; i < space; i += 1) {
+                        indent += ' ';
+                    }
+
+
+                } else if (typeof space === 'string') {
+                    indent = space;
+                }
+
+
+                rep = replacer;
+                if (replacer && typeof replacer !== 'function' &&
+                    (typeof replacer !== 'object' ||
+                        typeof replacer.length !== 'number')) {
+                    throw new Error('JSON.stringify');
+                }
+
+                return str('', {
+                    '': value
+                });
+            };
+        }
+
+        if (typeof JSON.parse !== 'function') {
+            JSON.parse = function (text, reviver) {
+
+                var j;
+
+                function walk(holder, key) {
+
+                    var k, v, value = holder[key];
+                    if (value && typeof value === 'object') {
+                        for (k in value) {
+                            if (Object.prototype.hasOwnProperty.call(value, k)) {
+                                v = walk(value, k);
+                                if (v !== undefined) {
+                                    value[k] = v;
+                                } else {
+                                    delete value[k];
+                                }
+                            }
+                        }
+                    }
+                    return reviver.call(holder, key, value);
+                }
+
+                text = String(text);
+                cx.lastIndex = 0;
+                if (cx.test(text)) {
+                    text = text.replace(cx, function (a) {
+                        return '\\u' +
+                            ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+                    });
+                }
+
+                if (/^[\],:{}\s]*$/
+                    .test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@')
+                        .replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']')
+                        .replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
+
+                    j = eval('(' + text + ')');
+
+                    return typeof reviver === 'function' ? walk({
+                        '': j
+                    }, '') : j;
+                }
+
+                throw new SyntaxError('JSON.parse');
+            };
+        }
+    }());
+
+
+    global.console = require('console');
+
+}(this, {}));
+
+WScript.Sleep(500);
+
+/*
+:cmd
+::if %errorlevel% == 0 exit
+pause>nul
+::*/
\ No newline at end of file
diff --git a/test/README.md b/test/README.md
deleted file mode 100644
index de88b06..0000000
--- a/test/README.md
+++ /dev/null
@@ -1,43 +0,0 @@
-#	HTML重构稿局部模板更新工具
-
-![banner](./banner.jpg)
-
-##	工具介绍
-
-css 有 import 语句可以引入外部的 css 文件，重构的同学很容易基于它实现公用样式的复用，但是 HTML 就没有这么幸运了，唯一能利用的似乎只有 iframe 标签，但是它因为它不受页面样式控制，几乎不可用来嵌入公用模板。要是HTML也能支持 include 语句那是多么幸福的事情啊！于是便有了这个小工具的诞生，使用它可以让重构页面支持类似 include 语句，方便批量更新公用模板，如头部与底部。
-
-##	快速入门
-
-###	include 语句
-
-编写页面的时候，在需要动态更新的地方使用特殊注释包裹即可，例如：
-
-```
- <!--[include './public/header.html']-->
-    <div id="header">
-        <ul class="nav">
-            <li><a href="./index.html">Home</a></li>
-            <li><a href="./news.html">News</a></li>
-            <li><a href="./about.html">about</a></li>
-        </ul>
-    </div>
- <!--[/include]-->
-```
-###	批量更新模板
-
-双击打开 includeHTML.bat，它会替换 include 注释包裹的 HTML 为'./public/header.html'的内容。
-
->	Tips: 你可以将 includeHTML.bat 放置在页面 SVN 目录
-
-##	运行演示例子
-
-下载程序包后，test 目录有一些演示的页面，其中 test/public 目录中放了一些公用模板，你可以尝试修改这些模板，双击 includeHTML.bat 后所有调用公用模板页面将会更新。
-
-
-##	常见问题
-
-1.	如何支持非 utf-8 编码的模板？答：使用右键直接修改程序源码配置即可。
-2.	如何指定单个文件处理，而不是处理整个目录？答：拖拽 HTML 文件到程序图标上松开即可。
-3.	如在 Mac 上运行？答：安装 nodejs，然后使用 nodejs 运行 includeHTML.js 即可。
-
->	注：封面 banner 模特为重构MM —— fufu
\ No newline at end of file
diff --git a/test/Thumbs.db b/test/Thumbs.db
deleted file mode 100755
index b230db000f3e4c4d2cd657af53dcda2ad7084999..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 7168
zcmeHMXH*o+wr=8p#33qS1|%oRFbD{Ugb|e_X-E=fKtOU*P%<czqhydAL`Dz<1PMcu
zFytVDL=gle!vJr%=iT#M_r9~%4ZrSt=j-)#@7`6_wZGa`)oXPR^n+(}s+i`0zri(t
z060A(1&Dv~<KgUc{sq(kfR8iI?@!Op&VF+O0M7gq|3M>gf{XP$f9E_05iXJEIS1iL
zf+H!87jPuQksQar*88pYpXdMd5zqmgafds=2B-i|xT`DRgUj+i4hDee_cj0f-tY&_
zsqMUPKCSG-`*pt%10(?{z#OmvV7RLoAd0gj0V^EE0SUkw=aax47Ju+W0N@Ak@qW$0
zA6EROfDmW*f`4)Ro8~{;|G(MY-!=bt`v0}<pZ5R15x9t(O$0ciaO>fG{pQC+2qqkP
z^8MW;`_u7%as>V;|7YW8vjFu?Rk$jEhxgwb``Hwr3=k0z5)u*+;Z8(EM8qI+5)ckl
zWMrh|U@96KFcla~%fP}&OUFbH247^q$i&JDg+gf=FLPdoaI!$4kn@M&;hKVoL6jsU
zln^>F9ps<JSu+480c7z20=&xrJ{XSxjCa-sKyg!;2p8?|0psrR2?%jfl8{~?!&P`o
zjeA=V5a8qD#|gldKE{;;gkT~Xc2Ol_T5Su^WfwZJr?ELC9M`K_=ye7+ImInq14%D1
zFkZaG#Kq0S%f~MvDJ2b)xvG3aMO955epC0Zp1y&h5yHya#`eA)(%#M8!_&*#$2TZA
zBs45MA~G&MAu%aAB{eNKFaK3RVNr3(n`+eCn%Z}D^&eZ?+B?vlUEP?W;gQj?@rlW~
zuk#CwOUo<YR=0j`@9ggF9~>T?>pIu@SNt{$|3()WrwbpK7DCXuE<Aj%bKzh@B6d+?
z8YOLzg$wOvv8N<-*JE?4T1Yv>bvEfOT?a2Pa7xT^ZJkT|i?V-ASm3{;>~~@RqiYf%
zC&0rcj{poP07qly^@h2z;@uzn0ut{x4?O!Ou@=IZ^gh8iw&gUjv;^s5ruI++%=tQ{
zdh#7}`Qsh39*qDR<dSqKEsJzM>&vHycjg8lyJNTc1a2(2CNR6L?#L5=%H@@cyHKQ0
zXyqjEa!U?>kF@vD*uv=s_Z4ePG;&^EhF+-5cl1>eS+R$PK4x<2@f$@MACeY9w@$N>
zo&&GeQ})f}h%2_Iqkb6-dOxSuts7!hQ#yvyDf$fYUIa;O4(F)ULd`z}q{33VQ8K!<
zSZVVs1vO!_?^!{2BB`j1lqojiXxFc#s0TF6T4URmvYh9r$dNVMt4s}1zMbUBj0T#)
z`>-=$cg)naXU~%vBca&@Z`OW3mU2+4Ip)u9O2#UsROszAQMH$<M7)mP;@{<$_1rL0
z6G4x(9m9H((lpXc&Fv~V9}ahkkRHQzbdqZH2c_TFj6F6U>uc}FKR_#v%9&pY$+a6a
zHj)th`p6M!q>g3{CEc&cYM)^+b-NYUYdU@X;ynq?Q0Q0rQrhMZ<nCW6>^D~j?7h4g
z!2*2bB}J~HLzUl6v%-bPZewig6}+zuL&|*hEKT@t_S`)_16pJ^Q5hs$Hq4HWLi<pm
zN7o0q25cPso=v$|8BAtsEKad%;1g507?4?<B#OKZM|^Bu;yJNyI#JLZ*saWNK;|NS
z!$NF^HoBkH(e*6T2F5|ut|k5~Z(r=lD(<mbK-o(3Vnmze-|^HAW%>U6F66^ewK}k$
z*DoBt_(=HyM@ninjWmC-Mfi~?)*-pU!+_nuIU6lG=`cE#I!P@4J{>g<gM6$re#!8h
zAy%DdthjuoROpudMy_bSpbz1&Vv{%L{h11r8wOnO@JqyL{8g|HIpP_mki<=4bTR~g
z%LI|FB<Ly}FSZP_V9Q!G&pzVLaV|wN)F<W#s$a1*va*;4r(vsWEyG;oB9Fi9DUaHW
zG*KhavJ8HFGt;yugMkXlh?dWWi>1uhoR%viJ$QT(54woxbT|aE-S2g)DuLJ{iG}E1
zbVnMc@IQ@%H{-t~uhOLXL>|HEBvui|9#$j)9P!H(h5`l1yl6Kf(=}rF3bEgy+-7r5
zVHzwU9e)kzpI4;O)|UMArk=y(#-$EzjpwiTc8kscl%Qx<t+Cam{<KDgt3b7iYISp8
zQMIbknCp{PL3y>JoWc+;u-sr-u+yX=L9~gl7Gc8Ohnj?|2-3U+N>Wvd=<fV%{7Bwx
z()lsLsD&DgI>*l`J6k!XIxh!@$9R!TBo&uky6Z!A1mZ{Jq&~UbXKjd<a8)Pja#96x
z9y7i7`bz({Aq}RwlJh(t8Qp}nf@V0%3Esc2^yTQ}&P|yN#1#i-db*7GjmH5*79Q)A
zXTUm{U;gx(wVv_=G)X6k?A_@1>H2y*+pA`bjn!K$n3X3fLDMnU^pRqs<K$0dDkk|7
zbE5LuHHu(zdXKGcy%|AGppFk1{E*2G9lns0dVL4FLptu7iCyz0_p*A?Ha}lo`{Rxy
z*;9c9m-^EWEcy_8Z~w>kH&PH0d3T9b=P7El682ym-)=R2*y8^-DAr|T;~_w@zUDa8
z7yELc^NTR6;S<H(vhB@nz0JjAvjef8{f|Cye^w$xX?(GARk(FLaw2@YF33d6ZI#xZ
zX=lsw$0m2@I@^yb$|sqrP{b(s`Iq+&LID+DMxIqh?osb=cw*ol&erv{2SUaJ-yexW
z@*pWecZYS3mh-w;l;|L{Rz>?|nvAAgqXkKI#LS{g@D-CCdW=br^DCqyn^w#eIz)R-
zgviG!r?j2ZRjuLhO(((@?KaskxqH`{V=(8AF3P+&r`QbCh%9)naj72^<IpatK)T9Q
z8%4t>xTbq2lq>3bu)b9$Gt|3^b72SF=oeDv^0}AemI%F*!i8^`)zN)SGvNS@cJ)x8
zLb=QJJb3vJ&u;$x@xysElWA?(MpWb^DOooE^?L*>Ze}iD{aBw?a4M3yYsnf+`ipIj
zyr`qTkuH$y2<26%5H}aY>I^cg4!5UAYS0)(uzm>JmYA0@Pu>Dugl+qS!lx0b1<tT_
z?LK({sc(voB~nEdwOXNcGu>i%3rAmHSC&(ymrPT<j~*)bQge$`wZ%}A?@I1#uIWD5
z#IlP^!{3so`aj`614JC=a-}s;p3C${T*t5#jGZ}&yRnS!gJ|lEu$=fM^mk+BQW=4j
zIC<LV7>w7eQW2S~i29TMFgY%l#}-JUb!=J9p68Gh12SJ$PqXF@d<{>&G-623qs-_a
zLQXh;g~{ZqO+htrG#Q6jag-(1LoN4{@%bT`8GL@=kx3@h*jQtOx~-BvsyUO`#+H;<
zAMbUex6oK*PpB{<*Iuf7((7j-4iRg8XfA|4u|E1%HD%#uyMUBVf=;!}8F1;KRA(4_
zA-Yf~mx>l#_$}ORi7hep)*8HHBv>xrD(c-*b=fIr!80#t*!ly(ydg&q;k6#Pa?PNF
z1LbjDM2ASqPqgJB%b3djf=ALd^+ONJQR80YpHVf+*3YYY?~(_)!t?=x=8GL7{LIc&
zSdloHOjZU)L(JT?gidUYC$SloX|LOh&#JtOF~hlTnLJzUqmMN5&FyQpR0<C~2OE?n
z<FG@drU+T}^fTbmh8I7G$e>c!8C{=QS@G=@I<SH2v2ZInNaCsq*}q|3Q)`ZreSOd9
zn%&+{@lX(fWKF$!D@@}1+tZ$K<1ZftdARxDiL^XOp7dqT*9+-1Zjos-Q*%4g_3~J)
zLoX>&t2>t41T;;v<Aj^WR!;pwFWl4wD7{k#TRpyNMw2=hjZY~#&NUKsF>EKdjXBZ#
zJC-PcKekyFtSx2Dl?&V%_Lp?{PMqNYiJ$w-GzAYN3Mau%JiE<JEE*FCJ{Z$2XrB|H
zqFF^`<oPg_PaS$y48c=x;;SmNQ0K9++#`P)nK$=rgTU}wY4OUN+qBbHZ~HIwb*MQf
z$WW!%0@kj?pj*0&mdk2F^WR@m5OicxjC|Fr#kk9!0c&oxJSQHd*vwfl09gz}IEP%h
z1*Jaa@Xj(|FBp>Ofi2CrzRu!@_d2Z5LquGL7c$`$1%2i~3z9G*IZ&h3hjEe#37VvH
z+6G)7evxvU-X6Xi_Hl+Z*10^Ox`Nf?%gjts(ro!MV0)dJq6Jv4!F$z>?ky9aZAxVf
zYr5p^*}Z_KSX_YGB^u*p`gq-%pN{%;aAEy>+~!GP&{$iJ`$*dDJKcQulqIUW7TIhJ
z$d+jGV)CLFO&w(olYac5(^kQkOcNosK7^M&*45NVay$%Kfaou1DP4E<4?Y@QqI9K@
zd?E)Pt13edC$J7qAc6(dlI&N$Vm<b{Za3)LuRHZDT7WLH#Ajur=Mh51P^uMA>OQ*9
zCRa<8-(}P-Hg>X{2G%Ur;4`R?JXF2#x;rhW2&tbO=QHNQI;c3v!-kh`9W<2<jq+>-
zlYW#~Y8*Mplzi~!E&p4Wi$2Fc;R0*P<_FMNXZY~?TiByc*TM>Pvtu2blsu&v|Ew1C
z!&L{yk7?F>B5<Lv(Wq-+RV6-}laWrqH&foha>;IeeIZkSipAb2I-9=7Oe9J*dq-Z5
zZgn{4(x`s&=L7d08HI4^f*VW^gah+>6OIDh0}ww=ug=_7K*SmM#0z>gm)%7FNR)&2
zNLD$|lR48~d%LH6yy8I|(&v^4+&dAw=ue+0j~b(S%A;^!HpgO^<qXIgZKxl)ylm@d
zh`_<*2bM3lS;saLz~EaODZ8^gdWZdF>pf)d&FcQ0lG`cYv!n^S#XODMh~fpMc`0{n
z`^~>0_8`or8rqM|W=T4=nha$w{cs?w{n3WeT8MY!HEx`V%_Uo6-wWbgI~1w~F$b{t
z({F!x{+2n5RgF9EBul7qHHrK3Lb1y1n>gY*Ow+5;Ui}*3ONw2nV%=$jK<_tqF;0~p
z#m=S^Y<Ag3i`{Mc(dMu07wMUebtV126zVoRm76Y#yq*kyxKu5vuNSg}7MEh2P~$l=
zFx;1#oHCJc1+?PX2#_(5U_S${astjKM2ySNtwFU{9v_|d?#s=VyYsYWTnL~(=!aus
zFQx5mQAgkS+=T_WKWMnWv|E=rD9<&mYI}Ou7x!DC>FP<01esrdgpeN_5o*eEE9m5_
z)bg(6o<DxJ_BT`ajCr@-Hl(a4wMU^Y2=UlhR1B+`+fs=P(|ng{Xk`^QI4@7~gQ{Hn
z3<y@!6j6*4TvESmH=iQKg713O*X?jjMMW0HAQLp3A!v3|A#?wQ_GNVvj*|IduV!rV
za?6qbgx>u+GX4;@*RaD@7c?tyWB^xT=@ooogasGC3tDYB_sK7NT5zjwq*TG?gSI`s
zYnl@yOEzI?jsw{$Ftdm4PvtziumMcpit<uJV#708BW3HHEE_T)@JXu>-EFZ%c~xI1
zrh2E6VB*_ovS-z*G=^(HaY>c10;A6F($ZB?5h;^m#4@<)nK@{DW9X*N#6H_(e%AXI
zPV3EgM@&OZ#$~V7lZS+3p-GYSE<w-t&H!uuL^{)u=knsM`ZY``!<Kb*$ex?#E*Aqt
zYpK0=Td)GIk$loFA#~b`OfkK!;O=}80v;Bo*Z~>P&?~9wji(wvk+E^ylT?tzen(9u
zd1~yNn7Te++k6`x5yi_%kp}#28ek)hFqlH?WJAwh^p=~qa|;b(qDgq8KarA(L;eh?
zoHKi6E_jOB{v_SbZ0uug8!F(~8N8XlU$*+GgCb2kFadL)c5|yzLPp0B>cX*Kf(`>!
zI1GWp9VhT^csS*Q)8=+0%oEn>2SW6;u0KB!=<xD|pvvn;4}9k}>l=+ApBrXXFBHlh
zkKJox3!UVSpiB1zaTgu<V`i91$hAu1p2S^^k9;x1JKo)nC;KvO7kSUhdTMy9#EPqT
z4F!Wf%K~SqR>#g)`>;?FND)0M|LRQr-Jfq%?(@yLhD6SA-SDv$*%OEH4@i6+SRx$n
z)$&Y(!fl{o&4(izQ%_H#n-pBKUCe4kwB7g~8yu*c4eNg^6oeYn=2cmEn0=1`UPj&n
z@#8K30<@6Na96>t^mRo#6|@cY5<kC)yg696C%iT?TMDH(fJ=h$&j35KZ1J0FvYPDv
zfsGa~1Oz^+SFObG^J=3WUJFFcG?KKd@aDBAOi#tH^0TDH<vc6DeLHZRH#buG0&nh<
O|BVV~6aUHws{aCRY(EzO

diff --git a/test/banner.jpg b/test/banner.jpg
deleted file mode 100644
index 62b8cf8c9654905f5eed1318e24936f4fb29a4b9..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 31947
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
Rk3KW4+!8?v#{Reb{{ix4nx6mw

diff --git a/test/includeHTML.bat b/test/includeHTML.bat
deleted file mode 100644
index 6d7bab5..0000000
--- a/test/includeHTML.bat
+++ /dev/null
@@ -1,1402 +0,0 @@
-@if (0===0) @end/*!node2bat | https://github.com/aui/node2bat | sugarpie.tang@gmail.com
-@echo off
-title loading..
-cd %~dp0
-call CScript.EXE "%~dpnx0" //Nologo //e:jscript %*
-title node
-goto cmd
--------------------------------*/
-(function () {
-
-console.log('[HTML\u5c40\u90e8\u6a21\u677f\u66f4\u65b0\u5de5\u5177]');
-console.log('@version: 0.0.1')
-console.log('\u4f1a\u81ea\u52a8\u66f4\u65b0\u5982\u4e0b\u6ce8\u91ca\u683c\u5f0f\u6807\u8bb0\u5c40\u90e8\u6a21\u677f\uff1a\n')
-console.log('<!--[include \'./public/header.html\']-->\n    ...\n<!--[/include]-->\n');
-console.log('------------------------------');
-
-var fs = require('fs');
-var path = require('path');
-
-var charset = 'utf-8'; // \u8bbe\u7f6e\u6a21\u677f\u7684\u7f16\u7801
-var EXTNAME_RE = /\.(html|htm|tpl)$/i;
-var INCLUDE_RE = /([\s\t]*)<!--\s*\[include\s*['"]*(.*?)['"]*\]\s*-->([\w\W]*?)<!--\s*\[\/include\]\s*-->/ig;
-var args = process.argv.slice(2);
-
-var compile = function (file) {
-	var html = fs.readFileSync(file, charset);
-	
-	console.log(file);
-	
-	html = html.replace(INCLUDE_RE, function ($1, blank, id, innerHTML) {
-
-		var newid = id.split('/').join(path.sep);
-		
-		var dirname = path.dirname(file);
-		var target = path.resolve(dirname, id.split('/').join(path.sep));
-
-		
-		if (fs.existsSync(target)) {
-			innerHTML = fs.readFileSync(target, charset);
-		} else {
-			console.log('Page not found: ' + target);
-		}
-		
-		return blank
-		+ "<!--[include '" + id.split('\\').join('/') + "']-->\n"
-		+ innerHTML
-		+ blank +  "<!--[/include]-->";
-	});
-	
-	fs.writeFileSync(file, html, charset);
-};
-
-
-var walk = function (dir) {
-	var dirList = fs.readdirSync(dir);
-
-	dirList.forEach(function (item) {
-		var target = path.join(dir, item);
-		
-		if (fs.statSync(target).isDirectory()) {
-			walk(target);
-		} else if (EXTNAME_RE.test(target)) {
-			compile(target);
-		}
-	});
-};
-
-if (args.length) {
-	args.forEach(function (target) {
-		if (!fs.existsSync(target)) {
-			return;
-		}
-		
-		if (fs.statSync(target).isDirectory()) {
-			walk(target);
-		} else if (EXTNAME_RE.test(target)) {
-			compile(target);
-		}
-	});
-} else {
-	walk('.\\');
-}
-
-console.log('------------------------------');
-console.log('End');
-
-})// NodeJS Basic API
-(function (global, exports) {
-
-global.global = global;
-
-global.console = {
-	log: function (message) {
-		if (typeof message !== 'string') {
-			message = this.__toSource(message);
-		}
-		
-		WScript.Echo(message);
-	},
-	__toSource: (function () {
-		var getType = function (obj) {
-			var toString = Object.prototype.toString;
-			return obj === null
-			? "Null" : obj === undefined
-			? "Undefined" : toString.call(obj).slice(8, -1);
-		};
-
-		return function toSource (obj) {
-			var type = getType(obj);
-			var string = '';
-			var temp;
-
-			switch (type) {
-				case 'Object':
-
-					temp = [];
-
-					for (var name in obj) {
-						temp.push(
-							JSON.stringify(name) + ':' + toSource(obj[name])
-						);
-					}
-
-					string =  '{' + temp.join(',') + '}';
-
-					break;
-				case 'Array':
-					temp = [];
-					var length = obj.length;
-
-					while (length) {
-						temp[--length] = toSource(obj[length]);
-					}
-
-					string = '[' + temp.join(',') + ']';
-
-					break;
-				case 'String':
-					string = JSON.stringify(obj);
-					break;
-				case 'Undefined':
-					string = 'undefined';
-					break;
-				case 'Boolean':
-				case 'Number':
-				case 'Null':
-					string = obj + '';
-					break;
-				case 'Function':
-
-					temp = obj
-					.toString()
-					.match(/^function\s*(\w+)\s*\(\)\s*\{\s*\[native\s*code\]\s*\}$/);
-
-					if (temp) {
-						string = temp[1];
-					} else {
-						string = obj + '';
-					}
-
-					break;
-				// Namespace
-				default:
-					string = type;
-			}
-
-			return string;
-		};
-	})()
-};
-
-global.process = {
-
-    argv: function () {
-        var Arguments = WScript.Arguments;
-        var length = Arguments.length;
-        var argv = ['node'];
-        
-        if (length) {
-            for (var i = 0; i < length; i ++) {
-                argv.push(Arguments(i));
-            }
-        }
-        
-        return argv;
-    }(),
-	
-	
-    cwd: function () {
-        return WScript
-        .ScriptFullName
-        .replace(WScript.ScriptName, '')
-        .replace(/\\+$/, '');
-    },
-	
-	
-	env: (function () {
-		var env = {};
-		var wsh = new ActiveXObject("WScript.Shell"); 
-		var user = wsh.Environment("User"); 
-		var system = wsh.Environment("System");
-		var list = [
-			'ALLUSERSPROFILE',
-			'APPDATA',
-			'CommonProgramFiles',
-			'COMPUTERNAME',
-			'ComSpec',
-			'configsetroot',
-			'FP_NO_HOST_CHECK',
-			'HOMEDRIVE',
-			'HOMEPATH',
-			'LOCALAPPDATA',
-			'LOGONSERVER',
-			'NUMBER_OF_PROCESSORS',
-			'OS',
-			'Path',
-			'PATHEXT',
-			'PROCESSOR_ARCHITECTURE',
-			'PROCESSOR_IDENTIFIER',
-			'PROCESSOR_LEVEL',
-			'PROCESSOR_REVISION',
-			'ProgramData',
-			'ProgramFiles',
-			'PROMPT',
-			'PSModulePath',
-			'PUBLIC',
-			'SESSIONNAME',
-			'SystemDrive',
-			'SystemRoot',
-			'TEMP',
-			'TMP',
-			'USERDOMAIN',
-			'USERNAME',
-			'USERPROFILE',
-			'windir'
-		];
-		
-		for (var name, info, i = 0; i < list.length; i ++) {
-			name = list[i];
-			info = user.Item(name);
-			if (!info && info !== 0) {
-				info = system.Item(name);
-			}
-			env[name] = info;
-		}
-		
-		return env;
-	})(),
-	
-	
-    exit: function (code) {
-        WScript.Quit(code);
-    },
-	
-	
-    stdout: {
-        write: function (message) {
-            WScript.Echo(message);
-        }
-    }
-};
-
-global.require = function (id) {
-    if (!exports[id]) {
-        throw new Error('Cannot find module \'' + id + '\'');
-    }
-    return exports[id];
-};
-
-
-global.__filename = WScript.ScriptFullName;
-
-global.__dirname = global.process.cwd();
-
-
-exports.fs = {};
-
-(function (exports) {
-
-	var fso = new ActiveXObject('Scripting.FileSystemObject');
-	
-	var fs = {
-
-		renameSync: function (oldPath, newPath) {
-			var statSync = fs.statSync(oldPath);
-			var file = fso[statSync.isFile() ? 'GetFile' : 'GetFolder'](oldPath);
-			file.Move(newPath); 
-		},
-
-		mkdirSync: function (path) {
-			fso.CreateFolder(path);
-		},
-
-		rmdirSync: function (path) {
-			fso.DeleteFolder(path, true);
-		},
-
-		unlinkSync: function (path) {
-			fso.DeleteFile(path, true); 
-		},
-
-		existsSync: function (path) {
-			var statSync = fs.statSync(path);
-			return statSync.isFile() || statSync.isDirectory();
-		},
-
-		statSync: function (path) {
-			return {
-				isFile: function () {
-					return fso.FileExists(path);
-				},
-				isDirectory: function () {
-					return fso.FolderExists(path);
-				}
-			};
-		},
-
-		readdirSync: function (path) {
-
-			var listall = function (path) {
-			
-				var fd = fso.GetFolder(path + '\\');
-				var fe = new Enumerator(fd.files);
-				var list = [];
-				var item;
-				
-				while(!fe.atEnd()) {
-					item = fe.item() + '';
-					item = item.replace(/^.*\\([^\\]*)$/, '$1');
-					list.push(item);
-					fe.moveNext();
-				}
-				
-				var folderList = new Enumerator(fd.SubFolders);
-				for (; !folderList.atEnd(); folderList.moveNext()) {
-					item = folderList.item() + '';
-					item = item.replace(/^.*\\([^\\]*)$/, '$1');
-					list.push(item);
-				}
-				
-				return list;
-			};
-
-			return listall(path);
-		},
-
-		readFileSync: function (file, charset) {
-			var stream = new ActiveXObject('adodb.stream');
-			var fileContent;
-
-			stream.type = charset ? 2 : 1;
-			stream.mode = 3;
-			stream.open();
-
-			if (charset) {
-				stream.charset = charset;
-			}
-			
-			try {
-				stream.loadFromFile(file);
-			} catch (e) {
-				throw e;
-			}
-
-			fileContent = new String(stream.readText());
-			fileContent.charset = charset;
-			stream.close();
-			return fileContent.toString();
-		},
-
-		writeFileSync: function (file, data, charset) {
-			var stream = new ActiveXObject('adodb.stream');
-			
-			stream.type = charset ? 2 : 1;
-
-			if (charset) {
-				stream.charset = charset;
-			}
-			
-			try {
-				stream.open();
-				if (charset) {
-					stream.writeText(data);
-				} else {
-					stream.write(data);
-				}
-				stream.saveToFile(file, 2);
-
-				return true;
-			} catch (e) {
-				throw e;
-			} finally {
-				stream.close();
-			}
-
-			return true;
-		}
-	};
-	
-	for (var name in fs) {
-		exports[name] = fs[name];
-		if (/Sync$/.test(name)) {
-			exports[name.replace(/Sync$/, '')] = (function (main) {
-				return function () {
-					var args = arguments;
-					var error = null;
-					var data = {};
-					var callback = args[args.length - 1];
-					if (typeof callback !== 'function') {
-						callback = function () {};
-					}
-					
-					try {
-						main.apply(global, args);
-					} catch (e) {
-						error = e;
-					}
-					
-					callback(error, data);
-				};
-			})(fs[name]);
-		}
-	}
-
-})(exports.fs);
-
-exports.path = {};
-
-(function (exports) {
-
-	// resolves . and .. elements in a path array with directory names there
-	// must be no slashes, empty elements, or device names (c:\) in the array
-	// (so also no leading and trailing slashes - it does not distinguish
-	// relative and absolute paths)
-	function normalizeArray(parts, allowAboveRoot) {
-	  // if the path tries to go above the root, `up` ends up > 0
-	  var up = 0;
-	  for (var i = parts.length - 1; i >= 0; i--) {
-		var last = parts[i];
-		if (last === '.') {
-		  parts.splice(i, 1);
-		} else if (last === '..') {
-		  parts.splice(i, 1);
-		  up++;
-		} else if (up) {
-		  parts.splice(i, 1);
-		  up--;
-		}
-	  }
-
-	  // if the path is allowed to go above the root, restore leading ..s
-	  if (allowAboveRoot) {
-		for (; up--; up) {
-		  parts.unshift('..');
-		}
-	  }
-
-	  return parts;
-	}
-  // Regex to split a windows path into three parts: [*, device, slash,
-  // tail] windows-only
-  var splitDeviceRe =
-      /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
-
-  // Regex to split the tail part of the above into [*, dir, basename, ext]
-  var splitTailRe =
-      /^([\s\S]*?)((?:\.{1,2}|[^\\\/]+?|)(\.[^.\/\\]*|))(?:[\\\/]*)$/;
-
-  // Function to split a filename into [root, dir, basename, ext]
-  // windows version
-  var splitPath = function(filename) {
-    // Separate device+slash from tail
-    var result = splitDeviceRe.exec(filename),
-        device = (result[1] || '') + (result[2] || ''),
-        tail = result[3] || '';
-    // Split the tail into dir, basename and extension
-    var result2 = splitTailRe.exec(tail),
-        dir = result2[1],
-        basename = result2[2],
-        ext = result2[3];
-    return [device, dir, basename, ext];
-  };
-
-  var normalizeUNCRoot = function(device) {
-    return '\\\\' + device.replace(/^[\\\/]+/, '').replace(/[\\\/]+/g, '\\');
-  };
-
-  // path.resolve([from ...], to)
-  // windows version
-  exports.resolve = function() {
-    var resolvedDevice = '',
-        resolvedTail = '',
-        resolvedAbsolute = false;
-
-    for (var i = arguments.length - 1; i >= -1; i--) {
-      var path;
-      if (i >= 0) {
-        path = arguments[i];
-      } else if (!resolvedDevice) {
-        path = process.cwd();
-      } else {
-        // Windows has the concept of drive-specific current working
-        // directories. If we've resolved a drive letter but not yet an
-        // absolute path, get cwd for that drive. We're sure the device is not
-        // an unc path at this points, because unc paths are always absolute.
-        path = process.env['=' + resolvedDevice];
-        // Verify that a drive-local cwd was found and that it actually points
-        // to our drive. If not, default to the drive's root.
-        if (!path || path.substr(0, 3).toLowerCase() !==
-            resolvedDevice.toLowerCase() + '\\') {
-          path = resolvedDevice + '\\';
-        }
-      }
-
-      // Skip empty and invalid entries
-      if (typeof path !== 'string') {
-        throw new TypeError('Arguments to path.resolve must be strings');
-      } else if (!path) {
-        continue;
-      }
-
-      var result = splitDeviceRe.exec(path),
-          device = result[1] || '',
-          isUnc = device && device.charAt(1) !== ':',
-          isAbsolute = exports.isAbsolute(path),
-          tail = result[3];
-
-      if (device &&
-          resolvedDevice &&
-          device.toLowerCase() !== resolvedDevice.toLowerCase()) {
-        // This path points to another device so it is not applicable
-        continue;
-      }
-
-      if (!resolvedDevice) {
-        resolvedDevice = device;
-      }
-      if (!resolvedAbsolute) {
-        resolvedTail = tail + '\\' + resolvedTail;
-        resolvedAbsolute = isAbsolute;
-      }
-
-      if (resolvedDevice && resolvedAbsolute) {
-        break;
-      }
-    }
-
-    // Convert slashes to backslashes when `resolvedDevice` points to an UNC
-    // root. Also squash multiple slashes into a single one where appropriate.
-    if (isUnc) {
-      resolvedDevice = normalizeUNCRoot(resolvedDevice);
-    }
-
-    // At this point the path should be resolved to a full absolute path,
-    // but handle relative paths to be safe (might happen when process.cwd()
-    // fails)
-
-    // Normalize the tail path
-
-    function f(p) {
-      return !!p;
-    }
-
-    resolvedTail = normalizeArray(resolvedTail.split(/[\\\/]+/).filter(f),
-                                  !resolvedAbsolute).join('\\');
-
-    return (resolvedDevice + (resolvedAbsolute ? '\\' : '') + resolvedTail) ||
-           '.';
-  };
-
-  // windows version
-  exports.normalize = function(path) {
-    var result = splitDeviceRe.exec(path),
-        device = result[1] || '',
-        isUnc = device && device.charAt(1) !== ':',
-        isAbsolute = exports.isAbsolute(path),
-        tail = result[3],
-        trailingSlash = /[\\\/]$/.test(tail);
-
-    // If device is a drive letter, we'll normalize to lower case.
-    if (device && device.charAt(1) === ':') {
-      device = device[0].toLowerCase() + device.substr(1);
-    }
-
-    // Normalize the tail path
-    tail = normalizeArray(tail.split(/[\\\/]+/).filter(function(p) {
-      return !!p;
-    }), !isAbsolute).join('\\');
-
-    if (!tail && !isAbsolute) {
-      tail = '.';
-    }
-    if (tail && trailingSlash) {
-      tail += '\\';
-    }
-
-    // Convert slashes to backslashes when `device` points to an UNC root.
-    // Also squash multiple slashes into a single one where appropriate.
-    if (isUnc) {
-      device = normalizeUNCRoot(device);
-    }
-
-    return device + (isAbsolute ? '\\' : '') + tail;
-  };
-
-  // windows version
-  exports.isAbsolute = function(path) {
-    var result = splitDeviceRe.exec(path),
-        device = result[1] || '',
-        isUnc = device && device.charAt(1) !== ':';
-    // UNC paths are always absolute
-    return !!result[2] || isUnc;
-  };
-
-  // windows version
-  exports.join = function() {
-    function f(p) {
-      if (typeof p !== 'string') {
-        throw new TypeError('Arguments to path.join must be strings');
-      }
-      return p;
-    }
-
-    var paths = Array.prototype.filter.call(arguments, f);
-    var joined = paths.join('\\');
-
-    // Make sure that the joined path doesn't start with two slashes, because
-    // normalize() will mistake it for an UNC path then.
-    //
-    // This step is skipped when it is very clear that the user actually
-    // intended to point at an UNC path. This is assumed when the first
-    // non-empty string arguments starts with exactly two slashes followed by
-    // at least one more non-slash character.
-    //
-    // Note that for normalize() to treat a path as an UNC path it needs to
-    // have at least 2 components, so we don't filter for that here.
-    // This means that the user can use join to construct UNC paths from
-    // a server name and a share name; for example:
-    //   path.join('//server', 'share') -> '\\\\server\\share\')
-    if (!/^[\\\/]{2}[^\\\/]/.test(paths[0])) {
-      joined = joined.replace(/^[\\\/]{2,}/, '\\');
-    }
-
-    return exports.normalize(joined);
-  };
-
-  // path.relative(from, to)
-  // it will solve the relative path from 'from' to 'to', for instance:
-  // from = 'C:\\orandea\\test\\aaa'
-  // to = 'C:\\orandea\\impl\\bbb'
-  // The output of the function should be: '..\\..\\impl\\bbb'
-  // windows version
-  exports.relative = function(from, to) {
-    from = exports.resolve(from);
-    to = exports.resolve(to);
-
-    // windows is not case sensitive
-    var lowerFrom = from.toLowerCase();
-    var lowerTo = to.toLowerCase();
-
-    function trim(arr) {
-      var start = 0;
-      for (; start < arr.length; start++) {
-        if (arr[start] !== '') break;
-      }
-
-      var end = arr.length - 1;
-      for (; end >= 0; end--) {
-        if (arr[end] !== '') break;
-      }
-
-      if (start > end) return [];
-      return arr.slice(start, end - start + 1);
-    }
-
-    var toParts = trim(to.split('\\'));
-
-    var lowerFromParts = trim(lowerFrom.split('\\'));
-    var lowerToParts = trim(lowerTo.split('\\'));
-
-    var length = Math.min(lowerFromParts.length, lowerToParts.length);
-    var samePartsLength = length;
-    for (var i = 0; i < length; i++) {
-      if (lowerFromParts[i] !== lowerToParts[i]) {
-        samePartsLength = i;
-        break;
-      }
-    }
-
-    if (samePartsLength == 0) {
-      return to;
-    }
-
-    var outputParts = [];
-    for (var i = samePartsLength; i < lowerFromParts.length; i++) {
-      outputParts.push('..');
-    }
-
-    outputParts = outputParts.concat(toParts.slice(samePartsLength));
-
-    return outputParts.join('\\');
-  };
-
-  exports.sep = '\\';
-  exports.delimiter = ';';
-
-  exports.dirname = function(path) {
-      var result = splitPath(path),
-          root = result[0],
-          dir = result[1];
-
-      if (!root && !dir) {
-        // No dirname whatsoever
-        return '.';
-      }
-
-      if (dir) {
-        // It has a dirname, strip trailing slash
-        dir = dir.substr(0, dir.length - 1);
-      }
-
-      return root + dir;
-  };
-
-
-  exports.basename = function(path, ext) {
-      var f = splitPath(path)[2];
-      // TODO: make this comparison case-insensitive on windows?
-      if (ext && f.substr(-1 * ext.length) === ext) {
-        f = f.substr(0, f.length - ext.length);
-      }
-      return f;
-  };
-
-
-  exports.extname = function(path) {
-      return splitPath(path)[3];
-  };
-
-
-})(exports.path);
-
-
-(function() {
-
-  // es5-safe
-  // ----------------
-  // Provides compatibility shims so that legacy JavaScript engines behave as
-  // closely as possible to ES5.
-  //
-  // Thanks to:
-  //  - http://es5.github.com/
-  //  - http://kangax.github.com/es5-compat-table/
-  //  - https://github.com/kriskowal/es5-shim
-  //  - http://perfectionkills.com/extending-built-in-native-objects-evil-or-not/
-  //  - https://gist.github.com/1120592
-  //  - https://code.google.com/p/v8/
-
-
-  var OP = Object.prototype;
-  var AP = Array.prototype;
-  var FP = Function.prototype;
-  var SP = String.prototype;
-  var hasOwnProperty = OP.hasOwnProperty;
-  var slice = AP.slice;
-
-
-  /*---------------------------------------*
-   * Function
-   *---------------------------------------*/
-
-  // ES-5 15.3.4.5
-  // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Function/bind
-  FP.bind || (FP.bind = function(that) {
-    var target = this;
-
-    // If IsCallable(func) is false, throw a TypeError exception.
-    if (typeof target !== 'function') {
-      throw new TypeError('Bind must be called on a function');
-    }
-
-    var boundArgs = slice.call(arguments, 1);
-
-    function bound() {
-      // Called as a constructor.
-      if (this instanceof bound) {
-        var self = createObject(target.prototype);
-        var result = target.apply(
-            self,
-            boundArgs.concat(slice.call(arguments))
-        );
-        return Object(result) === result ? result : self;
-      }
-      // Called as a function.
-      else {
-        return target.apply(
-            that,
-            boundArgs.concat(slice.call(arguments))
-        );
-      }
-    }
-
-    // NOTICE: The function.length is not writable.
-    //bound.length = Math.max(target.length - boundArgs.length, 0);
-
-    return bound;
-  });
-
-
-  // Helpers
-  function createObject(proto) {
-    var o;
-
-    if (Object.create) {
-      o = Object.create(proto);
-    }
-    else {
-      /** @constructor */
-      function F() {
-      }
-
-      F.prototype = proto;
-      o = new F();
-    }
-
-    return o;
-  }
-
-
-  /*---------------------------------------*
-   * Object
-   *---------------------------------------*/
-  // http://ejohn.org/blog/ecmascript-5-objects-and-properties/
-
-  // ES5 15.2.3.14
-  // http://whattheheadsaid.com/2010/10/a-safer-object-keys-compatibility-implementation
-  // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Object/keys
-  // https://developer.mozilla.org/en/ECMAScript_DontEnum_attribute
-  // http://msdn.microsoft.com/en-us/library/adebfyya(v=vs.94).aspx
-  Object.keys || (Object.keys = (function() {
-    var hasDontEnumBug = !{toString: ''}.propertyIsEnumerable('toString');
-    var DontEnums = [
-      'toString',
-      'toLocaleString',
-      'valueOf',
-      'hasOwnProperty',
-      'isPrototypeOf',
-      'propertyIsEnumerable',
-      'constructor'
-    ];
-    var DontEnumsLength = DontEnums.length;
-
-    return function(o) {
-      if (o !== Object(o)) {
-        throw new TypeError(o + ' is not an object');
-      }
-
-      var result = [];
-
-      for (var name in o) {
-        if (hasOwnProperty.call(o, name)) {
-          result.push(name);
-        }
-      }
-
-      if (hasDontEnumBug) {
-        for (var i = 0; i < DontEnumsLength; i++) {
-          if (hasOwnProperty.call(o, DontEnums[i])) {
-            result.push(DontEnums[i]);
-          }
-        }
-      }
-
-      return result;
-    };
-
-  })());
-
-
-  /*---------------------------------------*
-   * Array
-   *---------------------------------------*/
-  // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array
-  // https://github.com/kangax/fabric.js/blob/gh-pages/src/util/lang_array.js
-
-  // ES5 15.4.3.2
-  // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/isArray
-  Array.isArray || (Array.isArray = function(obj) {
-    return OP.toString.call(obj) === '[object Array]';
-  });
-
-
-  // ES5 15.4.4.18
-  // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/array/foreach
-  AP.forEach || (AP.forEach = function(fn, context) {
-    for (var i = 0, len = this.length >>> 0; i < len; i++) {
-      if (i in this) {
-        fn.call(context, this[i], i, this);
-      }
-    }
-  });
-
-
-  // ES5 15.4.4.19
-  // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map
-  AP.map || (AP.map = function(fn, context) {
-    var len = this.length >>> 0;
-    var result = new Array(len);
-
-    for (var i = 0; i < len; i++) {
-      if (i in this) {
-        result[i] = fn.call(context, this[i], i, this);
-      }
-    }
-
-    return result;
-  });
-
-
-  // ES5 15.4.4.20
-  // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/filter
-  AP.filter || (AP.filter = function(fn, context) {
-    var result = [], val;
-
-    for (var i = 0, len = this.length >>> 0; i < len; i++) {
-      if (i in this) {
-        val = this[i]; // in case fn mutates this
-        if (fn.call(context, val, i, this)) {
-          result.push(val);
-        }
-      }
-    }
-
-    return result;
-  });
-
-
-  // ES5 15.4.4.16
-  // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/every
-  AP.every || (AP.every = function(fn, context) {
-    for (var i = 0, len = this.length >>> 0; i < len; i++) {
-      if (i in this && !fn.call(context, this[i], i, this)) {
-        return false;
-      }
-    }
-    return true;
-  });
-
-
-  // ES5 15.4.4.17
-  // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/some
-  AP.some || (AP.some = function(fn, context) {
-    for (var i = 0, len = this.length >>> 0; i < len; i++) {
-      if (i in this && fn.call(context, this[i], i, this)) {
-        return true;
-      }
-    }
-    return false;
-  });
-
-
-  // ES5 15.4.4.21
-  // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/reduce
-  AP.reduce || (AP.reduce = function(fn /*, initial*/) {
-    if (typeof fn !== 'function') {
-      throw new TypeError(fn + ' is not an function');
-    }
-
-    var len = this.length >>> 0, i = 0, result;
-
-    if (arguments.length > 1) {
-      result = arguments[1];
-    }
-    else {
-      do {
-        if (i in this) {
-          result = this[i++];
-          break;
-        }
-        // if array contains no values, no initial value to return
-        if (++i >= len) {
-          throw new TypeError('reduce of empty array with on initial value');
-        }
-      }
-      while (true);
-    }
-
-    for (; i < len; i++) {
-      if (i in this) {
-        result = fn.call(null, result, this[i], i, this);
-      }
-    }
-
-    return result;
-  });
-
-
-  // ES5 15.4.4.22
-  // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/reduceRight
-  AP.reduceRight || (AP.reduceRight = function(fn /*, initial*/) {
-    if (typeof fn !== 'function') {
-      throw new TypeError(fn + ' is not an function');
-    }
-
-    var len = this.length >>> 0, i = len - 1, result;
-
-    if (arguments.length > 1) {
-      result = arguments[1];
-    }
-    else {
-      do {
-        if (i in this) {
-          result = this[i--];
-          break;
-        }
-        // if array contains no values, no initial value to return
-        if (--i < 0)
-          throw new TypeError('reduce of empty array with on initial value');
-      }
-      while (true);
-    }
-
-    for (; i >= 0; i--) {
-      if (i in this) {
-        result = fn.call(null, result, this[i], i, this);
-      }
-    }
-
-    return result;
-  });
-
-
-  // ES5 15.4.4.14
-  // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/indexOf
-  AP.indexOf || (AP.indexOf = function(value, from) {
-    var len = this.length >>> 0;
-
-    from = Number(from) || 0;
-    from = Math[from < 0 ? 'ceil' : 'floor'](from);
-    if (from < 0) {
-      from = Math.max(from + len, 0);
-    }
-
-    for (; from < len; from++) {
-      if (from in this && this[from] === value) {
-        return from;
-      }
-    }
-
-    return -1;
-  });
-
-
-  // ES5 15.4.4.15
-  // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/indexOf
-  AP.lastIndexOf || (AP.lastIndexOf = function(value, from) {
-    var len = this.length >>> 0;
-
-    from = Number(from) || len - 1;
-    from = Math[from < 0 ? 'ceil' : 'floor'](from);
-    if (from < 0) {
-      from += len;
-    }
-    from = Math.min(from, len - 1);
-
-    for (; from >= 0; from--) {
-      if (from in this && this[from] === value) {
-        return from;
-      }
-    }
-
-    return -1;
-  });
-
-
-  /*---------------------------------------*
-   * String
-   *---------------------------------------*/
-
-  // ES5 15.5.4.20
-  // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/String/trim
-  // http://blog.stevenlevithan.com/archives/faster-trim-javascript
-  // http://jsperf.com/mega-trim-test
-  SP.trim || (SP.trim = (function() {
-
-    // http://perfectionkills.com/whitespace-deviations/
-    var whiteSpaces = [
-
-      '\\s',
-      //'0009', // 'HORIZONTAL TAB'
-      //'000A', // 'LINE FEED OR NEW LINE'
-      //'000B', // 'VERTICAL TAB'
-      //'000C', // 'FORM FEED'
-      //'000D', // 'CARRIAGE RETURN'
-      //'0020', // 'SPACE'
-
-      '00A0', // 'NO-BREAK SPACE'
-      '1680', // 'OGHAM SPACE MARK'
-      '180E', // 'MONGOLIAN VOWEL SEPARATOR'
-
-      '2000-\\u200A',
-      //'2000', // 'EN QUAD'
-      //'2001', // 'EM QUAD'
-      //'2002', // 'EN SPACE'
-      //'2003', // 'EM SPACE'
-      //'2004', // 'THREE-PER-EM SPACE'
-      //'2005', // 'FOUR-PER-EM SPACE'
-      //'2006', // 'SIX-PER-EM SPACE'
-      //'2007', // 'FIGURE SPACE'
-      //'2008', // 'PUNCTUATION SPACE'
-      //'2009', // 'THIN SPACE'
-      //'200A', // 'HAIR SPACE'
-
-      '200B', // 'ZERO WIDTH SPACE (category Cf)
-      '2028', // 'LINE SEPARATOR'
-      '2029', // 'PARAGRAPH SEPARATOR'
-      '202F', // 'NARROW NO-BREAK SPACE'
-      '205F', // 'MEDIUM MATHEMATICAL SPACE'
-      '3000' //  'IDEOGRAPHIC SPACE'
-
-    ].join('\\u');
-
-    var trimLeftReg = new RegExp('^[' + whiteSpaces + ']+');
-    var trimRightReg = new RegExp('[' + whiteSpaces + ']+$');
-
-    return function() {
-      return String(this).replace(trimLeftReg, '').replace(trimRightReg, '');
-    }
-
-  })());
-
-
-  /*---------------------------------------*
-   * Date
-   *---------------------------------------*/
-
-  // ES5 15.9.4.4
-  // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Date/now
-  Date.now || (Date.now = function() {
-    return +new Date;
-  });
-
-})();
-
-/*
-    json2.js
-    2013-05-26
-
-    Public Domain.
-
-    NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
-
-    See http://www.JSON.org/js.html
-
-
-    This code should be minified before deployment.
-    See http://javascript.crockford.com/jsmin.html
-*/
-
-
-if (typeof JSON !== 'object') {
-    JSON = {};
-}
-
-(function () {
-    'use strict';
-
-    function f(n) {
-        return n < 10 ? '0' + n : n;
-    }
-
-    if (typeof Date.prototype.toJSON !== 'function') {
-
-        Date.prototype.toJSON = function () {
-
-            return isFinite(this.valueOf())
-                ? this.getUTCFullYear()     + '-' +
-                    f(this.getUTCMonth() + 1) + '-' +
-                    f(this.getUTCDate())      + 'T' +
-                    f(this.getUTCHours())     + ':' +
-                    f(this.getUTCMinutes())   + ':' +
-                    f(this.getUTCSeconds())   + 'Z'
-                : null;
-        };
-
-        String.prototype.toJSON      =
-            Number.prototype.toJSON  =
-            Boolean.prototype.toJSON = function () {
-                return this.valueOf();
-            };
-    }
-
-    var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
-        escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
-        gap,
-        indent,
-        meta = {
-            '\b': '\\b',
-            '\t': '\\t',
-            '\n': '\\n',
-            '\f': '\\f',
-            '\r': '\\r',
-            '"' : '\\"',
-            '\\': '\\\\'
-        },
-        rep;
-
-
-    function quote(string) {
-
-        escapable.lastIndex = 0;
-        return escapable.test(string) ? '"' + string.replace(escapable, function (a) {
-            var c = meta[a];
-            return typeof c === 'string'
-                ? c
-                : '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
-        }) + '"' : '"' + string + '"';
-    }
-
-
-    function str(key, holder) {
-
-        var i,
-            k,
-            v,
-            length,
-            mind = gap,
-            partial,
-            value = holder[key];
-
-        if (value && typeof value === 'object' &&
-                typeof value.toJSON === 'function') {
-            value = value.toJSON(key);
-        }
-
-        if (typeof rep === 'function') {
-            value = rep.call(holder, key, value);
-        }
-
-        switch (typeof value) {
-        case 'string':
-            return quote(value);
-
-        case 'number':
-
-            return isFinite(value) ? String(value) : 'null';
-
-        case 'boolean':
-        case 'null':
-
-            return String(value);
-
-
-        case 'object':
-
-
-            if (!value) {
-                return 'null';
-            }
-
-
-            gap += indent;
-            partial = [];
-
-
-            if (Object.prototype.toString.apply(value) === '[object Array]') {
-
-
-                length = value.length;
-                for (i = 0; i < length; i += 1) {
-                    partial[i] = str(i, value) || 'null';
-                }
-
-
-                v = partial.length === 0
-                    ? '[]'
-                    : gap
-                    ? '[\n' + gap + partial.join(',\n' + gap) + '\n' + mind + ']'
-                    : '[' + partial.join(',') + ']';
-                gap = mind;
-                return v;
-            }
-
-
-            if (rep && typeof rep === 'object') {
-                length = rep.length;
-                for (i = 0; i < length; i += 1) {
-                    if (typeof rep[i] === 'string') {
-                        k = rep[i];
-                        v = str(k, value);
-                        if (v) {
-                            partial.push(quote(k) + (gap ? ': ' : ':') + v);
-                        }
-                    }
-                }
-            } else {
-
-                for (k in value) {
-                    if (Object.prototype.hasOwnProperty.call(value, k)) {
-                        v = str(k, value);
-                        if (v) {
-                            partial.push(quote(k) + (gap ? ': ' : ':') + v);
-                        }
-                    }
-                }
-            }
-
-            v = partial.length === 0
-                ? '{}'
-                : gap
-                ? '{\n' + gap + partial.join(',\n' + gap) + '\n' + mind + '}'
-                : '{' + partial.join(',') + '}';
-            gap = mind;
-            return v;
-        }
-    }
-
-    if (typeof JSON.stringify !== 'function') {
-        JSON.stringify = function (value, replacer, space) {
-
-            var i;
-            gap = '';
-            indent = '';
-
-
-            if (typeof space === 'number') {
-                for (i = 0; i < space; i += 1) {
-                    indent += ' ';
-                }
-
-
-            } else if (typeof space === 'string') {
-                indent = space;
-            }
-
-
-            rep = replacer;
-            if (replacer && typeof replacer !== 'function' &&
-                    (typeof replacer !== 'object' ||
-                    typeof replacer.length !== 'number')) {
-                throw new Error('JSON.stringify');
-            }
-
-            return str('', {'': value});
-        };
-    }
-
-    if (typeof JSON.parse !== 'function') {
-        JSON.parse = function (text, reviver) {
-
-            var j;
-
-            function walk(holder, key) {
-
-                var k, v, value = holder[key];
-                if (value && typeof value === 'object') {
-                    for (k in value) {
-                        if (Object.prototype.hasOwnProperty.call(value, k)) {
-                            v = walk(value, k);
-                            if (v !== undefined) {
-                                value[k] = v;
-                            } else {
-                                delete value[k];
-                            }
-                        }
-                    }
-                }
-                return reviver.call(holder, key, value);
-            }
-
-            text = String(text);
-            cx.lastIndex = 0;
-            if (cx.test(text)) {
-                text = text.replace(cx, function (a) {
-                    return '\\u' +
-                        ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
-                });
-            }
-
-            if (/^[\],:{}\s]*$/
-                    .test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@')
-                        .replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']')
-                        .replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
-
-                j = eval('(' + text + ')');
-
-                return typeof reviver === 'function'
-                    ? walk({'': j}, '')
-                    : j;
-            }
-
-            throw new SyntaxError('JSON.parse');
-        };
-    }
-}());
-
-}(this, {}));
-/*-------------------------------
-:cmd
-::if %errorlevel% == 0 exit
-pause>nul
-*/
\ No newline at end of file
diff --git a/test/includeHTML.js b/test/includeHTML.js
deleted file mode 100755
index 92cdcaa..0000000
--- a/test/includeHTML.js
+++ /dev/null
@@ -1,77 +0,0 @@
-#!/usr/bin/env node
-
-console.log('[HTML局部模板更新工具]');
-console.log('@version: 0.0.1')
-console.log('会自动更新如下注释格式标记局部模板：\n')
-console.log('<!--[include \'./public/header.html\']-->\n    ...\n<!--[/include]-->\n');
-console.log('------------------------------');
-
-var fs = require('fs');
-var path = require('path');
-
-var charset = 'utf-8'; // 设置模板的编码
-var EXTNAME_RE = /\.(html|htm|tpl)$/i;
-var INCLUDE_RE = /([\s\t]*)<!--\s*\[include\s*['"]*(.*?)['"]*\]\s*-->([\w\W]*?)<!--\s*\[\/include\]\s*-->/ig;
-var args = process.argv.slice(2);
-
-var compile = function (file) {
-	var html = fs.readFileSync(file, charset);
-	
-	console.log(file);
-	
-	html = html.replace(INCLUDE_RE, function ($1, blank, id, innerHTML) {
-
-		var newid = id.split('/').join(path.sep);
-		
-		var dirname = path.dirname(file);
-		var target = path.resolve(dirname, id.split('/').join(path.sep));
-
-		
-		if (fs.existsSync(target)) {
-			innerHTML = fs.readFileSync(target, charset);
-		} else {
-			console.log('Page not found: ' + target);
-		}
-		
-		return blank
-		+ "<!--[include '" + id.split('\\').join('/') + "']-->\n"
-		+ innerHTML
-		+ blank +  "<!--[/include]-->";
-	});
-	
-	fs.writeFileSync(file, html, charset);
-};
-
-
-var walk = function (dir) {
-	var dirList = fs.readdirSync(dir);
-
-	dirList.forEach(function (item) {
-		var target = path.join(dir, item);
-		
-		if (fs.statSync(target).isDirectory()) {
-			walk(target);
-		} else if (EXTNAME_RE.test(target)) {
-			compile(target);
-		}
-	});
-};
-
-if (args.length) {
-	args.forEach(function (target) {
-		if (!fs.existsSync(target)) {
-			return;
-		}
-		
-		if (fs.statSync(target).isDirectory()) {
-			walk(target);
-		} else if (EXTNAME_RE.test(target)) {
-			compile(target);
-		}
-	});
-} else {
-	walk('.\\');
-}
-
-console.log('------------------------------');
-console.log('End');
\ No newline at end of file
diff --git a/test/test.bat b/test/test.bat
new file mode 100644
index 0000000..b3e3a2d
--- /dev/null
+++ b/test/test.bat
@@ -0,0 +1,2567 @@
+@if (0===0) @end/*
+@echo off
+title node
+cd %~dp0
+call CScript.EXE "%~dpnx0" //Nologo //e:jscript %*
+goto cmd
+-------------------------------------------------------
+Build       1401553789504
+Compiler    node2bat.js@0.0.2 | https://github.com/aui/node2bat
+-------------------------------------------------------
+*/(function () {
+
+try {
+var fs = require('fs');
+var path = require('path');
+var assert = require('assert');
+
+var index = 0;
+var log = function (label, message) {
+	console.log("> " + label);
+	console.log(message);
+}
+
+var label = function (label) {
+	index ++;
+	console.log("[" + index + "] " + label + '');
+};
+
+
+if (typeof WScript === 'object') {
+	console.log('node2bat \u652f\u6301\u6838\u5fc3\u7684 NodeJS API\uff0c\u5e76\u4e14\u652f\u6301 ECMA5 \u65b0\u589e\u52a0\u7684 JS \u65b9\u6cd5');
+	console.log('\n');
+	console.log('global');
+	console.log('    ' + Object.keys(global).join(', '));
+	console.log('process');
+	console.log('    ' + Object.keys(global.process).join(', '));
+	console.log('console');
+	console.log('    ' + Object.keys(global.console).join(', '));
+	console.log("require('fs')");
+	console.log('    ' + Object.keys(require('fs')).join(', '));
+	console.log("require('path')");
+	console.log('    ' + Object.keys(require('path')).join(', '));
+	console.log("require('util')");
+	console.log('    ' + Object.keys(require('util')).join(', '));
+
+	console.log('\n');
+	console.log('NodeJS API: http://nodejs.org/api/index.html');
+	console.log('----------------------------------------------------');
+	console.log('\n');
+}
+
+label('\u5f53\u524d\u8fd0\u884c\u7684\u6587\u4ef6\u540d');
+log("__filename", __filename);
+
+label('\u8fdb\u7a0b\u5f53\u524d\u5de5\u4f5c\u76ee\u5f55');
+log("__dirname", __dirname);
+
+label('\u8fdb\u7a0b');
+log("process", process);
+
+label('\u8fdb\u7a0b\u5f53\u524d\u5de5\u4f5c\u76ee\u5f55');
+log("process.cwd()", process.cwd());
+
+label('\u5411\u7ec8\u7aef\u6253\u5370\u4fe1\u606f');
+log("process.stdout.write('hello world')", '');
+process.stdout.write('hello world');
+
+label('\u8bfb\u53d6\u5916\u90e8 json');
+log("require('../package.json').name", require('../package.json').name);
+
+try {
+	fs.mkdirSync('./temp');
+} catch(e) {}
+
+try {
+	fs.mkdirSync('./temp/folder');
+} catch(e) {}
+
+
+label('\u5220\u9664\u5df2\u6709\u7684\u6587\u4ef6\u5939');
+log("fs.rmdirSync('./temp/folder')", fs.rmdirSync('./temp/folder'));
+
+label('\u521b\u5efa\u6587\u4ef6\u5939')
+log("fs.mkdirSync('./temp/folder')", fs.mkdirSync('./temp/folder'));
+
+// \u521b\u5efa\u6587\u4ef6\u5939\uff08\u76ee\u6807\u5df2\u7ecf\u5b58\u5728\uff09
+assert.throws(function () {
+	return fs.mkdirSync('./temp/folder');
+});
+
+label('\u91cd\u547d\u540d\u6587\u4ef6\u5939');
+log("fs.renameSync('./temp/folder', './temp/folder_2')", fs.renameSync('./temp/folder', './temp/folder_2'));
+
+label('\u5220\u9664\u5df2\u6709\u7684\u6587\u4ef6\u5939');
+log("fs.rmdirSync('./temp/folder_2')", fs.rmdirSync('./temp/folder_2'));
+
+// \u91cd\u547d\u540d\u6587\u4ef6\u5939\uff08\u6e90\u6587\u4ef6\u5939\u4e0d\u5b58\u5728\uff09
+assert.throws(function () {
+	return fs.renameSync('./temp/folder', './temp/folder_2');
+});
+
+label('\u521b\u5efa utf-8 \u7684\u6587\u672c\uff08\u65e0 BOM\uff09');
+log("fs.writeFileSync('./temp/file.txt', '\u7cd6\u997c', 'utf-8')", fs.writeFileSync('./temp/file.txt', '\u7cd6\u997c', 'utf-8'));
+
+label('\u8bfb\u53d6 utf-8 \u7684\u6587\u672c');
+log("fs.readFileSync('./temp/file.txt', 'utf-8')", fs.readFileSync('./temp/file.txt', 'utf-8'));
+
+label('\u5199\u5165 ascii \u7684\u6587\u672c');
+log("fs.writeFileSync('./temp/file.txt', 'hello world', 'ascii')", fs.writeFileSync('./temp/file.txt', 'hello world', 'ascii'));
+
+label('\u8bfb\u53d6 ascii \u7684\u6587\u672c');
+log("fs.readFileSync('./temp/file.txt', 'ascii')", fs.readFileSync('./temp/file.txt', 'ascii'));
+
+label('\u5224\u65ad\u6587\u4ef6\u6216\u76ee\u5f55\u662f\u5426\u5b58\u5728');
+log("fs.existsSync('./temp/file.txt')", fs.existsSync('./temp/file.txt'));
+
+label('\u5224\u65ad\u6587\u4ef6\u6216\u76ee\u5f55\u662f\u5426\u5b58\u5728');
+log("fs.existsSync('./temp/folder')", fs.existsSync('./temp/folder'));
+
+label('\u5224\u65ad\u6587\u4ef6\u6216\u76ee\u5f55\u662f\u5426\u5b58\u5728');
+log("fs.existsSync('./temp/777')", fs.existsSync('./temp/777'));
+
+label('\u8bfb\u53d6\u76ee\u5f55\u4fe1\u606f');
+log("fs.statSync('./temp')", fs.statSync('./temp'));
+
+label('\u8bfb\u53d6\u6587\u4ef6\u4fe1\u606f');
+log("fs.statSync('./temp/file.txt')", fs.statSync('./temp/file.txt'));
+
+label('\u5224\u65ad\u76ee\u5f55');
+log("fs.statSync('./temp').isDirectory()", fs.statSync('./temp').isDirectory());
+
+label('\u5224\u65ad\u6587\u4ef6');
+log("fs.statSync('./temp').isFile()", fs.statSync('./temp').isFile());
+
+// \u5224\u65ad\u4e0d\u5b58\u5728\u7684\u76ee\u5f55\u6216\u6587\u4ef6
+assert.throws(function () {
+	return fs.statSync('./temp_12345');
+});
+
+label('\u5220\u9664\u6587\u4ef6');
+log("fs.unlinkSync('./temp/file.txt')", fs.unlinkSync('./temp/file.txt'));
+
+// \u8bfb\u53d6\u4e0d\u5b58\u5728\u7684 json \u6587\u4ef6
+assert.throws(function () {
+	return require('../package_12345.json');
+});
+
+label('\u683c\u5f0f\u5316\u8def\u5f84');
+log("path.normalize('/foo/bar//baz/asdf/quux/..')", path.normalize('/foo/bar//baz/asdf/quux/..'));
+
+label('\u8def\u5f84\u8054\u5408');
+log("path.join('/foo', 'bar', 'baz/asdf', 'quux', '..')", path.join('/foo', 'bar', 'baz/asdf', 'quux', '..'));
+
+label('\u8def\u5f84\u5bfb\u822a');
+log("path.resolve('/foo/bar', './baz')", path.resolve('/foo/bar', './baz'));
+log("path.resolve('/foo/bar', '/tmp/file/')", path.resolve('/foo/bar', '/tmp/file/'));
+log("path.resolve('wwwroot', 'static_files/png/', '../gif/image.gif')", path.resolve('wwwroot', 'static_files/png/', '../gif/image.gif'));
+
+label('\u76f8\u5bf9\u8def\u5f84');
+log("path.relative('C:\\orandea\\test\\aaa', 'C:\\orandea\\impl\\bbb')", path.relative('C:\\orandea\\test\\aaa', 'C:\\orandea\\impl\\bbb'));
+log("path.relative('/data/orandea/test/aaa', '/data/orandea/impl/bbb')", path.relative('/data/orandea/test/aaa', '/data/orandea/impl/bbb'));
+
+label("\u6587\u4ef6\u5939\u540d\u79f0");
+log("path.dirname('/foo/bar/baz/asdf/quux')", path.dirname('/foo/bar/baz/asdf/quux'));
+
+label("\u6587\u4ef6\u540d\u79f0");
+log("path.basename('/foo/bar/baz/asdf/quux.html')", path.basename('/foo/bar/baz/asdf/quux.html'));
+log("path.basename('/foo/bar/baz/asdf/quux.html', '.html')", path.basename('/foo/bar/baz/asdf/quux.html', '.html'));
+
+label("\u6269\u5c55\u540d\u79f0");
+log("path.extname('index.html')", path.extname('index.html'));
+log("path.extname('index.coffee.md')", path.extname('index.coffee.md'));
+log("path.extname('index.')", path.extname('index.'));
+log("path.extname('index')", path.extname('index'));
+
+label("\u8def\u5f84\u5206\u9694\u7b26");
+log("'foo/bar/baz'.split(path.sep)", 'foo/bar/baz'.split(path.sep));
+log("'foo\\bar\\baz'.split(path.sep)", 'foo\\bar\\baz'.split(path.sep));
+
+label("\u8def\u5f84\u754c\u5b9a\u7b26");
+log("process.env.PATH.split(path.delimiter)", process.env.PATH.split(path.delimiter));
+} catch (e) {
+    console.error(e);
+    WScript.Quit(1);
+}
+
+}).call({
+    node2bat: "0.0.2"
+}, function (global, exports) {
+    // NodeJS Runtime
+    global.global = global;
+
+
+    global.__filename = WScript.ScriptFullName;
+
+    global.__dirname = WScript
+                .ScriptFullName
+                .replace(WScript.ScriptName, '')
+                .replace(/\\+$/, '');
+
+    global.process = {
+
+        title: 'node',
+
+        argv: function () {
+            var Arguments = WScript.Arguments;
+            var length = Arguments.length;
+            var argv = ['node', WScript.ScriptFullName];
+
+            if (length) {
+                for (var i = 0; i < length; i++) {
+                    argv.push(Arguments(i));
+                }
+            }
+
+            return argv;
+        }(),
+
+
+        cwd: function () {
+            return global.__dirname;
+        },
+
+        // @see http://technet.microsoft.com/en-us/library/ee156595.aspx
+        env: (function () {
+            var wsh = new ActiveXObject("WScript.Shell");
+            var processObject = wsh.Environment("Process");
+            var list = [
+                'ALLUSERSPROFILE',
+                'APPDATA',
+                'CommonProgramFiles',
+                'COMPUTERNAME',
+                'ComSpec',
+                'configsetroot',
+                'FP_NO_HOST_CHECK',
+                'HOMEDRIVE',
+                'HOMEPATH',
+                'LOCALAPPDATA',
+                'LOGONSERVER',
+                'NUMBER_OF_PROCESSORS',
+                'OS',
+                'Path',
+                'PATHEXT',
+                'PROCESSOR_ARCHITECTURE',
+                'PROCESSOR_IDENTIFIER',
+                'PROCESSOR_LEVEL',
+                'PROCESSOR_REVISION',
+                'ProgramData',
+                'ProgramFiles',
+                'PROMPT',
+                'PSModulePath',
+                'PUBLIC',
+                'SESSIONNAME',
+                'SystemDrive',
+                'SystemRoot',
+                'TEMP',
+                'TMP',
+                'USERDOMAIN',
+                'USERNAME',
+                'USERPROFILE',
+                'windir'
+            ];
+
+
+            var Env = function () {
+                for (var name, info, i = 0; i < list.length; i++) {
+                    name = list[i];
+                    info = processObject.Item(name);
+                    info = wsh.ExpandEnvironmentStrings(info);
+                    this[name] = info;
+                    Env.prototype[name.toUpperCase()] = info;
+                }
+            };
+
+            return new Env();
+        })(),
+
+
+        exit: function (code) {
+            WScript.Quit(code);
+        },
+
+
+        stdout: {
+            write: function (message) {
+                WScript.StdOut.Write(message);
+            }
+        },
+
+        stderr: {
+            write: function (message) {
+                WScript.StdOut.Write(message);
+            }
+        }
+    };
+
+
+    // CommonJS require()
+    global.require = function require (id) {
+        
+        var path = require.resolve(id);
+        var mod = require._modules[path];
+
+        if (!mod) {
+            if (/\.json$/i.test(id)) {
+                var fs = require('fs');
+                var text = fs.readFileSync(id, 'utf-8');
+                var json = JSON.parse(text);
+                return json;
+            } else {
+                throw new Error('failed to require "' + id + '"');
+            } 
+        }
+
+        if (!mod.exports) {
+            mod.exports = {};
+            mod.call(mod.exports, require.relative(path), mod.exports, mod);
+        }
+
+        return mod.exports;
+    }
+
+    // fn: function (require, exports, module) {}
+    function define (path, fn) {
+        require._modules[path] = fn;
+    };
+
+    require._modules = {};
+
+    require.resolve = function (path) {
+        var orig = path,
+            reg = path + '.js',
+            index = path + '/index.js';
+        return require._modules[reg] && reg || require._modules[index] && index || orig;
+    };
+
+
+    require.relative = function (parent) {
+        return function (p) {
+            if ('.' != p.substr(0, 1)) return require(p);
+
+            var path = parent.split('/'),
+                segs = p.split('/');
+            path.pop();
+
+            for (var i = 0; i < segs.length; i++) {
+                var seg = segs[i];
+                if ('..' == seg) path.pop();
+                else if ('.' != seg) path.push(seg);
+            }
+
+            return require(path.join('/'));
+        };
+    };
+
+
+    /*global.setTimeout = function (fn, time) {
+        WScript.Sleep(time);
+        if (typeof fn === 'function') {
+            fn();
+        } else {
+            eval(fn);
+        }
+    };
+
+
+    global.setInterval = function (fn, time) {
+        var interval = function () {
+
+            WScript.Sleep(time);
+
+            if (typeof fn === 'function') {
+                fn();
+            } else {
+                eval(fn);
+            }
+
+            interval();
+        };
+
+        interval();
+    };*/
+
+
+    define('util', function (require, exports, module) {
+        // 2014-04-04 02:39:42
+        var formatRegExp = /%[sdj%]/g;
+        exports.format = function (f) {
+            if (!isString(f)) {
+                var objects = [];
+                for (var i = 0; i < arguments.length; i++) {
+                    objects.push(inspect(arguments[i]));
+                }
+                return objects.join(' ');
+            }
+
+            var i = 1;
+            var args = arguments;
+            var len = args.length;
+            var str = String(f).replace(formatRegExp, function (x) {
+                if (x === '%%') return '%';
+                if (i >= len) return x;
+                switch (x) {
+                case '%s':
+                    return String(args[i++]);
+                case '%d':
+                    return Number(args[i++]);
+                case '%j':
+                    try {
+                        return JSON.stringify(args[i++]);
+                    } catch (_) {
+                        return '[Circular]';
+                    }
+                default:
+                    return x;
+                }
+            });
+            for (var x = args[i]; i < len; x = args[++i]) {
+                if (isNull(x) || !isObject(x)) {
+                    str += ' ' + x;
+                } else {
+                    str += ' ' + inspect(x);
+                }
+            }
+            return str;
+        };
+
+
+         // Mark that a method should not be used.
+         // Returns a modified function which warns once by default.
+         // If --no-deprecation is set, then it is a no-op.
+        exports.deprecate = function (fn, msg) {
+            // Allow for deprecating things in the process of starting up.
+            if (isUndefined(global.process)) {
+                return function () {
+                    return exports.deprecate(fn, msg).apply(this, arguments);
+                };
+            }
+
+            if (process.noDeprecation === true) {
+                return fn;
+            }
+
+            var warned = false;
+
+            function deprecated() {
+                if (!warned) {
+                    if (process.throwDeprecation) {
+                        throw new Error(msg);
+                    } else if (process.traceDeprecation) {
+                        console.trace(msg);
+                    } else {
+                        console.error(msg);
+                    }
+                    warned = true;
+                }
+                return fn.apply(this, arguments);
+            }
+
+            return deprecated;
+        };
+
+
+        var debugs = {};
+        var debugEnviron;
+        exports.debuglog = function (set) {
+            if (isUndefined(debugEnviron))
+                debugEnviron = process.env.NODE_DEBUG || '';
+            set = set.toUpperCase();
+            if (!debugs[set]) {
+                if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
+                    var pid = process.pid;
+                    debugs[set] = function () {
+                        var msg = exports.format.apply(exports, arguments);
+                        console.error('%s %d: %s', set, pid, msg);
+                    };
+                } else {
+                    debugs[set] = function () {};
+                }
+            }
+            return debugs[set];
+        };
+
+
+        /**
+         * Echos the value of a value. Trys to print the value out
+         * in the best way possible given the different types.
+         *
+         * @param {Object} obj The object to print out.
+         * @param {Object} opts Optional options object that alters the output.
+         */
+        /* legacy: obj, showHidden, depth, colors*/
+        function inspect(obj, opts) {
+            // default options
+            var ctx = {
+                seen: [],
+                stylize: stylizeNoColor
+            };
+            // legacy...
+            if (arguments.length >= 3) ctx.depth = arguments[2];
+            if (arguments.length >= 4) ctx.colors = arguments[3];
+            if (isBoolean(opts)) {
+                // legacy...
+                ctx.showHidden = opts;
+            } else if (opts) {
+                // got an "options" object
+                exports._extend(ctx, opts);
+            }
+            // set default options
+            if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
+            if (isUndefined(ctx.depth)) ctx.depth = 2;
+            if (isUndefined(ctx.colors)) ctx.colors = false;
+            if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
+            if (ctx.colors) ctx.stylize = stylizeWithColor;
+            return formatValue(ctx, obj, ctx.depth);
+        }
+        exports.inspect = inspect;
+
+
+         // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
+        inspect.colors = {
+            'bold': [1, 22],
+            'italic': [3, 23],
+            'underline': [4, 24],
+            'inverse': [7, 27],
+            'white': [37, 39],
+            'grey': [90, 39],
+            'black': [30, 39],
+            'blue': [34, 39],
+            'cyan': [36, 39],
+            'green': [32, 39],
+            'magenta': [35, 39],
+            'red': [31, 39],
+            'yellow': [33, 39]
+        };
+
+         // Don't use 'blue' not visible on cmd.exe
+        inspect.styles = {
+            'special': 'cyan',
+            'number': 'yellow',
+            'boolean': 'yellow',
+            'undefined': 'grey',
+            'null': 'bold',
+            'string': 'green',
+            'date': 'magenta',
+            // "name": intentionally not styling
+            'regexp': 'red'
+        };
+
+
+        function stylizeWithColor(str, styleType) {
+            var style = inspect.styles[styleType];
+
+            if (style) {
+                return '\u001b[' + inspect.colors[style][0] + 'm' + str +
+                    '\u001b[' + inspect.colors[style][1] + 'm';
+            } else {
+                return str;
+            }
+        }
+
+
+        function stylizeNoColor(str, styleType) {
+            return str;
+        }
+
+
+        function arrayToHash(array) {
+            var hash = {};
+
+            array.forEach(function (val, idx) {
+                hash[val] = true;
+            });
+
+            return hash;
+        }
+
+
+        function formatValue(ctx, value, recurseTimes) {
+            // Provide a hook for user-specified inspect functions.
+            // Check that value is an object with an inspect function on it
+            if (ctx.customInspect &&
+                value &&
+                isFunction(value.inspect) &&
+                // Filter out the util module, it's inspect function is special
+                value.inspect !== exports.inspect &&
+                // Also filter out any prototype objects using the circular check.
+                !(value.constructor && value.constructor.prototype === value)) {
+                var ret = value.inspect(recurseTimes, ctx);
+                if (!isString(ret)) {
+                    ret = formatValue(ctx, ret, recurseTimes);
+                }
+                return ret;
+            }
+
+            // Primitive types cannot have properties
+            var primitive = formatPrimitive(ctx, value);
+            if (primitive) {
+                return primitive;
+            }
+
+            // Look up the keys of the object.
+            var keys = Object.keys(value);
+            var visibleKeys = arrayToHash(keys);
+
+            if (ctx.showHidden) {
+                keys = Object.getOwnPropertyNames(value);
+            }
+
+            // This could be a boxed primitive (new String(), etc.), check valueOf()
+            // NOTE: Avoid calling `valueOf` on `Date` instance because it will return
+            // a number which, when object has some additional user-stored `keys`,
+            // will be printed out.
+            var formatted;
+            var raw = value;
+            try {
+                // the .valueOf() call can fail for a multitude of reasons
+                if (!isDate(value))
+                    raw = value.valueOf();
+            } catch (e) {
+                // ignore...
+            }
+
+            if (isString(raw)) {
+                // for boxed Strings, we have to remove the 0-n indexed entries,
+                // since they just noisey up the output and are redundant
+                keys = keys.filter(function (key) {
+                    return !(key >= 0 && key < raw.length);
+                });
+            }
+
+            // Some type of object without properties can be shortcutted.
+            if (keys.length === 0) {
+                if (isFunction(value)) {
+                    var name = value.name ? ': ' + value.name : '';
+                    return ctx.stylize('[Function' + name + ']', 'special');
+                }
+                if (isRegExp(value)) {
+                    return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+                }
+                if (isDate(value)) {
+                    return ctx.stylize(Date.prototype.toString.call(value), 'date');
+                }
+                if (isError(value)) {
+                    return formatError(value);
+                }
+                // now check the `raw` value to handle boxed primitives
+                if (isString(raw)) {
+                    formatted = formatPrimitiveNoColor(ctx, raw);
+                    return ctx.stylize('[String: ' + formatted + ']', 'string');
+                }
+                if (isNumber(raw)) {
+                    formatted = formatPrimitiveNoColor(ctx, raw);
+                    return ctx.stylize('[Number: ' + formatted + ']', 'number');
+                }
+                if (isBoolean(raw)) {
+                    formatted = formatPrimitiveNoColor(ctx, raw);
+                    return ctx.stylize('[Boolean: ' + formatted + ']', 'boolean');
+                }
+            }
+
+            var base = '',
+                array = false,
+                braces = ['{', '}'];
+
+            // Make Array say that they are Array
+            if (isArray(value)) {
+                array = true;
+                braces = ['[', ']'];
+            }
+
+            // Make functions say that they are functions
+            if (isFunction(value)) {
+                var n = value.name ? ': ' + value.name : '';
+                base = ' [Function' + n + ']';
+            }
+
+            // Make RegExps say that they are RegExps
+            if (isRegExp(value)) {
+                base = ' ' + RegExp.prototype.toString.call(value);
+            }
+
+            // Make dates with properties first say the date
+            if (isDate(value)) {
+                base = ' ' + Date.prototype.toUTCString.call(value);
+            }
+
+            // Make error with message first say the error
+            if (isError(value)) {
+                base = ' ' + formatError(value);
+            }
+
+            // Make boxed primitive Strings look like such
+            if (isString(raw)) {
+                formatted = formatPrimitiveNoColor(ctx, raw);
+                base = ' ' + '[String: ' + formatted + ']';
+            }
+
+            // Make boxed primitive Numbers look like such
+            if (isNumber(raw)) {
+                formatted = formatPrimitiveNoColor(ctx, raw);
+                base = ' ' + '[Number: ' + formatted + ']';
+            }
+
+            // Make boxed primitive Booleans look like such
+            if (isBoolean(raw)) {
+                formatted = formatPrimitiveNoColor(ctx, raw);
+                base = ' ' + '[Boolean: ' + formatted + ']';
+            }
+
+            if (keys.length === 0 && (!array || value.length === 0)) {
+                return braces[0] + base + braces[1];
+            }
+
+            if (recurseTimes < 0) {
+                if (isRegExp(value)) {
+                    return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+                } else {
+                    return ctx.stylize('[Object]', 'special');
+                }
+            }
+
+            ctx.seen.push(value);
+
+            var output;
+            if (array) {
+                output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
+            } else {
+                output = keys.map(function (key) {
+                    return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
+                });
+            }
+
+            ctx.seen.pop();
+
+            return reduceToSingleString(output, base, braces);
+        }
+
+
+        function formatPrimitive(ctx, value) {
+            if (isUndefined(value))
+                return ctx.stylize('undefined', 'undefined');
+            if (isString(value)) {
+                var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
+                    .replace(/'/g, "\\'")
+                    .replace(/\\"/g, '"') + '\'';
+                return ctx.stylize(simple, 'string');
+            }
+            if (isNumber(value)) {
+                // Format -0 as '-0'. Strict equality won't distinguish 0 from -0,
+                // so instead we use the fact that 1 / -0 < 0 whereas 1 / 0 > 0 .
+                if (value === 0 && 1 / value < 0)
+                    return ctx.stylize('-0', 'number');
+                return ctx.stylize('' + value, 'number');
+            }
+            if (isBoolean(value))
+                return ctx.stylize('' + value, 'boolean');
+            // For some reason typeof null is "object", so special case here.
+            if (isNull(value))
+                return ctx.stylize('null', 'null');
+        }
+
+
+        function formatPrimitiveNoColor(ctx, value) {
+            var stylize = ctx.stylize;
+            ctx.stylize = stylizeNoColor;
+            var str = formatPrimitive(ctx, value);
+            ctx.stylize = stylize;
+            return str;
+        }
+
+
+        function formatError(value) {
+            return '[' + Error.prototype.toString.call(value) + ']';
+        }
+
+
+        function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
+            var output = [];
+            for (var i = 0, l = value.length; i < l; ++i) {
+                if (hasOwnProperty(value, String(i))) {
+                    output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+                        String(i), true));
+                } else {
+                    output.push('');
+                }
+            }
+            keys.forEach(function (key) {
+                if (!key.match(/^\d+$/)) {
+                    output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+                        key, true));
+                }
+            });
+            return output;
+        }
+
+
+        function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
+            var name, str, desc;
+            desc = /*Object.getOwnPropertyDescriptor(value, key) ||*/ {
+                value: value[key]
+            };
+            if (desc.get) {
+                if (desc.set) {
+                    str = ctx.stylize('[Getter/Setter]', 'special');
+                } else {
+                    str = ctx.stylize('[Getter]', 'special');
+                }
+            } else {
+                if (desc.set) {
+                    str = ctx.stylize('[Setter]', 'special');
+                }
+            }
+            if (!hasOwnProperty(visibleKeys, key)) {
+                name = '[' + key + ']';
+            }
+            if (!str) {
+                if (ctx.seen.indexOf(desc.value) < 0) {
+                    if (isNull(recurseTimes)) {
+                        str = formatValue(ctx, desc.value, null);
+                    } else {
+                        str = formatValue(ctx, desc.value, recurseTimes - 1);
+                    }
+                    if (str.indexOf('\n') > -1) {
+                        if (array) {
+                            str = str.split('\n').map(function (line) {
+                                return '  ' + line;
+                            }).join('\n').substr(2);
+                        } else {
+                            str = '\n' + str.split('\n').map(function (line) {
+                                return '   ' + line;
+                            }).join('\n');
+                        }
+                    }
+                } else {
+                    str = ctx.stylize('[Circular]', 'special');
+                }
+            }
+            if (isUndefined(name)) {
+                if (array && key.match(/^\d+$/)) {
+                    return str;
+                }
+                name = JSON.stringify('' + key);
+                if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+                    name = name.substr(1, name.length - 2);
+                    name = ctx.stylize(name, 'name');
+                } else {
+                    name = name.replace(/'/g, "\\'")
+                        .replace(/\\"/g, '"')
+                        .replace(/(^"|"$)/g, "'")
+                        .replace(/\\\\/g, '\\');
+                    name = ctx.stylize(name, 'string');
+                }
+            }
+
+            return name + ': ' + str;
+        }
+
+
+        function reduceToSingleString(output, base, braces) {
+            var length = output.reduce(function (prev, cur) {
+                return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
+            }, 0);
+
+            if (length > 60) {
+                return braces[0] +
+                    (base === '' ? '' : base + '\n ') +
+                    ' ' +
+                    output.join(',\n  ') +
+                    ' ' +
+                    braces[1];
+            }
+
+            return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
+        }
+
+
+         // NOTE: These type checking functions intentionally don't use `instanceof`
+         // because it is fragile and can be easily faked with `Object.create()`.
+        var isArray = exports.isArray = Array.isArray;
+
+        function isBoolean(arg) {
+            return typeof arg === 'boolean';
+        }
+        exports.isBoolean = isBoolean;
+
+        function isNull(arg) {
+            return arg === null;
+        }
+        exports.isNull = isNull;
+
+        function isNullOrUndefined(arg) {
+            return arg == null;
+        }
+        exports.isNullOrUndefined = isNullOrUndefined;
+
+        function isNumber(arg) {
+            return typeof arg === 'number';
+        }
+        exports.isNumber = isNumber;
+
+        function isString(arg) {
+            return typeof arg === 'string';
+        }
+        exports.isString = isString;
+
+        function isSymbol(arg) {
+            return typeof arg === 'symbol';
+        }
+        exports.isSymbol = isSymbol;
+
+        function isUndefined(arg) {
+            return arg === void 0;
+        }
+        exports.isUndefined = isUndefined;
+
+        function isRegExp(re) {
+            return isObject(re) && objectToString(re) === '[object RegExp]';
+        }
+        exports.isRegExp = isRegExp;
+
+        function isObject(arg) {
+            return typeof arg === 'object' && arg !== null;
+        }
+        exports.isObject = isObject;
+
+        function isDate(d) {
+            return isObject(d) && objectToString(d) === '[object Date]';
+        }
+        exports.isDate = isDate;
+
+        function isError(e) {
+            return isObject(e) &&
+                (objectToString(e) === '[object Error]' || e instanceof Error);
+        }
+        exports.isError = isError;
+
+        function isFunction(arg) {
+            return typeof arg === 'function';
+        }
+        exports.isFunction = isFunction;
+
+        function isPrimitive(arg) {
+            return arg === null ||
+                typeof arg === 'boolean' ||
+                typeof arg === 'number' ||
+                typeof arg === 'string' ||
+                typeof arg === 'symbol' || // ES6 symbol
+                typeof arg === 'undefined';
+        }
+        exports.isPrimitive = isPrimitive;
+
+        function objectToString(o) {
+            return Object.prototype.toString.call(o);
+        }
+
+
+        function pad(n) {
+            return n < 10 ? '0' + n.toString(10) : n.toString(10);
+        }
+
+
+        var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
+            'Oct', 'Nov', 'Dec'
+        ];
+
+         // 26 Feb 16:19:34
+        function timestamp() {
+            var d = new Date();
+            var time = [pad(d.getHours()),
+                pad(d.getMinutes()),
+                pad(d.getSeconds())
+            ].join(':');
+            return [d.getDate(), months[d.getMonth()], time].join(' ');
+        }
+
+
+         // log is just a thin wrapper to console.log that prepends a timestamp
+        exports.log = function () {
+            console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
+        };
+
+
+        exports._extend = function (origin, add) {
+            // Don't do anything if add isn't an object
+            if (!add || !isObject(add)) return origin;
+
+            var keys = Object.keys(add);
+            var i = keys.length;
+            while (i--) {
+                origin[keys[i]] = add[keys[i]];
+            }
+            return origin;
+        };
+
+        function hasOwnProperty(obj, prop) {
+            return Object.prototype.hasOwnProperty.call(obj, prop);
+        }
+
+
+        var uv;
+        exports._errnoException = function (err, syscall, original) {
+            if (isUndefined(uv)) uv = process.binding('uv');
+            var errname = uv.errname(err);
+            var message = syscall + ' ' + errname;
+            if (original)
+                message += ' ' + original;
+            var e = new Error(message);
+            e.code = errname;
+            e.errno = errname;
+            e.syscall = syscall;
+            return e;
+        };
+    });
+
+
+    define('console', function (require, exports, module) {
+        // 2013-08-02 06:08:01 
+        var util = require('util');
+
+        function Console(stdout, stderr) {
+            if (!(this instanceof Console)) {
+                return new Console(stdout, stderr);
+            }
+            if (!stdout || !util.isFunction(stdout.write)) {
+                throw new TypeError('Console expects a writable stream instance');
+            }
+            if (!stderr) {
+                stderr = stdout;
+            }
+
+            this._stdout = stdout;
+            this._stderr = stderr;
+            this._times = {};
+
+            // bind the prototype functions to this Console instance
+            Object.keys(Console.prototype).forEach(function (k) {
+                this[k] = this[k].bind(this);
+            }, this);
+        }
+
+        Console.prototype.log = function () {
+            this._stdout.write(util.format.apply(this, arguments) + '\n');
+        };
+
+
+        Console.prototype.info = Console.prototype.log;
+
+
+        Console.prototype.warn = function () {
+            this._stderr.write(util.format.apply(this, arguments) + '\n');
+        };
+
+
+        Console.prototype.error = Console.prototype.warn;
+
+
+        Console.prototype.dir = function (object) {
+            this._stdout.write(util.inspect(object, {
+                customInspect: false
+            }) + '\n');
+        };
+
+
+        Console.prototype.time = function (label) {
+            this._times[label] = Date.now();
+        };
+
+
+        Console.prototype.timeEnd = function (label) {
+            var time = this._times[label];
+            if (!time) {
+                throw new Error('No such label: ' + label);
+            }
+            var duration = Date.now() - time;
+            this.log('%s: %dms', label, duration);
+        };
+
+
+        Console.prototype.assert = function (expression) {
+            if (!expression) {
+                var arr = Array.prototype.slice.call(arguments, 1);
+                require('assert').ok(false, util.format.apply(this, arr));
+            }
+        };
+
+
+        module.exports = new Console(process.stdout, process.stderr);
+        module.exports.Console = Console;
+    });
+
+
+    define('fs', function (require, exports, module) {
+
+        var fso = new ActiveXObject('Scripting.FileSystemObject');
+
+        var Stat = function (path) {
+            var info;
+            this._path = path;
+
+            if (this.isFile()) {
+                info = fso.GetFile(path);
+            } else if (this.isDirectory()) {
+                info = fso.GetFolder(path);
+            } else {
+                throw new Error('ENOENT, no such file or directory ' + JSON.stringify(path));
+            }
+
+            this.size = info.Size; // TODO: 读取目录不准确
+            this.atime = new Date(info.DateLastAccessed);
+            this.mtime = new Date(info.DateLastModified);
+            this.ctime = new Date(info.DateCreated);
+        };
+
+        Stat.prototype = {
+            isFile: function () {
+                return fso.FileExists(this._path);
+            },
+            isDirectory: function () {
+                return fso.FolderExists(this._path);
+            }
+        };
+
+        exports.renameSync = function (oldPath, newPath) {
+            var statSync = exports.statSync(oldPath);
+            var file = fso[statSync.isFile() ? 'GetFile' : 'GetFolder'](oldPath);
+            if (exports.existsSync(newPath)) {
+                exports.unlinkSync(newPath);
+            }
+            file.Move(newPath);
+        };
+
+        exports.mkdirSync = function (path) {
+            // TODO: Error Info
+            fso.CreateFolder(path);
+        };
+
+        exports.mkdirSync = function (path) {
+            fso.CreateFolder(path);
+        };
+
+        exports.rmdirSync = function (path) {
+            fso.DeleteFolder(path, true);
+        };
+
+        exports.unlinkSync = function (path) {
+            fso.DeleteFile(path, true);
+        };
+
+        exports.existsSync = function (path) {
+            try {
+                var statSync = exports.statSync(path);
+                return statSync.isFile() || statSync.isDirectory();
+            } catch (e) {
+                return false;
+            }  
+        };
+
+        exports.statSync = function (path) {
+            return new Stat(path);
+        };
+
+        exports.readdirSync = function (path) {
+
+            var listall = function (path) {
+
+                var fd = fso.GetFolder(path + '\\');
+                var fe = new Enumerator(fd.files);
+                var list = [];
+                var item;
+
+                while (!fe.atEnd()) {
+                    item = fe.item() + '';
+                    item = item.replace(/^.*\\([^\\]*)$/, '$1');
+                    list.push(item);
+                    fe.moveNext();
+                }
+
+                var folderList = new Enumerator(fd.SubFolders);
+                for (; !folderList.atEnd(); folderList.moveNext()) {
+                    item = folderList.item() + '';
+                    item = item.replace(/^.*\\([^\\]*)$/, '$1');
+                    list.push(item);
+                }
+
+                return list;
+            };
+
+            return listall(path);
+        };
+
+        exports.readFileSync = function (file, charset) {
+            var stream = new ActiveXObject('adodb.stream');
+            var fileContent;
+
+            stream.Type = charset ? 2 : 1;
+            stream.Open();
+
+            if (charset) {
+                stream.Charset = charset;
+            } else {
+                throw new TypeError('Bad arguments');
+            }
+
+            try {
+                stream.LoadFromFile(file);
+            } catch (e) {
+                throw e;
+            }
+
+            fileContent = new String(stream.ReadText());
+            fileContent.Charset = charset;
+            stream.Close();
+
+            return fileContent.toString();
+        };
+
+        // @see http://bathome.l3.wuyou.com/redirect.php?goto=findpost&ptid=10300&pid=66972
+        // @see http://www.clockworksoftware.com/asp/Products/vbs2js.asp
+        exports.writeFileSync = function (file, data, charset) {
+            var binData;
+            var stream = new ActiveXObject("adodb.Stream");
+
+            stream.Open();
+
+            try {
+                
+                if (charset) {
+
+
+                    stream.Position = 0;
+                    stream.CharSet = charset;
+                    stream.WriteText(data);
+                    stream.SetEOS();
+
+                    stream.Position = 0;
+                    stream.Type = 1;
+
+                    // TODO: test BOM
+                    // /^0xEF0xBB0xBF/
+                    if (charset !== 'ascii') {
+                        stream.Position = 3;
+                    }
+                    
+                    binData = stream.Read(-1); 
+
+                    stream.Position = 0;
+                    stream.Write(binData);
+                    stream.SetEOS();
+                    
+
+                    stream.SaveToFile(file, 2);
+                } else {
+                    
+                    //stream.Type = 1;
+                    //stream.Write(data);
+                    //stream.SaveToFile(file, 2);
+                    throw new TypeError('Bad arguments');
+                }
+
+            } catch (e) {
+                throw e;
+            } finally {
+                stream.close();
+            }
+        };
+    });
+
+
+    define('path', function (require, exports, module) {
+
+        // resolves . and .. elements in a path array with directory names there
+        // must be no slashes, empty elements, or device names (c:\) in the array
+        // (so also no leading and trailing slashes - it does not distinguish
+        // relative and absolute paths)
+        function normalizeArray(parts, allowAboveRoot) {
+            // if the path tries to go above the root, `up` ends up > 0
+            var up = 0;
+            for (var i = parts.length - 1; i >= 0; i--) {
+                var last = parts[i];
+                if (last === '.') {
+                    parts.splice(i, 1);
+                } else if (last === '..') {
+                    parts.splice(i, 1);
+                    up++;
+                } else if (up) {
+                    parts.splice(i, 1);
+                    up--;
+                }
+            }
+
+            // if the path is allowed to go above the root, restore leading ..s
+            if (allowAboveRoot) {
+                for (; up--; up) {
+                    parts.unshift('..');
+                }
+            }
+
+            return parts;
+        }
+        // Regex to split a windows path into three parts: [*, device, slash,
+        // tail] windows-only
+        var splitDeviceRe =
+            /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
+
+        // Regex to split the tail part of the above into [*, dir, basename, ext]
+        var splitTailRe =
+            /^([\s\S]*?)((?:\.{1,2}|[^\\\/]+?|)(\.[^.\/\\]*|))(?:[\\\/]*)$/;
+
+        // Function to split a filename into [root, dir, basename, ext]
+        // windows version
+        var splitPath = function (filename) {
+            // Separate device+slash from tail
+            var result = splitDeviceRe.exec(filename),
+                device = (result[1] || '') + (result[2] || ''),
+                tail = result[3] || '';
+            // Split the tail into dir, basename and extension
+            var result2 = splitTailRe.exec(tail),
+                dir = result2[1],
+                basename = result2[2],
+                ext = result2[3];
+            return [device, dir, basename, ext];
+        };
+
+        var normalizeUNCRoot = function (device) {
+            return '\\\\' + device.replace(/^[\\\/]+/, '').replace(/[\\\/]+/g, '\\');
+        };
+
+        // path.resolve([from ...], to)
+        // windows version
+        exports.resolve = function () {
+            var resolvedDevice = '',
+                resolvedTail = '',
+                resolvedAbsolute = false;
+
+            for (var i = arguments.length - 1; i >= -1; i--) {
+                var path;
+                if (i >= 0) {
+                    path = arguments[i];
+                } else if (!resolvedDevice) {
+                    path = process.cwd();
+                } else {
+                    // Windows has the concept of drive-specific current working
+                    // directories. If we've resolved a drive letter but not yet an
+                    // absolute path, get cwd for that drive. We're sure the device is not
+                    // an unc path at this points, because unc paths are always absolute.
+                    path = process.env['=' + resolvedDevice];
+                    // Verify that a drive-local cwd was found and that it actually points
+                    // to our drive. If not, default to the drive's root.
+                    if (!path || path.substr(0, 3).toLowerCase() !==
+                        resolvedDevice.toLowerCase() + '\\') {
+                        path = resolvedDevice + '\\';
+                    }
+                }
+
+                // Skip empty and invalid entries
+                if (typeof path !== 'string') {
+                    throw new TypeError('Arguments to path.resolve must be strings');
+                } else if (!path) {
+                    continue;
+                }
+
+                var result = splitDeviceRe.exec(path),
+                    device = result[1] || '',
+                    isUnc = device && device.charAt(1) !== ':',
+                    isAbsolute = exports.isAbsolute(path),
+                    tail = result[3];
+
+                if (device &&
+                    resolvedDevice &&
+                    device.toLowerCase() !== resolvedDevice.toLowerCase()) {
+                    // This path points to another device so it is not applicable
+                    continue;
+                }
+
+                if (!resolvedDevice) {
+                    resolvedDevice = device;
+                }
+                if (!resolvedAbsolute) {
+                    resolvedTail = tail + '\\' + resolvedTail;
+                    resolvedAbsolute = isAbsolute;
+                }
+
+                if (resolvedDevice && resolvedAbsolute) {
+                    break;
+                }
+            }
+
+            // Convert slashes to backslashes when `resolvedDevice` points to an UNC
+            // root. Also squash multiple slashes into a single one where appropriate.
+            if (isUnc) {
+                resolvedDevice = normalizeUNCRoot(resolvedDevice);
+            }
+
+            // At this point the path should be resolved to a full absolute path,
+            // but handle relative paths to be safe (might happen when process.cwd()
+            // fails)
+
+            // Normalize the tail path
+
+            function f(p) {
+                return !!p;
+            }
+
+            resolvedTail = normalizeArray(resolvedTail.split(/[\\\/]+/).filter(f), !resolvedAbsolute).join('\\');
+
+            return (resolvedDevice + (resolvedAbsolute ? '\\' : '') + resolvedTail) ||
+                '.';
+        };
+
+        // windows version
+        exports.normalize = function (path) {
+            var result = splitDeviceRe.exec(path),
+                device = result[1] || '',
+                isUnc = device && device.charAt(1) !== ':',
+                isAbsolute = exports.isAbsolute(path),
+                tail = result[3],
+                trailingSlash = /[\\\/]$/.test(tail);
+
+            // If device is a drive letter, we'll normalize to lower case.
+            if (device && device.charAt(1) === ':') {
+                device = device[0].toLowerCase() + device.substr(1);
+            }
+
+            // Normalize the tail path
+            tail = normalizeArray(tail.split(/[\\\/]+/).filter(function (p) {
+                return !!p;
+            }), !isAbsolute).join('\\');
+
+            if (!tail && !isAbsolute) {
+                tail = '.';
+            }
+            if (tail && trailingSlash) {
+                tail += '\\';
+            }
+
+            // Convert slashes to backslashes when `device` points to an UNC root.
+            // Also squash multiple slashes into a single one where appropriate.
+            if (isUnc) {
+                device = normalizeUNCRoot(device);
+            }
+
+            return device + (isAbsolute ? '\\' : '') + tail;
+        };
+
+        // windows version
+        exports.isAbsolute = function (path) {
+            var result = splitDeviceRe.exec(path),
+                device = result[1] || '',
+                isUnc = device && device.charAt(1) !== ':';
+            // UNC paths are always absolute
+            return !!result[2] || isUnc;
+        };
+
+        // windows version
+        exports.join = function () {
+            function f(p) {
+                if (typeof p !== 'string') {
+                    throw new TypeError('Arguments to path.join must be strings');
+                }
+                return p;
+            }
+
+            var paths = Array.prototype.filter.call(arguments, f);
+            var joined = paths.join('\\');
+
+            // Make sure that the joined path doesn't start with two slashes, because
+            // normalize() will mistake it for an UNC path then.
+            //
+            // This step is skipped when it is very clear that the user actually
+            // intended to point at an UNC path. This is assumed when the first
+            // non-empty string arguments starts with exactly two slashes followed by
+            // at least one more non-slash character.
+            //
+            // Note that for normalize() to treat a path as an UNC path it needs to
+            // have at least 2 components, so we don't filter for that here.
+            // This means that the user can use join to construct UNC paths from
+            // a server name and a share name; for example:
+            //   path.join('//server', 'share') -> '\\\\server\\share\')
+            if (!/^[\\\/]{2}[^\\\/]/.test(paths[0])) {
+                joined = joined.replace(/^[\\\/]{2,}/, '\\');
+            }
+
+            return exports.normalize(joined);
+        };
+
+        // path.relative(from, to)
+        // it will solve the relative path from 'from' to 'to', for instance:
+        // from = 'C:\\orandea\\test\\aaa'
+        // to = 'C:\\orandea\\impl\\bbb'
+        // The output of the function should be: '..\\..\\impl\\bbb'
+        // windows version
+        exports.relative = function (from, to) {
+            from = exports.resolve(from);
+            to = exports.resolve(to);
+
+            // windows is not case sensitive
+            var lowerFrom = from.toLowerCase();
+            var lowerTo = to.toLowerCase();
+
+            function trim(arr) {
+                var start = 0;
+                for (; start < arr.length; start++) {
+                    if (arr[start] !== '') break;
+                }
+
+                var end = arr.length - 1;
+                for (; end >= 0; end--) {
+                    if (arr[end] !== '') break;
+                }
+
+                if (start > end) return [];
+                return arr.slice(start, end - start + 1);
+            }
+
+            var toParts = trim(to.split('\\'));
+
+            var lowerFromParts = trim(lowerFrom.split('\\'));
+            var lowerToParts = trim(lowerTo.split('\\'));
+
+            var length = Math.min(lowerFromParts.length, lowerToParts.length);
+            var samePartsLength = length;
+            for (var i = 0; i < length; i++) {
+                if (lowerFromParts[i] !== lowerToParts[i]) {
+                    samePartsLength = i;
+                    break;
+                }
+            }
+
+            if (samePartsLength == 0) {
+                return to;
+            }
+
+            var outputParts = [];
+            for (var i = samePartsLength; i < lowerFromParts.length; i++) {
+                outputParts.push('..');
+            }
+
+            outputParts = outputParts.concat(toParts.slice(samePartsLength));
+
+            return outputParts.join('\\');
+        };
+
+        exports.sep = '\\';
+        exports.delimiter = ';';
+
+        exports.dirname = function (path) {
+            var result = splitPath(path),
+                root = result[0],
+                dir = result[1];
+
+            if (!root && !dir) {
+                // No dirname whatsoever
+                return '.';
+            }
+
+            if (dir) {
+                // It has a dirname, strip trailing slash
+                dir = dir.substr(0, dir.length - 1);
+            }
+
+            return root + dir;
+        };
+
+
+        exports.basename = function (path, ext) {
+            var f = splitPath(path)[2];
+            // TODO: make this comparison case-insensitive on windows?
+            if (ext && f.substr(-1 * ext.length) === ext) {
+                f = f.substr(0, f.length - ext.length);
+            }
+            return f;
+        };
+
+
+        exports.extname = function (path) {
+            return splitPath(path)[3];
+        };
+    });
+
+    
+    define('assert', function (require, exports, module) {
+        // 2014-03-03 03:54:19 
+        var util = require('util');
+        var pSlice = Array.prototype.slice;
+
+        // 1. The assert module provides functions that throw
+        // AssertionError's when particular conditions are not met. The
+        // assert module must conform to the following interface.
+
+        var assert = module.exports = ok;
+
+        // 2. The AssertionError is defined in assert.
+        // new assert.AssertionError({ message: message,
+        //                             actual: actual,
+        //                             expected: expected })
+
+        assert.AssertionError = function AssertionError(options) {
+            this.name = 'AssertionError';
+            this.actual = options.actual;
+            this.expected = options.expected;
+            this.operator = options.operator;
+            if (options.message) {
+                this.message = options.message;
+                this.generatedMessage = false;
+            } else {
+                this.message = getMessage(this);
+                this.generatedMessage = true;
+            }
+            //var stackStartFunction = options.stackStartFunction || fail;
+            //Error.captureStackTrace(this, stackStartFunction);
+        };
+
+        // assert.AssertionError instanceof Error
+        //util.inherits(assert.AssertionError, Error);
+        assert.AssertionError.prototype = Error.prototype;
+
+        function replacer(key, value) {
+            if (util.isUndefined(value)) {
+                return '' + value;
+            }
+            if (util.isNumber(value) && (isNaN(value) || !isFinite(value))) {
+                return value.toString();
+            }
+            if (util.isFunction(value) || util.isRegExp(value)) {
+                return value.toString();
+            }
+            return value;
+        }
+
+        function truncate(s, n) {
+            if (util.isString(s)) {
+                return s.length < n ? s : s.slice(0, n);
+            } else {
+                return s;
+            }
+        }
+
+        function getMessage(self) {
+            return truncate(JSON.stringify(self.actual, replacer), 128) + ' ' +
+                self.operator + ' ' +
+                truncate(JSON.stringify(self.expected, replacer), 128);
+        }
+
+        // At present only the three keys mentioned above are used and
+        // understood by the spec. Implementations or sub modules can pass
+        // other keys to the AssertionError's constructor - they will be
+        // ignored.
+
+        // 3. All of the following functions must throw an AssertionError
+        // when a corresponding condition is not met, with a message that
+        // may be undefined if not provided.  All assertion methods provide
+        // both the actual and expected values to the assertion error for
+        // display purposes.
+
+        function fail(actual, expected, message, operator, stackStartFunction) {
+            throw new assert.AssertionError({
+                message: message,
+                actual: actual,
+                expected: expected,
+                operator: operator,
+                stackStartFunction: stackStartFunction
+            });
+        }
+
+        // EXTENSION! allows for well behaved errors defined elsewhere.
+        assert.fail = fail;
+
+        // 4. Pure assertion tests whether a value is truthy, as determined
+        // by !!guard.
+        // assert.ok(guard, message_opt);
+        // This statement is equivalent to assert.equal(true, !!guard,
+        // message_opt);. To test strictly for the value true, use
+        // assert.strictEqual(true, guard, message_opt);.
+
+        function ok(value, message) {
+            if (!value) fail(value, true, message, '==', assert.ok);
+        }
+        assert.ok = ok;
+
+        // 5. The equality assertion tests shallow, coercive equality with
+        // ==.
+        // assert.equal(actual, expected, message_opt);
+
+        assert.equal = function equal(actual, expected, message) {
+            if (actual != expected) fail(actual, expected, message, '==', assert.equal);
+        };
+
+        // 6. The non-equality assertion tests for whether two objects are not equal
+        // with != assert.notEqual(actual, expected, message_opt);
+
+        assert.notEqual = function notEqual(actual, expected, message) {
+            if (actual == expected) {
+                fail(actual, expected, message, '!=', assert.notEqual);
+            }
+        };
+
+        // 7. The equivalence assertion tests a deep equality relation.
+        // assert.deepEqual(actual, expected, message_opt);
+
+        assert.deepEqual = function deepEqual(actual, expected, message) {
+            if (!_deepEqual(actual, expected)) {
+                fail(actual, expected, message, 'deepEqual', assert.deepEqual);
+            }
+        };
+
+        function _deepEqual(actual, expected) {
+            // 7.1. All identical values are equivalent, as determined by ===.
+            if (actual === expected) {
+                return true;
+
+            } else if (util.isDate(actual) && util.isDate(expected)) {
+                return actual.getTime() === expected.getTime();
+
+                // 7.3 If the expected value is a RegExp object, the actual value is
+                // equivalent if it is also a RegExp object with the same source and
+                // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).
+            } else if (util.isRegExp(actual) && util.isRegExp(expected)) {
+                return actual.source === expected.source &&
+                    actual.global === expected.global &&
+                    actual.multiline === expected.multiline &&
+                    actual.lastIndex === expected.lastIndex &&
+                    actual.ignoreCase === expected.ignoreCase;
+
+                // 7.4. Other pairs that do not both pass typeof value == 'object',
+                // equivalence is determined by ==.
+            } else if (!util.isObject(actual) && !util.isObject(expected)) {
+                return actual == expected;
+
+                // 7.5 For all other Object pairs, including Array objects, equivalence is
+                // determined by having the same number of owned properties (as verified
+                // with Object.prototype.hasOwnProperty.call), the same set of keys
+                // (although not necessarily the same order), equivalent values for every
+                // corresponding key, and an identical 'prototype' property. Note: this
+                // accounts for both named and indexed properties on Arrays.
+            } else {
+                return objEquiv(actual, expected);
+            }
+        }
+
+        function isArguments(object) {
+            return Object.prototype.toString.call(object) == '[object Arguments]';
+        }
+
+        function objEquiv(a, b) {
+            if (util.isNullOrUndefined(a) || util.isNullOrUndefined(b))
+                return false;
+            // an identical 'prototype' property.
+            if (a.prototype !== b.prototype) return false;
+            //~~~I've managed to break Object.keys through screwy arguments passing.
+            //   Converting to array solves the problem.
+            var aIsArgs = isArguments(a),
+                bIsArgs = isArguments(b);
+            if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))
+                return false;
+            if (aIsArgs) {
+                a = pSlice.call(a);
+                b = pSlice.call(b);
+                return _deepEqual(a, b);
+            }
+            try {
+                var ka = Object.keys(a),
+                    kb = Object.keys(b),
+                    key, i;
+            } catch (e) { //happens when one is a string literal and the other isn't
+                return false;
+            }
+            // having the same number of owned properties (keys incorporates
+            // hasOwnProperty)
+            if (ka.length != kb.length)
+                return false;
+            //the same set of keys (although not necessarily the same order),
+            ka.sort();
+            kb.sort();
+            //~~~cheap key test
+            for (i = ka.length - 1; i >= 0; i--) {
+                if (ka[i] != kb[i])
+                    return false;
+            }
+            //equivalent values for every corresponding key, and
+            //~~~possibly expensive deep test
+            for (i = ka.length - 1; i >= 0; i--) {
+                key = ka[i];
+                if (!_deepEqual(a[key], b[key])) return false;
+            }
+            return true;
+        }
+
+        // 8. The non-equivalence assertion tests for any deep inequality.
+        // assert.notDeepEqual(actual, expected, message_opt);
+
+        assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
+            if (_deepEqual(actual, expected)) {
+                fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);
+            }
+        };
+
+        // 9. The strict equality assertion tests strict equality, as determined by ===.
+        // assert.strictEqual(actual, expected, message_opt);
+
+        assert.strictEqual = function strictEqual(actual, expected, message) {
+            if (actual !== expected) {
+                fail(actual, expected, message, '===', assert.strictEqual);
+            }
+        };
+
+        // 10. The strict non-equality assertion tests for strict inequality, as
+        // determined by !==.  assert.notStrictEqual(actual, expected, message_opt);
+
+        assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
+            if (actual === expected) {
+                fail(actual, expected, message, '!==', assert.notStrictEqual);
+            }
+        };
+
+        function expectedException(actual, expected) {
+            if (!actual || !expected) {
+                return false;
+            }
+
+            if (Object.prototype.toString.call(expected) == '[object RegExp]') {
+                return expected.test(actual);
+            } else if (actual instanceof expected) {
+                return true;
+            } else if (expected.call({}, actual) === true) {
+                return true;
+            }
+
+            return false;
+        }
+
+        function _throws(shouldThrow, block, expected, message) {
+            var actual;
+
+            if (util.isString(expected)) {
+                message = expected;
+                expected = null;
+            }
+
+            try {
+                block();
+            } catch (e) {
+                actual = e;
+            }
+
+            message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +
+                (message ? ' ' + message : '.');
+
+            if (shouldThrow && !actual) {
+                fail(actual, expected, 'Missing expected exception' + message);
+            }
+
+            if (!shouldThrow && expectedException(actual, expected)) {
+                fail(actual, expected, 'Got unwanted exception' + message);
+            }
+
+            if ((shouldThrow && actual && expected &&
+                !expectedException(actual, expected)) || (!shouldThrow && actual)) {
+                throw actual;
+            }
+        }
+
+        // 11. Expected to throw an error:
+        // assert.throws(block, Error_opt, message_opt);
+
+        assert.throws = function (block, /*optional*/ error, /*optional*/ message) {
+            _throws.apply(this, [true].concat(pSlice.call(arguments)));
+        };
+
+        // EXTENSION! This is annoying to write outside this module.
+        assert.doesNotThrow = function (block, /*optional*/ message) {
+            _throws.apply(this, [false].concat(pSlice.call(arguments)));
+        };
+
+        assert.ifError = function (err) {
+            if (err) {
+                throw err;
+            }
+        };
+    });
+    
+
+    (function () {
+
+        // es5-safe
+        // ----------------
+        // Provides compatibility shims so that legacy JavaScript engines behave as
+        // closely as possible to ES5.
+        //
+        // Thanks to:
+        //  - http://es5.github.com/
+        //  - http://kangax.github.com/es5-compat-table/
+        //  - https://github.com/kriskowal/es5-shim
+        //  - http://perfectionkills.com/extending-built-in-native-objects-evil-or-not/
+        //  - https://gist.github.com/1120592
+        //  - https://code.google.com/p/v8/
+
+
+        var OP = Object.prototype;
+        var AP = Array.prototype;
+        var FP = Function.prototype;
+        var SP = String.prototype;
+        var hasOwnProperty = OP.hasOwnProperty;
+        var slice = AP.slice;
+
+
+        /*---------------------------------------*
+         * Function
+         *---------------------------------------*/
+
+        // ES-5 15.3.4.5
+        // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Function/bind
+        FP.bind || (FP.bind = function (that) {
+            var target = this;
+
+            // If IsCallable(func) is false, throw a TypeError exception.
+            if (typeof target !== 'function') {
+                throw new TypeError('Bind must be called on a function');
+            }
+
+            var boundArgs = slice.call(arguments, 1);
+
+            function bound() {
+                // Called as a constructor.
+                if (this instanceof bound) {
+                    var self = createObject(target.prototype);
+                    var result = target.apply(
+                        self,
+                        boundArgs.concat(slice.call(arguments))
+                    );
+                    return Object(result) === result ? result : self;
+                }
+                // Called as a function.
+                else {
+                    return target.apply(
+                        that,
+                        boundArgs.concat(slice.call(arguments))
+                    );
+                }
+            }
+
+            // NOTICE: The function.length is not writable.
+            //bound.length = Math.max(target.length - boundArgs.length, 0);
+
+            return bound;
+        });
+
+
+        // Helpers
+
+        function createObject(proto) {
+            var o;
+
+            if (Object.create) {
+                o = Object.create(proto);
+            } else {
+                /** @constructor */
+
+                function F() {}
+
+                F.prototype = proto;
+                o = new F();
+            }
+
+            return o;
+        }
+
+
+        /*---------------------------------------*
+         * Object
+         *---------------------------------------*/
+        // http://ejohn.org/blog/ecmascript-5-objects-and-properties/
+
+        // ES5 15.2.3.14
+        // http://whattheheadsaid.com/2010/10/a-safer-object-keys-compatibility-implementation
+        // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Object/keys
+        // https://developer.mozilla.org/en/ECMAScript_DontEnum_attribute
+        // http://msdn.microsoft.com/en-us/library/adebfyya(v=vs.94).aspx
+        Object.keys || (Object.keys = (function () {
+            var hasDontEnumBug = !{
+                toString: ''
+            }.propertyIsEnumerable('toString');
+            var DontEnums = [
+                'toString',
+                'toLocaleString',
+                'valueOf',
+                'hasOwnProperty',
+                'isPrototypeOf',
+                'propertyIsEnumerable',
+                'constructor'
+            ];
+            var DontEnumsLength = DontEnums.length;
+
+            return function (o) {
+                if (o !== Object(o)) {
+                    throw new TypeError(o + ' is not an object');
+                }
+
+                var result = [];
+
+                for (var name in o) {
+                    if (hasOwnProperty.call(o, name)) {
+                        result.push(name);
+                    }
+                }
+
+                if (hasDontEnumBug) {
+                    for (var i = 0; i < DontEnumsLength; i++) {
+                        if (hasOwnProperty.call(o, DontEnums[i])) {
+                            result.push(DontEnums[i]);
+                        }
+                    }
+                }
+
+                return result;
+            };
+
+        })());
+
+
+        // ES5 1.8.5
+        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames
+        Object.getOwnPropertyNames || (Object.getOwnPropertyNames = function (obj) {
+            var keys = [];
+
+            // Only iterate the keys if we were given an object, and
+            // a special check for null, as typeof null == "object"
+            if (typeof obj === "object" && obj !== null) {
+                // Use a standard for in loop
+                for (var x in obj) {
+                    // A for in will iterate over members on the prototype
+                    // chain as well, but Object.getOwnPropertyNames returns
+                    // only those directly on the object, so use hasOwnProperty.
+                    if (obj.hasOwnProperty(x)) {
+                        keys.push(x);
+                    }
+                }
+            }
+
+            return keys;
+        });
+
+
+
+        /*---------------------------------------*
+         * Array
+         *---------------------------------------*/
+        // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array
+        // https://github.com/kangax/fabric.js/blob/gh-pages/src/util/lang_array.js
+
+        // ES5 15.4.3.2
+        // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/isArray
+        Array.isArray || (Array.isArray = function (obj) {
+            return OP.toString.call(obj) === '[object Array]';
+        });
+
+
+        // ES5 15.4.4.18
+        // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/array/foreach
+        AP.forEach || (AP.forEach = function (fn, context) {
+            for (var i = 0, len = this.length >>> 0; i < len; i++) {
+                if (i in this) {
+                    fn.call(context, this[i], i, this);
+                }
+            }
+        });
+
+
+        // ES5 15.4.4.19
+        // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map
+        AP.map || (AP.map = function (fn, context) {
+            var len = this.length >>> 0;
+            var result = new Array(len);
+
+            for (var i = 0; i < len; i++) {
+                if (i in this) {
+                    result[i] = fn.call(context, this[i], i, this);
+                }
+            }
+
+            return result;
+        });
+
+
+        // ES5 15.4.4.20
+        // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/filter
+        AP.filter || (AP.filter = function (fn, context) {
+            var result = [],
+                val;
+
+            for (var i = 0, len = this.length >>> 0; i < len; i++) {
+                if (i in this) {
+                    val = this[i]; // in case fn mutates this
+                    if (fn.call(context, val, i, this)) {
+                        result.push(val);
+                    }
+                }
+            }
+
+            return result;
+        });
+
+
+        // ES5 15.4.4.16
+        // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/every
+        AP.every || (AP.every = function (fn, context) {
+            for (var i = 0, len = this.length >>> 0; i < len; i++) {
+                if (i in this && !fn.call(context, this[i], i, this)) {
+                    return false;
+                }
+            }
+            return true;
+        });
+
+
+        // ES5 15.4.4.17
+        // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/some
+        AP.some || (AP.some = function (fn, context) {
+            for (var i = 0, len = this.length >>> 0; i < len; i++) {
+                if (i in this && fn.call(context, this[i], i, this)) {
+                    return true;
+                }
+            }
+            return false;
+        });
+
+
+        // ES5 15.4.4.21
+        // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/reduce
+        AP.reduce || (AP.reduce = function (fn /*, initial*/ ) {
+            if (typeof fn !== 'function') {
+                throw new TypeError(fn + ' is not an function');
+            }
+
+            var len = this.length >>> 0,
+                i = 0,
+                result;
+
+            if (arguments.length > 1) {
+                result = arguments[1];
+            } else {
+                do {
+                    if (i in this) {
+                        result = this[i++];
+                        break;
+                    }
+                    // if array contains no values, no initial value to return
+                    if (++i >= len) {
+                        throw new TypeError('reduce of empty array with on initial value');
+                    }
+                }
+                while (true);
+            }
+
+            for (; i < len; i++) {
+                if (i in this) {
+                    result = fn.call(null, result, this[i], i, this);
+                }
+            }
+
+            return result;
+        });
+
+
+        // ES5 15.4.4.22
+        // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/reduceRight
+        AP.reduceRight || (AP.reduceRight = function (fn /*, initial*/ ) {
+            if (typeof fn !== 'function') {
+                throw new TypeError(fn + ' is not an function');
+            }
+
+            var len = this.length >>> 0,
+                i = len - 1,
+                result;
+
+            if (arguments.length > 1) {
+                result = arguments[1];
+            } else {
+                do {
+                    if (i in this) {
+                        result = this[i--];
+                        break;
+                    }
+                    // if array contains no values, no initial value to return
+                    if (--i < 0)
+                        throw new TypeError('reduce of empty array with on initial value');
+                }
+                while (true);
+            }
+
+            for (; i >= 0; i--) {
+                if (i in this) {
+                    result = fn.call(null, result, this[i], i, this);
+                }
+            }
+
+            return result;
+        });
+
+
+        // ES5 15.4.4.14
+        // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/indexOf
+        AP.indexOf || (AP.indexOf = function (value, from) {
+            var len = this.length >>> 0;
+
+            from = Number(from) || 0;
+            from = Math[from < 0 ? 'ceil' : 'floor'](from);
+            if (from < 0) {
+                from = Math.max(from + len, 0);
+            }
+
+            for (; from < len; from++) {
+                if (from in this && this[from] === value) {
+                    return from;
+                }
+            }
+
+            return -1;
+        });
+
+
+        // ES5 15.4.4.15
+        // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/indexOf
+        AP.lastIndexOf || (AP.lastIndexOf = function (value, from) {
+            var len = this.length >>> 0;
+
+            from = Number(from) || len - 1;
+            from = Math[from < 0 ? 'ceil' : 'floor'](from);
+            if (from < 0) {
+                from += len;
+            }
+            from = Math.min(from, len - 1);
+
+            for (; from >= 0; from--) {
+                if (from in this && this[from] === value) {
+                    return from;
+                }
+            }
+
+            return -1;
+        });
+
+
+        /*---------------------------------------*
+         * String
+         *---------------------------------------*/
+
+        // ES5 15.5.4.20
+        // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/String/trim
+        // http://blog.stevenlevithan.com/archives/faster-trim-javascript
+        // http://jsperf.com/mega-trim-test
+        SP.trim || (SP.trim = (function () {
+
+            // http://perfectionkills.com/whitespace-deviations/
+            var whiteSpaces = [
+
+                '\\s',
+                //'0009', // 'HORIZONTAL TAB'
+                //'000A', // 'LINE FEED OR NEW LINE'
+                //'000B', // 'VERTICAL TAB'
+                //'000C', // 'FORM FEED'
+                //'000D', // 'CARRIAGE RETURN'
+                //'0020', // 'SPACE'
+
+                '00A0', // 'NO-BREAK SPACE'
+                '1680', // 'OGHAM SPACE MARK'
+                '180E', // 'MONGOLIAN VOWEL SEPARATOR'
+
+                '2000-\\u200A',
+                //'2000', // 'EN QUAD'
+                //'2001', // 'EM QUAD'
+                //'2002', // 'EN SPACE'
+                //'2003', // 'EM SPACE'
+                //'2004', // 'THREE-PER-EM SPACE'
+                //'2005', // 'FOUR-PER-EM SPACE'
+                //'2006', // 'SIX-PER-EM SPACE'
+                //'2007', // 'FIGURE SPACE'
+                //'2008', // 'PUNCTUATION SPACE'
+                //'2009', // 'THIN SPACE'
+                //'200A', // 'HAIR SPACE'
+
+                '200B', // 'ZERO WIDTH SPACE (category Cf)
+                '2028', // 'LINE SEPARATOR'
+                '2029', // 'PARAGRAPH SEPARATOR'
+                '202F', // 'NARROW NO-BREAK SPACE'
+                '205F', // 'MEDIUM MATHEMATICAL SPACE'
+                '3000' //  'IDEOGRAPHIC SPACE'
+
+            ].join('\\u');
+
+            var trimLeftReg = new RegExp('^[' + whiteSpaces + ']+');
+            var trimRightReg = new RegExp('[' + whiteSpaces + ']+$');
+
+            return function () {
+                return String(this).replace(trimLeftReg, '').replace(trimRightReg, '');
+            }
+
+        })());
+
+
+        /*---------------------------------------*
+         * Date
+         *---------------------------------------*/
+
+        // ES5 15.9.4.4
+        // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Date/now
+        Date.now || (Date.now = function () {
+            return +new Date;
+        });
+
+    })();
+
+
+    /*
+    json2.js
+    2013-05-26
+
+    Public Domain.
+
+    NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
+
+    See http://www.JSON.org/js.html
+
+
+    This code should be minified before deployment.
+    See http://javascript.crockford.com/jsmin.html
+    */
+
+
+    if (typeof JSON !== 'object') {
+        JSON = {};
+    }
+
+    (function () {
+        'use strict';
+
+        function f(n) {
+            return n < 10 ? '0' + n : n;
+        }
+
+        if (typeof Date.prototype.toJSON !== 'function') {
+
+            Date.prototype.toJSON = function () {
+
+                return isFinite(this.valueOf()) ? this.getUTCFullYear() + '-' +
+                    f(this.getUTCMonth() + 1) + '-' +
+                    f(this.getUTCDate()) + 'T' +
+                    f(this.getUTCHours()) + ':' +
+                    f(this.getUTCMinutes()) + ':' +
+                    f(this.getUTCSeconds()) + 'Z' : null;
+            };
+
+            String.prototype.toJSON =
+                Number.prototype.toJSON =
+                Boolean.prototype.toJSON = function () {
+                    return this.valueOf();
+            };
+        }
+
+        var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
+            escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
+            gap,
+            indent,
+            meta = {
+                '\b': '\\b',
+                '\t': '\\t',
+                '\n': '\\n',
+                '\f': '\\f',
+                '\r': '\\r',
+                '"': '\\"',
+                '\\': '\\\\'
+            },
+            rep;
+
+
+        function quote(string) {
+
+            escapable.lastIndex = 0;
+            return escapable.test(string) ? '"' + string.replace(escapable, function (a) {
+                var c = meta[a];
+                return typeof c === 'string' ? c : '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+            }) + '"' : '"' + string + '"';
+        }
+
+
+        function str(key, holder) {
+
+            var i,
+                k,
+                v,
+                length,
+                mind = gap,
+                partial,
+                value = holder[key];
+
+            if (value && typeof value === 'object' &&
+                typeof value.toJSON === 'function') {
+                value = value.toJSON(key);
+            }
+
+            if (typeof rep === 'function') {
+                value = rep.call(holder, key, value);
+            }
+
+            switch (typeof value) {
+            case 'string':
+                return quote(value);
+
+            case 'number':
+
+                return isFinite(value) ? String(value) : 'null';
+
+            case 'boolean':
+            case 'null':
+
+                return String(value);
+
+
+            case 'object':
+
+
+                if (!value) {
+                    return 'null';
+                }
+
+
+                gap += indent;
+                partial = [];
+
+
+                if (Object.prototype.toString.apply(value) === '[object Array]') {
+
+
+                    length = value.length;
+                    for (i = 0; i < length; i += 1) {
+                        partial[i] = str(i, value) || 'null';
+                    }
+
+
+                    v = partial.length === 0 ? '[]' : gap ? '[\n' + gap + partial.join(',\n' + gap) + '\n' + mind + ']' : '[' + partial.join(',') + ']';
+                    gap = mind;
+                    return v;
+                }
+
+
+                if (rep && typeof rep === 'object') {
+                    length = rep.length;
+                    for (i = 0; i < length; i += 1) {
+                        if (typeof rep[i] === 'string') {
+                            k = rep[i];
+                            v = str(k, value);
+                            if (v) {
+                                partial.push(quote(k) + (gap ? ': ' : ':') + v);
+                            }
+                        }
+                    }
+                } else {
+
+                    for (k in value) {
+                        if (Object.prototype.hasOwnProperty.call(value, k)) {
+                            v = str(k, value);
+                            if (v) {
+                                partial.push(quote(k) + (gap ? ': ' : ':') + v);
+                            }
+                        }
+                    }
+                }
+
+                v = partial.length === 0 ? '{}' : gap ? '{\n' + gap + partial.join(',\n' + gap) + '\n' + mind + '}' : '{' + partial.join(',') + '}';
+                gap = mind;
+                return v;
+            }
+        }
+
+        if (typeof JSON.stringify !== 'function') {
+            JSON.stringify = function (value, replacer, space) {
+
+                var i;
+                gap = '';
+                indent = '';
+
+
+                if (typeof space === 'number') {
+                    for (i = 0; i < space; i += 1) {
+                        indent += ' ';
+                    }
+
+
+                } else if (typeof space === 'string') {
+                    indent = space;
+                }
+
+
+                rep = replacer;
+                if (replacer && typeof replacer !== 'function' &&
+                    (typeof replacer !== 'object' ||
+                        typeof replacer.length !== 'number')) {
+                    throw new Error('JSON.stringify');
+                }
+
+                return str('', {
+                    '': value
+                });
+            };
+        }
+
+        if (typeof JSON.parse !== 'function') {
+            JSON.parse = function (text, reviver) {
+
+                var j;
+
+                function walk(holder, key) {
+
+                    var k, v, value = holder[key];
+                    if (value && typeof value === 'object') {
+                        for (k in value) {
+                            if (Object.prototype.hasOwnProperty.call(value, k)) {
+                                v = walk(value, k);
+                                if (v !== undefined) {
+                                    value[k] = v;
+                                } else {
+                                    delete value[k];
+                                }
+                            }
+                        }
+                    }
+                    return reviver.call(holder, key, value);
+                }
+
+                text = String(text);
+                cx.lastIndex = 0;
+                if (cx.test(text)) {
+                    text = text.replace(cx, function (a) {
+                        return '\\u' +
+                            ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+                    });
+                }
+
+                if (/^[\],:{}\s]*$/
+                    .test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@')
+                        .replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']')
+                        .replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
+
+                    j = eval('(' + text + ')');
+
+                    return typeof reviver === 'function' ? walk({
+                        '': j
+                    }, '') : j;
+                }
+
+                throw new SyntaxError('JSON.parse');
+            };
+        }
+    }());
+
+
+    global.console = require('console');
+
+}(this, {}));
+
+WScript.Sleep(500);
+
+/*
+:cmd
+::if %errorlevel% == 0 exit
+pause>nul
+::*/
\ No newline at end of file
diff --git a/test/test.js b/test/test.js
new file mode 100644
index 0000000..602ea8c
--- /dev/null
+++ b/test/test.js
@@ -0,0 +1,171 @@
+var fs = require('fs');
+var path = require('path');
+var assert = require('assert');
+
+var index = 0;
+var log = function (label, message) {
+	console.log("> " + label);
+	console.log(message);
+}
+
+var label = function (label) {
+	index ++;
+	console.log("[" + index + "] " + label + '');
+};
+
+
+if (typeof WScript === 'object') {
+	console.log('node2bat 支持核心的 NodeJS API，并且支持 ECMA5 新增加的 JS 方法');
+	console.log('\n');
+	console.log('global');
+	console.log('    ' + Object.keys(global).join(', '));
+	console.log('process');
+	console.log('    ' + Object.keys(global.process).join(', '));
+	console.log('console');
+	console.log('    ' + Object.keys(global.console).join(', '));
+	console.log("require('fs')");
+	console.log('    ' + Object.keys(require('fs')).join(', '));
+	console.log("require('path')");
+	console.log('    ' + Object.keys(require('path')).join(', '));
+	console.log("require('util')");
+	console.log('    ' + Object.keys(require('util')).join(', '));
+
+	console.log('\n');
+	console.log('NodeJS API: http://nodejs.org/api/index.html');
+	console.log('----------------------------------------------------');
+	console.log('\n');
+}
+
+label('当前运行的文件名');
+log("__filename", __filename);
+
+label('进程当前工作目录');
+log("__dirname", __dirname);
+
+label('进程');
+log("process", process);
+
+label('进程当前工作目录');
+log("process.cwd()", process.cwd());
+
+label('向终端打印信息');
+log("process.stdout.write('hello world')", '');
+process.stdout.write('hello world');
+
+label('读取外部 json');
+log("require('../package.json').name", require('../package.json').name);
+
+try {
+	fs.mkdirSync('./temp');
+} catch(e) {}
+
+try {
+	fs.mkdirSync('./temp/folder');
+} catch(e) {}
+
+
+label('删除已有的文件夹');
+log("fs.rmdirSync('./temp/folder')", fs.rmdirSync('./temp/folder'));
+
+label('创建文件夹')
+log("fs.mkdirSync('./temp/folder')", fs.mkdirSync('./temp/folder'));
+
+// 创建文件夹（目标已经存在）
+assert.throws(function () {
+	return fs.mkdirSync('./temp/folder');
+});
+
+label('重命名文件夹');
+log("fs.renameSync('./temp/folder', './temp/folder_2')", fs.renameSync('./temp/folder', './temp/folder_2'));
+
+label('删除已有的文件夹');
+log("fs.rmdirSync('./temp/folder_2')", fs.rmdirSync('./temp/folder_2'));
+
+// 重命名文件夹（源文件夹不存在）
+assert.throws(function () {
+	return fs.renameSync('./temp/folder', './temp/folder_2');
+});
+
+label('创建 utf-8 的文本（无 BOM）');
+log("fs.writeFileSync('./temp/file.txt', '糖饼', 'utf-8')", fs.writeFileSync('./temp/file.txt', '糖饼', 'utf-8'));
+
+label('读取 utf-8 的文本');
+log("fs.readFileSync('./temp/file.txt', 'utf-8')", fs.readFileSync('./temp/file.txt', 'utf-8'));
+
+label('写入 ascii 的文本');
+log("fs.writeFileSync('./temp/file.txt', 'hello world', 'ascii')", fs.writeFileSync('./temp/file.txt', 'hello world', 'ascii'));
+
+label('读取 ascii 的文本');
+log("fs.readFileSync('./temp/file.txt', 'ascii')", fs.readFileSync('./temp/file.txt', 'ascii'));
+
+label('判断文件或目录是否存在');
+log("fs.existsSync('./temp/file.txt')", fs.existsSync('./temp/file.txt'));
+
+label('判断文件或目录是否存在');
+log("fs.existsSync('./temp/folder')", fs.existsSync('./temp/folder'));
+
+label('判断文件或目录是否存在');
+log("fs.existsSync('./temp/777')", fs.existsSync('./temp/777'));
+
+label('读取目录信息');
+log("fs.statSync('./temp')", fs.statSync('./temp'));
+
+label('读取文件信息');
+log("fs.statSync('./temp/file.txt')", fs.statSync('./temp/file.txt'));
+
+label('判断目录');
+log("fs.statSync('./temp').isDirectory()", fs.statSync('./temp').isDirectory());
+
+label('判断文件');
+log("fs.statSync('./temp').isFile()", fs.statSync('./temp').isFile());
+
+// 判断不存在的目录或文件
+assert.throws(function () {
+	return fs.statSync('./temp_12345');
+});
+
+label('删除文件');
+log("fs.unlinkSync('./temp/file.txt')", fs.unlinkSync('./temp/file.txt'));
+
+// 读取不存在的 json 文件
+assert.throws(function () {
+	return require('../package_12345.json');
+});
+
+label('格式化路径');
+log("path.normalize('/foo/bar//baz/asdf/quux/..')", path.normalize('/foo/bar//baz/asdf/quux/..'));
+
+label('路径联合');
+log("path.join('/foo', 'bar', 'baz/asdf', 'quux', '..')", path.join('/foo', 'bar', 'baz/asdf', 'quux', '..'));
+
+label('路径寻航');
+log("path.resolve('/foo/bar', './baz')", path.resolve('/foo/bar', './baz'));
+log("path.resolve('/foo/bar', '/tmp/file/')", path.resolve('/foo/bar', '/tmp/file/'));
+log("path.resolve('wwwroot', 'static_files/png/', '../gif/image.gif')", path.resolve('wwwroot', 'static_files/png/', '../gif/image.gif'));
+
+label('相对路径');
+log("path.relative('C:\\orandea\\test\\aaa', 'C:\\orandea\\impl\\bbb')", path.relative('C:\\orandea\\test\\aaa', 'C:\\orandea\\impl\\bbb'));
+log("path.relative('/data/orandea/test/aaa', '/data/orandea/impl/bbb')", path.relative('/data/orandea/test/aaa', '/data/orandea/impl/bbb'));
+
+label("文件夹名称");
+log("path.dirname('/foo/bar/baz/asdf/quux')", path.dirname('/foo/bar/baz/asdf/quux'));
+
+label("文件名称");
+log("path.basename('/foo/bar/baz/asdf/quux.html')", path.basename('/foo/bar/baz/asdf/quux.html'));
+log("path.basename('/foo/bar/baz/asdf/quux.html', '.html')", path.basename('/foo/bar/baz/asdf/quux.html', '.html'));
+
+label("扩展名称");
+log("path.extname('index.html')", path.extname('index.html'));
+log("path.extname('index.coffee.md')", path.extname('index.coffee.md'));
+log("path.extname('index.')", path.extname('index.'));
+log("path.extname('index')", path.extname('index'));
+
+label("路径分隔符");
+log("'foo/bar/baz'.split(path.sep)", 'foo/bar/baz'.split(path.sep));
+log("'foo\\bar\\baz'.split(path.sep)", 'foo\\bar\\baz'.split(path.sep));
+
+label("路径界定符");
+log("process.env.PATH.split(path.delimiter)", process.env.PATH.split(path.delimiter));
+
+
+
diff --git a/test/test/public/footer.html b/test/test/public/footer.html
deleted file mode 100755
index 1dd2dbb..0000000
--- a/test/test/public/footer.html
+++ /dev/null
@@ -1,3 +0,0 @@
-	<div id="footer">
-		(c) 2013 <a href="https://github.com/aui">github.com/aui</a>
-	</div>
\ No newline at end of file