From 789308a12a3f16a9ff67844b26044fb8ff9e156a Mon Sep 17 00:00:00 2001
From: Lieuwe Rooijakkers <lieuwerooijakkers@gmail.com>
Date: Wed, 10 Jun 2015 14:36:22 +0200
Subject: [PATCH 01/18] add empty planner package

---
 .meteor/packages                  |  1 +
 .meteor/versions                  |  1 +
 packages/planner/README.md        |  0
 packages/planner/package.js       | 22 ++++++++++++++++++++++
 packages/planner/planner-tests.js |  5 +++++
 packages/planner/planner.js       |  1 +
 6 files changed, 30 insertions(+)
 create mode 100644 packages/planner/README.md
 create mode 100644 packages/planner/package.js
 create mode 100644 packages/planner/planner-tests.js
 create mode 100644 packages/planner/planner.js

diff --git a/.meteor/packages b/.meteor/packages
index f504d7d6..141449c4 100644
--- a/.meteor/packages
+++ b/.meteor/packages
@@ -45,3 +45,4 @@ rzymek:moment-locale-nl
 appshore:recaptcha
 tmeasday:publish-counts
 tail:core
+planner
diff --git a/.meteor/versions b/.meteor/versions
index 75a2a932..c11bcd16 100644
--- a/.meteor/versions
+++ b/.meteor/versions
@@ -76,6 +76,7 @@ ordered-dict@1.0.3
 percolate:paginated-subscription@0.2.4
 percolate:synced-cron@1.2.0
 percolate:velocityjs@1.2.1_1
+planner@0.0.1
 qnub:emojione@0.0.3
 random@1.0.3
 reactive-dict@1.1.0
diff --git a/packages/planner/README.md b/packages/planner/README.md
new file mode 100644
index 00000000..e69de29b
diff --git a/packages/planner/package.js b/packages/planner/package.js
new file mode 100644
index 00000000..d08be307
--- /dev/null
+++ b/packages/planner/package.js
@@ -0,0 +1,22 @@
+Package.describe({
+  name: 'planner',
+  version: '0.0.1',
+  // Brief, one-line summary of the package.
+  summary: 'The plan algorithm of simplyHomework.',
+  // URL to the Git repository containing the source code for this package.
+  git: '',
+  // By default, Meteor will default to using README.md for documentation.
+  // To avoid submitting documentation, set this field to null.
+  documentation: 'README.md'
+});
+
+Package.onUse(function(api) {
+  api.versionsFrom('1.1.0.2');
+  api.addFiles('planner.js');
+});
+
+Package.onTest(function(api) {
+  api.use('tinytest');
+  api.use('planner');
+  api.addFiles('planner-tests.js');
+});
diff --git a/packages/planner/planner-tests.js b/packages/planner/planner-tests.js
new file mode 100644
index 00000000..c5623d89
--- /dev/null
+++ b/packages/planner/planner-tests.js
@@ -0,0 +1,5 @@
+// Write your tests here!
+// Here is an example.
+Tinytest.add('example', function (test) {
+  test.equal(true, true);
+});
diff --git a/packages/planner/planner.js b/packages/planner/planner.js
new file mode 100644
index 00000000..164ddd9e
--- /dev/null
+++ b/packages/planner/planner.js
@@ -0,0 +1 @@
+// Write your package code here!

From 0f2444e615f408d11c7663c8bd654686fc4d5c28 Mon Sep 17 00:00:00 2001
From: tomsmeding <hallo@tomsmeding.nl>
Date: Wed, 10 Jun 2015 14:42:27 +0200
Subject: [PATCH 02/18] Beginning for planner

---
 packages/planner/planner.js | 94 ++++++++++++++++++++++++++++++++++++-
 1 file changed, 93 insertions(+), 1 deletion(-)

diff --git a/packages/planner/planner.js b/packages/planner/planner.js
index 164ddd9e..ad6dad34 100644
--- a/packages/planner/planner.js
+++ b/packages/planner/planner.js
@@ -1 +1,93 @@
-// Write your package code here!
+var assert=require("assert");
+
+function HomeworkDescription(){
+	if(!(this instanceof HomeworkDescription))return new HomeworkDescription;
+
+	//A unique identifier for a subject. Can be pretty much anything, lest it's a primitive type
+	// and unique and fixed, i.e. there is only one identifier per subject and only one subject per identifier.
+	this.subject=null;
+
+	//Items in `location` can be multiple things, e.g.
+	//- [chapter,paragraph,exercise]
+	//- [bookid,page,exercise]
+	//- [chapter,exercise]
+	//- [bookid,page]
+	//In general, anything that can be expressed in a sequence of integers that specifies the location.
+	//The `location` property contains an array of those, because homework can be multiple exercises, for example.
+	//Please make the array contiguous, though; don't mix indexing conventions! (!) (!!)
+	this.location=[];
+}
+
+function Planner(){
+	if(!(this instanceof Planner))return new Planner;
+
+	var subjects={}; //The Cache
+
+	//`timetaken` in any unit you find convenient; but please be consistent. Suggestion: seconds.
+	this.learn=function(hwdesc,timetaken){
+		var i,j,idx,subj,loc;
+		assert(hwdesc instanceof HomeworkDescription);
+		subj=hwdesc.subject;
+		loc=hwdesc.location;
+		assert(loc.length!=0);
+		if(!subjects[subj]){
+			subjects[subj]=new Array(loc[0].length);
+			for(i=0;i<loc[0].length;i++){
+				if(!subjects[subj][i])subjects[subj][i]={};
+				for(j=0;j<loc.length;j++){
+					if(subjects[subj][i][loc[j][i]]){
+						subjects[subj][i][loc[j][i]].push(timetaken/loc.length);
+					} else {
+						subjects[subj][i][loc[j][i]]=[timetaken/loc.length];
+					}
+				}
+			}
+		}
+	};
+
+	this.estimate=function(hwdesc){
+		var subj,loc;
+		assert(hwdesc instanceof HomeworkDescription);
+		subj=hwdesc.subject;
+		loc=hwdesc.location;
+		var total=0;
+		loc.forEach(function(locitem){
+			total+=rms(subjects[subj].map(function(sitem,i){
+				console.log(sitem,locitem[i],sitem[locitem[i]]);
+				return rms(sitem[locitem[i]]);
+			}));
+		});
+		return total;
+	};
+
+	this.persistable=function(){
+		return subjects;
+	}
+}
+
+
+function rms(arr){
+	var sum,i,len;
+	sum=0;
+	len=arr.length;
+	for(i=0;i<len;i++)sum+=arr[i]*arr[i];
+	return Math.sqrt(sum/len);
+}
+
+
+
+module.exports={
+	HomeworkDescription:HomeworkDescription,
+	Planner:Planner
+};
+
+/*
+var REQ=require("./planner");
+var h=REQ.HomeworkDescription();
+h.subject="ne";
+h.location=[[1,2],[1,3]];
+var P=REQ.Planner();
+P.learn(h,10);
+console.log(util.inspect(P.persistable(),{depth:10}));
+P.estimate(h);
+*/

From f2e52150f014a991e9c888350fd45fbe37371eb4 Mon Sep 17 00:00:00 2001
From: Lieuwe Rooijakkers <lieuwerooijakkers@gmail.com>
Date: Wed, 10 Jun 2015 14:48:03 +0200
Subject: [PATCH 03/18] meteorify current planner

---
 packages/planner/package.js | 31 +++++++++++++++++--------------
 packages/planner/planner.js | 13 +++----------
 2 files changed, 20 insertions(+), 24 deletions(-)

diff --git a/packages/planner/package.js b/packages/planner/package.js
index d08be307..6f8b1b61 100644
--- a/packages/planner/package.js
+++ b/packages/planner/package.js
@@ -1,22 +1,25 @@
 Package.describe({
-  name: 'planner',
-  version: '0.0.1',
-  // Brief, one-line summary of the package.
-  summary: 'The plan algorithm of simplyHomework.',
-  // URL to the Git repository containing the source code for this package.
-  git: '',
-  // By default, Meteor will default to using README.md for documentation.
-  // To avoid submitting documentation, set this field to null.
-  documentation: 'README.md'
+	name: 'planner',
+	version: '0.0.1',
+	// Brief, one-line summary of the package.
+	summary: 'The plan algorithm of simplyHomework.',
+	// URL to the Git repository containing the source code for this package.
+	git: '',
+	// By default, Meteor will default to using README.md for documentation.
+	// To avoid submitting documentation, set this field to null.
+	documentation: 'README.md'
 });
 
 Package.onUse(function(api) {
-  api.versionsFrom('1.1.0.2');
-  api.addFiles('planner.js');
+	api.versionsFrom('1.1.0.2');
+	api.addFiles('planner.js');
+
+	api.export("HomeworkDescription");
+	api.export("Planner");
 });
 
 Package.onTest(function(api) {
-  api.use('tinytest');
-  api.use('planner');
-  api.addFiles('planner-tests.js');
+	api.use('tinytest');
+	api.use('planner');
+	api.addFiles('planner-tests.js');
 });
diff --git a/packages/planner/planner.js b/packages/planner/planner.js
index ad6dad34..868cc40a 100644
--- a/packages/planner/planner.js
+++ b/packages/planner/planner.js
@@ -1,6 +1,6 @@
-var assert=require("assert");
+var assert = Npm.require("assert");
 
-function HomeworkDescription(){
+HomeworkDescription = function () {
 	if(!(this instanceof HomeworkDescription))return new HomeworkDescription;
 
 	//A unique identifier for a subject. Can be pretty much anything, lest it's a primitive type
@@ -18,7 +18,7 @@ function HomeworkDescription(){
 	this.location=[];
 }
 
-function Planner(){
+Planner = function () {
 	if(!(this instanceof Planner))return new Planner;
 
 	var subjects={}; //The Cache
@@ -74,13 +74,6 @@ function rms(arr){
 	return Math.sqrt(sum/len);
 }
 
-
-
-module.exports={
-	HomeworkDescription:HomeworkDescription,
-	Planner:Planner
-};
-
 /*
 var REQ=require("./planner");
 var h=REQ.HomeworkDescription();

From 41b7f21521a4d2d7f63edd4bb7c2f4b900f08423 Mon Sep 17 00:00:00 2001
From: tomsmeding <hallo@tomsmeding.nl>
Date: Wed, 10 Jun 2015 16:24:55 +0200
Subject: [PATCH 04/18] Make planner meteory and nodey at the same time

---
 packages/planner/planner.js | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/packages/planner/planner.js b/packages/planner/planner.js
index 868cc40a..51cc6e24 100644
--- a/packages/planner/planner.js
+++ b/packages/planner/planner.js
@@ -1,6 +1,8 @@
-var assert = Npm.require("assert");
+var assert;
+if(typeof Meteor!="undefined")assert=Npm.require("assert");
+else assert=require("assert");
 
-HomeworkDescription = function () {
+HomeworkDescription=function(){
 	if(!(this instanceof HomeworkDescription))return new HomeworkDescription;
 
 	//A unique identifier for a subject. Can be pretty much anything, lest it's a primitive type
@@ -18,7 +20,7 @@ HomeworkDescription = function () {
 	this.location=[];
 }
 
-Planner = function () {
+Planner=function(){
 	if(!(this instanceof Planner))return new Planner;
 
 	var subjects={}; //The Cache
@@ -74,6 +76,13 @@ function rms(arr){
 	return Math.sqrt(sum/len);
 }
 
+if(typeof Meteor=="undefined"){
+	module.exports={
+		HomeworkDescription:HomeworkDescription,
+		Planner:Planner
+	};
+}
+
 /*
 var REQ=require("./planner");
 var h=REQ.HomeworkDescription();

From 5fe4f75baf654aaf2ac81fed748bef13d814e4ff Mon Sep 17 00:00:00 2001
From: Lieuwe Rooijakkers <lieuwerooijakkers@gmail.com>
Date: Fri, 12 Jun 2015 20:10:56 +0200
Subject: [PATCH 05/18] add module info to planner

---
 packages/planner/planner.js | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/packages/planner/planner.js b/packages/planner/planner.js
index 51cc6e24..a79cc7b7 100644
--- a/packages/planner/planner.js
+++ b/packages/planner/planner.js
@@ -1,3 +1,9 @@
+/*
+ * simplyHomework plan algorithm and stuff.
+ * @author simply
+ * @module planner
+ */
+
 var assert;
 if(typeof Meteor!="undefined")assert=Npm.require("assert");
 else assert=require("assert");

From 8a41a64a0e3989c11122be23ad87f9fd0609dcc8 Mon Sep 17 00:00:00 2001
From: Lieuwe Rooijakkers <lieuwerooijakkers@gmail.com>
Date: Fri, 17 Jul 2015 02:28:03 +0200
Subject: [PATCH 06/18] make planner runnable clientside

---
 packages/planner/planner.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/packages/planner/planner.js b/packages/planner/planner.js
index a79cc7b7..275b272d 100644
--- a/packages/planner/planner.js
+++ b/packages/planner/planner.js
@@ -4,9 +4,9 @@
  * @module planner
  */
 
-var assert;
-if(typeof Meteor!="undefined")assert=Npm.require("assert");
-else assert=require("assert");
+var assert = function (val) {
+	if (!val) throw new Error("AssertionError: false == true");
+};
 
 HomeworkDescription=function(){
 	if(!(this instanceof HomeworkDescription))return new HomeworkDescription;

From 9365b6a575ec07602f2d2b1d2ccf9eaf8abab52f Mon Sep 17 00:00:00 2001
From: tomsmeding <hallo@tomsmeding.nl>
Date: Thu, 27 Aug 2015 20:18:15 +0200
Subject: [PATCH 07/18] Add deepcopy to repo

---
 .../planner/node_modules/deepcopy/.npmignore  |     4 +
 .../planner/node_modules/deepcopy/HISTORY.md  |    46 +
 .../planner/node_modules/deepcopy/LICENSE     |    21 +
 .../planner/node_modules/deepcopy/README.md   |   156 +
 .../planner/node_modules/deepcopy/bower.json  |    14 +
 .../bower_components/es5-shim/.bower.json     |    43 +
 .../bower_components/es5-shim/CHANGES         |   176 +
 .../bower_components/es5-shim/CONTRIBUTORS.md |    27 +
 .../bower_components/es5-shim/LICENSE         |    22 +
 .../bower_components/es5-shim/Makefile        |    23 +
 .../bower_components/es5-shim/README.md       |   167 +
 .../bower_components/es5-shim/bower.json      |    34 +
 .../bower_components/es5-shim/component.json  |    19 +
 .../bower_components/es5-shim/es5-sham.js     |   496 +
 .../bower_components/es5-shim/es5-sham.map    |     1 +
 .../bower_components/es5-shim/es5-sham.min.js |     7 +
 .../bower_components/es5-shim/es5-shim.js     |  1435 ++
 .../bower_components/es5-shim/es5-shim.map    |     1 +
 .../bower_components/es5-shim/es5-shim.min.js |     7 +
 .../bower_components/es5-shim/package.json    |    74 +
 .../bower_components/es5-shim/shims.json      |     7 +
 .../bower_components/mocha/.bower.json        |    56 +
 .../bower_components/mocha/.editorconfig      |    18 +
 .../deepcopy/bower_components/mocha/.mailmap  |     1 +
 .../bower_components/mocha/CONTRIBUTING.md    |    49 +
 .../bower_components/mocha/HISTORY.md         |   801 ++
 .../deepcopy/bower_components/mocha/LICENSE   |    22 +
 .../deepcopy/bower_components/mocha/README.md |   226 +
 .../bower_components/mocha/bower.json         |    47 +
 .../bower_components/mocha/media/logo.svg     |     7 +
 .../deepcopy/bower_components/mocha/mocha.css |   270 +
 .../deepcopy/bower_components/mocha/mocha.js  |  6298 +++++++++
 .../bower_components/power-assert/.bower.json |    56 +
 .../power-assert/CHANGELOG.md                 |   217 +
 .../power-assert/MIT-LICENSE.txt              |    20 +
 .../bower_components/power-assert/README.md   |   982 ++
 .../bower_components/power-assert/bower.json  |    46 +
 .../power-assert/build/power-assert.js        | 11647 ++++++++++++++++
 .../planner/node_modules/deepcopy/deepcopy.js |   229 +
 .../node_modules/deepcopy/package.json        |    69 +
 .../planner/node_modules/deepcopy/testem.json |     5 +
 41 files changed, 23846 insertions(+)
 create mode 100644 packages/planner/node_modules/deepcopy/.npmignore
 create mode 100644 packages/planner/node_modules/deepcopy/HISTORY.md
 create mode 100644 packages/planner/node_modules/deepcopy/LICENSE
 create mode 100644 packages/planner/node_modules/deepcopy/README.md
 create mode 100644 packages/planner/node_modules/deepcopy/bower.json
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/es5-shim/.bower.json
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/es5-shim/CHANGES
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/es5-shim/CONTRIBUTORS.md
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/es5-shim/LICENSE
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/es5-shim/Makefile
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/es5-shim/README.md
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/es5-shim/bower.json
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/es5-shim/component.json
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-sham.js
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-sham.map
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-sham.min.js
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-shim.js
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-shim.map
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-shim.min.js
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/es5-shim/package.json
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/es5-shim/shims.json
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/mocha/.bower.json
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/mocha/.editorconfig
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/mocha/.mailmap
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/mocha/CONTRIBUTING.md
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/mocha/HISTORY.md
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/mocha/LICENSE
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/mocha/README.md
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/mocha/bower.json
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/mocha/media/logo.svg
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/mocha/mocha.css
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/mocha/mocha.js
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/power-assert/.bower.json
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/power-assert/CHANGELOG.md
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/power-assert/MIT-LICENSE.txt
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/power-assert/README.md
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/power-assert/bower.json
 create mode 100644 packages/planner/node_modules/deepcopy/bower_components/power-assert/build/power-assert.js
 create mode 100644 packages/planner/node_modules/deepcopy/deepcopy.js
 create mode 100644 packages/planner/node_modules/deepcopy/package.json
 create mode 100644 packages/planner/node_modules/deepcopy/testem.json

diff --git a/packages/planner/node_modules/deepcopy/.npmignore b/packages/planner/node_modules/deepcopy/.npmignore
new file mode 100644
index 00000000..7cd09eab
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/.npmignore
@@ -0,0 +1,4 @@
+deepcopy.min.js
+.closurelinter
+.travis.yml
+test/
diff --git a/packages/planner/node_modules/deepcopy/HISTORY.md b/packages/planner/node_modules/deepcopy/HISTORY.md
new file mode 100644
index 00000000..ab2105d3
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/HISTORY.md
@@ -0,0 +1,46 @@
+# 0.5.0 / 2015-04-11
+
+  - supported for Symbol
+
+# 0.4.0 / 2015-01-10
+
+  - refactored
+  - bugfix for Firefox
+  - supported for Buffer (node.js only)
+  - changed to use power-assert from expect.js
+
+# 0.3.3 / 2013-12-03
+
+  - bugfix
+    - thanks to @kjirou
+
+# 0.3.2 / 2013-09-08
+
+  - more compressed deepcopy.min.js
+  - changed from chai to expect.js
+
+# 0.3.1 / 2013-06-12
+
+  - changed from Array#indexOf to indexOfArray
+
+# 0.3.0 / 2013-06-01
+
+  - added support for browser
+  - changed repository name to deepcopy.js from deepcopy
+
+# 0.2.0 / 2013-05-26
+
+  - added support for circular reference
+  - rewrote README.md
+
+# 0.1.2 / 2013-03-29
+
+  - added support for node.js 0.10
+
+# 0.1.1 / 2013-01-28
+
+  - rewrote README.md
+
+# 0.1.0 / 2013-01-26
+
+  - initial release
diff --git a/packages/planner/node_modules/deepcopy/LICENSE b/packages/planner/node_modules/deepcopy/LICENSE
new file mode 100644
index 00000000..95dccda6
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/LICENSE
@@ -0,0 +1,21 @@
+(The MIT LICENSE)
+
+Copyright (c) 2013 sasa+1 <sasaplus1@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.
diff --git a/packages/planner/node_modules/deepcopy/README.md b/packages/planner/node_modules/deepcopy/README.md
new file mode 100644
index 00000000..f2ea14aa
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/README.md
@@ -0,0 +1,156 @@
+# deepcopy.js
+
+[![Build Status](https://travis-ci.org/sasaplus1/deepcopy.js.svg)](https://travis-ci.org/sasaplus1/deepcopy.js)
+[![Dependency Status](https://gemnasium.com/sasaplus1/deepcopy.js.svg)](https://gemnasium.com/sasaplus1/deepcopy.js)
+[![NPM version](https://badge.fury.io/js/deepcopy.svg)](http://badge.fury.io/js/deepcopy)
+[![Bower version](https://badge.fury.io/bo/deepcopy.svg)](http://badge.fury.io/bo/deepcopy)
+
+deep copy for any data
+
+## Installation
+
+### npm
+
+```sh
+$ npm install deepcopy
+```
+
+### bower
+
+```sh
+$ bower install deepcopy
+```
+
+## Usage
+
+### node.js
+
+```js
+var deepcopy = require('deepcopy');
+```
+
+### browser
+
+```html
+<script src="deepcopy.min.js"></script>
+```
+
+define `deepcopy` by `define()` if using AMD loader.
+
+otherwise `deepcopy` export to global.
+
+### Example
+
+```js
+var data, shallow, deep;
+
+data = {
+  objects: {
+    array: [
+      null, undefined, new Date, /deepcopy/ig
+    ],
+    object: {
+      number: NaN,
+      string: 'A',
+      boolean: true
+    },
+    to: null
+  }
+};
+
+// circular reference
+data.objects.to = data;
+
+// shallow copy and deep copy
+shallow = data;
+deep = deepcopy(data);
+
+// remove entry
+delete data.objects;
+
+// results
+console.log(data);
+// {}
+console.log(shallow);
+// {}
+console.log(require('util').inspect(deep, { depth: null }));
+// { objects:
+//    { array:
+//       [ null,
+//         undefined,
+//         Sat Jan 10 2015 03:18:32 GMT+0900 (JST),
+//         /deepcopy/gi ],
+//      object: { number: NaN, string: 'A', boolean: true },
+//      to: [Circular] } }
+```
+
+```js
+var data, deep;
+
+data = { object: {} };
+data.object[Symbol.for('sym')] = 123;
+
+deep = deepcopy(data);
+
+delete data.object;
+
+console.log(data.object);
+// undefined
+console.log(deep.object[Symbol.for('sym')]);
+// 123
+```
+
+## Functions
+
+### deepcopy(value)
+
+* `value`
+  * `*` - copy target value
+* `return`
+  * `*` - deep copied value
+
+return deep copied value.
+
+supported types are below:
+
+* Number
+* String
+* Boolean
+* Null
+* Undefined
+* Function (shallow copy)
+* Date
+* RegExp
+* Array
+  * recursive copy
+  * also can copy if it has circular reference
+* Object
+  * recursive copy
+  * also can copy if it has circular reference
+* Buffer (node.js only)
+* Symbol
+
+## Test
+
+### node.js
+
+```sh
+$ npm install
+$ npm test
+```
+
+### browser
+
+```sh
+$ npm install
+$ npm run bower
+$ npm run testem
+```
+
+## Contributors
+
+* [kjirou](https://github.com/kjirou)
+
+## License
+
+The MIT license. Please see LICENSE file.
diff --git a/packages/planner/node_modules/deepcopy/bower.json b/packages/planner/node_modules/deepcopy/bower.json
new file mode 100644
index 00000000..8cc555c6
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower.json
@@ -0,0 +1,14 @@
+{
+  "name": "deepcopy",
+  "main": "./deepcopy.min.js",
+  "ignore": [
+    "**/.*",
+    "node_modules",
+    "bower_components"
+  ],
+  "devDependencies": {
+    "es5-shim": "~4.0",
+    "mocha": "~2.1",
+    "power-assert": "~0.10"
+  }
+}
diff --git a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/.bower.json b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/.bower.json
new file mode 100644
index 00000000..a856b1f8
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/.bower.json
@@ -0,0 +1,43 @@
+{
+  "name": "es5-shim",
+  "version": "4.0.6",
+  "main": "es5-shim.js",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/es-shims/es5-shim"
+  },
+  "homepage": "https://github.com/es-shims/es5-shim",
+  "authors": [
+    "Kris Kowal <kris@cixar.com> (http://github.com/kriskowal/)",
+    "Sami Samhuri <sami.samhuri@gmail.com> (http://samhuri.net/)",
+    "Florian Schäfer <florian.schaefer@gmail.com> (http://github.com/fschaefer)",
+    "Irakli Gozalishvili <rfobic@gmail.com> (http://jeditoolkit.com)",
+    "Kit Cambridge <kitcambridge@gmail.com> (http://kitcambridge.github.com)",
+    "Jordan Harband <ljharb@gmail.com> (https://github.com/ljharb/)"
+  ],
+  "description": "ECMAScript 5 compatibility shims for legacy JavaScript engines",
+  "keywords": [
+    "shim",
+    "es5",
+    "es5 shim",
+    "javascript",
+    "ecmascript",
+    "polyfill"
+  ],
+  "license": "MIT",
+  "ignore": [
+    "**/.*",
+    "node_modules",
+    "bower_components",
+    "tests"
+  ],
+  "_release": "4.0.6",
+  "_resolution": {
+    "type": "version",
+    "tag": "v4.0.6",
+    "commit": "aeb6b1cc477d1f452f0badff4631aba9ba501562"
+  },
+  "_source": "git://github.com/es-shims/es5-shim.git",
+  "_target": "~4.0",
+  "_originalSource": "es5-shim"
+}
\ No newline at end of file
diff --git a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/CHANGES b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/CHANGES
new file mode 100644
index 00000000..d5480c48
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/CHANGES
@@ -0,0 +1,176 @@
+4.0.6
+  - Update `jscs`, `uglify-js`, add `eslint`
+  - es5-sham: fix Object.defineProperty to not check for own properties (#211)
+  - Fix Array#splice bug in Safari 5 (#284)
+  - Fix `Object.keys` issue with boxed primitives with extra properties in older browsers. (#242, #285)
+
+4.0.5
+  - Update `jscs` so tests pass
+
+4.0.4
+  - Style/indentation/whitespace cleanups.
+  - README tweaks
+
+4.0.3
+  - Fix keywords (#268)
+  - add some Date tests
+  - Note in README that the es5-sham requires the es5-shim (https://github.com/es-shims/es5-shim/issues/256#issuecomment-52875710)
+
+4.0.2
+  - Start including version numbers in minified files (#267)
+
+4.0.1
+  - Fix legacy arguments object detection in Object.keys (#260)
+
+4.0.0
+  - No longer shim the ES5-spec behavior of splice when `deleteCount` is omitted - since no engines implement it, and ES6 changes it. (#255)
+  - Use Object.defineProperty where available, so that polyfills are non-enumerable when possible (#250)
+  - lots of internal refactoring
+  - Fixed a bug referencing String#indexOf and String#lastIndexOf before polyfilling it (#253, #254)
+
+3.4.0
+  - Removed nonstandard SpiderMonkey extension to Array#splice - when `deleteCount` is omitted, it's now treated as 0. (#192, #239)
+  - Fix Object.keys with Arguments objects in Safari 5.0
+  - Now shimming String#split in Opera 10.6
+  - Avoid using "toString" as a variable name, since that breaks Opera
+  - Internal implementation and test cleanups
+
+3.3.2
+ - Remove an internal "bind" call, which should make the shim a bit faster
+ - Fix a bug with object boxing in Array#reduceRight that was failing a test in IE 6
+
+3.3.1
+ - Fixing an Array#splice bug in IE 6/7
+ - cleaning up Array#splice tests
+
+3.3.0
+ - Fix Array#reduceRight in node 0.6 and older browsers (#238)
+
+3.2.0
+ - Fix es5-sham UMD definition to work properly with AMD (#237)
+ - Ensure that Array methods do not autobox context in strict mode (#233)
+
+3.1.1
+ - Update minified files (#231)
+
+3.1.0
+ - Fix String#replace in Firefox up through 29 (#228)
+
+3.0.2
+ - Fix `Function#bind` in IE 7 and 8 (#224, #225, #226)
+
+3.0.1
+ - Version bump to ensure npm has newest minified assets
+
+3.0.0
+ - es5-sham: fix `Object.getPrototypeOf` and `Object.getOwnPropertyDescriptor` for Opera Mini
+ - Better override noncompliant native ES5 methods: `Array#forEach`, `Array#map`, `Array#filter`, `Array#every`, `Array#some`, `Array#reduce`, `Date.parse`, `String#trim`
+ - Added spec-compliant shim for `parseInt`
+ - Ensure `Object.keys` handles more edge cases with `arguments` objects and boxed primitives
+ - Improve minification of builds
+
+2.3.0
+ - parseInt is now properly shimmed in ES3 browsers to default the radix
+ - update URLs to point to the new organization
+
+2.2.0
+ - Function.prototype.bind shim now reports correct length on a bound function
+ - fix node 0.6.x v8 bug in Array#forEach
+ - test improvements
+
+2.1.0
+ - Object.create fixes
+ - tweaks to the Object.defineProperties shim
+
+2.0.0
+ - Separate reliable shims from dubious shims (shams).
+
+1.2.10
+ - Group-effort Style Cleanup
+ - Took a stab at fixing Object.defineProperty on IE8 without
+   bad side-effects. (@hax)
+ - Object.isExtensible no longer fakes it. (@xavierm)
+ - Date.prototype.toISOString no longer deals with partial
+   ISO dates, per spec (@kitcambridge)
+ - More (mostly from @bryanforbes)
+
+1.2.9
+ - Corrections to toISOString by @kitcambridge
+ - Fixed three bugs in array methods revealed by Jasmine tests.
+ - Cleaned up Function.prototype.bind with more fixes and tests from
+   @bryanforbes.
+
+1.2.8
+ - Actually fixed problems with Function.prototype.bind, and regressions
+   from 1.2.7 (@bryanforbes, @jdalton #36)
+
+1.2.7 - REGRESSED
+ - Fixed problems with Function.prototype.bind when called as a constructor.
+   (@jdalton #36)
+
+1.2.6
+ - Revised Date.parse to match ES 5.1 (kitcambridge)
+
+1.2.5
+ - Fixed a bug for padding it Date..toISOString (tadfisher issue #33)
+
+1.2.4
+ - Fixed a descriptor bug in Object.defineProperty (raynos)
+
+1.2.3
+ - Cleaned up RequireJS and <script> boilerplate
+
+1.2.2
+ - Changed reduce to follow the letter of the spec with regard to having and
+   owning properties.
+ - Fixed a bug where RegExps pass as Functions in some engines in reduce.
+
+1.2.1
+ - Adding few fixes to make jshint happy.
+ - Fix for issue #12, function expressions can cause scoping issues in IE.
+ - NPM will minify on install or when `npm run-script install` is executed.
+ - Adding .gitignore to avoid publishing dev dependencies.
+
+1.2.0
+ - Making script loadable as AMD module.
+ - Adding `indexOf` to the list of safe shims.
+
+1.1.0
+ - Added support for accessor properties where possible (which is all browsers
+   except IE).
+ - Stop exposing bound function's (that are returned by
+   `Function.prototype.bind`) internal properties (`bound, boundTo, boundArgs`)
+   as in some cases (when using facade objects for example) capabilities of the
+   enclosed functions will be leaked.
+ - `Object.create` now explicitly sets `__proto__` property to guarantee
+   correct behavior of `Object.getPrototypeOf`'s on all objects created using
+   `Object.create`.
+ - Switched to `===` from `==` where possible as it's slightly faster on older
+   browsers that are target of this lib.
+ - Added names to all anonymous functions to have a better stack traces.
+
+1.0.0
+ - fixed Date.toISODate, using UTC accessors, as in
+   http://code.google.com/p/v8/source/browse/trunk/src/date.js?r=6120#986
+   (arian)
+
+0.0.4
+ - Revised Object.getPrototypeOf to work in more cases
+   in response to http://ejohn.org/blog/objectgetprototypeof/
+   [issue #2] (fschaefer)
+
+0.0.3
+ - Fixed typos in Object.keys (samsonjs)
+
+0.0.2
+   Per kangax's recommendations:
+ - faster Object.create(null)
+ - fixed a function-scope function declaration statement in Object.create
+
+0.0.1
+ - fixed Object.create(null), in so far as that's possible
+ - reworked Rhino Object.freeze(Function) bug detector and patcher
+
+0.0.0
+ - forked from narwhal-lib
+
diff --git a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/CONTRIBUTORS.md b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/CONTRIBUTORS.md
new file mode 100644
index 00000000..43ebf770
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/CONTRIBUTORS.md
@@ -0,0 +1,27 @@
+
+-   kriskowal Kris Kowal Copyright (C) 2009-2011 MIT License
+-   tlrobinson Tom Robinson Copyright (C) 2009-2010 MIT License (Narwhal
+    Project)
+-   dantman Daniel Friesen Copyright (C) 2010 XXX TODO License or CLA
+-   fschaefer Florian Schäfer Copyright (C) 2010 MIT License
+-   Gozala Irakli Gozalishvili Copyright (C) 2010 MIT License
+-   kitcambridge Kit Cambridge Copyright (C) 2011 MIT License
+-   kossnocorp Sasha Koss XXX TODO License or CLA
+-   bryanforbes Bryan Forbes XXX TODO License or CLA
+-   killdream Quildreen Motta Copyright (C) 2011 MIT Licence
+-   michaelficarra Michael Ficarra Copyright (C) 2011 3-clause BSD
+    License
+-   sharkbrainguy Gerard Paapu Copyright (C) 2011 MIT License
+-   bbqsrc Brendan Molloy (C) 2011 Creative Commons Zero (public domain)
+-   iwyg XXX TODO License or CLA
+-   DomenicDenicola Domenic Denicola Copyright (C) 2011 MIT License
+-   xavierm02 Montillet Xavier Copyright (C) 2011 MIT License
+-   Raynos Jake Verbaten Copyright (C) 2011 MIT Licence
+-   samsonjs Sami Samhuri Copyright (C) 2010 MIT License
+-   rwldrn Rick Waldron Copyright (C) 2011 MIT License
+-   lexer Alexey Zakharov XXX TODO License or CLA
+-   280 North Inc. (Now Motorola LLC, a subsidiary of Google Inc.)
+    Copyright (C) 2009 MIT License
+-   Steven Levithan Copyright (C) 2012 MIT License
+-   Jordan Harband (C) 2013 MIT License
+
diff --git a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/LICENSE b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/LICENSE
new file mode 100644
index 00000000..3dbd7de3
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/LICENSE
@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (C) 2009-2014 Kristopher Michael Kowal and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
diff --git a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/Makefile b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/Makefile
new file mode 100644
index 00000000..c4086599
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/Makefile
@@ -0,0 +1,23 @@
+
+.PHONY: verify-tag verify-changes release
+
+default: release
+
+verify-tag:
+ifndef TAG
+	$(error TAG is undefined)
+endif
+
+CHANGES_ERROR = $(error No CHANGES specified)
+
+verify-changes:
+	@ (git status -sb --porcelain | \grep -E '^( M|M ) CHANGES' > /dev/null) || (echo no CHANGES specified && exit 2)
+
+release: verify-changes verify-tag
+	@ OLD_TAG=`git describe --abbrev=0 --tags` && \
+		npm run minify && \
+		replace "$${OLD_TAG/v/}" "$(TAG)" -- *.min.js *.json README.md && \
+		replace "blob/master" "blob/v$(TAG)" -- *.min.js && \
+		git commit -m "v$(TAG)" *.js *.map *.json README.md CHANGES && \
+		git tag "v$(TAG)"
+
diff --git a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/README.md b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/README.md
new file mode 100644
index 00000000..5c78c7e1
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/README.md
@@ -0,0 +1,167 @@
+#es5-shim <sup>[![Version Badge][npm-version-svg]][npm-url]</sup>
+
+[![npm badge][npm-badge-png]][npm-url]
+
+[![Build Status][travis-svg]][travis-url]
+[![dependency status][deps-svg]][deps-url]
+[![dev dependency status][dev-deps-svg]][dev-deps-url]
+
+`es5-shim.js` and `es5-shim.min.js` monkey-patch a JavaScript context to
+contain all EcmaScript 5 methods that can be faithfully emulated with a
+legacy JavaScript engine.
+
+`es5-sham.js` and `es5-sham.min.js` monkey-patch other ES5 methods as
+closely as possible.  For these methods, as closely as possible to ES5
+is not very close.  Many of these shams are intended only to allow code
+to be written to ES5 without causing run-time errors in older engines.
+In many cases, this means that these shams cause many ES5 methods to
+silently fail.  Decide carefully whether this is what you want.
+**Note:** `es5-sham.js` requires `es5-shim.js` to be able to work properly.
+
+
+## Tests
+
+The tests are written with the Jasmine BDD test framework.
+To run the tests, navigate to <root-folder>/tests/ , or,
+simply `npm install` and `npm test`.
+
+## Shims
+
+### Complete tests ###
+
+* Array.prototype.every
+* Array.prototype.filter
+* Array.prototype.forEach
+* Array.prototype.indexOf
+* Array.prototype.lastIndexOf
+* Array.prototype.map
+* Array.prototype.some
+* Array.prototype.reduce
+* Array.prototype.reduceRight
+* Array.isArray
+* Date.now
+* Date.prototype.toJSON
+* Function.prototype.bind
+    * :warning: Caveat: the bound function has a prototype property.
+    * :warning: Caveat: bound functions do not try too hard to keep you
+      from manipulating their ``arguments`` and ``caller`` properties.
+    * :warning: Caveat: bound functions don't have checks in ``call`` and
+      ``apply`` to avoid executing as a constructor.
+* Number.prototype.toFixed
+* Object.keys
+* String.prototype.split
+* String.prototype.trim
+* String.prototype.replace
+    * Firefox (through v29) natively handles capturing groups incorrectly.
+* Date.parse (for ISO parsing)
+* Date.prototype.toISOString
+* parseInt
+
+## Shams
+
+* :warning: Object.create
+
+    For the case of simply "begetting" an object that inherits
+    prototypically from another, this should work fine across legacy
+    engines.
+
+    :warning: The second argument is passed to Object.defineProperties
+    which will probably fail either silently or with extreme prejudice.
+
+* :warning: Object.getPrototypeOf
+
+    This will return "undefined" in some cases.  It uses `__proto__` if
+    it's available.  Failing that, it uses constructor.prototype, which
+    depends on the constructor property of the object's prototype having
+    not been replaced.  If your object was created like this, it won't
+    work:
+
+        function Foo() {
+        }
+        Foo.prototype = {};
+
+    Because the prototype reassignment destroys the constructor
+    property.
+
+    This will work for all objects that were created using
+    `Object.create` implemented with this library.
+
+* :warning: Object.getOwnPropertyNames
+
+    This method uses Object.keys, so it will not be accurate on legacy
+    engines.
+
+* Object.isSealed
+
+    Returns "false" in all legacy engines for all objects, which is
+    conveniently guaranteed to be accurate.
+
+* Object.isFrozen
+
+    Returns "false" in all legacy engines for all objects, which is
+    conveniently guaranteed to be accurate.
+
+* Object.isExtensible
+
+    Works like a charm, by trying very hard to extend the object then
+    redacting the extension.
+
+### May fail
+
+* :warning: Object.getOwnPropertyDescriptor
+
+    The behavior of this shim does not conform to ES5.  It should
+    probably not be used at this time, until its behavior has been
+    reviewed and been confirmed to be useful in legacy engines.
+
+* :warning: Object.defineProperty
+
+    In the worst of circumstances, IE 8 provides a version of this
+    method that only works on DOM objects.  This sham will not be
+    installed.  The given version of `defineProperty` will throw an
+    exception if used on non-DOM objects.
+
+    In slightly better circumstances, this method will silently fail to
+    set "writable", "enumerable", and "configurable" properties.
+
+    Providing a getter or setter with "get" or "set" on a descriptor
+    will silently fail on engines that lack "__defineGetter__" and
+    "__defineSetter__", which include all versions of IE.
+
+    https://github.com/es-shims/es5-shim/issues#issue/5
+
+* :warning: Object.defineProperties
+
+    This uses the Object.defineProperty shim.
+
+* Object.seal
+
+    Silently fails on all legacy engines.  This should be
+    fine unless you are depending on the safety and security
+    provisions of this method, which you cannot possibly
+    obtain in legacy engines.
+
+* Object.freeze
+
+    Silently fails on all legacy engines.  This should be
+    fine unless you are depending on the safety and security
+    provisions of this method, which you cannot possibly
+    obtain in legacy engines.
+
+* Object.preventExtensions
+
+    Silently fails on all legacy engines.  This should be
+    fine unless you are depending on the safety and security
+    provisions of this method, which you cannot possibly
+    obtain in legacy engines.
+
+[npm-url]: https://npmjs.org/package/es5-shim
+[npm-version-svg]: http://vb.teelaun.ch/es-shims/es5-shim.svg
+[travis-svg]: https://travis-ci.org/es-shims/es5-shim.svg
+[travis-url]: https://travis-ci.org/es-shims/es5-shim
+[deps-svg]: https://david-dm.org/es-shims/es5-shim.svg
+[deps-url]: https://david-dm.org/es-shims/es5-shim
+[dev-deps-svg]: https://david-dm.org/es-shims/es5-shim/dev-status.svg
+[dev-deps-url]: https://david-dm.org/es-shims/es5-shim#info=devDependencies
+[npm-badge-png]: https://nodei.co/npm/es5-shim.png?downloads=true&stars=true
+
diff --git a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/bower.json b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/bower.json
new file mode 100644
index 00000000..d2ce3c77
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/bower.json
@@ -0,0 +1,34 @@
+{
+    "name": "es5-shim",
+    "version": "4.0.6",
+    "main": "es5-shim.js",
+    "repository": {
+        "type": "git",
+        "url": "git://github.com/es-shims/es5-shim"
+    },
+    "homepage": "https://github.com/es-shims/es5-shim",
+    "authors": [
+        "Kris Kowal <kris@cixar.com> (http://github.com/kriskowal/)",
+        "Sami Samhuri <sami.samhuri@gmail.com> (http://samhuri.net/)",
+        "Florian Schäfer <florian.schaefer@gmail.com> (http://github.com/fschaefer)",
+        "Irakli Gozalishvili <rfobic@gmail.com> (http://jeditoolkit.com)",
+        "Kit Cambridge <kitcambridge@gmail.com> (http://kitcambridge.github.com)",
+        "Jordan Harband <ljharb@gmail.com> (https://github.com/ljharb/)"
+    ],
+    "description": "ECMAScript 5 compatibility shims for legacy JavaScript engines",
+    "keywords": [
+        "shim",
+        "es5",
+        "es5 shim",
+        "javascript",
+        "ecmascript",
+        "polyfill"
+    ],
+    "license": "MIT",
+    "ignore": [
+        "**/.*",
+        "node_modules",
+        "bower_components",
+        "tests"
+    ]
+}
diff --git a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/component.json b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/component.json
new file mode 100644
index 00000000..dda4e636
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/component.json
@@ -0,0 +1,19 @@
+{
+    "name": "es5-shim",
+    "repo": "es-shims/es5-shim",
+    "description": "ECMAScript 5 compatibility shims for legacy JavaScript engines",
+    "version": "v4.0.6",
+    "keywords": [
+        "shim",
+        "es5",
+        "es5 shim",
+        "javascript",
+        "ecmascript",
+        "polyfill"
+    ],
+    "license": "MIT",
+    "main": "es5-shim.js",
+    "scripts": [
+        "es5-shim.js"
+    ]
+}
diff --git a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-sham.js b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-sham.js
new file mode 100644
index 00000000..73c51228
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-sham.js
@@ -0,0 +1,496 @@
+/*!
+ * https://github.com/es-shims/es5-shim
+ * @license es5-shim Copyright 2009-2014 by contributors, MIT License
+ * see https://github.com/es-shims/es5-shim/blob/master/LICENSE
+ */
+
+// vim: ts=4 sts=4 sw=4 expandtab
+
+//Add semicolon to prevent IIFE from being passed as argument to concated code.
+;
+
+// UMD (Universal Module Definition)
+// see https://github.com/umdjs/umd/blob/master/returnExports.js
+(function (root, factory) {
+    'use strict';
+    /*global define, exports, module */
+    if (typeof define === 'function' && define.amd) {
+        // AMD. Register as an anonymous module.
+        define(factory);
+    } else if (typeof exports === 'object') {
+        // Node. Does not work with strict CommonJS, but
+        // only CommonJS-like enviroments that support module.exports,
+        // like Node.
+        module.exports = factory();
+    } else {
+        // Browser globals (root is window)
+        root.returnExports = factory();
+  }
+}(this, function () {
+
+var call = Function.prototype.call;
+var prototypeOfObject = Object.prototype;
+var owns = call.bind(prototypeOfObject.hasOwnProperty);
+
+// If JS engine supports accessors creating shortcuts.
+var defineGetter;
+var defineSetter;
+var lookupGetter;
+var lookupSetter;
+var supportsAccessors = owns(prototypeOfObject, '__defineGetter__');
+if (supportsAccessors) {
+    /*eslint-disable no-underscore-dangle */
+    defineGetter = call.bind(prototypeOfObject.__defineGetter__);
+    defineSetter = call.bind(prototypeOfObject.__defineSetter__);
+    lookupGetter = call.bind(prototypeOfObject.__lookupGetter__);
+    lookupSetter = call.bind(prototypeOfObject.__lookupSetter__);
+    /*eslint-enable no-underscore-dangle */
+}
+
+// ES5 15.2.3.2
+// http://es5.github.com/#x15.2.3.2
+if (!Object.getPrototypeOf) {
+    // https://github.com/es-shims/es5-shim/issues#issue/2
+    // http://ejohn.org/blog/objectgetprototypeof/
+    // recommended by fschaefer on github
+    //
+    // sure, and webreflection says ^_^
+    // ... this will nerever possibly return null
+    // ... Opera Mini breaks here with infinite loops
+    Object.getPrototypeOf = function getPrototypeOf(object) {
+        /*eslint-disable no-proto */
+        var proto = object.__proto__;
+        /*eslint-enable no-proto */
+        if (proto || proto === null) {
+            return proto;
+        } else if (object.constructor) {
+            return object.constructor.prototype;
+        } else {
+            return prototypeOfObject;
+        }
+    };
+}
+
+//ES5 15.2.3.3
+//http://es5.github.com/#x15.2.3.3
+
+function doesGetOwnPropertyDescriptorWork(object) {
+    try {
+        object.sentinel = 0;
+        return Object.getOwnPropertyDescriptor(object, 'sentinel').value === 0;
+    } catch (exception) {
+        // returns falsy
+    }
+}
+
+//check whether getOwnPropertyDescriptor works if it's given. Otherwise,
+//shim partially.
+if (Object.defineProperty) {
+    var getOwnPropertyDescriptorWorksOnObject = doesGetOwnPropertyDescriptorWork({});
+    var getOwnPropertyDescriptorWorksOnDom = typeof document === 'undefined' ||
+    doesGetOwnPropertyDescriptorWork(document.createElement('div'));
+    if (!getOwnPropertyDescriptorWorksOnDom || !getOwnPropertyDescriptorWorksOnObject) {
+        var getOwnPropertyDescriptorFallback = Object.getOwnPropertyDescriptor;
+    }
+}
+
+if (!Object.getOwnPropertyDescriptor || getOwnPropertyDescriptorFallback) {
+    var ERR_NON_OBJECT = 'Object.getOwnPropertyDescriptor called on a non-object: ';
+
+    /*eslint-disable no-proto */
+    Object.getOwnPropertyDescriptor = function getOwnPropertyDescriptor(object, property) {
+        if ((typeof object !== 'object' && typeof object !== 'function') || object === null) {
+            throw new TypeError(ERR_NON_OBJECT + object);
+        }
+
+        // make a valiant attempt to use the real getOwnPropertyDescriptor
+        // for I8's DOM elements.
+        if (getOwnPropertyDescriptorFallback) {
+            try {
+                return getOwnPropertyDescriptorFallback.call(Object, object, property);
+            } catch (exception) {
+                // try the shim if the real one doesn't work
+            }
+        }
+
+        var descriptor;
+
+        // If object does not owns property return undefined immediately.
+        if (!owns(object, property)) {
+            return descriptor;
+        }
+
+        // If object has a property then it's for sure both `enumerable` and
+        // `configurable`.
+        descriptor = { enumerable: true, configurable: true };
+
+        // If JS engine supports accessor properties then property may be a
+        // getter or setter.
+        if (supportsAccessors) {
+            // Unfortunately `__lookupGetter__` will return a getter even
+            // if object has own non getter property along with a same named
+            // inherited getter. To avoid misbehavior we temporary remove
+            // `__proto__` so that `__lookupGetter__` will return getter only
+            // if it's owned by an object.
+            var prototype = object.__proto__;
+            var notPrototypeOfObject = object !== prototypeOfObject;
+            // avoid recursion problem, breaking in Opera Mini when
+            // Object.getOwnPropertyDescriptor(Object.prototype, 'toString')
+            // or any other Object.prototype accessor
+            if (notPrototypeOfObject) {
+                object.__proto__ = prototypeOfObject;
+            }
+
+            var getter = lookupGetter(object, property);
+            var setter = lookupSetter(object, property);
+
+            if (notPrototypeOfObject) {
+                // Once we have getter and setter we can put values back.
+                object.__proto__ = prototype;
+            }
+
+            if (getter || setter) {
+                if (getter) {
+                    descriptor.get = getter;
+                }
+                if (setter) {
+                    descriptor.set = setter;
+                }
+                // If it was accessor property we're done and return here
+                // in order to avoid adding `value` to the descriptor.
+                return descriptor;
+            }
+        }
+
+        // If we got this far we know that object has an own property that is
+        // not an accessor so we set it as a value and return descriptor.
+        descriptor.value = object[property];
+        descriptor.writable = true;
+        return descriptor;
+    };
+    /*eslint-enable no-proto */
+}
+
+// ES5 15.2.3.4
+// http://es5.github.com/#x15.2.3.4
+if (!Object.getOwnPropertyNames) {
+    Object.getOwnPropertyNames = function getOwnPropertyNames(object) {
+        return Object.keys(object);
+    };
+}
+
+// ES5 15.2.3.5
+// http://es5.github.com/#x15.2.3.5
+if (!Object.create) {
+
+    // Contributed by Brandon Benvie, October, 2012
+    var createEmpty;
+    var supportsProto = !({ __proto__: null } instanceof Object);
+                        // the following produces false positives
+                        // in Opera Mini => not a reliable check
+                        // Object.prototype.__proto__ === null
+    /*global document */
+    if (supportsProto || typeof document === 'undefined') {
+        createEmpty = function () {
+            return { __proto__: null };
+        };
+    } else {
+        // In old IE __proto__ can't be used to manually set `null`, nor does
+        // any other method exist to make an object that inherits from nothing,
+        // aside from Object.prototype itself. Instead, create a new global
+        // object and *steal* its Object.prototype and strip it bare. This is
+        // used as the prototype to create nullary objects.
+        createEmpty = function () {
+            var iframe = document.createElement('iframe');
+            var parent = document.body || document.documentElement;
+            iframe.style.display = 'none';
+            parent.appendChild(iframe);
+            /*eslint-disable no-script-url */
+            iframe.src = 'javascript:';
+            /*eslint-enable no-script-url */
+            var empty = iframe.contentWindow.Object.prototype;
+            parent.removeChild(iframe);
+            iframe = null;
+            delete empty.constructor;
+            delete empty.hasOwnProperty;
+            delete empty.propertyIsEnumerable;
+            delete empty.isPrototypeOf;
+            delete empty.toLocaleString;
+            delete empty.toString;
+            delete empty.valueOf;
+            /*eslint-disable no-proto */
+            empty.__proto__ = null;
+            /*eslint-enable no-proto */
+
+            function Empty() {}
+            Empty.prototype = empty;
+            // short-circuit future calls
+            createEmpty = function () {
+                return new Empty();
+            };
+            return new Empty();
+        };
+    }
+
+    Object.create = function create(prototype, properties) {
+
+        var object;
+        function Type() {}  // An empty constructor.
+
+        if (prototype === null) {
+            object = createEmpty();
+        } else {
+            if (typeof prototype !== 'object' && typeof prototype !== 'function') {
+                // In the native implementation `parent` can be `null`
+                // OR *any* `instanceof Object`  (Object|Function|Array|RegExp|etc)
+                // Use `typeof` tho, b/c in old IE, DOM elements are not `instanceof Object`
+                // like they are in modern browsers. Using `Object.create` on DOM elements
+                // is...err...probably inappropriate, but the native version allows for it.
+                throw new TypeError('Object prototype may only be an Object or null'); // same msg as Chrome
+            }
+            Type.prototype = prototype;
+            object = new Type();
+            // IE has no built-in implementation of `Object.getPrototypeOf`
+            // neither `__proto__`, but this manually setting `__proto__` will
+            // guarantee that `Object.getPrototypeOf` will work as expected with
+            // objects created using `Object.create`
+            /*eslint-disable no-proto */
+            object.__proto__ = prototype;
+            /*eslint-enable no-proto */
+        }
+
+        if (properties !== void 0) {
+            Object.defineProperties(object, properties);
+        }
+
+        return object;
+    };
+}
+
+// ES5 15.2.3.6
+// http://es5.github.com/#x15.2.3.6
+
+// Patch for WebKit and IE8 standard mode
+// Designed by hax <hax.github.com>
+// related issue: https://github.com/es-shims/es5-shim/issues#issue/5
+// IE8 Reference:
+//     http://msdn.microsoft.com/en-us/library/dd282900.aspx
+//     http://msdn.microsoft.com/en-us/library/dd229916.aspx
+// WebKit Bugs:
+//     https://bugs.webkit.org/show_bug.cgi?id=36423
+
+function doesDefinePropertyWork(object) {
+    try {
+        Object.defineProperty(object, 'sentinel', {});
+        return 'sentinel' in object;
+    } catch (exception) {
+        // returns falsy
+    }
+}
+
+// check whether defineProperty works if it's given. Otherwise,
+// shim partially.
+if (Object.defineProperty) {
+    var definePropertyWorksOnObject = doesDefinePropertyWork({});
+    var definePropertyWorksOnDom = typeof document === 'undefined' ||
+        doesDefinePropertyWork(document.createElement('div'));
+    if (!definePropertyWorksOnObject || !definePropertyWorksOnDom) {
+        var definePropertyFallback = Object.defineProperty,
+            definePropertiesFallback = Object.defineProperties;
+    }
+}
+
+if (!Object.defineProperty || definePropertyFallback) {
+    var ERR_NON_OBJECT_DESCRIPTOR = 'Property description must be an object: ';
+    var ERR_NON_OBJECT_TARGET = 'Object.defineProperty called on non-object: ';
+    var ERR_ACCESSORS_NOT_SUPPORTED = 'getters & setters can not be defined on this javascript engine';
+
+    Object.defineProperty = function defineProperty(object, property, descriptor) {
+        if ((typeof object !== 'object' && typeof object !== 'function') || object === null) {
+            throw new TypeError(ERR_NON_OBJECT_TARGET + object);
+        }
+        if ((typeof descriptor !== 'object' && typeof descriptor !== 'function') || descriptor === null) {
+            throw new TypeError(ERR_NON_OBJECT_DESCRIPTOR + descriptor);
+        }
+        // make a valiant attempt to use the real defineProperty
+        // for I8's DOM elements.
+        if (definePropertyFallback) {
+            try {
+                return definePropertyFallback.call(Object, object, property, descriptor);
+            } catch (exception) {
+                // try the shim if the real one doesn't work
+            }
+        }
+
+        // If it's a data property.
+        if ('value' in descriptor) {
+            // fail silently if 'writable', 'enumerable', or 'configurable'
+            // are requested but not supported
+            /*
+            // alternate approach:
+            if ( // can't implement these features; allow false but not true
+                ('writable' in descriptor && !descriptor.writable) ||
+                ('enumerable' in descriptor && !descriptor.enumerable) ||
+                ('configurable' in descriptor && !descriptor.configurable)
+            ))
+                throw new RangeError(
+                    'This implementation of Object.defineProperty does not support configurable, enumerable, or writable.'
+                );
+            */
+
+            if (supportsAccessors && (lookupGetter(object, property) || lookupSetter(object, property))) {
+                // As accessors are supported only on engines implementing
+                // `__proto__` we can safely override `__proto__` while defining
+                // a property to make sure that we don't hit an inherited
+                // accessor.
+                /*eslint-disable no-proto */
+                var prototype = object.__proto__;
+                object.__proto__ = prototypeOfObject;
+                // Deleting a property anyway since getter / setter may be
+                // defined on object itself.
+                delete object[property];
+                object[property] = descriptor.value;
+                // Setting original `__proto__` back now.
+                object.__proto__ = prototype;
+                /*eslint-enable no-proto */
+            } else {
+                object[property] = descriptor.value;
+            }
+        } else {
+            if (!supportsAccessors) {
+                throw new TypeError(ERR_ACCESSORS_NOT_SUPPORTED);
+            }
+            // If we got that far then getters and setters can be defined !!
+            if ('get' in descriptor) {
+                defineGetter(object, property, descriptor.get);
+            }
+            if ('set' in descriptor) {
+                defineSetter(object, property, descriptor.set);
+            }
+        }
+        return object;
+    };
+}
+
+// ES5 15.2.3.7
+// http://es5.github.com/#x15.2.3.7
+if (!Object.defineProperties || definePropertiesFallback) {
+    Object.defineProperties = function defineProperties(object, properties) {
+        // make a valiant attempt to use the real defineProperties
+        if (definePropertiesFallback) {
+            try {
+                return definePropertiesFallback.call(Object, object, properties);
+            } catch (exception) {
+                // try the shim if the real one doesn't work
+            }
+        }
+
+        for (var property in properties) {
+            if (owns(properties, property) && property !== '__proto__') {
+                Object.defineProperty(object, property, properties[property]);
+            }
+        }
+        return object;
+    };
+}
+
+// ES5 15.2.3.8
+// http://es5.github.com/#x15.2.3.8
+if (!Object.seal) {
+    Object.seal = function seal(object) {
+        if (Object(object) !== object) {
+            throw new TypeError('Object.seal can only be called on Objects.');
+        }
+        // this is misleading and breaks feature-detection, but
+        // allows "securable" code to "gracefully" degrade to working
+        // but insecure code.
+        return object;
+    };
+}
+
+// ES5 15.2.3.9
+// http://es5.github.com/#x15.2.3.9
+if (!Object.freeze) {
+    Object.freeze = function freeze(object) {
+        if (Object(object) !== object) {
+            throw new TypeError('Object.freeze can only be called on Objects.');
+        }
+        // this is misleading and breaks feature-detection, but
+        // allows "securable" code to "gracefully" degrade to working
+        // but insecure code.
+        return object;
+    };
+}
+
+// detect a Rhino bug and patch it
+try {
+    Object.freeze(function () {});
+} catch (exception) {
+    Object.freeze = (function freeze(freezeObject) {
+        return function freeze(object) {
+            if (typeof object === 'function') {
+                return object;
+            } else {
+                return freezeObject(object);
+            }
+        };
+    }(Object.freeze));
+}
+
+// ES5 15.2.3.10
+// http://es5.github.com/#x15.2.3.10
+if (!Object.preventExtensions) {
+    Object.preventExtensions = function preventExtensions(object) {
+        if (Object(object) !== object) {
+            throw new TypeError('Object.preventExtensions can only be called on Objects.');
+        }
+        // this is misleading and breaks feature-detection, but
+        // allows "securable" code to "gracefully" degrade to working
+        // but insecure code.
+        return object;
+    };
+}
+
+// ES5 15.2.3.11
+// http://es5.github.com/#x15.2.3.11
+if (!Object.isSealed) {
+    Object.isSealed = function isSealed(object) {
+        if (Object(object) !== object) {
+            throw new TypeError('Object.isSealed can only be called on Objects.');
+        }
+        return false;
+    };
+}
+
+// ES5 15.2.3.12
+// http://es5.github.com/#x15.2.3.12
+if (!Object.isFrozen) {
+    Object.isFrozen = function isFrozen(object) {
+        if (Object(object) !== object) {
+            throw new TypeError('Object.isFrozen can only be called on Objects.');
+        }
+        return false;
+    };
+}
+
+// ES5 15.2.3.13
+// http://es5.github.com/#x15.2.3.13
+if (!Object.isExtensible) {
+    Object.isExtensible = function isExtensible(object) {
+        // 1. If Type(O) is not Object throw a TypeError exception.
+        if (Object(object) !== object) {
+            throw new TypeError('Object.isExtensible can only be called on Objects.');
+        }
+        // 2. Return the Boolean value of the [[Extensible]] internal property of O.
+        var name = '';
+        while (owns(object, name)) {
+            name += '?';
+        }
+        object[name] = true;
+        var returnValue = owns(object, name);
+        delete object[name];
+        return returnValue;
+    };
+}
+
+}));
diff --git a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-sham.map b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-sham.map
new file mode 100644
index 00000000..6f95560b
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-sham.map
@@ -0,0 +1 @@
+{"version":3,"sources":["es5-sham.js"],"names":["root","factory","define","amd","exports","module","returnExports","this","call","Function","prototype","prototypeOfObject","Object","owns","bind","hasOwnProperty","defineGetter","defineSetter","lookupGetter","lookupSetter","supportsAccessors","__defineGetter__","__defineSetter__","__lookupGetter__","__lookupSetter__","getPrototypeOf","object","proto","__proto__","constructor","doesGetOwnPropertyDescriptorWork","sentinel","getOwnPropertyDescriptor","value","exception","defineProperty","getOwnPropertyDescriptorWorksOnObject","getOwnPropertyDescriptorWorksOnDom","document","createElement","getOwnPropertyDescriptorFallback","ERR_NON_OBJECT","property","TypeError","descriptor","enumerable","configurable","notPrototypeOfObject","getter","setter","get","set","writable","getOwnPropertyNames","keys","create","createEmpty","supportsProto","iframe","parent","body","documentElement","style","display","appendChild","src","empty","contentWindow","removeChild","propertyIsEnumerable","isPrototypeOf","toLocaleString","toString","valueOf","Empty","properties","Type","defineProperties","doesDefinePropertyWork","definePropertyWorksOnObject","definePropertyWorksOnDom","definePropertyFallback","definePropertiesFallback","ERR_NON_OBJECT_DESCRIPTOR","ERR_NON_OBJECT_TARGET","ERR_ACCESSORS_NOT_SUPPORTED","seal","freeze","freezeObject","preventExtensions","isSealed","isFrozen","isExtensible","name","returnValue"],"mappings":";;;;;CAaC,SAAUA,EAAMC,GACb,YAEA,UAAWC,UAAW,YAAcA,OAAOC,IAAK,CAE5CD,OAAOD,OACJ,UAAWG,WAAY,SAAU,CAIpCC,OAAOD,QAAUH,QACd,CAEHD,EAAKM,cAAgBL,OAE3BM,KAAM,WAER,GAAIC,GAAOC,SAASC,UAAUF,IAC9B,IAAIG,GAAoBC,OAAOF,SAC/B,IAAIG,GAAOL,EAAKM,KAAKH,EAAkBI,eAGvC,IAAIC,EACJ,IAAIC,EACJ,IAAIC,EACJ,IAAIC,EACJ,IAAIC,GAAoBP,EAAKF,EAAmB,mBAChD,IAAIS,EAAmB,CAEnBJ,EAAeR,EAAKM,KAAKH,EAAkBU,iBAC3CJ,GAAeT,EAAKM,KAAKH,EAAkBW,iBAC3CJ,GAAeV,EAAKM,KAAKH,EAAkBY,iBAC3CJ,GAAeX,EAAKM,KAAKH,EAAkBa,kBAM/C,IAAKZ,OAAOa,eAAgB,CAQxBb,OAAOa,eAAiB,QAASA,GAAeC,GAE5C,GAAIC,GAAQD,EAAOE,SAEnB,IAAID,GAASA,IAAU,KAAM,CACzB,MAAOA,OACJ,IAAID,EAAOG,YAAa,CAC3B,MAAOH,GAAOG,YAAYnB,cACvB,CACH,MAAOC,KAQnB,QAASmB,GAAiCJ,GACtC,IACIA,EAAOK,SAAW,CAClB,OAAOnB,QAAOoB,yBAAyBN,EAAQ,YAAYO,QAAU,EACvE,MAAOC,KAOb,GAAItB,OAAOuB,eAAgB,CACvB,GAAIC,GAAwCN,KAC5C,IAAIO,SAA4CC,YAAa,aAC7DR,EAAiCQ,SAASC,cAAc,OACxD,KAAKF,IAAuCD,EAAuC,CAC/E,GAAII,GAAmC5B,OAAOoB,0BAItD,IAAKpB,OAAOoB,0BAA4BQ,EAAkC,CACtE,GAAIC,GAAiB,0DAGrB7B,QAAOoB,yBAA2B,QAASA,GAAyBN,EAAQgB,GACxE,SAAYhB,KAAW,gBAAmBA,KAAW,YAAeA,IAAW,KAAM,CACjF,KAAM,IAAIiB,WAAUF,EAAiBf,GAKzC,GAAIc,EAAkC,CAClC,IACI,MAAOA,GAAiChC,KAAKI,OAAQc,EAAQgB,GAC/D,MAAOR,KAKb,GAAIU,EAGJ,KAAK/B,EAAKa,EAAQgB,GAAW,CACzB,MAAOE,GAKXA,GAAeC,WAAY,KAAMC,aAAc,KAI/C,IAAI1B,EAAmB,CAMnB,GAAIV,GAAYgB,EAAOE,SACvB,IAAImB,GAAuBrB,IAAWf,CAItC,IAAIoC,EAAsB,CACtBrB,EAAOE,UAAYjB,EAGvB,GAAIqC,GAAS9B,EAAaQ,EAAQgB,EAClC,IAAIO,GAAS9B,EAAaO,EAAQgB,EAElC,IAAIK,EAAsB,CAEtBrB,EAAOE,UAAYlB,EAGvB,GAAIsC,GAAUC,EAAQ,CAClB,GAAID,EAAQ,CACRJ,EAAWM,IAAMF,EAErB,GAAIC,EAAQ,CACRL,EAAWO,IAAMF,EAIrB,MAAOL,IAMfA,EAAWX,MAAQP,EAAOgB,EAC1BE,GAAWQ,SAAW,IACtB,OAAOR,IAOf,IAAKhC,OAAOyC,oBAAqB,CAC7BzC,OAAOyC,oBAAsB,QAASA,GAAoB3B,GACtD,MAAOd,QAAO0C,KAAK5B,IAM3B,IAAKd,OAAO2C,OAAQ,CAGhB,GAAIC,EACJ,IAAIC,MAAoB7B,UAAW,eAAkBhB,QAKrD,IAAI6C,SAAwBnB,YAAa,YAAa,CAClDkB,EAAc,WACV,OAAS5B,UAAW,WAErB,CAMH4B,EAAc,WACV,GAAIE,GAASpB,SAASC,cAAc,SACpC,IAAIoB,GAASrB,SAASsB,MAAQtB,SAASuB,eACvCH,GAAOI,MAAMC,QAAU,MACvBJ,GAAOK,YAAYN,EAEnBA,GAAOO,IAAM,aAEb,IAAIC,GAAQR,EAAOS,cAAcvD,OAAOF,SACxCiD,GAAOS,YAAYV,EACnBA,GAAS,WACFQ,GAAMrC,kBACNqC,GAAMnD,qBACNmD,GAAMG,2BACNH,GAAMI,oBACNJ,GAAMK,qBACNL,GAAMM,eACNN,GAAMO,OAEbP,GAAMtC,UAAY,IAGlB,SAAS8C,MACTA,EAAMhE,UAAYwD,CAElBV,GAAc,WACV,MAAO,IAAIkB,GAEf,OAAO,IAAIA,IAInB9D,OAAO2C,OAAS,QAASA,GAAO7C,EAAWiE,GAEvC,GAAIjD,EACJ,SAASkD,MAET,GAAIlE,IAAc,KAAM,CACpBgB,EAAS8B,QACN,CACH,SAAW9C,KAAc,gBAAmBA,KAAc,WAAY,CAMlE,KAAM,IAAIiC,WAAU,kDAExBiC,EAAKlE,UAAYA,CACjBgB,GAAS,GAAIkD,EAMblD,GAAOE,UAAYlB,EAIvB,GAAIiE,QAAoB,GAAG,CACvB/D,OAAOiE,iBAAiBnD,EAAQiD,GAGpC,MAAOjD,IAgBf,QAASoD,GAAuBpD,GAC5B,IACId,OAAOuB,eAAeT,EAAQ,cAC9B,OAAO,YAAcA,GACvB,MAAOQ,KAOb,GAAItB,OAAOuB,eAAgB,CACvB,GAAI4C,GAA8BD,KAClC,IAAIE,SAAkC1C,YAAa,aAC/CwC,EAAuBxC,SAASC,cAAc,OAClD,KAAKwC,IAAgCC,EAA0B,CAC3D,GAAIC,GAAyBrE,OAAOuB,eAChC+C,EAA2BtE,OAAOiE,kBAI9C,IAAKjE,OAAOuB,gBAAkB8C,EAAwB,CAClD,GAAIE,GAA4B,0CAChC,IAAIC,GAAwB,8CAC5B,IAAIC,GAA8B,gEAElCzE,QAAOuB,eAAiB,QAASA,GAAeT,EAAQgB,EAAUE,GAC9D,SAAYlB,KAAW,gBAAmBA,KAAW,YAAeA,IAAW,KAAM,CACjF,KAAM,IAAIiB,WAAUyC,EAAwB1D,GAEhD,SAAYkB,KAAe,gBAAmBA,KAAe,YAAeA,IAAe,KAAM,CAC7F,KAAM,IAAID,WAAUwC,EAA4BvC,GAIpD,GAAIqC,EAAwB,CACxB,IACI,MAAOA,GAAuBzE,KAAKI,OAAQc,EAAQgB,EAAUE,GAC/D,MAAOV,KAMb,GAAI,SAAWU,GAAY,CAevB,GAAIxB,IAAsBF,EAAaQ,EAAQgB,IAAavB,EAAaO,EAAQgB,IAAY,CAMzF,GAAIhC,GAAYgB,EAAOE,SACvBF,GAAOE,UAAYjB,QAGZe,GAAOgB,EACdhB,GAAOgB,GAAYE,EAAWX,KAE9BP,GAAOE,UAAYlB,MAEhB,CACHgB,EAAOgB,GAAYE,EAAWX,WAE/B,CACH,IAAKb,EAAmB,CACpB,KAAM,IAAIuB,WAAU0C,GAGxB,GAAI,OAASzC,GAAY,CACrB5B,EAAaU,EAAQgB,EAAUE,EAAWM,KAE9C,GAAI,OAASN,GAAY,CACrB3B,EAAaS,EAAQgB,EAAUE,EAAWO,MAGlD,MAAOzB,IAMf,IAAKd,OAAOiE,kBAAoBK,EAA0B,CACtDtE,OAAOiE,iBAAmB,QAASA,GAAiBnD,EAAQiD,GAExD,GAAIO,EAA0B,CAC1B,IACI,MAAOA,GAAyB1E,KAAKI,OAAQc,EAAQiD,GACvD,MAAOzC,KAKb,IAAK,GAAIQ,KAAYiC,GAAY,CAC7B,GAAI9D,EAAK8D,EAAYjC,IAAaA,IAAa,YAAa,CACxD9B,OAAOuB,eAAeT,EAAQgB,EAAUiC,EAAWjC,KAG3D,MAAOhB,IAMf,IAAKd,OAAO0E,KAAM,CACd1E,OAAO0E,KAAO,QAASA,GAAK5D,GACxB,GAAId,OAAOc,KAAYA,EAAQ,CAC3B,KAAM,IAAIiB,WAAU,8CAKxB,MAAOjB,IAMf,IAAKd,OAAO2E,OAAQ,CAChB3E,OAAO2E,OAAS,QAASA,GAAO7D,GAC5B,GAAId,OAAOc,KAAYA,EAAQ,CAC3B,KAAM,IAAIiB,WAAU,gDAKxB,MAAOjB,IAKf,IACId,OAAO2E,OAAO,cAChB,MAAOrD,GACLtB,OAAO2E,OAAU,QAASA,GAAOC,GAC7B,MAAO,SAASD,GAAO7D,GACnB,SAAWA,KAAW,WAAY,CAC9B,MAAOA,OACJ,CACH,MAAO8D,GAAa9D,MAG9Bd,OAAO2E,QAKb,IAAK3E,OAAO6E,kBAAmB,CAC3B7E,OAAO6E,kBAAoB,QAASA,GAAkB/D,GAClD,GAAId,OAAOc,KAAYA,EAAQ,CAC3B,KAAM,IAAIiB,WAAU,2DAKxB,MAAOjB,IAMf,IAAKd,OAAO8E,SAAU,CAClB9E,OAAO8E,SAAW,QAASA,GAAShE,GAChC,GAAId,OAAOc,KAAYA,EAAQ,CAC3B,KAAM,IAAIiB,WAAU,kDAExB,MAAO,QAMf,IAAK/B,OAAO+E,SAAU,CAClB/E,OAAO+E,SAAW,QAASA,GAASjE,GAChC,GAAId,OAAOc,KAAYA,EAAQ,CAC3B,KAAM,IAAIiB,WAAU,kDAExB,MAAO,QAMf,IAAK/B,OAAOgF,aAAc,CACtBhF,OAAOgF,aAAe,QAASA,GAAalE,GAExC,GAAId,OAAOc,KAAYA,EAAQ,CAC3B,KAAM,IAAIiB,WAAU,sDAGxB,GAAIkD,GAAO,EACX,OAAOhF,EAAKa,EAAQmE,GAAO,CACvBA,GAAQ,IAEZnE,EAAOmE,GAAQ,IACf,IAAIC,GAAcjF,EAAKa,EAAQmE,SACxBnE,GAAOmE,EACd,OAAOC"}
\ No newline at end of file
diff --git a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-sham.min.js b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-sham.min.js
new file mode 100644
index 00000000..f5df1caa
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-sham.min.js
@@ -0,0 +1,7 @@
+/*!
+ * https://github.com/es-shims/es5-shim
+ * @license es5-shim Copyright 2009-2014 by contributors, MIT License
+ * see https://github.com/es-shims/es5-shim/blob/v4.0.6/LICENSE
+ */
+(function(e,t){"use strict";if(typeof define==="function"&&define.amd){define(t)}else if(typeof exports==="object"){module.exports=t()}else{e.returnExports=t()}})(this,function(){var e=Function.prototype.call;var t=Object.prototype;var r=e.bind(t.hasOwnProperty);var n;var o;var c;var i;var f=r(t,"__defineGetter__");if(f){n=e.bind(t.__defineGetter__);o=e.bind(t.__defineSetter__);c=e.bind(t.__lookupGetter__);i=e.bind(t.__lookupSetter__)}if(!Object.getPrototypeOf){Object.getPrototypeOf=function E(e){var r=e.__proto__;if(r||r===null){return r}else if(e.constructor){return e.constructor.prototype}else{return t}}}function l(e){try{e.sentinel=0;return Object.getOwnPropertyDescriptor(e,"sentinel").value===0}catch(t){}}if(Object.defineProperty){var u=l({});var a=typeof document==="undefined"||l(document.createElement("div"));if(!a||!u){var p=Object.getOwnPropertyDescriptor}}if(!Object.getOwnPropertyDescriptor||p){var b="Object.getOwnPropertyDescriptor called on a non-object: ";Object.getOwnPropertyDescriptor=function g(e,n){if(typeof e!=="object"&&typeof e!=="function"||e===null){throw new TypeError(b+e)}if(p){try{return p.call(Object,e,n)}catch(o){}}var l;if(!r(e,n)){return l}l={enumerable:true,configurable:true};if(f){var u=e.__proto__;var a=e!==t;if(a){e.__proto__=t}var s=c(e,n);var O=i(e,n);if(a){e.__proto__=u}if(s||O){if(s){l.get=s}if(O){l.set=O}return l}}l.value=e[n];l.writable=true;return l}}if(!Object.getOwnPropertyNames){Object.getOwnPropertyNames=function T(e){return Object.keys(e)}}if(!Object.create){var s;var O=!({__proto__:null}instanceof Object);if(O||typeof document==="undefined"){s=function(){return{__proto__:null}}}else{s=function(){var e=document.createElement("iframe");var t=document.body||document.documentElement;e.style.display="none";t.appendChild(e);e.src="javascript:";var r=e.contentWindow.Object.prototype;t.removeChild(e);e=null;delete r.constructor;delete r.hasOwnProperty;delete r.propertyIsEnumerable;delete r.isPrototypeOf;delete r.toLocaleString;delete r.toString;delete r.valueOf;r.__proto__=null;function n(){}n.prototype=r;s=function(){return new n};return new n}}Object.create=function x(e,t){var r;function n(){}if(e===null){r=s()}else{if(typeof e!=="object"&&typeof e!=="function"){throw new TypeError("Object prototype may only be an Object or null")}n.prototype=e;r=new n;r.__proto__=e}if(t!==void 0){Object.defineProperties(r,t)}return r}}function j(e){try{Object.defineProperty(e,"sentinel",{});return"sentinel"in e}catch(t){}}if(Object.defineProperty){var d=j({});var y=typeof document==="undefined"||j(document.createElement("div"));if(!d||!y){var _=Object.defineProperty,v=Object.defineProperties}}if(!Object.defineProperty||_){var w="Property description must be an object: ";var P="Object.defineProperty called on non-object: ";var h="getters & setters can not be defined on this javascript engine";Object.defineProperty=function z(e,r,l){if(typeof e!=="object"&&typeof e!=="function"||e===null){throw new TypeError(P+e)}if(typeof l!=="object"&&typeof l!=="function"||l===null){throw new TypeError(w+l)}if(_){try{return _.call(Object,e,r,l)}catch(u){}}if("value"in l){if(f&&(c(e,r)||i(e,r))){var a=e.__proto__;e.__proto__=t;delete e[r];e[r]=l.value;e.__proto__=a}else{e[r]=l.value}}else{if(!f){throw new TypeError(h)}if("get"in l){n(e,r,l.get)}if("set"in l){o(e,r,l.set)}}return e}}if(!Object.defineProperties||v){Object.defineProperties=function S(e,t){if(v){try{return v.call(Object,e,t)}catch(n){}}for(var o in t){if(r(t,o)&&o!=="__proto__"){Object.defineProperty(e,o,t[o])}}return e}}if(!Object.seal){Object.seal=function D(e){if(Object(e)!==e){throw new TypeError("Object.seal can only be called on Objects.")}return e}}if(!Object.freeze){Object.freeze=function F(e){if(Object(e)!==e){throw new TypeError("Object.freeze can only be called on Objects.")}return e}}try{Object.freeze(function(){})}catch(m){Object.freeze=function k(e){return function t(r){if(typeof r==="function"){return r}else{return e(r)}}}(Object.freeze)}if(!Object.preventExtensions){Object.preventExtensions=function G(e){if(Object(e)!==e){throw new TypeError("Object.preventExtensions can only be called on Objects.")}return e}}if(!Object.isSealed){Object.isSealed=function C(e){if(Object(e)!==e){throw new TypeError("Object.isSealed can only be called on Objects.")}return false}}if(!Object.isFrozen){Object.isFrozen=function N(e){if(Object(e)!==e){throw new TypeError("Object.isFrozen can only be called on Objects.")}return false}}if(!Object.isExtensible){Object.isExtensible=function I(e){if(Object(e)!==e){throw new TypeError("Object.isExtensible can only be called on Objects.")}var t="";while(r(e,t)){t+="?"}e[t]=true;var n=r(e,t);delete e[t];return n}}});
+//# sourceMappingURL=es5-sham.map
\ No newline at end of file
diff --git a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-shim.js b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-shim.js
new file mode 100644
index 00000000..d3e4c9cc
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-shim.js
@@ -0,0 +1,1435 @@
+/*!
+ * https://github.com/es-shims/es5-shim
+ * @license es5-shim Copyright 2009-2014 by contributors, MIT License
+ * see https://github.com/es-shims/es5-shim/blob/master/LICENSE
+ */
+
+// vim: ts=4 sts=4 sw=4 expandtab
+
+// Add semicolon to prevent IIFE from being passed as argument to concatenated code.
+;
+
+// UMD (Universal Module Definition)
+// see https://github.com/umdjs/umd/blob/master/returnExports.js
+(function (root, factory) {
+    'use strict';
+    /*global define, exports, module */
+    if (typeof define === 'function' && define.amd) {
+        // AMD. Register as an anonymous module.
+        define(factory);
+    } else if (typeof exports === 'object') {
+        // Node. Does not work with strict CommonJS, but
+        // only CommonJS-like enviroments that support module.exports,
+        // like Node.
+        module.exports = factory();
+    } else {
+        // Browser globals (root is window)
+        root.returnExports = factory();
+    }
+}(this, function () {
+
+/**
+ * Brings an environment as close to ECMAScript 5 compliance
+ * as is possible with the facilities of erstwhile engines.
+ *
+ * Annotated ES5: http://es5.github.com/ (specific links below)
+ * ES5 Spec: http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf
+ * Required reading: http://javascriptweblog.wordpress.com/2011/12/05/extending-javascript-natives/
+ */
+
+// Shortcut to an often accessed properties, in order to avoid multiple
+// dereference that costs universally.
+var ArrayPrototype = Array.prototype;
+var ObjectPrototype = Object.prototype;
+var FunctionPrototype = Function.prototype;
+var StringPrototype = String.prototype;
+var NumberPrototype = Number.prototype;
+var array_slice = ArrayPrototype.slice;
+var array_splice = ArrayPrototype.splice;
+var array_push = ArrayPrototype.push;
+var array_unshift = ArrayPrototype.unshift;
+var call = FunctionPrototype.call;
+
+// Having a toString local variable name breaks in Opera so use to_string.
+var to_string = ObjectPrototype.toString;
+
+var isFunction = function (val) {
+    return to_string.call(val) === '[object Function]';
+};
+var isRegex = function (val) {
+    return to_string.call(val) === '[object RegExp]';
+};
+var isArray = function isArray(obj) {
+    return to_string.call(obj) === '[object Array]';
+};
+var isString = function isString(obj) {
+    return to_string.call(obj) === '[object String]';
+};
+var isArguments = function isArguments(value) {
+    var str = to_string.call(value);
+    var isArgs = str === '[object Arguments]';
+    if (!isArgs) {
+        isArgs = !isArray(value) &&
+          value !== null &&
+          typeof value === 'object' &&
+          typeof value.length === 'number' &&
+          value.length >= 0 &&
+          isFunction(value.callee);
+    }
+    return isArgs;
+};
+
+/* inlined from http://npmjs.com/define-properties */
+var defineProperties = (function (has) {
+  var supportsDescriptors = Object.defineProperty && (function () {
+      try {
+          Object.defineProperty({}, 'x', {});
+          return true;
+      } catch (e) { /* this is ES3 */
+          return false;
+      }
+  }());
+
+  // Define configurable, writable and non-enumerable props
+  // if they don't exist.
+  var defineProperty;
+  if (supportsDescriptors) {
+      defineProperty = function (object, name, method, forceAssign) {
+          if (!forceAssign && (name in object)) { return; }
+          Object.defineProperty(object, name, {
+              configurable: true,
+              enumerable: false,
+              writable: true,
+              value: method
+          });
+      };
+  } else {
+      defineProperty = function (object, name, method, forceAssign) {
+          if (!forceAssign && (name in object)) { return; }
+          object[name] = method;
+      };
+  }
+  return function defineProperties(object, map, forceAssign) {
+      for (var name in map) {
+          if (has.call(map, name)) {
+            defineProperty(object, name, map[name], forceAssign);
+          }
+      }
+  };
+}(ObjectPrototype.hasOwnProperty));
+
+//
+// Util
+// ======
+//
+
+// ES5 9.4
+// http://es5.github.com/#x9.4
+// http://jsperf.com/to-integer
+
+function toInteger(num) {
+    var n = +num;
+    if (n !== n) { // isNaN
+        n = 0;
+    } else if (n !== 0 && n !== (1 / 0) && n !== -(1 / 0)) {
+        n = (n > 0 || -1) * Math.floor(Math.abs(n));
+    }
+    return n;
+}
+
+function isPrimitive(input) {
+    var type = typeof input;
+    return input === null ||
+        type === 'undefined' ||
+        type === 'boolean' ||
+        type === 'number' ||
+        type === 'string';
+}
+
+function toPrimitive(input) {
+    var val, valueOf, toStr;
+    if (isPrimitive(input)) {
+        return input;
+    }
+    valueOf = input.valueOf;
+    if (isFunction(valueOf)) {
+        val = valueOf.call(input);
+        if (isPrimitive(val)) {
+            return val;
+        }
+    }
+    toStr = input.toString;
+    if (isFunction(toStr)) {
+        val = toStr.call(input);
+        if (isPrimitive(val)) {
+            return val;
+        }
+    }
+    throw new TypeError();
+}
+
+var ES = {
+    // ES5 9.9
+    // http://es5.github.com/#x9.9
+    ToObject: function (o) {
+        /*jshint eqnull: true */
+        if (o == null) { // this matches both null and undefined
+            throw new TypeError("can't convert " + o + ' to object');
+        }
+        return Object(o);
+    },
+    ToUint32: function ToUint32(x) {
+        return x >>> 0;
+    }
+};
+
+//
+// Function
+// ========
+//
+
+// ES-5 15.3.4.5
+// http://es5.github.com/#x15.3.4.5
+
+var Empty = function Empty() {};
+
+defineProperties(FunctionPrototype, {
+    bind: function bind(that) { // .length is 1
+        // 1. Let Target be the this value.
+        var target = this;
+        // 2. If IsCallable(Target) is false, throw a TypeError exception.
+        if (!isFunction(target)) {
+            throw new TypeError('Function.prototype.bind called on incompatible ' + target);
+        }
+        // 3. Let A be a new (possibly empty) internal list of all of the
+        //   argument values provided after thisArg (arg1, arg2 etc), in order.
+        // XXX slicedArgs will stand in for "A" if used
+        var args = array_slice.call(arguments, 1); // for normal call
+        // 4. Let F be a new native ECMAScript object.
+        // 11. Set the [[Prototype]] internal property of F to the standard
+        //   built-in Function prototype object as specified in 15.3.3.1.
+        // 12. Set the [[Call]] internal property of F as described in
+        //   15.3.4.5.1.
+        // 13. Set the [[Construct]] internal property of F as described in
+        //   15.3.4.5.2.
+        // 14. Set the [[HasInstance]] internal property of F as described in
+        //   15.3.4.5.3.
+        var bound;
+        var binder = function () {
+
+            if (this instanceof bound) {
+                // 15.3.4.5.2 [[Construct]]
+                // When the [[Construct]] internal method of a function object,
+                // F that was created using the bind function is called with a
+                // list of arguments ExtraArgs, the following steps are taken:
+                // 1. Let target be the value of F's [[TargetFunction]]
+                //   internal property.
+                // 2. If target has no [[Construct]] internal method, a
+                //   TypeError exception is thrown.
+                // 3. Let boundArgs be the value of F's [[BoundArgs]] internal
+                //   property.
+                // 4. Let args be a new list containing the same values as the
+                //   list boundArgs in the same order followed by the same
+                //   values as the list ExtraArgs in the same order.
+                // 5. Return the result of calling the [[Construct]] internal
+                //   method of target providing args as the arguments.
+
+                var result = target.apply(
+                    this,
+                    args.concat(array_slice.call(arguments))
+                );
+                if (Object(result) === result) {
+                    return result;
+                }
+                return this;
+
+            } else {
+                // 15.3.4.5.1 [[Call]]
+                // When the [[Call]] internal method of a function object, F,
+                // which was created using the bind function is called with a
+                // this value and a list of arguments ExtraArgs, the following
+                // steps are taken:
+                // 1. Let boundArgs be the value of F's [[BoundArgs]] internal
+                //   property.
+                // 2. Let boundThis be the value of F's [[BoundThis]] internal
+                //   property.
+                // 3. Let target be the value of F's [[TargetFunction]] internal
+                //   property.
+                // 4. Let args be a new list containing the same values as the
+                //   list boundArgs in the same order followed by the same
+                //   values as the list ExtraArgs in the same order.
+                // 5. Return the result of calling the [[Call]] internal method
+                //   of target providing boundThis as the this value and
+                //   providing args as the arguments.
+
+                // equiv: target.call(this, ...boundArgs, ...args)
+                return target.apply(
+                    that,
+                    args.concat(array_slice.call(arguments))
+                );
+
+            }
+
+        };
+
+        // 15. If the [[Class]] internal property of Target is "Function", then
+        //     a. Let L be the length property of Target minus the length of A.
+        //     b. Set the length own property of F to either 0 or L, whichever is
+        //       larger.
+        // 16. Else set the length own property of F to 0.
+
+        var boundLength = Math.max(0, target.length - args.length);
+
+        // 17. Set the attributes of the length own property of F to the values
+        //   specified in 15.3.5.1.
+        var boundArgs = [];
+        for (var i = 0; i < boundLength; i++) {
+            boundArgs.push('$' + i);
+        }
+
+        // XXX Build a dynamic function with desired amount of arguments is the only
+        // way to set the length property of a function.
+        // In environments where Content Security Policies enabled (Chrome extensions,
+        // for ex.) all use of eval or Function costructor throws an exception.
+        // However in all of these environments Function.prototype.bind exists
+        // and so this code will never be executed.
+        bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this, arguments); }')(binder);
+
+        if (target.prototype) {
+            Empty.prototype = target.prototype;
+            bound.prototype = new Empty();
+            // Clean up dangling references.
+            Empty.prototype = null;
+        }
+
+        // TODO
+        // 18. Set the [[Extensible]] internal property of F to true.
+
+        // TODO
+        // 19. Let thrower be the [[ThrowTypeError]] function Object (13.2.3).
+        // 20. Call the [[DefineOwnProperty]] internal method of F with
+        //   arguments "caller", PropertyDescriptor {[[Get]]: thrower, [[Set]]:
+        //   thrower, [[Enumerable]]: false, [[Configurable]]: false}, and
+        //   false.
+        // 21. Call the [[DefineOwnProperty]] internal method of F with
+        //   arguments "arguments", PropertyDescriptor {[[Get]]: thrower,
+        //   [[Set]]: thrower, [[Enumerable]]: false, [[Configurable]]: false},
+        //   and false.
+
+        // TODO
+        // NOTE Function objects created using Function.prototype.bind do not
+        // have a prototype property or the [[Code]], [[FormalParameters]], and
+        // [[Scope]] internal properties.
+        // XXX can't delete prototype in pure-js.
+
+        // 22. Return F.
+        return bound;
+    }
+});
+
+// _Please note: Shortcuts are defined after `Function.prototype.bind` as we
+// us it in defining shortcuts.
+var owns = call.bind(ObjectPrototype.hasOwnProperty);
+
+//
+// Array
+// =====
+//
+
+// ES5 15.4.4.12
+// http://es5.github.com/#x15.4.4.12
+var spliceNoopReturnsEmptyArray = (function () {
+    var a = [1, 2];
+    var result = a.splice();
+    return a.length === 2 && isArray(result) && result.length === 0;
+}());
+defineProperties(ArrayPrototype, {
+    // Safari 5.0 bug where .splice() returns undefined
+    splice: function splice(start, deleteCount) {
+        if (arguments.length === 0) {
+            return [];
+        } else {
+            return array_splice.apply(this, arguments);
+        }
+    }
+}, !spliceNoopReturnsEmptyArray);
+
+var spliceWorksWithEmptyObject = (function () {
+    var obj = {};
+    ArrayPrototype.splice.call(obj, 0, 0, 1);
+    return obj.length === 1;
+}());
+defineProperties(ArrayPrototype, {
+    splice: function splice(start, deleteCount) {
+        if (arguments.length === 0) { return []; }
+        var args = arguments;
+        this.length = Math.max(toInteger(this.length), 0);
+        if (arguments.length > 0 && typeof deleteCount !== 'number') {
+            args = array_slice.call(arguments);
+            if (args.length < 2) {
+                args.push(this.length - start);
+            } else {
+                args[1] = toInteger(deleteCount);
+            }
+        }
+        return array_splice.apply(this, args);
+    }
+}, !spliceWorksWithEmptyObject);
+
+// ES5 15.4.4.12
+// http://es5.github.com/#x15.4.4.13
+// Return len+argCount.
+// [bugfix, ielt8]
+// IE < 8 bug: [].unshift(0) === undefined but should be "1"
+var hasUnshiftReturnValueBug = [].unshift(0) !== 1;
+defineProperties(ArrayPrototype, {
+    unshift: function () {
+        array_unshift.apply(this, arguments);
+        return this.length;
+    }
+}, hasUnshiftReturnValueBug);
+
+// ES5 15.4.3.2
+// http://es5.github.com/#x15.4.3.2
+// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/isArray
+defineProperties(Array, { isArray: isArray });
+
+// The IsCallable() check in the Array functions
+// has been replaced with a strict check on the
+// internal class of the object to trap cases where
+// the provided function was actually a regular
+// expression literal, which in V8 and
+// JavaScriptCore is a typeof "function".  Only in
+// V8 are regular expression literals permitted as
+// reduce parameters, so it is desirable in the
+// general case for the shim to match the more
+// strict and common behavior of rejecting regular
+// expressions.
+
+// ES5 15.4.4.18
+// http://es5.github.com/#x15.4.4.18
+// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/array/forEach
+
+// Check failure of by-index access of string characters (IE < 9)
+// and failure of `0 in boxedString` (Rhino)
+var boxedString = Object('a');
+var splitString = boxedString[0] !== 'a' || !(0 in boxedString);
+
+var properlyBoxesContext = function properlyBoxed(method) {
+    // Check node 0.6.21 bug where third parameter is not boxed
+    var properlyBoxesNonStrict = true;
+    var properlyBoxesStrict = true;
+    if (method) {
+        method.call('foo', function (_, __, context) {
+            if (typeof context !== 'object') { properlyBoxesNonStrict = false; }
+        });
+
+        method.call([1], function () {
+            'use strict';
+            properlyBoxesStrict = typeof this === 'string';
+        }, 'x');
+    }
+    return !!method && properlyBoxesNonStrict && properlyBoxesStrict;
+};
+
+defineProperties(ArrayPrototype, {
+    forEach: function forEach(fun /*, thisp*/) {
+        var object = ES.ToObject(this),
+            self = splitString && isString(this) ? this.split('') : object,
+            thisp = arguments[1],
+            i = -1,
+            length = self.length >>> 0;
+
+        // If no callback function or if callback is not a callable function
+        if (!isFunction(fun)) {
+            throw new TypeError(); // TODO message
+        }
+
+        while (++i < length) {
+            if (i in self) {
+                // Invoke the callback function with call, passing arguments:
+                // context, property value, property key, thisArg object
+                // context
+                fun.call(thisp, self[i], i, object);
+            }
+        }
+    }
+}, !properlyBoxesContext(ArrayPrototype.forEach));
+
+// ES5 15.4.4.19
+// http://es5.github.com/#x15.4.4.19
+// https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map
+defineProperties(ArrayPrototype, {
+    map: function map(fun /*, thisp*/) {
+        var object = ES.ToObject(this),
+            self = splitString && isString(this) ? this.split('') : object,
+            length = self.length >>> 0,
+            result = Array(length),
+            thisp = arguments[1];
+
+        // If no callback function or if callback is not a callable function
+        if (!isFunction(fun)) {
+            throw new TypeError(fun + ' is not a function');
+        }
+
+        for (var i = 0; i < length; i++) {
+            if (i in self) {
+                result[i] = fun.call(thisp, self[i], i, object);
+            }
+        }
+        return result;
+    }
+}, !properlyBoxesContext(ArrayPrototype.map));
+
+// ES5 15.4.4.20
+// http://es5.github.com/#x15.4.4.20
+// https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/filter
+defineProperties(ArrayPrototype, {
+    filter: function filter(fun /*, thisp */) {
+        var object = ES.ToObject(this),
+            self = splitString && isString(this) ? this.split('') : object,
+            length = self.length >>> 0,
+            result = [],
+            value,
+            thisp = arguments[1];
+
+        // If no callback function or if callback is not a callable function
+        if (!isFunction(fun)) {
+            throw new TypeError(fun + ' is not a function');
+        }
+
+        for (var i = 0; i < length; i++) {
+            if (i in self) {
+                value = self[i];
+                if (fun.call(thisp, value, i, object)) {
+                    result.push(value);
+                }
+            }
+        }
+        return result;
+    }
+}, !properlyBoxesContext(ArrayPrototype.filter));
+
+// ES5 15.4.4.16
+// http://es5.github.com/#x15.4.4.16
+// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/every
+defineProperties(ArrayPrototype, {
+    every: function every(fun /*, thisp */) {
+        var object = ES.ToObject(this),
+            self = splitString && isString(this) ? this.split('') : object,
+            length = self.length >>> 0,
+            thisp = arguments[1];
+
+        // If no callback function or if callback is not a callable function
+        if (!isFunction(fun)) {
+            throw new TypeError(fun + ' is not a function');
+        }
+
+        for (var i = 0; i < length; i++) {
+            if (i in self && !fun.call(thisp, self[i], i, object)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}, !properlyBoxesContext(ArrayPrototype.every));
+
+// ES5 15.4.4.17
+// http://es5.github.com/#x15.4.4.17
+// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/some
+defineProperties(ArrayPrototype, {
+    some: function some(fun /*, thisp */) {
+        var object = ES.ToObject(this),
+            self = splitString && isString(this) ? this.split('') : object,
+            length = self.length >>> 0,
+            thisp = arguments[1];
+
+        // If no callback function or if callback is not a callable function
+        if (!isFunction(fun)) {
+            throw new TypeError(fun + ' is not a function');
+        }
+
+        for (var i = 0; i < length; i++) {
+            if (i in self && fun.call(thisp, self[i], i, object)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}, !properlyBoxesContext(ArrayPrototype.some));
+
+// ES5 15.4.4.21
+// http://es5.github.com/#x15.4.4.21
+// https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/reduce
+var reduceCoercesToObject = false;
+if (ArrayPrototype.reduce) {
+    reduceCoercesToObject = typeof ArrayPrototype.reduce.call('es5', function (_, __, ___, list) { return list; }) === 'object';
+}
+defineProperties(ArrayPrototype, {
+    reduce: function reduce(fun /*, initial*/) {
+        var object = ES.ToObject(this),
+            self = splitString && isString(this) ? this.split('') : object,
+            length = self.length >>> 0;
+
+        // If no callback function or if callback is not a callable function
+        if (!isFunction(fun)) {
+            throw new TypeError(fun + ' is not a function');
+        }
+
+        // no value to return if no initial value and an empty array
+        if (!length && arguments.length === 1) {
+            throw new TypeError('reduce of empty array with no initial value');
+        }
+
+        var i = 0;
+        var result;
+        if (arguments.length >= 2) {
+            result = arguments[1];
+        } else {
+            do {
+                if (i in self) {
+                    result = self[i++];
+                    break;
+                }
+
+                // if array contains no values, no initial value to return
+                if (++i >= length) {
+                    throw new TypeError('reduce of empty array with no initial value');
+                }
+            } while (true);
+        }
+
+        for (; i < length; i++) {
+            if (i in self) {
+                result = fun.call(void 0, result, self[i], i, object);
+            }
+        }
+
+        return result;
+    }
+}, !reduceCoercesToObject);
+
+// ES5 15.4.4.22
+// http://es5.github.com/#x15.4.4.22
+// https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/reduceRight
+var reduceRightCoercesToObject = false;
+if (ArrayPrototype.reduceRight) {
+    reduceRightCoercesToObject = typeof ArrayPrototype.reduceRight.call('es5', function (_, __, ___, list) { return list; }) === 'object';
+}
+defineProperties(ArrayPrototype, {
+    reduceRight: function reduceRight(fun /*, initial*/) {
+        var object = ES.ToObject(this),
+            self = splitString && isString(this) ? this.split('') : object,
+            length = self.length >>> 0;
+
+        // If no callback function or if callback is not a callable function
+        if (!isFunction(fun)) {
+            throw new TypeError(fun + ' is not a function');
+        }
+
+        // no value to return if no initial value, empty array
+        if (!length && arguments.length === 1) {
+            throw new TypeError('reduceRight of empty array with no initial value');
+        }
+
+        var result, i = length - 1;
+        if (arguments.length >= 2) {
+            result = arguments[1];
+        } else {
+            do {
+                if (i in self) {
+                    result = self[i--];
+                    break;
+                }
+
+                // if array contains no values, no initial value to return
+                if (--i < 0) {
+                    throw new TypeError('reduceRight of empty array with no initial value');
+                }
+            } while (true);
+        }
+
+        if (i < 0) {
+            return result;
+        }
+
+        do {
+            if (i in self) {
+                result = fun.call(void 0, result, self[i], i, object);
+            }
+        } while (i--);
+
+        return result;
+    }
+}, !reduceRightCoercesToObject);
+
+// ES5 15.4.4.14
+// http://es5.github.com/#x15.4.4.14
+// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/indexOf
+var hasFirefox2IndexOfBug = Array.prototype.indexOf && [0, 1].indexOf(1, 2) !== -1;
+defineProperties(ArrayPrototype, {
+    indexOf: function indexOf(sought /*, fromIndex */) {
+        var self = splitString && isString(this) ? this.split('') : ES.ToObject(this),
+            length = self.length >>> 0;
+
+        if (!length) {
+            return -1;
+        }
+
+        var i = 0;
+        if (arguments.length > 1) {
+            i = toInteger(arguments[1]);
+        }
+
+        // handle negative indices
+        i = i >= 0 ? i : Math.max(0, length + i);
+        for (; i < length; i++) {
+            if (i in self && self[i] === sought) {
+                return i;
+            }
+        }
+        return -1;
+    }
+}, hasFirefox2IndexOfBug);
+
+// ES5 15.4.4.15
+// http://es5.github.com/#x15.4.4.15
+// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/lastIndexOf
+var hasFirefox2LastIndexOfBug = Array.prototype.lastIndexOf && [0, 1].lastIndexOf(0, -3) !== -1;
+defineProperties(ArrayPrototype, {
+    lastIndexOf: function lastIndexOf(sought /*, fromIndex */) {
+        var self = splitString && isString(this) ? this.split('') : ES.ToObject(this),
+            length = self.length >>> 0;
+
+        if (!length) {
+            return -1;
+        }
+        var i = length - 1;
+        if (arguments.length > 1) {
+            i = Math.min(i, toInteger(arguments[1]));
+        }
+        // handle negative indices
+        i = i >= 0 ? i : length - Math.abs(i);
+        for (; i >= 0; i--) {
+            if (i in self && sought === self[i]) {
+                return i;
+            }
+        }
+        return -1;
+    }
+}, hasFirefox2LastIndexOfBug);
+
+//
+// Object
+// ======
+//
+
+// ES5 15.2.3.14
+// http://es5.github.com/#x15.2.3.14
+
+// http://whattheheadsaid.com/2010/10/a-safer-object-keys-compatibility-implementation
+var hasDontEnumBug = !({'toString': null}).propertyIsEnumerable('toString'),
+    hasProtoEnumBug = function () {}.propertyIsEnumerable('prototype'),
+    hasStringEnumBug = !owns('x', '0'),
+    dontEnums = [
+        'toString',
+        'toLocaleString',
+        'valueOf',
+        'hasOwnProperty',
+        'isPrototypeOf',
+        'propertyIsEnumerable',
+        'constructor'
+    ],
+    dontEnumsLength = dontEnums.length;
+
+defineProperties(Object, {
+    keys: function keys(object) {
+        var isFn = isFunction(object),
+            isArgs = isArguments(object),
+            isObject = object !== null && typeof object === 'object',
+            isStr = isObject && isString(object);
+
+        if (!isObject && !isFn && !isArgs) {
+            throw new TypeError('Object.keys called on a non-object');
+        }
+
+        var theKeys = [];
+        var skipProto = hasProtoEnumBug && isFn;
+        if ((isStr && hasStringEnumBug) || isArgs) {
+            for (var i = 0; i < object.length; ++i) {
+                theKeys.push(String(i));
+            }
+        }
+
+        if (!isArgs) {
+            for (var name in object) {
+                if (!(skipProto && name === 'prototype') && owns(object, name)) {
+                    theKeys.push(String(name));
+                }
+            }
+        }
+
+        if (hasDontEnumBug) {
+            var ctor = object.constructor,
+                skipConstructor = ctor && ctor.prototype === object;
+            for (var j = 0; j < dontEnumsLength; j++) {
+                var dontEnum = dontEnums[j];
+                if (!(skipConstructor && dontEnum === 'constructor') && owns(object, dontEnum)) {
+                    theKeys.push(dontEnum);
+                }
+            }
+        }
+        return theKeys;
+    }
+});
+
+var keysWorksWithArguments = Object.keys && (function () {
+    // Safari 5.0 bug
+    return Object.keys(arguments).length === 2;
+}(1, 2));
+var originalKeys = Object.keys;
+defineProperties(Object, {
+    keys: function keys(object) {
+        if (isArguments(object)) {
+            return originalKeys(ArrayPrototype.slice.call(object));
+        } else {
+            return originalKeys(object);
+        }
+    }
+}, !keysWorksWithArguments);
+
+//
+// Date
+// ====
+//
+
+// ES5 15.9.5.43
+// http://es5.github.com/#x15.9.5.43
+// This function returns a String value represent the instance in time
+// represented by this Date object. The format of the String is the Date Time
+// string format defined in 15.9.1.15. All fields are present in the String.
+// The time zone is always UTC, denoted by the suffix Z. If the time value of
+// this object is not a finite Number a RangeError exception is thrown.
+var negativeDate = -62198755200000;
+var negativeYearString = '-000001';
+var hasNegativeDateBug = Date.prototype.toISOString && new Date(negativeDate).toISOString().indexOf(negativeYearString) === -1;
+
+defineProperties(Date.prototype, {
+    toISOString: function toISOString() {
+        var result, length, value, year, month;
+        if (!isFinite(this)) {
+            throw new RangeError('Date.prototype.toISOString called on non-finite value.');
+        }
+
+        year = this.getUTCFullYear();
+
+        month = this.getUTCMonth();
+        // see https://github.com/es-shims/es5-shim/issues/111
+        year += Math.floor(month / 12);
+        month = (month % 12 + 12) % 12;
+
+        // the date time string format is specified in 15.9.1.15.
+        result = [month + 1, this.getUTCDate(), this.getUTCHours(), this.getUTCMinutes(), this.getUTCSeconds()];
+        year = (
+            (year < 0 ? '-' : (year > 9999 ? '+' : '')) +
+            ('00000' + Math.abs(year)).slice((0 <= year && year <= 9999) ? -4 : -6)
+        );
+
+        length = result.length;
+        while (length--) {
+            value = result[length];
+            // pad months, days, hours, minutes, and seconds to have two
+            // digits.
+            if (value < 10) {
+                result[length] = '0' + value;
+            }
+        }
+        // pad milliseconds to have three digits.
+        return (
+            year + '-' + result.slice(0, 2).join('-') +
+            'T' + result.slice(2).join(':') + '.' +
+            ('000' + this.getUTCMilliseconds()).slice(-3) + 'Z'
+        );
+    }
+}, hasNegativeDateBug);
+
+
+// ES5 15.9.5.44
+// http://es5.github.com/#x15.9.5.44
+// This function provides a String representation of a Date object for use by
+// JSON.stringify (15.12.3).
+var dateToJSONIsSupported = false;
+try {
+    dateToJSONIsSupported = (
+        Date.prototype.toJSON &&
+        new Date(NaN).toJSON() === null &&
+        new Date(negativeDate).toJSON().indexOf(negativeYearString) !== -1 &&
+        Date.prototype.toJSON.call({ // generic
+            toISOString: function () {
+                return true;
+            }
+        })
+    );
+} catch (e) {
+}
+if (!dateToJSONIsSupported) {
+    Date.prototype.toJSON = function toJSON(key) {
+        // When the toJSON method is called with argument key, the following
+        // steps are taken:
+
+        // 1.  Let O be the result of calling ToObject, giving it the this
+        // value as its argument.
+        // 2. Let tv be toPrimitive(O, hint Number).
+        var o = Object(this),
+            tv = toPrimitive(o),
+            toISO;
+        // 3. If tv is a Number and is not finite, return null.
+        if (typeof tv === 'number' && !isFinite(tv)) {
+            return null;
+        }
+        // 4. Let toISO be the result of calling the [[Get]] internal method of
+        // O with argument "toISOString".
+        toISO = o.toISOString;
+        // 5. If IsCallable(toISO) is false, throw a TypeError exception.
+        if (typeof toISO !== 'function') {
+            throw new TypeError('toISOString property is not callable');
+        }
+        // 6. Return the result of calling the [[Call]] internal method of
+        //  toISO with O as the this value and an empty argument list.
+        return toISO.call(o);
+
+        // NOTE 1 The argument is ignored.
+
+        // NOTE 2 The toJSON function is intentionally generic; it does not
+        // require that its this value be a Date object. Therefore, it can be
+        // transferred to other kinds of objects for use as a method. However,
+        // it does require that any such object have a toISOString method. An
+        // object is free to use the argument key to filter its
+        // stringification.
+    };
+}
+
+// ES5 15.9.4.2
+// http://es5.github.com/#x15.9.4.2
+// based on work shared by Daniel Friesen (dantman)
+// http://gist.github.com/303249
+var supportsExtendedYears = Date.parse('+033658-09-27T01:46:40.000Z') === 1e15;
+var acceptsInvalidDates = !isNaN(Date.parse('2012-04-04T24:00:00.500Z')) || !isNaN(Date.parse('2012-11-31T23:59:59.000Z'));
+var doesNotParseY2KNewYear = isNaN(Date.parse('2000-01-01T00:00:00.000Z'));
+if (!Date.parse || doesNotParseY2KNewYear || acceptsInvalidDates || !supportsExtendedYears) {
+    // XXX global assignment won't work in embeddings that use
+    // an alternate object for the context.
+    /*global Date: true */
+    /*eslint-disable no-undef*/
+    Date = (function (NativeDate) {
+    /*eslint-enable no-undef*/
+        // Date.length === 7
+        function Date(Y, M, D, h, m, s, ms) {
+            var length = arguments.length;
+            if (this instanceof NativeDate) {
+                var date = length === 1 && String(Y) === Y ? // isString(Y)
+                    // We explicitly pass it through parse:
+                    new NativeDate(Date.parse(Y)) :
+                    // We have to manually make calls depending on argument
+                    // length here
+                    length >= 7 ? new NativeDate(Y, M, D, h, m, s, ms) :
+                    length >= 6 ? new NativeDate(Y, M, D, h, m, s) :
+                    length >= 5 ? new NativeDate(Y, M, D, h, m) :
+                    length >= 4 ? new NativeDate(Y, M, D, h) :
+                    length >= 3 ? new NativeDate(Y, M, D) :
+                    length >= 2 ? new NativeDate(Y, M) :
+                    length >= 1 ? new NativeDate(Y) :
+                                  new NativeDate();
+                // Prevent mixups with unfixed Date object
+                date.constructor = Date;
+                return date;
+            }
+            return NativeDate.apply(this, arguments);
+        }
+
+        // 15.9.1.15 Date Time String Format.
+        var isoDateExpression = new RegExp('^' +
+            '(\\d{4}|[+-]\\d{6})' + // four-digit year capture or sign +
+                                      // 6-digit extended year
+            '(?:-(\\d{2})' + // optional month capture
+            '(?:-(\\d{2})' + // optional day capture
+            '(?:' + // capture hours:minutes:seconds.milliseconds
+                'T(\\d{2})' + // hours capture
+                ':(\\d{2})' + // minutes capture
+                '(?:' + // optional :seconds.milliseconds
+                    ':(\\d{2})' + // seconds capture
+                    '(?:(\\.\\d{1,}))?' + // milliseconds capture
+                ')?' +
+            '(' + // capture UTC offset component
+                'Z|' + // UTC capture
+                '(?:' + // offset specifier +/-hours:minutes
+                    '([-+])' + // sign capture
+                    '(\\d{2})' + // hours offset capture
+                    ':(\\d{2})' + // minutes offset capture
+                ')' +
+            ')?)?)?)?' +
+        '$');
+
+        var months = [
+            0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365
+        ];
+
+        function dayFromMonth(year, month) {
+            var t = month > 1 ? 1 : 0;
+            return (
+                months[month] +
+                Math.floor((year - 1969 + t) / 4) -
+                Math.floor((year - 1901 + t) / 100) +
+                Math.floor((year - 1601 + t) / 400) +
+                365 * (year - 1970)
+            );
+        }
+
+        function toUTC(t) {
+            return Number(new NativeDate(1970, 0, 1, 0, 0, 0, t));
+        }
+
+        // Copy any custom methods a 3rd party library may have added
+        for (var key in NativeDate) {
+            Date[key] = NativeDate[key];
+        }
+
+        // Copy "native" methods explicitly; they may be non-enumerable
+        Date.now = NativeDate.now;
+        Date.UTC = NativeDate.UTC;
+        Date.prototype = NativeDate.prototype;
+        Date.prototype.constructor = Date;
+
+        // Upgrade Date.parse to handle simplified ISO 8601 strings
+        Date.parse = function parse(string) {
+            var match = isoDateExpression.exec(string);
+            if (match) {
+                // parse months, days, hours, minutes, seconds, and milliseconds
+                // provide default values if necessary
+                // parse the UTC offset component
+                var year = Number(match[1]),
+                    month = Number(match[2] || 1) - 1,
+                    day = Number(match[3] || 1) - 1,
+                    hour = Number(match[4] || 0),
+                    minute = Number(match[5] || 0),
+                    second = Number(match[6] || 0),
+                    millisecond = Math.floor(Number(match[7] || 0) * 1000),
+                    // When time zone is missed, local offset should be used
+                    // (ES 5.1 bug)
+                    // see https://bugs.ecmascript.org/show_bug.cgi?id=112
+                    isLocalTime = Boolean(match[4] && !match[8]),
+                    signOffset = match[9] === '-' ? 1 : -1,
+                    hourOffset = Number(match[10] || 0),
+                    minuteOffset = Number(match[11] || 0),
+                    result;
+                if (
+                    hour < (
+                        minute > 0 || second > 0 || millisecond > 0 ?
+                        24 : 25
+                    ) &&
+                    minute < 60 && second < 60 && millisecond < 1000 &&
+                    month > -1 && month < 12 && hourOffset < 24 &&
+                    minuteOffset < 60 && // detect invalid offsets
+                    day > -1 &&
+                    day < (
+                        dayFromMonth(year, month + 1) -
+                        dayFromMonth(year, month)
+                    )
+                ) {
+                    result = (
+                        (dayFromMonth(year, month) + day) * 24 +
+                        hour +
+                        hourOffset * signOffset
+                    ) * 60;
+                    result = (
+                        (result + minute + minuteOffset * signOffset) * 60 +
+                        second
+                    ) * 1000 + millisecond;
+                    if (isLocalTime) {
+                        result = toUTC(result);
+                    }
+                    if (-8.64e15 <= result && result <= 8.64e15) {
+                        return result;
+                    }
+                }
+                return NaN;
+            }
+            return NativeDate.parse.apply(this, arguments);
+        };
+
+        return Date;
+    }(Date));
+    /*global Date: false */
+}
+
+// ES5 15.9.4.4
+// http://es5.github.com/#x15.9.4.4
+if (!Date.now) {
+    Date.now = function now() {
+        return new Date().getTime();
+    };
+}
+
+
+//
+// Number
+// ======
+//
+
+// ES5.1 15.7.4.5
+// http://es5.github.com/#x15.7.4.5
+var hasToFixedBugs = NumberPrototype.toFixed && (
+  (0.00008).toFixed(3) !== '0.000' ||
+  (0.9).toFixed(0) !== '1' ||
+  (1.255).toFixed(2) !== '1.25' ||
+  (1000000000000000128).toFixed(0) !== '1000000000000000128'
+);
+
+var toFixedHelpers = {
+  base: 1e7,
+  size: 6,
+  data: [0, 0, 0, 0, 0, 0],
+  multiply: function multiply(n, c) {
+      var i = -1;
+      while (++i < toFixedHelpers.size) {
+          c += n * toFixedHelpers.data[i];
+          toFixedHelpers.data[i] = c % toFixedHelpers.base;
+          c = Math.floor(c / toFixedHelpers.base);
+      }
+  },
+  divide: function divide(n) {
+      var i = toFixedHelpers.size, c = 0;
+      while (--i >= 0) {
+          c += toFixedHelpers.data[i];
+          toFixedHelpers.data[i] = Math.floor(c / n);
+          c = (c % n) * toFixedHelpers.base;
+      }
+  },
+  numToString: function numToString() {
+      var i = toFixedHelpers.size;
+      var s = '';
+      while (--i >= 0) {
+          if (s !== '' || i === 0 || toFixedHelpers.data[i] !== 0) {
+              var t = String(toFixedHelpers.data[i]);
+              if (s === '') {
+                  s = t;
+              } else {
+                  s += '0000000'.slice(0, 7 - t.length) + t;
+              }
+          }
+      }
+      return s;
+  },
+  pow: function pow(x, n, acc) {
+      return (n === 0 ? acc : (n % 2 === 1 ? pow(x, n - 1, acc * x) : pow(x * x, n / 2, acc)));
+  },
+  log: function log(x) {
+      var n = 0;
+      while (x >= 4096) {
+          n += 12;
+          x /= 4096;
+      }
+      while (x >= 2) {
+          n += 1;
+          x /= 2;
+      }
+      return n;
+  }
+};
+
+defineProperties(NumberPrototype, {
+    toFixed: function toFixed(fractionDigits) {
+        var f, x, s, m, e, z, j, k;
+
+        // Test for NaN and round fractionDigits down
+        f = Number(fractionDigits);
+        f = f !== f ? 0 : Math.floor(f);
+
+        if (f < 0 || f > 20) {
+            throw new RangeError('Number.toFixed called with invalid number of decimals');
+        }
+
+        x = Number(this);
+
+        // Test for NaN
+        if (x !== x) {
+            return 'NaN';
+        }
+
+        // If it is too big or small, return the string value of the number
+        if (x <= -1e21 || x >= 1e21) {
+            return String(x);
+        }
+
+        s = '';
+
+        if (x < 0) {
+            s = '-';
+            x = -x;
+        }
+
+        m = '0';
+
+        if (x > 1e-21) {
+            // 1e-21 < x < 1e21
+            // -70 < log2(x) < 70
+            e = toFixedHelpers.log(x * toFixedHelpers.pow(2, 69, 1)) - 69;
+            z = (e < 0 ? x * toFixedHelpers.pow(2, -e, 1) : x / toFixedHelpers.pow(2, e, 1));
+            z *= 0x10000000000000; // Math.pow(2, 52);
+            e = 52 - e;
+
+            // -18 < e < 122
+            // x = z / 2 ^ e
+            if (e > 0) {
+                toFixedHelpers.multiply(0, z);
+                j = f;
+
+                while (j >= 7) {
+                    toFixedHelpers.multiply(1e7, 0);
+                    j -= 7;
+                }
+
+                toFixedHelpers.multiply(toFixedHelpers.pow(10, j, 1), 0);
+                j = e - 1;
+
+                while (j >= 23) {
+                    toFixedHelpers.divide(1 << 23);
+                    j -= 23;
+                }
+
+                toFixedHelpers.divide(1 << j);
+                toFixedHelpers.multiply(1, 1);
+                toFixedHelpers.divide(2);
+                m = toFixedHelpers.numToString();
+            } else {
+                toFixedHelpers.multiply(0, z);
+                toFixedHelpers.multiply(1 << (-e), 0);
+                m = toFixedHelpers.numToString() + '0.00000000000000000000'.slice(2, 2 + f);
+            }
+        }
+
+        if (f > 0) {
+            k = m.length;
+
+            if (k <= f) {
+                m = s + '0.0000000000000000000'.slice(0, f - k + 2) + m;
+            } else {
+                m = s + m.slice(0, k - f) + '.' + m.slice(k - f);
+            }
+        } else {
+            m = s + m;
+        }
+
+        return m;
+    }
+}, hasToFixedBugs);
+
+
+//
+// String
+// ======
+//
+
+// ES5 15.5.4.14
+// http://es5.github.com/#x15.5.4.14
+
+// [bugfix, IE lt 9, firefox 4, Konqueror, Opera, obscure browsers]
+// Many browsers do not split properly with regular expressions or they
+// do not perform the split correctly under obscure conditions.
+// See http://blog.stevenlevithan.com/archives/cross-browser-split
+// I've tested in many browsers and this seems to cover the deviant ones:
+//    'ab'.split(/(?:ab)*/) should be ["", ""], not [""]
+//    '.'.split(/(.?)(.?)/) should be ["", ".", "", ""], not ["", ""]
+//    'tesst'.split(/(s)*/) should be ["t", undefined, "e", "s", "t"], not
+//       [undefined, "t", undefined, "e", ...]
+//    ''.split(/.?/) should be [], not [""]
+//    '.'.split(/()()/) should be ["."], not ["", "", "."]
+
+var string_split = StringPrototype.split;
+if (
+    'ab'.split(/(?:ab)*/).length !== 2 ||
+    '.'.split(/(.?)(.?)/).length !== 4 ||
+    'tesst'.split(/(s)*/)[1] === 't' ||
+    'test'.split(/(?:)/, -1).length !== 4 ||
+    ''.split(/.?/).length ||
+    '.'.split(/()()/).length > 1
+) {
+    (function () {
+        var compliantExecNpcg = typeof (/()??/).exec('')[1] === 'undefined'; // NPCG: nonparticipating capturing group
+
+        StringPrototype.split = function (separator, limit) {
+            var string = this;
+            if (typeof separator === 'undefined' && limit === 0) {
+                return [];
+            }
+
+            // If `separator` is not a regex, use native split
+            if (to_string.call(separator) !== '[object RegExp]') {
+                return string_split.call(this, separator, limit);
+            }
+
+            var output = [],
+                flags = (separator.ignoreCase ? 'i' : '') +
+                        (separator.multiline ? 'm' : '') +
+                        (separator.extended ? 'x' : '') + // Proposed for ES6
+                        (separator.sticky ? 'y' : ''), // Firefox 3+
+                lastLastIndex = 0,
+                // Make `global` and avoid `lastIndex` issues by working with a copy
+                separator2, match, lastIndex, lastLength;
+            separator = new RegExp(separator.source, flags + 'g');
+            string += ''; // Type-convert
+            if (!compliantExecNpcg) {
+                // Doesn't need flags gy, but they don't hurt
+                separator2 = new RegExp('^' + separator.source + '$(?!\\s)', flags);
+            }
+            /* Values for `limit`, per the spec:
+             * If undefined: 4294967295 // Math.pow(2, 32) - 1
+             * If 0, Infinity, or NaN: 0
+             * If positive number: limit = Math.floor(limit); if (limit > 4294967295) limit -= 4294967296;
+             * If negative number: 4294967296 - Math.floor(Math.abs(limit))
+             * If other: Type-convert, then use the above rules
+             */
+            limit = typeof limit === 'undefined' ?
+                -1 >>> 0 : // Math.pow(2, 32) - 1
+                ES.ToUint32(limit);
+            match = separator.exec(string);
+            while (match) {
+                // `separator.lastIndex` is not reliable cross-browser
+                lastIndex = match.index + match[0].length;
+                if (lastIndex > lastLastIndex) {
+                    output.push(string.slice(lastLastIndex, match.index));
+                    // Fix browsers whose `exec` methods don't consistently return `undefined` for
+                    // nonparticipating capturing groups
+                    if (!compliantExecNpcg && match.length > 1) {
+                        /*eslint-disable no-loop-func */
+                        match[0].replace(separator2, function () {
+                            for (var i = 1; i < arguments.length - 2; i++) {
+                                if (typeof arguments[i] === 'undefined') {
+                                    match[i] = void 0;
+                                }
+                            }
+                        });
+                        /*eslint-enable no-loop-func */
+                    }
+                    if (match.length > 1 && match.index < string.length) {
+                        array_push.apply(output, match.slice(1));
+                    }
+                    lastLength = match[0].length;
+                    lastLastIndex = lastIndex;
+                    if (output.length >= limit) {
+                        break;
+                    }
+                }
+                if (separator.lastIndex === match.index) {
+                    separator.lastIndex++; // Avoid an infinite loop
+                }
+                match = separator.exec(string);
+            }
+            if (lastLastIndex === string.length) {
+                if (lastLength || !separator.test('')) {
+                    output.push('');
+                }
+            } else {
+                output.push(string.slice(lastLastIndex));
+            }
+            return output.length > limit ? output.slice(0, limit) : output;
+        };
+    }());
+
+// [bugfix, chrome]
+// If separator is undefined, then the result array contains just one String,
+// which is the this value (converted to a String). If limit is not undefined,
+// then the output array is truncated so that it contains no more than limit
+// elements.
+// "0".split(undefined, 0) -> []
+} else if ('0'.split(void 0, 0).length) {
+    StringPrototype.split = function split(separator, limit) {
+        if (typeof separator === 'undefined' && limit === 0) { return []; }
+        return string_split.call(this, separator, limit);
+    };
+}
+
+var str_replace = StringPrototype.replace;
+var replaceReportsGroupsCorrectly = (function () {
+    var groups = [];
+    'x'.replace(/x(.)?/g, function (match, group) {
+        groups.push(group);
+    });
+    return groups.length === 1 && typeof groups[0] === 'undefined';
+}());
+
+if (!replaceReportsGroupsCorrectly) {
+    StringPrototype.replace = function replace(searchValue, replaceValue) {
+        var isFn = isFunction(replaceValue);
+        var hasCapturingGroups = isRegex(searchValue) && (/\)[*?]/).test(searchValue.source);
+        if (!isFn || !hasCapturingGroups) {
+            return str_replace.call(this, searchValue, replaceValue);
+        } else {
+            var wrappedReplaceValue = function (match) {
+                var length = arguments.length;
+                var originalLastIndex = searchValue.lastIndex;
+                searchValue.lastIndex = 0;
+                var args = searchValue.exec(match) || [];
+                searchValue.lastIndex = originalLastIndex;
+                args.push(arguments[length - 2], arguments[length - 1]);
+                return replaceValue.apply(this, args);
+            };
+            return str_replace.call(this, searchValue, wrappedReplaceValue);
+        }
+    };
+}
+
+// ECMA-262, 3rd B.2.3
+// Not an ECMAScript standard, although ECMAScript 3rd Edition has a
+// non-normative section suggesting uniform semantics and it should be
+// normalized across all browsers
+// [bugfix, IE lt 9] IE < 9 substr() with negative value not working in IE
+var string_substr = StringPrototype.substr;
+var hasNegativeSubstrBug = ''.substr && '0b'.substr(-1) !== 'b';
+defineProperties(StringPrototype, {
+    substr: function substr(start, length) {
+        return string_substr.call(
+            this,
+            start < 0 ? ((start = this.length + start) < 0 ? 0 : start) : start,
+            length
+        );
+    }
+}, hasNegativeSubstrBug);
+
+// ES5 15.5.4.20
+// whitespace from: http://es5.github.io/#x15.5.4.20
+var ws = '\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003' +
+    '\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028' +
+    '\u2029\uFEFF';
+var zeroWidth = '\u200b';
+var wsRegexChars = '[' + ws + ']';
+var trimBeginRegexp = new RegExp('^' + wsRegexChars + wsRegexChars + '*');
+var trimEndRegexp = new RegExp(wsRegexChars + wsRegexChars + '*$');
+var hasTrimWhitespaceBug = StringPrototype.trim && (ws.trim() || !zeroWidth.trim());
+defineProperties(StringPrototype, {
+    // http://blog.stevenlevithan.com/archives/faster-trim-javascript
+    // http://perfectionkills.com/whitespace-deviations/
+    trim: function trim() {
+        if (typeof this === 'undefined' || this === null) {
+            throw new TypeError("can't convert " + this + ' to object');
+        }
+        return String(this).replace(trimBeginRegexp, '').replace(trimEndRegexp, '');
+    }
+}, hasTrimWhitespaceBug);
+
+// ES-5 15.1.2.2
+if (parseInt(ws + '08') !== 8 || parseInt(ws + '0x16') !== 22) {
+    /*global parseInt: true */
+    parseInt = (function (origParseInt) {
+        var hexRegex = /^0[xX]/;
+        return function parseIntES5(str, radix) {
+            str = String(str).trim();
+            if (!Number(radix)) {
+                radix = hexRegex.test(str) ? 16 : 10;
+            }
+            return origParseInt(str, radix);
+        };
+    }(parseInt));
+}
+
+}));
diff --git a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-shim.map b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-shim.map
new file mode 100644
index 00000000..bf9437b1
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-shim.map
@@ -0,0 +1 @@
+{"version":3,"sources":["es5-shim.js"],"names":["root","factory","define","amd","exports","module","returnExports","this","ArrayPrototype","Array","prototype","ObjectPrototype","Object","FunctionPrototype","Function","StringPrototype","String","NumberPrototype","Number","array_slice","slice","array_splice","splice","array_push","push","array_unshift","unshift","call","to_string","toString","isFunction","val","isRegex","isArray","obj","isString","isArguments","value","str","isArgs","length","callee","defineProperties","has","supportsDescriptors","defineProperty","e","object","name","method","forceAssign","configurable","enumerable","writable","map","hasOwnProperty","toInteger","num","n","Math","floor","abs","isPrimitive","input","type","toPrimitive","valueOf","toStr","TypeError","ES","ToObject","o","ToUint32","x","Empty","bind","that","target","args","arguments","bound","binder","result","apply","concat","boundLength","max","boundArgs","i","join","owns","spliceNoopReturnsEmptyArray","a","start","deleteCount","spliceWorksWithEmptyObject","hasUnshiftReturnValueBug","boxedString","splitString","properlyBoxesContext","properlyBoxed","properlyBoxesNonStrict","properlyBoxesStrict","_","__","context","forEach","fun","self","split","thisp","filter","every","some","reduceCoercesToObject","reduce","___","list","reduceRightCoercesToObject","reduceRight","hasFirefox2IndexOfBug","indexOf","sought","hasFirefox2LastIndexOfBug","lastIndexOf","min","hasDontEnumBug","propertyIsEnumerable","hasProtoEnumBug","hasStringEnumBug","dontEnums","dontEnumsLength","keys","isFn","isObject","isStr","theKeys","skipProto","ctor","constructor","skipConstructor","j","dontEnum","keysWorksWithArguments","originalKeys","negativeDate","negativeYearString","hasNegativeDateBug","Date","toISOString","year","month","isFinite","RangeError","getUTCFullYear","getUTCMonth","getUTCDate","getUTCHours","getUTCMinutes","getUTCSeconds","getUTCMilliseconds","dateToJSONIsSupported","toJSON","NaN","key","tv","toISO","supportsExtendedYears","parse","acceptsInvalidDates","isNaN","doesNotParseY2KNewYear","NativeDate","Y","M","D","h","m","s","ms","date","isoDateExpression","RegExp","months","dayFromMonth","t","toUTC","now","UTC","string","match","exec","day","hour","minute","second","millisecond","isLocalTime","Boolean","signOffset","hourOffset","minuteOffset","getTime","hasToFixedBugs","toFixed","toFixedHelpers","base","size","data","multiply","c","divide","numToString","pow","acc","log","fractionDigits","f","z","k","string_split","compliantExecNpcg","separator","limit","output","flags","ignoreCase","multiline","extended","sticky","lastLastIndex","separator2","lastIndex","lastLength","source","index","replace","test","str_replace","replaceReportsGroupsCorrectly","groups","group","searchValue","replaceValue","hasCapturingGroups","wrappedReplaceValue","originalLastIndex","string_substr","substr","hasNegativeSubstrBug","ws","zeroWidth","wsRegexChars","trimBeginRegexp","trimEndRegexp","hasTrimWhitespaceBug","trim","parseInt","origParseInt","hexRegex","parseIntES5","radix"],"mappings":";;;;;CAaC,SAAUA,EAAMC,GACb,YAEA,UAAWC,UAAW,YAAcA,OAAOC,IAAK,CAE5CD,OAAOD,OACJ,UAAWG,WAAY,SAAU,CAIpCC,OAAOD,QAAUH,QACd,CAEHD,EAAKM,cAAgBL,OAE3BM,KAAM,WAaR,GAAIC,GAAiBC,MAAMC,SAC3B,IAAIC,GAAkBC,OAAOF,SAC7B,IAAIG,GAAoBC,SAASJ,SACjC,IAAIK,GAAkBC,OAAON,SAC7B,IAAIO,GAAkBC,OAAOR,SAC7B,IAAIS,GAAcX,EAAeY,KACjC,IAAIC,GAAeb,EAAec,MAClC,IAAIC,GAAaf,EAAegB,IAChC,IAAIC,GAAgBjB,EAAekB,OACnC,IAAIC,GAAOd,EAAkBc,IAG7B,IAAIC,GAAYjB,EAAgBkB,QAEhC,IAAIC,GAAa,SAAUC,GACvB,MAAOH,GAAUD,KAAKI,KAAS,oBAEnC,IAAIC,GAAU,SAAUD,GACpB,MAAOH,GAAUD,KAAKI,KAAS,kBAEnC,IAAIE,GAAU,QAASA,IAAQC,GAC3B,MAAON,GAAUD,KAAKO,KAAS,iBAEnC,IAAIC,GAAW,QAASA,IAASD,GAC7B,MAAON,GAAUD,KAAKO,KAAS,kBAEnC,IAAIE,GAAc,QAASA,IAAYC,GACnC,GAAIC,GAAMV,EAAUD,KAAKU,EACzB,IAAIE,GAASD,IAAQ,oBACrB,KAAKC,EAAQ,CACTA,GAAUN,EAAQI,IAChBA,IAAU,YACHA,KAAU,gBACVA,GAAMG,SAAW,UACxBH,EAAMG,QAAU,GAChBV,EAAWO,EAAMI,QAEvB,MAAOF,GAIX,IAAIG,GAAoB,SAAUC,GAChC,GAAIC,GAAsBhC,OAAOiC,gBAAmB,WAChD,IACIjC,OAAOiC,kBAAmB,OAC1B,OAAO,MACT,MAAOC,GACL,MAAO,UAMf,IAAID,EACJ,IAAID,EAAqB,CACrBC,EAAiB,SAAUE,EAAQC,EAAMC,EAAQC,GAC7C,IAAKA,GAAgBF,IAAQD,GAAS,CAAE,OACxCnC,OAAOiC,eAAeE,EAAQC,GAC1BG,aAAc,KACdC,WAAY,MACZC,SAAU,KACVhB,MAAOY,SAGZ,CACHJ,EAAiB,SAAUE,EAAQC,EAAMC,EAAQC,GAC7C,IAAKA,GAAgBF,IAAQD,GAAS,CAAE,OACxCA,EAAOC,GAAQC,GAGvB,MAAO,SAASP,GAAiBK,EAAQO,EAAKJ,GAC1C,IAAK,GAAIF,KAAQM,GAAK,CAClB,GAAIX,EAAIhB,KAAK2B,EAAKN,GAAO,CACvBH,EAAeE,EAAQC,EAAMM,EAAIN,GAAOE,OAIlDvC,EAAgB4C,eAWlB,SAASC,GAAUC,GACf,GAAIC,IAAKD,CACT,IAAIC,IAAMA,EAAG,CACTA,EAAI,MACD,IAAIA,IAAM,GAAKA,IAAO,EAAI,GAAMA,MAAQ,EAAI,GAAI,CACnDA,GAAKA,EAAI,IAAM,GAAKC,KAAKC,MAAMD,KAAKE,IAAIH,IAE5C,MAAOA,GAGX,QAASI,GAAYC,GACjB,GAAIC,SAAcD,EAClB,OAAOA,KAAU,MACbC,IAAS,aACTA,IAAS,WACTA,IAAS,UACTA,IAAS,SAGjB,QAASC,GAAYF,GACjB,GAAIhC,GAAKmC,EAASC,CAClB,IAAIL,EAAYC,GAAQ,CACpB,MAAOA,GAEXG,EAAUH,EAAMG,OAChB,IAAIpC,EAAWoC,GAAU,CACrBnC,EAAMmC,EAAQvC,KAAKoC,EACnB,IAAID,EAAY/B,GAAM,CAClB,MAAOA,IAGfoC,EAAQJ,EAAMlC,QACd,IAAIC,EAAWqC,GAAQ,CACnBpC,EAAMoC,EAAMxC,KAAKoC,EACjB,IAAID,EAAY/B,GAAM,CAClB,MAAOA,IAGf,KAAM,IAAIqC,WAGd,GAAIC,IAGAC,SAAU,SAAUC,GAEhB,GAAIA,GAAK,KAAM,CACX,KAAM,IAAIH,WAAU,iBAAmBG,EAAI,cAE/C,MAAO3D,QAAO2D,IAElBC,SAAU,QAASA,IAASC,GACxB,MAAOA,KAAM,GAYrB,IAAIC,GAAQ,QAASA,OAErBhC,GAAiB7B,GACb8D,KAAM,QAASA,IAAKC,GAEhB,GAAIC,GAAStE,IAEb,KAAKuB,EAAW+C,GAAS,CACrB,KAAM,IAAIT,WAAU,kDAAoDS,GAK5E,GAAIC,GAAO3D,EAAYQ,KAAKoD,UAAW,EAUvC,IAAIC,EACJ,IAAIC,GAAS,WAET,GAAI1E,eAAgByE,GAAO,CAiBvB,GAAIE,GAASL,EAAOM,MAChB5E,KACAuE,EAAKM,OAAOjE,EAAYQ,KAAKoD,YAEjC,IAAInE,OAAOsE,KAAYA,EAAQ,CAC3B,MAAOA,GAEX,MAAO3E,UAEJ,CAoBH,MAAOsE,GAAOM,MACVP,EACAE,EAAKM,OAAOjE,EAAYQ,KAAKoD,cAazC,IAAIM,GAAc1B,KAAK2B,IAAI,EAAGT,EAAOrC,OAASsC,EAAKtC,OAInD,IAAI+C,KACJ,KAAK,GAAIC,GAAI,EAAGA,EAAIH,EAAaG,IAAK,CAClCD,EAAU/D,KAAK,IAAMgE,GASzBR,EAAQlE,SAAS,SAAU,oBAAsByE,EAAUE,KAAK,KAAO,8CAA8CR,EAErH,IAAIJ,EAAOnE,UAAW,CAClBgE,EAAMhE,UAAYmE,EAAOnE,SACzBsE,GAAMtE,UAAY,GAAIgE,EAEtBA,GAAMhE,UAAY,KAwBtB,MAAOsE,KAMf,IAAIU,GAAO/D,EAAKgD,KAAKhE,EAAgB4C,eASrC,IAAIoC,GAA+B,WAC/B,GAAIC,IAAK,EAAG,EACZ,IAAIV,GAASU,EAAEtE,QACf,OAAOsE,GAAEpD,SAAW,GAAKP,EAAQiD,IAAWA,EAAO1C,SAAW,IAElEE,GAAiBlC,GAEbc,OAAQ,QAASA,IAAOuE,EAAOC,GAC3B,GAAIf,UAAUvC,SAAW,EAAG,CACxB,aACG,CACH,MAAOnB,GAAa8D,MAAM5E,KAAMwE,eAGxCY,EAEJ,IAAII,GAA8B,WAC9B,GAAI7D,KACJ1B,GAAec,OAAOK,KAAKO,EAAK,EAAG,EAAG,EACtC,OAAOA,GAAIM,SAAW,IAE1BE,GAAiBlC,GACbc,OAAQ,QAASA,IAAOuE,EAAOC,GAC3B,GAAIf,UAAUvC,SAAW,EAAG,CAAE,SAC9B,GAAIsC,GAAOC,SACXxE,MAAKiC,OAASmB,KAAK2B,IAAI9B,EAAUjD,KAAKiC,QAAS,EAC/C,IAAIuC,UAAUvC,OAAS,SAAYsD,KAAgB,SAAU,CACzDhB,EAAO3D,EAAYQ,KAAKoD,UACxB,IAAID,EAAKtC,OAAS,EAAG,CACjBsC,EAAKtD,KAAKjB,KAAKiC,OAASqD,OACrB,CACHf,EAAK,GAAKtB,EAAUsC,IAG5B,MAAOzE,GAAa8D,MAAM5E,KAAMuE,MAEpCiB,EAOJ,IAAIC,MAA8BtE,QAAQ,KAAO,CACjDgB,GAAiBlC,GACbkB,QAAS,WACLD,EAAc0D,MAAM5E,KAAMwE,UAC1B,OAAOxE,MAAKiC,SAEjBwD,EAKHtD,GAAiBjC,OAASwB,QAASA,GAoBnC,IAAIgE,GAAcrF,OAAO,IACzB,IAAIsF,GAAcD,EAAY,KAAO,OAAS,IAAKA,GAEnD,IAAIE,GAAuB,QAASC,IAAcnD,GAE9C,GAAIoD,GAAyB,IAC7B,IAAIC,GAAsB,IAC1B,IAAIrD,EAAQ,CACRA,EAAOtB,KAAK,MAAO,SAAU4E,EAAGC,EAAIC,GAChC,SAAWA,KAAY,SAAU,CAAEJ,EAAyB,QAGhEpD,GAAOtB,MAAM,GAAI,WACb,YACA2E,SAA6B/F,QAAS,UACvC,KAEP,QAAS0C,GAAUoD,GAA0BC,EAGjD5D,GAAiBlC,GACbkG,QAAS,QAASA,IAAQC,GACtB,GAAI5D,GAASsB,EAAGC,SAAS/D,MACrBqG,EAAOV,GAAe/D,EAAS5B,MAAQA,KAAKsG,MAAM,IAAM9D,EACxD+D,EAAQ/B,UAAU,GAClBS,GAAK,EACLhD,EAASoE,EAAKpE,SAAW,CAG7B,KAAKV,EAAW6E,GAAM,CAClB,KAAM,IAAIvC,WAGd,QAASoB,EAAIhD,EAAQ,CACjB,GAAIgD,IAAKoB,GAAM,CAIXD,EAAIhF,KAAKmF,EAAOF,EAAKpB,GAAIA,EAAGzC,QAIxCoD,EAAqB3F,EAAekG,SAKxChE,GAAiBlC,GACb8C,IAAK,QAASA,IAAIqD,GACd,GAAI5D,GAASsB,EAAGC,SAAS/D,MACrBqG,EAAOV,GAAe/D,EAAS5B,MAAQA,KAAKsG,MAAM,IAAM9D,EACxDP,EAASoE,EAAKpE,SAAW,EACzB0C,EAASzE,MAAM+B,GACfsE,EAAQ/B,UAAU,EAGtB,KAAKjD,EAAW6E,GAAM,CAClB,KAAM,IAAIvC,WAAUuC,EAAM,sBAG9B,IAAK,GAAInB,GAAI,EAAGA,EAAIhD,EAAQgD,IAAK,CAC7B,GAAIA,IAAKoB,GAAM,CACX1B,EAAOM,GAAKmB,EAAIhF,KAAKmF,EAAOF,EAAKpB,GAAIA,EAAGzC,IAGhD,MAAOmC,MAEXiB,EAAqB3F,EAAe8C,KAKxCZ,GAAiBlC,GACbuG,OAAQ,QAASA,IAAOJ,GACpB,GAAI5D,GAASsB,EAAGC,SAAS/D,MACrBqG,EAAOV,GAAe/D,EAAS5B,MAAQA,KAAKsG,MAAM,IAAM9D,EACxDP,EAASoE,EAAKpE,SAAW,EACzB0C,KACA7C,EACAyE,EAAQ/B,UAAU,EAGtB,KAAKjD,EAAW6E,GAAM,CAClB,KAAM,IAAIvC,WAAUuC,EAAM,sBAG9B,IAAK,GAAInB,GAAI,EAAGA,EAAIhD,EAAQgD,IAAK,CAC7B,GAAIA,IAAKoB,GAAM,CACXvE,EAAQuE,EAAKpB,EACb,IAAImB,EAAIhF,KAAKmF,EAAOzE,EAAOmD,EAAGzC,GAAS,CACnCmC,EAAO1D,KAAKa,KAIxB,MAAO6C,MAEXiB,EAAqB3F,EAAeuG,QAKxCrE,GAAiBlC,GACbwG,MAAO,QAASA,IAAML,GAClB,GAAI5D,GAASsB,EAAGC,SAAS/D,MACrBqG,EAAOV,GAAe/D,EAAS5B,MAAQA,KAAKsG,MAAM,IAAM9D,EACxDP,EAASoE,EAAKpE,SAAW,EACzBsE,EAAQ/B,UAAU,EAGtB,KAAKjD,EAAW6E,GAAM,CAClB,KAAM,IAAIvC,WAAUuC,EAAM,sBAG9B,IAAK,GAAInB,GAAI,EAAGA,EAAIhD,EAAQgD,IAAK,CAC7B,GAAIA,IAAKoB,KAASD,EAAIhF,KAAKmF,EAAOF,EAAKpB,GAAIA,EAAGzC,GAAS,CACnD,MAAO,QAGf,MAAO,SAEXoD,EAAqB3F,EAAewG,OAKxCtE,GAAiBlC,GACbyG,KAAM,QAASA,IAAKN,GAChB,GAAI5D,GAASsB,EAAGC,SAAS/D,MACrBqG,EAAOV,GAAe/D,EAAS5B,MAAQA,KAAKsG,MAAM,IAAM9D,EACxDP,EAASoE,EAAKpE,SAAW,EACzBsE,EAAQ/B,UAAU,EAGtB,KAAKjD,EAAW6E,GAAM,CAClB,KAAM,IAAIvC,WAAUuC,EAAM,sBAG9B,IAAK,GAAInB,GAAI,EAAGA,EAAIhD,EAAQgD,IAAK,CAC7B,GAAIA,IAAKoB,IAAQD,EAAIhF,KAAKmF,EAAOF,EAAKpB,GAAIA,EAAGzC,GAAS,CAClD,MAAO,OAGf,MAAO,UAEXoD,EAAqB3F,EAAeyG,MAKxC,IAAIC,GAAwB,KAC5B,IAAI1G,EAAe2G,OAAQ,CACvBD,QAA+B1G,GAAe2G,OAAOxF,KAAK,MAAO,SAAU4E,EAAGC,EAAIY,EAAKC,GAAQ,MAAOA,OAAa,SAEvH3E,EAAiBlC,GACb2G,OAAQ,QAASA,IAAOR,GACpB,GAAI5D,GAASsB,EAAGC,SAAS/D,MACrBqG,EAAOV,GAAe/D,EAAS5B,MAAQA,KAAKsG,MAAM,IAAM9D,EACxDP,EAASoE,EAAKpE,SAAW,CAG7B,KAAKV,EAAW6E,GAAM,CAClB,KAAM,IAAIvC,WAAUuC,EAAM,sBAI9B,IAAKnE,GAAUuC,UAAUvC,SAAW,EAAG,CACnC,KAAM,IAAI4B,WAAU,+CAGxB,GAAIoB,GAAI,CACR,IAAIN,EACJ,IAAIH,UAAUvC,QAAU,EAAG,CACvB0C,EAASH,UAAU,OAChB,CACH,EAAG,CACC,GAAIS,IAAKoB,GAAM,CACX1B,EAAS0B,EAAKpB,IACd,OAIJ,KAAMA,GAAKhD,EAAQ,CACf,KAAM,IAAI4B,WAAU,sDAEnB,MAGb,KAAOoB,EAAIhD,EAAQgD,IAAK,CACpB,GAAIA,IAAKoB,GAAM,CACX1B,EAASyB,EAAIhF,SAAU,GAAGuD,EAAQ0B,EAAKpB,GAAIA,EAAGzC,IAItD,MAAOmC,MAEXgC,EAKJ,IAAII,GAA6B,KACjC,IAAI9G,EAAe+G,YAAa,CAC5BD,QAAoC9G,GAAe+G,YAAY5F,KAAK,MAAO,SAAU4E,EAAGC,EAAIY,EAAKC,GAAQ,MAAOA,OAAa,SAEjI3E,EAAiBlC,GACb+G,YAAa,QAASA,IAAYZ,GAC9B,GAAI5D,GAASsB,EAAGC,SAAS/D,MACrBqG,EAAOV,GAAe/D,EAAS5B,MAAQA,KAAKsG,MAAM,IAAM9D,EACxDP,EAASoE,EAAKpE,SAAW,CAG7B,KAAKV,EAAW6E,GAAM,CAClB,KAAM,IAAIvC,WAAUuC,EAAM,sBAI9B,IAAKnE,GAAUuC,UAAUvC,SAAW,EAAG,CACnC,KAAM,IAAI4B,WAAU,oDAGxB,GAAIc,GAAQM,EAAIhD,EAAS,CACzB,IAAIuC,UAAUvC,QAAU,EAAG,CACvB0C,EAASH,UAAU,OAChB,CACH,EAAG,CACC,GAAIS,IAAKoB,GAAM,CACX1B,EAAS0B,EAAKpB,IACd,OAIJ,KAAMA,EAAI,EAAG,CACT,KAAM,IAAIpB,WAAU,2DAEnB,MAGb,GAAIoB,EAAI,EAAG,CACP,MAAON,GAGX,EAAG,CACC,GAAIM,IAAKoB,GAAM,CACX1B,EAASyB,EAAIhF,SAAU,GAAGuD,EAAQ0B,EAAKpB,GAAIA,EAAGzC,UAE7CyC,IAET,OAAON,MAEXoC,EAKJ,IAAIE,GAAwB/G,MAAMC,UAAU+G,UAAY,EAAG,GAAGA,QAAQ,EAAG,MAAQ,CACjF/E,GAAiBlC,GACbiH,QAAS,QAASA,IAAQC,GACtB,GAAId,GAAOV,GAAe/D,EAAS5B,MAAQA,KAAKsG,MAAM,IAAMxC,EAAGC,SAAS/D,MACpEiC,EAASoE,EAAKpE,SAAW,CAE7B,KAAKA,EAAQ,CACT,OAAQ,EAGZ,GAAIgD,GAAI,CACR,IAAIT,UAAUvC,OAAS,EAAG,CACtBgD,EAAIhC,EAAUuB,UAAU,IAI5BS,EAAIA,GAAK,EAAIA,EAAI7B,KAAK2B,IAAI,EAAG9C,EAASgD,EACtC,MAAOA,EAAIhD,EAAQgD,IAAK,CACpB,GAAIA,IAAKoB,IAAQA,EAAKpB,KAAOkC,EAAQ,CACjC,MAAOlC,IAGf,OAAQ,IAEbgC,EAKH,IAAIG,GAA4BlH,MAAMC,UAAUkH,cAAgB,EAAG,GAAGA,YAAY,GAAI,MAAQ,CAC9FlF,GAAiBlC,GACboH,YAAa,QAASA,IAAYF,GAC9B,GAAId,GAAOV,GAAe/D,EAAS5B,MAAQA,KAAKsG,MAAM,IAAMxC,EAAGC,SAAS/D,MACpEiC,EAASoE,EAAKpE,SAAW,CAE7B,KAAKA,EAAQ,CACT,OAAQ,EAEZ,GAAIgD,GAAIhD,EAAS,CACjB,IAAIuC,UAAUvC,OAAS,EAAG,CACtBgD,EAAI7B,KAAKkE,IAAIrC,EAAGhC,EAAUuB,UAAU,KAGxCS,EAAIA,GAAK,EAAIA,EAAIhD,EAASmB,KAAKE,IAAI2B,EACnC,MAAOA,GAAK,EAAGA,IAAK,CAChB,GAAIA,IAAKoB,IAAQc,IAAWd,EAAKpB,GAAI,CACjC,MAAOA,IAGf,OAAQ,IAEbmC,EAWH,IAAIG,KAAoBjG,SAAY,MAAOkG,qBAAqB,YAC5DC,EAAkB,aAAeD,qBAAqB,aACtDE,GAAoBvC,EAAK,IAAK,KAC9BwC,GACI,WACA,iBACA,UACA,iBACA,gBACA,uBACA,eAEJC,EAAkBD,EAAU1F,MAEhCE,GAAiB9B,QACbwH,KAAM,QAASA,IAAKrF,GAChB,GAAIsF,GAAOvG,EAAWiB,GAClBR,EAASH,EAAYW,GACrBuF,EAAWvF,IAAW,YAAeA,KAAW,SAChDwF,EAAQD,GAAYnG,EAASY,EAEjC,KAAKuF,IAAaD,IAAS9F,EAAQ,CAC/B,KAAM,IAAI6B,WAAU,sCAGxB,GAAIoE,KACJ,IAAIC,GAAYT,GAAmBK,CACnC,IAAKE,GAASN,GAAqB1F,EAAQ,CACvC,IAAK,GAAIiD,GAAI,EAAGA,EAAIzC,EAAOP,SAAUgD,EAAG,CACpCgD,EAAQhH,KAAKR,OAAOwE,KAI5B,IAAKjD,EAAQ,CACT,IAAK,GAAIS,KAAQD,GAAQ,CACrB,KAAM0F,GAAazF,IAAS,cAAgB0C,EAAK3C,EAAQC,GAAO,CAC5DwF,EAAQhH,KAAKR,OAAOgC,MAKhC,GAAI8E,EAAgB,CAChB,GAAIY,GAAO3F,EAAO4F,YACdC,EAAkBF,GAAQA,EAAKhI,YAAcqC,CACjD,KAAK,GAAI8F,GAAI,EAAGA,EAAIV,EAAiBU,IAAK,CACtC,GAAIC,GAAWZ,EAAUW,EACzB,MAAMD,GAAmBE,IAAa,gBAAkBpD,EAAK3C,EAAQ+F,GAAW,CAC5EN,EAAQhH,KAAKsH,KAIzB,MAAON,KAIf,IAAIO,GAAyBnI,OAAOwH,MAAS,WAEzC,MAAOxH,QAAOwH,KAAKrD,WAAWvC,SAAW,GAC3C,EAAG,EACL,IAAIwG,GAAepI,OAAOwH,IAC1B1F,GAAiB9B,QACbwH,KAAM,QAASA,IAAKrF,GAChB,GAAIX,EAAYW,GAAS,CACrB,MAAOiG,GAAaxI,EAAeY,MAAMO,KAAKoB,QAC3C,CACH,MAAOiG,GAAajG,OAG5BgG,EAcJ,IAAIE,IAAgB,WACpB,IAAIC,GAAqB,SACzB,IAAIC,GAAqBC,KAAK1I,UAAU2I,aAAe,GAAID,MAAKH,GAAcI,cAAc5B,QAAQyB,MAAyB,CAE7HxG,GAAiB0G,KAAK1I,WAClB2I,YAAa,QAASA,MAClB,GAAInE,GAAQ1C,EAAQH,EAAOiH,EAAMC,CACjC,KAAKC,SAASjJ,MAAO,CACjB,KAAM,IAAIkJ,YAAW,0DAGzBH,EAAO/I,KAAKmJ,gBAEZH,GAAQhJ,KAAKoJ,aAEbL,IAAQ3F,KAAKC,MAAM2F,EAAQ,GAC3BA,IAASA,EAAQ,GAAK,IAAM,EAG5BrE,IAAUqE,EAAQ,EAAGhJ,KAAKqJ,aAAcrJ,KAAKsJ,cAAetJ,KAAKuJ,gBAAiBvJ,KAAKwJ,gBACvFT,IACKA,EAAO,EAAI,IAAOA,EAAO,KAAO,IAAM,KACtC,QAAU3F,KAAKE,IAAIyF,IAAOlI,MAAO,GAAKkI,GAAQA,GAAQ,MAAS,GAAK,EAGzE9G,GAAS0C,EAAO1C,MAChB,OAAOA,IAAU,CACbH,EAAQ6C,EAAO1C,EAGf,IAAIH,EAAQ,GAAI,CACZ6C,EAAO1C,GAAU,IAAMH,GAI/B,MACIiH,GAAO,IAAMpE,EAAO9D,MAAM,EAAG,GAAGqE,KAAK,KACrC,IAAMP,EAAO9D,MAAM,GAAGqE,KAAK,KAAO,KACjC,MAAQlF,KAAKyJ,sBAAsB5I,OAAO,GAAK,MAGzD+H,EAOH,IAAIc,GAAwB,KAC5B,KACIA,EACIb,KAAK1I,UAAUwJ,QACf,GAAId,MAAKe,KAAKD,WAAa,MAC3B,GAAId,MAAKH,GAAciB,SAASzC,QAAQyB,MAAyB,GACjEE,KAAK1I,UAAUwJ,OAAOvI,MAClB0H,YAAa,WACT,MAAO,SAIrB,MAAOvG,IAET,IAAKmH,EAAuB,CACxBb,KAAK1I,UAAUwJ,OAAS,QAASA,IAAOE,GAOpC,GAAI7F,GAAI3D,OAAOL,MACX8J,EAAKpG,EAAYM,GACjB+F,CAEJ,UAAWD,KAAO,WAAab,SAASa,GAAK,CACzC,MAAO,MAIXC,EAAQ/F,EAAE8E,WAEV,UAAWiB,KAAU,WAAY,CAC7B,KAAM,IAAIlG,WAAU,wCAIxB,MAAOkG,GAAM3I,KAAK4C,IAiB1B,GAAIgG,GAAwBnB,KAAKoB,MAAM,iCAAmC,IAC1E,IAAIC,IAAuBC,MAAMtB,KAAKoB,MAAM,+BAAiCE,MAAMtB,KAAKoB,MAAM,4BAC9F,IAAIG,GAAyBD,MAAMtB,KAAKoB,MAAM,4BAC9C,KAAKpB,KAAKoB,OAASG,GAA0BF,IAAwBF,EAAuB,CAKxFnB,KAAQ,SAAUwB,GAGd,QAASxB,GAAKyB,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,GAC5B,GAAI3I,GAASuC,UAAUvC,MACvB,IAAIjC,eAAgBqK,GAAY,CAC5B,GAAIQ,GAAO5I,IAAW,GAAKxB,OAAO6J,KAAOA,EAErC,GAAID,GAAWxB,EAAKoB,MAAMK,IAG1BrI,GAAU,EAAI,GAAIoI,GAAWC,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,GAC/C3I,GAAU,EAAI,GAAIoI,GAAWC,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,GAC5C1I,GAAU,EAAI,GAAIoI,GAAWC,EAAGC,EAAGC,EAAGC,EAAGC,GACzCzI,GAAU,EAAI,GAAIoI,GAAWC,EAAGC,EAAGC,EAAGC,GACtCxI,GAAU,EAAI,GAAIoI,GAAWC,EAAGC,EAAGC,GACnCvI,GAAU,EAAI,GAAIoI,GAAWC,EAAGC,GAChCtI,GAAU,EAAI,GAAIoI,GAAWC,GACf,GAAID,EAEtBQ,GAAKzC,YAAcS,CACnB,OAAOgC,GAEX,MAAOR,GAAWzF,MAAM5E,KAAMwE,WAIlC,GAAIsG,GAAoB,GAAIC,QAAO,IAC/B,sBAEA,eACA,eACA,MACI,YACA,YACA,MACI,YACA,oBACJ,KACJ,IACI,KACA,MACI,SACA,WACA,YACJ,IACJ,WACJ,IAEA,IAAIC,IACA,EAAG,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAG3D,SAASC,GAAalC,EAAMC,GACxB,GAAIkC,GAAIlC,EAAQ,EAAI,EAAI,CACxB,OACIgC,GAAOhC,GACP5F,KAAKC,OAAO0F,EAAO,KAAOmC,GAAK,GAC/B9H,KAAKC,OAAO0F,EAAO,KAAOmC,GAAK,KAC/B9H,KAAKC,OAAO0F,EAAO,KAAOmC,GAAK,KAC/B,KAAOnC,EAAO,MAItB,QAASoC,GAAMD,GACX,MAAOvK,QAAO,GAAI0J,GAAW,KAAM,EAAG,EAAG,EAAG,EAAG,EAAGa,IAItD,IAAK,GAAIrB,KAAOQ,GAAY,CACxBxB,EAAKgB,GAAOQ,EAAWR,GAI3BhB,EAAKuC,IAAMf,EAAWe,GACtBvC,GAAKwC,IAAMhB,EAAWgB,GACtBxC,GAAK1I,UAAYkK,EAAWlK,SAC5B0I,GAAK1I,UAAUiI,YAAcS,CAG7BA,GAAKoB,MAAQ,QAASA,GAAMqB,GACxB,GAAIC,GAAQT,EAAkBU,KAAKF,EACnC,IAAIC,EAAO,CAIP,GAAIxC,GAAOpI,OAAO4K,EAAM,IACpBvC,EAAQrI,OAAO4K,EAAM,IAAM,GAAK,EAChCE,EAAM9K,OAAO4K,EAAM,IAAM,GAAK,EAC9BG,EAAO/K,OAAO4K,EAAM,IAAM,GAC1BI,EAAShL,OAAO4K,EAAM,IAAM,GAC5BK,EAASjL,OAAO4K,EAAM,IAAM,GAC5BM,EAAczI,KAAKC,MAAM1C,OAAO4K,EAAM,IAAM,GAAK,KAIjDO,EAAcC,QAAQR,EAAM,KAAOA,EAAM,IACzCS,EAAaT,EAAM,KAAO,IAAM,GAAK,EACrCU,EAAatL,OAAO4K,EAAM,KAAO,GACjCW,EAAevL,OAAO4K,EAAM,KAAO,GACnC5G,CACJ,IACI+G,GACIC,EAAS,GAAKC,EAAS,GAAKC,EAAc,EAC1C,GAAK,KAETF,EAAS,IAAMC,EAAS,IAAMC,EAAc,KAC5C7C,GAAS,GAAKA,EAAQ,IAAMiD,EAAa,IACzCC,EAAe,IACfT,GAAO,GACPA,EACIR,EAAalC,EAAMC,EAAQ,GAC3BiC,EAAalC,EAAMC,GAEzB,CACErE,IACKsG,EAAalC,EAAMC,GAASyC,GAAO,GACpCC,EACAO,EAAaD,GACb,EACJrH,KACKA,EAASgH,EAASO,EAAeF,GAAc,GAChDJ,GACA,IAAOC,CACX,IAAIC,EAAa,CACbnH,EAASwG,EAAMxG,GAEnB,IAAK,QAAWA,GAAUA,GAAU,OAAS,CACzC,MAAOA,IAGf,MAAOiF,KAEX,MAAOS,GAAWJ,MAAMrF,MAAM5E,KAAMwE,WAGxC,OAAOqE,IACTA,MAMN,IAAKA,KAAKuC,IAAK,CACXvC,KAAKuC,IAAM,QAASA,MAChB,OAAO,GAAIvC,OAAOsD,WAY1B,GAAIC,GAAiB1L,EAAgB2L,UACnC,KAAUA,QAAQ,KAAO,SACzB,GAAMA,QAAQ,KAAO,KACrB,MAAQA,QAAQ,KAAO,QACvB,kBAAsBA,QAAQ,KAAO,sBAGvC,IAAIC,IACFC,KAAM,IACNC,KAAM,EACNC,MAAO,EAAG,EAAG,EAAG,EAAG,EAAG,GACtBC,SAAU,QAASA,IAASvJ,EAAGwJ,GAC3B,GAAI1H,IAAK,CACT,SAASA,EAAIqH,EAAeE,KAAM,CAC9BG,GAAKxJ,EAAImJ,EAAeG,KAAKxH,EAC7BqH,GAAeG,KAAKxH,GAAK0H,EAAIL,EAAeC,IAC5CI,GAAIvJ,KAAKC,MAAMsJ,EAAIL,EAAeC,QAG1CK,OAAQ,QAASA,IAAOzJ,GACpB,GAAI8B,GAAIqH,EAAeE,KAAMG,EAAI,CACjC,SAAS1H,GAAK,EAAG,CACb0H,GAAKL,EAAeG,KAAKxH,EACzBqH,GAAeG,KAAKxH,GAAK7B,KAAKC,MAAMsJ,EAAIxJ,EACxCwJ,GAAKA,EAAIxJ,EAAKmJ,EAAeC,OAGrCM,YAAa,QAASA,MAClB,GAAI5H,GAAIqH,EAAeE,IACvB,IAAI7B,GAAI,EACR,SAAS1F,GAAK,EAAG,CACb,GAAI0F,IAAM,IAAM1F,IAAM,GAAKqH,EAAeG,KAAKxH,KAAO,EAAG,CACrD,GAAIiG,GAAIzK,OAAO6L,EAAeG,KAAKxH,GACnC,IAAI0F,IAAM,GAAI,CACVA,EAAIO,MACD,CACHP,GAAK,UAAU9J,MAAM,EAAG,EAAIqK,EAAEjJ,QAAUiJ,IAIpD,MAAOP,IAEXmC,IAAK,QAASA,IAAI5I,EAAGf,EAAG4J,GACpB,MAAQ5J,KAAM,EAAI4J,EAAO5J,EAAI,IAAM,EAAI2J,GAAI5I,EAAGf,EAAI,EAAG4J,EAAM7I,GAAK4I,GAAI5I,EAAIA,EAAGf,EAAI,EAAG4J,IAEtFC,IAAK,QAASA,IAAI9I,GACd,GAAIf,GAAI,CACR,OAAOe,GAAK,KAAM,CACdf,GAAK,EACLe,IAAK,KAET,MAAOA,GAAK,EAAG,CACXf,GAAK,CACLe,IAAK,EAET,MAAOf,IAIbhB,GAAiBzB,GACb2L,QAAS,QAASA,IAAQY,GACtB,GAAIC,GAAGhJ,EAAGyG,EAAGD,EAAGnI,EAAG4K,EAAG7E,EAAG8E,CAGzBF,GAAIvM,OAAOsM,EACXC,GAAIA,IAAMA,EAAI,EAAI9J,KAAKC,MAAM6J,EAE7B,IAAIA,EAAI,GAAKA,EAAI,GAAI,CACjB,KAAM,IAAIhE,YAAW,yDAGzBhF,EAAIvD,OAAOX,KAGX,IAAIkE,IAAMA,EAAG,CACT,MAAO,MAIX,GAAIA,IAAM,MAAQA,GAAK,KAAM,CACzB,MAAOzD,QAAOyD,GAGlByG,EAAI,EAEJ,IAAIzG,EAAI,EAAG,CACPyG,EAAI,GACJzG,IAAKA,EAGTwG,EAAI,GAEJ,IAAIxG,EAAI,MAAO,CAGX3B,EAAI+J,EAAeU,IAAI9I,EAAIoI,EAAeQ,IAAI,EAAG,GAAI,IAAM,EAC3DK,GAAK5K,EAAI,EAAI2B,EAAIoI,EAAeQ,IAAI,GAAIvK,EAAG,GAAK2B,EAAIoI,EAAeQ,IAAI,EAAGvK,EAAG,EAC7E4K,IAAK,gBACL5K,GAAI,GAAKA,CAIT,IAAIA,EAAI,EAAG,CACP+J,EAAeI,SAAS,EAAGS,EAC3B7E,GAAI4E,CAEJ,OAAO5E,GAAK,EAAG,CACXgE,EAAeI,SAAS,IAAK,EAC7BpE,IAAK,EAGTgE,EAAeI,SAASJ,EAAeQ,IAAI,GAAIxE,EAAG,GAAI,EACtDA,GAAI/F,EAAI,CAER,OAAO+F,GAAK,GAAI,CACZgE,EAAeM,OAAO,GAAK,GAC3BtE,IAAK,GAGTgE,EAAeM,OAAO,GAAKtE,EAC3BgE,GAAeI,SAAS,EAAG,EAC3BJ,GAAeM,OAAO,EACtBlC,GAAI4B,EAAeO,kBAChB,CACHP,EAAeI,SAAS,EAAGS,EAC3Bb,GAAeI,SAAS,IAAOnK,EAAI,EACnCmI,GAAI4B,EAAeO,cAAgB,yBAAyBhM,MAAM,EAAG,EAAIqM,IAIjF,GAAIA,EAAI,EAAG,CACPE,EAAI1C,EAAEzI,MAEN,IAAImL,GAAKF,EAAG,CACRxC,EAAIC,EAAI,wBAAwB9J,MAAM,EAAGqM,EAAIE,EAAI,GAAK1C,MACnD,CACHA,EAAIC,EAAID,EAAE7J,MAAM,EAAGuM,EAAIF,GAAK,IAAMxC,EAAE7J,MAAMuM,EAAIF,QAE/C,CACHxC,EAAIC,EAAID,EAGZ,MAAOA,KAEZ0B,EAuBH,IAAIiB,GAAe7M,EAAgB8F,KACnC,IACI,KAAKA,MAAM,WAAWrE,SAAW,GACjC,IAAIqE,MAAM,YAAYrE,SAAW,GACjC,QAAQqE,MAAM,QAAQ,KAAO,KAC7B,OAAOA,MAAM,QAAS,GAAGrE,SAAW,GACpC,GAAGqE,MAAM,MAAMrE,QACf,IAAIqE,MAAM,QAAQrE,OAAS,EAC7B,EACG,WACG,GAAIqL,SAA2B,OAAS9B,KAAK,IAAI,KAAO,WAExDhL,GAAgB8F,MAAQ,SAAUiH,EAAWC,GACzC,GAAIlC,GAAStL,IACb,UAAWuN,KAAc,aAAeC,IAAU,EAAG,CACjD,SAIJ,GAAInM,EAAUD,KAAKmM,KAAe,kBAAmB,CACjD,MAAOF,GAAajM,KAAKpB,KAAMuN,EAAWC,GAG9C,GAAIC,MACAC,GAASH,EAAUI,WAAa,IAAM,KAC7BJ,EAAUK,UAAY,IAAM,KAC5BL,EAAUM,SAAW,IAAM,KAC3BN,EAAUO,OAAS,IAAM,IAClCC,EAAgB,EAEhBC,EAAYzC,EAAO0C,EAAWC,CAClCX,GAAY,GAAIxC,QAAOwC,EAAUY,OAAQT,EAAQ,IACjDpC,IAAU,EACV,KAAKgC,EAAmB,CAEpBU,EAAa,GAAIjD,QAAO,IAAMwC,EAAUY,OAAS,WAAYT,GASjEF,QAAeA,KAAU,aACpB,IAAM,EACP1J,EAAGG,SAASuJ,EAChBjC,GAAQgC,EAAU/B,KAAKF,EACvB,OAAOC,EAAO,CAEV0C,EAAY1C,EAAM6C,MAAQ7C,EAAM,GAAGtJ,MACnC,IAAIgM,EAAYF,EAAe,CAC3BN,EAAOxM,KAAKqK,EAAOzK,MAAMkN,EAAexC,EAAM6C,OAG9C,KAAKd,GAAqB/B,EAAMtJ,OAAS,EAAG,CAExCsJ,EAAM,GAAG8C,QAAQL,EAAY,WACzB,IAAK,GAAI/I,GAAI,EAAGA,EAAIT,UAAUvC,OAAS,EAAGgD,IAAK,CAC3C,SAAWT,WAAUS,KAAO,YAAa,CACrCsG,EAAMtG,OAAU,OAMhC,GAAIsG,EAAMtJ,OAAS,GAAKsJ,EAAM6C,MAAQ9C,EAAOrJ,OAAQ,CACjDjB,EAAW4D,MAAM6I,EAAQlC,EAAM1K,MAAM,IAEzCqN,EAAa3C,EAAM,GAAGtJ,MACtB8L,GAAgBE,CAChB,IAAIR,EAAOxL,QAAUuL,EAAO,CACxB,OAGR,GAAID,EAAUU,YAAc1C,EAAM6C,MAAO,CACrCb,EAAUU,YAEd1C,EAAQgC,EAAU/B,KAAKF,GAE3B,GAAIyC,IAAkBzC,EAAOrJ,OAAQ,CACjC,GAAIiM,IAAeX,EAAUe,KAAK,IAAK,CACnCb,EAAOxM,KAAK,SAEb,CACHwM,EAAOxM,KAAKqK,EAAOzK,MAAMkN,IAE7B,MAAON,GAAOxL,OAASuL,EAAQC,EAAO5M,MAAM,EAAG2M,GAASC,WAU7D,IAAI,IAAInH,UAAW,GAAG,GAAGrE,OAAQ,CACpCzB,EAAgB8F,MAAQ,QAASA,IAAMiH,EAAWC,GAC9C,SAAWD,KAAc,aAAeC,IAAU,EAAG,CAAE,SACvD,MAAOH,GAAajM,KAAKpB,KAAMuN,EAAWC,IAIlD,GAAIe,GAAc/N,EAAgB6N,OAClC,IAAIG,GAAiC,WACjC,GAAIC,KACJ,KAAIJ,QAAQ,SAAU,SAAU9C,EAAOmD,GACnCD,EAAOxN,KAAKyN,IAEhB,OAAOD,GAAOxM,SAAW,SAAYwM,GAAO,KAAO,cAGvD,KAAKD,EAA+B,CAChChO,EAAgB6N,QAAU,QAASA,IAAQM,EAAaC,GACpD,GAAI9G,GAAOvG,EAAWqN,EACtB,IAAIC,GAAqBpN,EAAQkN,IAAgB,SAAWL,KAAKK,EAAYR,OAC7E,KAAKrG,IAAS+G,EAAoB,CAC9B,MAAON,GAAYnN,KAAKpB,KAAM2O,EAAaC,OACxC,CACH,GAAIE,GAAsB,SAAUvD,GAChC,GAAItJ,GAASuC,UAAUvC,MACvB,IAAI8M,GAAoBJ,EAAYV,SACpCU,GAAYV,UAAY,CACxB,IAAI1J,GAAOoK,EAAYnD,KAAKD,MAC5BoD,GAAYV,UAAYc,CACxBxK,GAAKtD,KAAKuD,UAAUvC,EAAS,GAAIuC,UAAUvC,EAAS,GACpD,OAAO2M,GAAahK,MAAM5E,KAAMuE,GAEpC,OAAOgK,GAAYnN,KAAKpB,KAAM2O,EAAaG,KAUvD,GAAIE,GAAgBxO,EAAgByO,MACpC,IAAIC,IAAuB,GAAGD,QAAU,KAAKA,QAAQ,KAAO,GAC5D9M,GAAiB3B,GACbyO,OAAQ,QAASA,IAAO3J,EAAOrD,GAC3B,MAAO+M,GAAc5N,KACjBpB,KACAsF,EAAQ,GAAMA,EAAQtF,KAAKiC,OAASqD,GAAS,EAAI,EAAIA,EAASA,EAC9DrD,KAGTiN,GAIH,IAAIC,IAAK,oDACL,qEACA,cACJ,IAAIC,IAAY,QAChB,IAAIC,IAAe,IAAMF,GAAK,GAC9B,IAAIG,IAAkB,GAAIvE,QAAO,IAAMsE,GAAeA,GAAe,IACrE,IAAIE,IAAgB,GAAIxE,QAAOsE,GAAeA,GAAe,KAC7D,IAAIG,IAAuBhP,EAAgBiP,OAASN,GAAGM,SAAWL,GAAUK,OAC5EtN,GAAiB3B,GAGbiP,KAAM,QAASA,MACX,SAAWzP,QAAS,aAAeA,OAAS,KAAM,CAC9C,KAAM,IAAI6D,WAAU,iBAAmB7D,KAAO,cAElD,MAAOS,QAAOT,MAAMqO,QAAQiB,GAAiB,IAAIjB,QAAQkB,GAAe,MAE7EC,GAGH,IAAIE,SAASP,GAAK,QAAU,GAAKO,SAASP,GAAK,UAAY,GAAI,CAE3DO,SAAY,SAAUC,GAClB,GAAIC,GAAW,QACf,OAAO,SAASC,GAAY9N,EAAK+N,GAC7B/N,EAAMtB,OAAOsB,GAAK0N,MAClB,KAAK9O,OAAOmP,GAAQ,CAChBA,EAAQF,EAAStB,KAAKvM,GAAO,GAAK,GAEtC,MAAO4N,GAAa5N,EAAK+N,KAE/BJ"}
\ No newline at end of file
diff --git a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-shim.min.js b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-shim.min.js
new file mode 100644
index 00000000..773caae5
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-shim.min.js
@@ -0,0 +1,7 @@
+/*!
+ * https://github.com/es-shims/es5-shim
+ * @license es5-shim Copyright 2009-2014 by contributors, MIT License
+ * see https://github.com/es-shims/es5-shim/blob/v4.0.6/LICENSE
+ */
+(function(t,e){"use strict";if(typeof define==="function"&&define.amd){define(e)}else if(typeof exports==="object"){module.exports=e()}else{t.returnExports=e()}})(this,function(){var t=Array.prototype;var e=Object.prototype;var r=Function.prototype;var n=String.prototype;var i=Number.prototype;var a=t.slice;var o=t.splice;var u=t.push;var l=t.unshift;var s=r.call;var f=e.toString;var c=function(t){return f.call(t)==="[object Function]"};var p=function(t){return f.call(t)==="[object RegExp]"};var h=function ue(t){return f.call(t)==="[object Array]"};var v=function le(t){return f.call(t)==="[object String]"};var g=function se(t){var e=f.call(t);var r=e==="[object Arguments]";if(!r){r=!h(t)&&t!==null&&typeof t==="object"&&typeof t.length==="number"&&t.length>=0&&c(t.callee)}return r};var y=function(t){var e=Object.defineProperty&&function(){try{Object.defineProperty({},"x",{});return true}catch(t){return false}}();var r;if(e){r=function(t,e,r,n){if(!n&&e in t){return}Object.defineProperty(t,e,{configurable:true,enumerable:false,writable:true,value:r})}}else{r=function(t,e,r,n){if(!n&&e in t){return}t[e]=r}}return function n(e,i,a){for(var o in i){if(t.call(i,o)){r(e,o,i[o],a)}}}}(e.hasOwnProperty);function d(t){var e=+t;if(e!==e){e=0}else if(e!==0&&e!==1/0&&e!==-(1/0)){e=(e>0||-1)*Math.floor(Math.abs(e))}return e}function m(t){var e=typeof t;return t===null||e==="undefined"||e==="boolean"||e==="number"||e==="string"}function b(t){var e,r,n;if(m(t)){return t}r=t.valueOf;if(c(r)){e=r.call(t);if(m(e)){return e}}n=t.toString;if(c(n)){e=n.call(t);if(m(e)){return e}}throw new TypeError}var w={ToObject:function(t){if(t==null){throw new TypeError("can't convert "+t+" to object")}return Object(t)},ToUint32:function fe(t){return t>>>0}};var x=function ce(){};y(r,{bind:function pe(t){var e=this;if(!c(e)){throw new TypeError("Function.prototype.bind called on incompatible "+e)}var r=a.call(arguments,1);var n;var i=function(){if(this instanceof n){var i=e.apply(this,r.concat(a.call(arguments)));if(Object(i)===i){return i}return this}else{return e.apply(t,r.concat(a.call(arguments)))}};var o=Math.max(0,e.length-r.length);var u=[];for(var l=0;l<o;l++){u.push("$"+l)}n=Function("binder","return function ("+u.join(",")+"){ return binder.apply(this, arguments); }")(i);if(e.prototype){x.prototype=e.prototype;n.prototype=new x;x.prototype=null}return n}});var O=s.bind(e.hasOwnProperty);var T=function(){var t=[1,2];var e=t.splice();return t.length===2&&h(e)&&e.length===0}();y(t,{splice:function he(t,e){if(arguments.length===0){return[]}else{return o.apply(this,arguments)}}},!T);var j=function(){var e={};t.splice.call(e,0,0,1);return e.length===1}();y(t,{splice:function ve(t,e){if(arguments.length===0){return[]}var r=arguments;this.length=Math.max(d(this.length),0);if(arguments.length>0&&typeof e!=="number"){r=a.call(arguments);if(r.length<2){r.push(this.length-t)}else{r[1]=d(e)}}return o.apply(this,r)}},!j);var S=[].unshift(0)!==1;y(t,{unshift:function(){l.apply(this,arguments);return this.length}},S);y(Array,{isArray:h});var E=Object("a");var N=E[0]!=="a"||!(0 in E);var I=function ge(t){var e=true;var r=true;if(t){t.call("foo",function(t,r,n){if(typeof n!=="object"){e=false}});t.call([1],function(){"use strict";r=typeof this==="string"},"x")}return!!t&&e&&r};y(t,{forEach:function ye(t){var e=w.ToObject(this),r=N&&v(this)?this.split(""):e,n=arguments[1],i=-1,a=r.length>>>0;if(!c(t)){throw new TypeError}while(++i<a){if(i in r){t.call(n,r[i],i,e)}}}},!I(t.forEach));y(t,{map:function de(t){var e=w.ToObject(this),r=N&&v(this)?this.split(""):e,n=r.length>>>0,i=Array(n),a=arguments[1];if(!c(t)){throw new TypeError(t+" is not a function")}for(var o=0;o<n;o++){if(o in r){i[o]=t.call(a,r[o],o,e)}}return i}},!I(t.map));y(t,{filter:function me(t){var e=w.ToObject(this),r=N&&v(this)?this.split(""):e,n=r.length>>>0,i=[],a,o=arguments[1];if(!c(t)){throw new TypeError(t+" is not a function")}for(var u=0;u<n;u++){if(u in r){a=r[u];if(t.call(o,a,u,e)){i.push(a)}}}return i}},!I(t.filter));y(t,{every:function be(t){var e=w.ToObject(this),r=N&&v(this)?this.split(""):e,n=r.length>>>0,i=arguments[1];if(!c(t)){throw new TypeError(t+" is not a function")}for(var a=0;a<n;a++){if(a in r&&!t.call(i,r[a],a,e)){return false}}return true}},!I(t.every));y(t,{some:function we(t){var e=w.ToObject(this),r=N&&v(this)?this.split(""):e,n=r.length>>>0,i=arguments[1];if(!c(t)){throw new TypeError(t+" is not a function")}for(var a=0;a<n;a++){if(a in r&&t.call(i,r[a],a,e)){return true}}return false}},!I(t.some));var D=false;if(t.reduce){D=typeof t.reduce.call("es5",function(t,e,r,n){return n})==="object"}y(t,{reduce:function xe(t){var e=w.ToObject(this),r=N&&v(this)?this.split(""):e,n=r.length>>>0;if(!c(t)){throw new TypeError(t+" is not a function")}if(!n&&arguments.length===1){throw new TypeError("reduce of empty array with no initial value")}var i=0;var a;if(arguments.length>=2){a=arguments[1]}else{do{if(i in r){a=r[i++];break}if(++i>=n){throw new TypeError("reduce of empty array with no initial value")}}while(true)}for(;i<n;i++){if(i in r){a=t.call(void 0,a,r[i],i,e)}}return a}},!D);var M=false;if(t.reduceRight){M=typeof t.reduceRight.call("es5",function(t,e,r,n){return n})==="object"}y(t,{reduceRight:function Oe(t){var e=w.ToObject(this),r=N&&v(this)?this.split(""):e,n=r.length>>>0;if(!c(t)){throw new TypeError(t+" is not a function")}if(!n&&arguments.length===1){throw new TypeError("reduceRight of empty array with no initial value")}var i,a=n-1;if(arguments.length>=2){i=arguments[1]}else{do{if(a in r){i=r[a--];break}if(--a<0){throw new TypeError("reduceRight of empty array with no initial value")}}while(true)}if(a<0){return i}do{if(a in r){i=t.call(void 0,i,r[a],a,e)}}while(a--);return i}},!M);var F=Array.prototype.indexOf&&[0,1].indexOf(1,2)!==-1;y(t,{indexOf:function Te(t){var e=N&&v(this)?this.split(""):w.ToObject(this),r=e.length>>>0;if(!r){return-1}var n=0;if(arguments.length>1){n=d(arguments[1])}n=n>=0?n:Math.max(0,r+n);for(;n<r;n++){if(n in e&&e[n]===t){return n}}return-1}},F);var R=Array.prototype.lastIndexOf&&[0,1].lastIndexOf(0,-3)!==-1;y(t,{lastIndexOf:function je(t){var e=N&&v(this)?this.split(""):w.ToObject(this),r=e.length>>>0;if(!r){return-1}var n=r-1;if(arguments.length>1){n=Math.min(n,d(arguments[1]))}n=n>=0?n:r-Math.abs(n);for(;n>=0;n--){if(n in e&&t===e[n]){return n}}return-1}},R);var U=!{toString:null}.propertyIsEnumerable("toString"),k=function(){}.propertyIsEnumerable("prototype"),C=!O("x","0"),A=["toString","toLocaleString","valueOf","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","constructor"],P=A.length;y(Object,{keys:function Se(t){var e=c(t),r=g(t),n=t!==null&&typeof t==="object",i=n&&v(t);if(!n&&!e&&!r){throw new TypeError("Object.keys called on a non-object")}var a=[];var o=k&&e;if(i&&C||r){for(var u=0;u<t.length;++u){a.push(String(u))}}if(!r){for(var l in t){if(!(o&&l==="prototype")&&O(t,l)){a.push(String(l))}}}if(U){var s=t.constructor,f=s&&s.prototype===t;for(var p=0;p<P;p++){var h=A[p];if(!(f&&h==="constructor")&&O(t,h)){a.push(h)}}}return a}});var Z=Object.keys&&function(){return Object.keys(arguments).length===2}(1,2);var J=Object.keys;y(Object,{keys:function Ee(e){if(g(e)){return J(t.slice.call(e))}else{return J(e)}}},!Z);var z=-621987552e5;var $="-000001";var B=Date.prototype.toISOString&&new Date(z).toISOString().indexOf($)===-1;y(Date.prototype,{toISOString:function Ne(){var t,e,r,n,i;if(!isFinite(this)){throw new RangeError("Date.prototype.toISOString called on non-finite value.")}n=this.getUTCFullYear();i=this.getUTCMonth();n+=Math.floor(i/12);i=(i%12+12)%12;t=[i+1,this.getUTCDate(),this.getUTCHours(),this.getUTCMinutes(),this.getUTCSeconds()];n=(n<0?"-":n>9999?"+":"")+("00000"+Math.abs(n)).slice(0<=n&&n<=9999?-4:-6);e=t.length;while(e--){r=t[e];if(r<10){t[e]="0"+r}}return n+"-"+t.slice(0,2).join("-")+"T"+t.slice(2).join(":")+"."+("000"+this.getUTCMilliseconds()).slice(-3)+"Z"}},B);var H=false;try{H=Date.prototype.toJSON&&new Date(NaN).toJSON()===null&&new Date(z).toJSON().indexOf($)!==-1&&Date.prototype.toJSON.call({toISOString:function(){return true}})}catch(L){}if(!H){Date.prototype.toJSON=function Ie(t){var e=Object(this),r=b(e),n;if(typeof r==="number"&&!isFinite(r)){return null}n=e.toISOString;if(typeof n!=="function"){throw new TypeError("toISOString property is not callable")}return n.call(e)}}var X=Date.parse("+033658-09-27T01:46:40.000Z")===1e15;var Y=!isNaN(Date.parse("2012-04-04T24:00:00.500Z"))||!isNaN(Date.parse("2012-11-31T23:59:59.000Z"));var q=isNaN(Date.parse("2000-01-01T00:00:00.000Z"));if(!Date.parse||q||Y||!X){Date=function(t){function e(r,n,i,a,o,u,l){var s=arguments.length;if(this instanceof t){var f=s===1&&String(r)===r?new t(e.parse(r)):s>=7?new t(r,n,i,a,o,u,l):s>=6?new t(r,n,i,a,o,u):s>=5?new t(r,n,i,a,o):s>=4?new t(r,n,i,a):s>=3?new t(r,n,i):s>=2?new t(r,n):s>=1?new t(r):new t;f.constructor=e;return f}return t.apply(this,arguments)}var r=new RegExp("^"+"(\\d{4}|[+-]\\d{6})"+"(?:-(\\d{2})"+"(?:-(\\d{2})"+"(?:"+"T(\\d{2})"+":(\\d{2})"+"(?:"+":(\\d{2})"+"(?:(\\.\\d{1,}))?"+")?"+"("+"Z|"+"(?:"+"([-+])"+"(\\d{2})"+":(\\d{2})"+")"+")?)?)?)?"+"$");var n=[0,31,59,90,120,151,181,212,243,273,304,334,365];function i(t,e){var r=e>1?1:0;return n[e]+Math.floor((t-1969+r)/4)-Math.floor((t-1901+r)/100)+Math.floor((t-1601+r)/400)+365*(t-1970)}function a(e){return Number(new t(1970,0,1,0,0,0,e))}for(var o in t){e[o]=t[o]}e.now=t.now;e.UTC=t.UTC;e.prototype=t.prototype;e.prototype.constructor=e;e.parse=function u(e){var n=r.exec(e);if(n){var o=Number(n[1]),u=Number(n[2]||1)-1,l=Number(n[3]||1)-1,s=Number(n[4]||0),f=Number(n[5]||0),c=Number(n[6]||0),p=Math.floor(Number(n[7]||0)*1e3),h=Boolean(n[4]&&!n[8]),v=n[9]==="-"?1:-1,g=Number(n[10]||0),y=Number(n[11]||0),d;if(s<(f>0||c>0||p>0?24:25)&&f<60&&c<60&&p<1e3&&u>-1&&u<12&&g<24&&y<60&&l>-1&&l<i(o,u+1)-i(o,u)){d=((i(o,u)+l)*24+s+g*v)*60;d=((d+f+y*v)*60+c)*1e3+p;if(h){d=a(d)}if(-864e13<=d&&d<=864e13){return d}}return NaN}return t.parse.apply(this,arguments)};return e}(Date)}if(!Date.now){Date.now=function De(){return(new Date).getTime()}}var G=i.toFixed&&(8e-5.toFixed(3)!=="0.000"||.9.toFixed(0)!=="1"||1.255.toFixed(2)!=="1.25"||0xde0b6b3a7640080.toFixed(0)!=="1000000000000000128");var K={base:1e7,size:6,data:[0,0,0,0,0,0],multiply:function Me(t,e){var r=-1;while(++r<K.size){e+=t*K.data[r];K.data[r]=e%K.base;e=Math.floor(e/K.base)}},divide:function Fe(t){var e=K.size,r=0;while(--e>=0){r+=K.data[e];K.data[e]=Math.floor(r/t);r=r%t*K.base}},numToString:function Re(){var t=K.size;var e="";while(--t>=0){if(e!==""||t===0||K.data[t]!==0){var r=String(K.data[t]);if(e===""){e=r}else{e+="0000000".slice(0,7-r.length)+r}}}return e},pow:function Ue(t,e,r){return e===0?r:e%2===1?Ue(t,e-1,r*t):Ue(t*t,e/2,r)},log:function ke(t){var e=0;while(t>=4096){e+=12;t/=4096}while(t>=2){e+=1;t/=2}return e}};y(i,{toFixed:function Ce(t){var e,r,n,i,a,o,u,l;e=Number(t);e=e!==e?0:Math.floor(e);if(e<0||e>20){throw new RangeError("Number.toFixed called with invalid number of decimals")}r=Number(this);if(r!==r){return"NaN"}if(r<=-1e21||r>=1e21){return String(r)}n="";if(r<0){n="-";r=-r}i="0";if(r>1e-21){a=K.log(r*K.pow(2,69,1))-69;o=a<0?r*K.pow(2,-a,1):r/K.pow(2,a,1);o*=4503599627370496;a=52-a;if(a>0){K.multiply(0,o);u=e;while(u>=7){K.multiply(1e7,0);u-=7}K.multiply(K.pow(10,u,1),0);u=a-1;while(u>=23){K.divide(1<<23);u-=23}K.divide(1<<u);K.multiply(1,1);K.divide(2);i=K.numToString()}else{K.multiply(0,o);K.multiply(1<<-a,0);i=K.numToString()+"0.00000000000000000000".slice(2,2+e)}}if(e>0){l=i.length;if(l<=e){i=n+"0.0000000000000000000".slice(0,e-l+2)+i}else{i=n+i.slice(0,l-e)+"."+i.slice(l-e)}}else{i=n+i}return i}},G);var Q=n.split;if("ab".split(/(?:ab)*/).length!==2||".".split(/(.?)(.?)/).length!==4||"tesst".split(/(s)*/)[1]==="t"||"test".split(/(?:)/,-1).length!==4||"".split(/.?/).length||".".split(/()()/).length>1){(function(){var t=typeof/()??/.exec("")[1]==="undefined";n.split=function(e,r){var n=this;if(typeof e==="undefined"&&r===0){return[]}if(f.call(e)!=="[object RegExp]"){return Q.call(this,e,r)}var i=[],a=(e.ignoreCase?"i":"")+(e.multiline?"m":"")+(e.extended?"x":"")+(e.sticky?"y":""),o=0,l,s,c,p;e=new RegExp(e.source,a+"g");n+="";if(!t){l=new RegExp("^"+e.source+"$(?!\\s)",a)}r=typeof r==="undefined"?-1>>>0:w.ToUint32(r);s=e.exec(n);while(s){c=s.index+s[0].length;if(c>o){i.push(n.slice(o,s.index));if(!t&&s.length>1){s[0].replace(l,function(){for(var t=1;t<arguments.length-2;t++){if(typeof arguments[t]==="undefined"){s[t]=void 0}}})}if(s.length>1&&s.index<n.length){u.apply(i,s.slice(1))}p=s[0].length;o=c;if(i.length>=r){break}}if(e.lastIndex===s.index){e.lastIndex++}s=e.exec(n)}if(o===n.length){if(p||!e.test("")){i.push("")}}else{i.push(n.slice(o))}return i.length>r?i.slice(0,r):i}})()}else if("0".split(void 0,0).length){n.split=function Ae(t,e){if(typeof t==="undefined"&&e===0){return[]}return Q.call(this,t,e)}}var V=n.replace;var W=function(){var t=[];"x".replace(/x(.)?/g,function(e,r){t.push(r)});return t.length===1&&typeof t[0]==="undefined"}();if(!W){n.replace=function Pe(t,e){var r=c(e);var n=p(t)&&/\)[*?]/.test(t.source);if(!r||!n){return V.call(this,t,e)}else{var i=function(r){var n=arguments.length;var i=t.lastIndex;t.lastIndex=0;var a=t.exec(r)||[];t.lastIndex=i;a.push(arguments[n-2],arguments[n-1]);return e.apply(this,a)};return V.call(this,t,i)}}}var _=n.substr;var te="".substr&&"0b".substr(-1)!=="b";y(n,{substr:function Ze(t,e){return _.call(this,t<0?(t=this.length+t)<0?0:t:t,e)}},te);var ee="	\n\f\r \xa0\u1680\u180e\u2000\u2001\u2002\u2003"+"\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028"+"\u2029\ufeff";var re="\u200b";var ne="["+ee+"]";var ie=new RegExp("^"+ne+ne+"*");var ae=new RegExp(ne+ne+"*$");var oe=n.trim&&(ee.trim()||!re.trim());y(n,{trim:function Je(){if(typeof this==="undefined"||this===null){throw new TypeError("can't convert "+this+" to object")}return String(this).replace(ie,"").replace(ae,"")}},oe);if(parseInt(ee+"08")!==8||parseInt(ee+"0x16")!==22){parseInt=function(t){var e=/^0[xX]/;return function r(n,i){n=String(n).trim();if(!Number(i)){i=e.test(n)?16:10}return t(n,i)}}(parseInt)}});
+//# sourceMappingURL=es5-shim.map
\ No newline at end of file
diff --git a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/package.json b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/package.json
new file mode 100644
index 00000000..6124a476
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/package.json
@@ -0,0 +1,74 @@
+{
+  "name": "es5-shim",
+  "version": "4.0.6",
+  "description": "ECMAScript 5 compatibility shims for legacy JavaScript engines",
+  "homepage": "http://github.com/es-shims/es5-shim/",
+  "contributors": [
+    "Kris Kowal <kris@cixar.com> (http://github.com/kriskowal/)",
+    "Sami Samhuri <sami.samhuri@gmail.com> (http://samhuri.net/)",
+    "Florian Schäfer <florian.schaefer@gmail.com> (http://github.com/fschaefer)",
+    "Irakli Gozalishvili <rfobic@gmail.com> (http://jeditoolkit.com)",
+    "Kit Cambridge <kitcambridge@gmail.com> (http://kitcambridge.github.com)",
+    "Jordan Harband <ljharb@gmail.com> (https://github.com/ljharb/)"
+  ],
+  "bugs": {
+    "mail": "ljharb@gmail.com",
+    "url": "http://github.com/es-shims/es5-shim/issues"
+  },
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "http://github.com/es-shims/es5-shim/raw/master/LICENSE"
+    }
+  ],
+  "main": "es5-shim.js",
+  "repository": {
+    "type": "git",
+    "url": "http://github.com/es-shims/es5-shim.git"
+  },
+  "scripts": {
+    "minify": "npm run minify-shim && npm run minify-sham",
+    "minify-shim": "uglifyjs es5-shim.js --comments --source-map=es5-shim.map -m -b ascii_only=true,beautify=false > es5-shim.min.js",
+    "minify-sham": "uglifyjs es5-sham.js --comments --source-map=es5-sham.map -m -b ascii_only=true,beautify=false > es5-sham.min.js",
+    "test": "npm run lint && jasmine-node --matchall ./ tests/spec/",
+    "test-native": "jasmine-node --matchall tests/spec/",
+    "lint": "npm run jscs && npm run eslint",
+    "eslint": "eslint --reset tests/helpers/*.js tests/spec/*.js es5-shim.js es5-sham.js",
+    "jscs": "jscs tests/helpers/*.js tests/spec/*.js es5-shim.js es5-sham.js"
+  },
+  "devDependencies": {
+    "eslint": "~0.12.0",
+    "jasmine-node": "~1.14.5",
+    "jscs": "~1.10.0",
+    "uglify-js": "~2.4.16"
+  },
+  "engines": {
+    "node": ">=0.4.0"
+  },
+  "testling": {
+    "browsers": [
+      "iexplore/6.0..latest",
+      "firefox/3.0..6.0",
+      "firefox/18.0..latest",
+      "firefox/nightly",
+      "chrome/4.0..10.0",
+      "chrome/25.0..latest",
+      "chrome/canary",
+      "opera/10.0..latest",
+      "opera/next",
+      "safari/4.0..latest",
+      "ipad/6.0..latest",
+      "iphone/6.0..latest",
+      "android-browser/4.2"
+    ]
+  },
+  "keywords": [
+    "shim",
+    "es5",
+    "es5 shim",
+    "javascript",
+    "ecmascript",
+    "polyfill"
+  ]
+}
+
diff --git a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/shims.json b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/shims.json
new file mode 100644
index 00000000..0c5430a8
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/shims.json
@@ -0,0 +1,7 @@
+{
+    "Object": {
+        "prototype": {},
+        "keys": "object-keys"
+    }
+}
+
diff --git a/packages/planner/node_modules/deepcopy/bower_components/mocha/.bower.json b/packages/planner/node_modules/deepcopy/bower_components/mocha/.bower.json
new file mode 100644
index 00000000..23cbf9a5
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/mocha/.bower.json
@@ -0,0 +1,56 @@
+{
+  "name": "mocha",
+  "version": "2.1.0",
+  "homepage": "http://mocha.github.io/mocha",
+  "description": "simple, flexible, fun test framework",
+  "authors": [
+    "TJ Holowaychuk <tj@vision-media.ca>",
+    "Joshua Appelman <joshua@jbna.nl>",
+    "Oleg Gaidarenko <markelog@gmail.com>",
+    "Christoffer Hallas <christoffer.hallas@gmail.com>",
+    "Christopher Hiller <chiller@badwing.com>",
+    "Travis Jeffery <tj@travisjeffery.com>",
+    "Johnathan Ong <me@jongleberry.com>",
+    "Guillermo Rauch <rauchg@gmail.com>"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/mochajs/mocha.git"
+  },
+  "main": [
+    "mocha.js",
+    "mocha.css"
+  ],
+  "ignore": [
+    "bin",
+    "editors",
+    "images",
+    "lib",
+    "support",
+    "test",
+    ".gitignore",
+    ".npmignore",
+    ".travis.yml",
+    "component.json",
+    "index.js",
+    "Makefile",
+    "package.json"
+  ],
+  "keywords": [
+    "mocha",
+    "test",
+    "bdd",
+    "tdd",
+    "tap"
+  ],
+  "license": "MIT",
+  "_release": "2.1.0",
+  "_resolution": {
+    "type": "version",
+    "tag": "2.1.0",
+    "commit": "5cabbb9f90f85f178aa61d21ddc8abce010ac8e8"
+  },
+  "_source": "git://github.com/mochajs/mocha.git",
+  "_target": "~2.1",
+  "_originalSource": "mocha"
+}
\ No newline at end of file
diff --git a/packages/planner/node_modules/deepcopy/bower_components/mocha/.editorconfig b/packages/planner/node_modules/deepcopy/bower_components/mocha/.editorconfig
new file mode 100644
index 00000000..e3a4859e
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/mocha/.editorconfig
@@ -0,0 +1,18 @@
+# This file is for unifying the coding style for different editors and IDEs
+# editorconfig.org
+
+root = true
+
+[*]
+end_of_line = lf
+charset = utf-8
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_style = space
+indent_size = 2
+
+[Makefile]
+indent_style = tab
+
+[*.md]
+trim_trailing_whitespace = false
diff --git a/packages/planner/node_modules/deepcopy/bower_components/mocha/.mailmap b/packages/planner/node_modules/deepcopy/bower_components/mocha/.mailmap
new file mode 100644
index 00000000..70401312
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/mocha/.mailmap
@@ -0,0 +1 @@
+TJ Holowaychuk <tj@vision-media.ca>
\ No newline at end of file
diff --git a/packages/planner/node_modules/deepcopy/bower_components/mocha/CONTRIBUTING.md b/packages/planner/node_modules/deepcopy/bower_components/mocha/CONTRIBUTING.md
new file mode 100644
index 00000000..6d172f08
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/mocha/CONTRIBUTING.md
@@ -0,0 +1,49 @@
+# Contributing to Mocha
+
+Hi!  We could use your help.  Let us help you help us.  Or something.
+
+## General
+
+1. If you are looking for a place to begin, **please send PRs for bugfixes instead of new features**, and/or **look for issues labeled `PR PLEASE`.**
+
+2.  **Help with documentation and the wiki is always appreciated**.
+
+3.  Please **be courteous and constructive** when commenting on issues, commits, and pull requests.
+
+## Bug Reports & Issues
+
+1.  When reporting a bug, please **provide steps to reproduce**.  If possible, show code.
+  
+2.  Please **show all code in JavaScript**.  We don't all read `<insert-language-that-compiles-to-JavaScript-here>`.  If you do not, you will be asked to.
+
+3.  Because Mocha works with many third-party libraries and tools, **ensure the bug you are reporting is actually within Mocha**.
+
+4.  If you report a bug, and it is inactive for a significant amount of time, it may be closed.  **Please respond promptly to requests for more information**.
+
+## Pull Requests
+
+1. Before sending a large PR, it's recommended to **create an issue to propose the change**.  Nobody wants to write a book of code and throw it away.
+
+2.  Because Mocha should be kept as maintainable as possible, its codebase must be kept slim.  Historically, *most PRs for new features are not merged*.  New features inevitably increase the size of the codebase, and thus reduce maintainability.  Only features *deemed essential* are likely to be merged--this is at the discretion of the maintainer(s).  If your PR for a feature is not merged, this doesn't necessarily mean your PR was a bad idea, wouldn't be used, or otherwise sucks.  It just means **only essential PRs for new features are likely to be merged**. 
+
+3.  Due to the above, before creating a PR for a new feature, **create an issue to propose the feature.**
+
+4.  Please **respect existing coding conventions**, whatever those may be.
+
+5.  If your PR has been waiting in limbo for some time, it's very helpful to **rebase against master**, which will make it easier to merge.
+
+6.  Please **add tests for new code**.
+
+7.  **Always run `npm test` before sending a PR.**  If you break the tests, your PR will not be accepted until they are fixed.
+
+## Source Control
+
+1. Please **squash your commits** when sending a pull request.  If you are unfamiliar with this process, see [this guide](https://help.github.com/articles/about-git-rebase/).  If you have already pushed your changesets and are squashing thereafter, this may necessitate the use of a "force push".  Please [read the docs](http://git-scm.com/docs/git-push) before you attempt this. 
+ 
+2. Please **follow the commit message conventions [outlined here](https://medium.com/code-adventures/git-conventions-a940ee20862d).**
+
+## TL;DR
+
+**Be kind, be diligent, look before you leap into a PR, and follow common community conventions**.
+
+*- The Mocha Team*
diff --git a/packages/planner/node_modules/deepcopy/bower_components/mocha/HISTORY.md b/packages/planner/node_modules/deepcopy/bower_components/mocha/HISTORY.md
new file mode 100644
index 00000000..95f0f0f9
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/mocha/HISTORY.md
@@ -0,0 +1,801 @@
+
+2.1.0 / 2014-12-23
+==================
+
+ * showDiff: don’t stringify strings
+ * Clean up unused module dependencies.
+ * Filter zero-length strings from mocha.opts
+ * only write to stdout in reporters
+ * Revert "only write to stdout in reporters"
+ * Print colored output only to a tty
+ * update summary in README.md
+ * rename Readme.md/History.md to README.md/HISTORY.md because neurotic
+ * add .mailmap to fix "git shortlog" or "git summary" output
+ * fixes #1461: nyan-reporter now respects Base.useColors, fixed bug where Base.color would not return a string when str wasn't a string.
+ * Use existing test URL builder in failed replay links
+ * modify .travis.yml: use travis_retry; closes #1449
+ * fix -t 0 behavior; closes #1446
+ * fix tests (whoops)
+ * improve diff behavior
+ * Preserve pathname when linking to individual tests
+ * Fix test
+ * Tiny typo in comments fixed
+ * after hooks now being called on failed tests when using bail, fixes #1093
+ * fix throwing undefined/null now makes tests fail, fixes #1395
+ * compiler extensions are added as watched extensions, removed non-standard extensions from watch regex, resolves #1221
+ * prefix/namespace for suite titles in markdown reporter, fixes #554
+ * fix more bad markdown in CONTRIBUTING.md
+ * fix bad markdown in CONTRIBUTING.md
+ * add setImmediate/clearImmediate to globals; closes #1435
+ * Fix buffer diffs (closes #1132, closes #1433)
+ * add a CONTRIBUTING.md.  closes #882
+ * fix intermittent build failures (maybe). closes #1407
+ * add Slack notification to .travis.yml
+ * Fix slack link
+ * Add slack room to readme
+ * Update maintainers
+ * update maintainers and contributors
+ * resolves #1393: kill children with more effort on SIGINT
+ * xunit reporter support for optionally writing to a file
+ * if a reporter has a .done method, call it before exiting
+ * add support for reporter options
+ * only write to stdout in reporters
+
+2.0.0 / 2014-10-21
+==================
+
+ * remove: support for node 0.6.x, 0.4.x
+ * fix: landing reporter with non ansi characters (#211)
+ * fix: html reporter - preserve query params when navigating to suites/tests (#1358)
+ * fix: json stream reporter add error message to failed test
+ * fix: fixes for visionmedia -> mochajs
+ * fix: use stdio, fixes node deprecation warnings (#1391)
+
+1.21.5 / 2014-10-11
+==================
+
+ * fix: build for NodeJS v0.6.x
+ * fix: do not attempt to highlight syntax when non-HTML reporter is used
+ * update: escape-string-regexp to 1.0.2.
+ * fix: botched indentation in canonicalize()
+ * fix: .gitignore: ignore .patch and .diff files
+ * fix: changed 'Catched' to 'Caught' in uncaught exception error handler messages
+ * add: `pending` field for json reporter
+ * fix: Runner.prototype.uncaught: don't double-end runnables that already have a state.
+ * fix: --recursive, broken by f0facd2e
+ * update: replaces escapeRegexp with the escape-string-regexp package.
+ * update: commander to 2.3.0.
+ * update: diff to 1.0.8.
+ * fix: ability to disable syntax highlighting (#1329)
+ * fix: added empty object to errorJSON() call to catch when no error is present
+ * fix: never time out after calling enableTimeouts(false)
+ * fix: timeout(0) will work at suite level (#1300)
+ * Fix for --watch+only() issue (#888 )
+ * fix: respect err.showDiff, add Base reporter test (#810)
+
+1.22.1-3 / 2014-07-27
+==================
+
+  * fix: disabling timeouts with this.timeout(0) (#1301)
+
+1.22.1-3 / 2014-07-27
+==================
+
+  * fix: local uis and reporters (#1288)
+  * fix: building 1.21.0's changes in the browser (#1284)
+
+1.21.0 / 2014-07-23
+==================
+
+  * add: --no-timeouts option (#1262, #1268)
+  * add: --*- deprecation node flags (#1217)
+  * add: --watch-extensions argument (#1247)
+  * change: spec reporter is default (#1228)
+  * fix: diff output showing incorrect +/- (#1182)
+  * fix: diffs of circular structures (#1179)
+  * fix: re-render the progress bar when progress has changed only (#1151)
+  * fix support for environments with global and window (#1159)
+  * fix: reverting to previously defined onerror handler (#1178)
+  * fix: stringify non error objects passed to done() (#1270)
+  * fix: using local ui, reporters (#1267)
+  * fix: cleaning es6 arrows (#1176)
+  * fix: don't include attrs in failure tag for xunit (#1244)
+  * fix: fail tests that return a promise if promise is rejected w/o a reason (#1224)
+  * fix: showing failed tests in doc reporter (#1117)
+  * fix: dot reporter dots being off (#1204)
+  * fix: catch empty throws (#1219)
+  * fix: honoring timeout for sync operations (#1242)
+  * update: growl to 1.8.0
+
+1.20.1 / 2014-06-03
+==================
+
+  * update: should dev dependency to ~4.0.0 (#1231)
+
+1.20.0 / 2014-05-28
+==================
+
+  * add: filenames to suite objects (#1222)
+
+1.19.0 / 2014-05-17
+==================
+
+  * add: browser script option to package.json
+  * add: export file in Mocha.Test objects (#1174)
+  * add: add docs for wrapped node flags
+  * fix: mocha.run() to return error status in browser (#1216)
+  * fix: clean() to show failure details (#1205)
+  * fix: regex that generates html for new keyword (#1201)
+  * fix: sibling suites have inherited but separate contexts (#1164)
+
+
+1.18.2 / 2014-03-18
+==================
+
+  * fix: html runner was prevented from using #mocha as the default root el (#1162)
+
+1.18.1 / 2014-03-18
+==================
+
+  * fix: named before/after hooks in bdd, tdd, qunit interfaces (#1161)
+
+1.18.0 / 2014-03-13
+==================
+
+  * add: promise support (#329)
+  * add: named before/after hooks (#966)
+
+1.17.1 / 2014-01-22
+==================
+
+  * fix: expected messages in should.js (should.js#168)
+  * fix: expect errno global in node versions < v0.9.11 (#1111)
+  * fix: unreliable checkGlobals optimization (#1110)
+
+1.17.0 / 2014-01-09
+==================
+
+  * add: able to require globals (describe, it, etc.) through mocha (#1077)
+  * fix: abort previous run on --watch change (#1100)
+  * fix: reset context for each --watch triggered run (#1099)
+  * fix: error when cli can't resolve path or pattern (#799)
+  * fix: canonicalize objects before stringifying and diffing them (#1079)
+  * fix: make CR call behave like carriage return for non tty (#1087)
+
+
+1.16.2 / 2013-12-23
+==================
+
+  * fix: couple issues with ie 8 (#1082, #1081)
+  * fix: issue running the xunit reporter in browsers (#1068)
+  * fix: issue with firefox < 3.5 (#725)
+
+
+1.16.1 / 2013-12-19
+==================
+
+  * fix: recompiled for missed changes from the last release
+
+
+1.16.0 / 2013-12-19
+==================
+
+  * add: Runnable.globals(arr) for per test global whitelist (#1046)
+  * add: mocha.throwError(err) for assertion libs to call (#985)
+  * remove: --watch's spinner (#806)
+  * fix: duplicate test output for multi-line specs in spec reporter (#1006)
+  * fix: gracefully exit on SIGINT (#1063)
+  * fix expose the specified ui only in the browser (#984)
+  * fix: ensure process exit code is preserved when using --no-exit (#1059)
+  * fix: return true from window.onerror handler (#868)
+  * fix: xunit reporter to use process.stdout.write (#1068)
+  * fix: utils.clean(str) indentation (#761)
+  * fix: xunit reporter returning test duration a NaN (#1039)
+
+1.15.1 / 2013-12-03
+==================
+
+  * fix: recompiled for missed changes from the last release
+
+1.15.0 / 2013-12-02
+==================
+
+  * add: `--no-exit` to prevent `process.exit()` (#1018)
+  * fix: using inline diffs (#1044)
+  * fix: show pending test details in xunit reporter (#1051)
+  * fix: faster global leak detection (#1024)
+  * fix: yui compression (#1035)
+  * fix: wrapping long lines in test results (#1030, #1031)
+  * fix: handle errors in hooks (#1043)
+
+1.14.0 / 2013-11-02
+==================
+
+  * add: unified diff (#862)
+  * add: set MOCHA_COLORS env var to use colors (#965)
+  * add: able to override tests links in html reporters (#776)
+  * remove: teamcity reporter (#954)
+  * update: commander dependency to 2.0.0 (#1010)
+  * fix: mocha --ui will try to require the ui if not built in, as --reporter does (#1022)
+  * fix: send cursor commands only if isatty (#184, #1003)
+  * fix: include assertion message in base reporter (#993, #991)
+  * fix: consistent return of it, it.only, and describe, describe.only (#840)
+
+1.13.0 / 2013-09-15
+==================
+
+  * add: sort test files with --sort (#813)
+  * update: diff depedency to 1.0.7
+  * update: glob dependency to 3.2.3 (#927)
+  * fix: diffs show whitespace differences (#976)
+  * fix: improve global leaks (#783)
+  * fix: firefox window.getInterface leak
+  * fix: accessing iframe via window[iframeIndex] leak
+  * fix: faster global leak checking
+  * fix: reporter pending css selector (#970)
+
+1.12.1 / 2013-08-29
+==================
+
+ * remove test.js from .gitignore
+ * update included version of ms.js
+
+1.12.0 / 2013-07-01
+==================
+
+ * add: prevent diffs for differing types. Closes #900
+ * add `Mocha.process` hack for phantomjs
+ * fix: use compilers with requires
+ * fix regexps in diffs. Closes #890
+ * fix xunit NaN on failure. Closes #894
+ * fix: strip tab indentation in `clean` utility method
+ * fix: textmate bundle installation
+
+1.11.0 / 2013-06-12
+==================
+
+ * add --prof support
+ * add --harmony support
+ * add --harmony-generators support
+ * add "Uncaught " prefix to uncaught exceptions
+ * add web workers support
+ * add `suite.skip()`
+ * change to output # of pending / passing even on failures. Closes #872
+ * fix: prevent hooks from being called if we are bailing
+ * fix `this.timeout(0)`
+
+1.10.0 / 2013-05-21
+==================
+
+ * add add better globbing support for windows via `glob` module
+ * add support to pass through flags such as --debug-brk=1234. Closes #852
+ * add test.only, test.skip to qunit interface
+ * change to always use word-based diffs for now. Closes #733
+ * change `mocha init` tests.html to index.html
+ * fix `process` global leak in the browser
+ * fix: use resolve() instead of join() for --require
+ * fix: filterLeaks() condition to not consider indices in global object as leaks
+ * fix: restrict mocha.css styling to #mocha id
+ * fix: save timer references to avoid Sinon interfering in the browser build.
+
+1.9.0 / 2013-04-03
+==================
+
+  * add improved setImmediate implementation
+  * replace --ignore-leaks with --check-leaks
+  * change default of ignoreLeaks to true. Closes #791
+  * remove scrolling for HTML reporter
+  * fix retina support
+  * fix tmbundle, restrict to js scope
+
+1.8.2 / 2013-03-11
+==================
+
+  * add `setImmediate` support for 0.10.x
+  * fix mocha -w spinner on windows
+
+1.8.1 / 2013-01-09
+==================
+
+  * fix .bail() arity check causing it to default to true
+
+1.8.0 / 2013-01-08
+==================
+
+  * add Mocha() options bail support
+  * add `Mocha#bail()` method
+  * add instanceof check back for inheriting from Error
+  * add component.json
+  * add diff.js to browser build
+  * update growl
+  * fix TAP reporter failures comment :D
+
+1.7.4 / 2012-12-06
+==================
+
+  * add total number of passes and failures to TAP
+  * remove .bind() calls. re #680
+  * fix indexOf. Closes #680
+
+1.7.3 / 2012-11-30
+==================
+
+  * fix uncaught error support for the browser
+  * revert uncaught "fix" which breaks node
+
+1.7.2 / 2012-11-28
+==================
+
+  * fix uncaught errors to expose the original error message
+
+1.7.0 / 2012-11-07
+==================
+
+  * add `--async-only` support to prevent false positives for missing `done()`
+  * add sorting by filename in code coverage
+  * add HTML 5 doctype to browser template.
+  * add play button to html reporter to rerun a single test
+  * add `this.timeout(ms)` as Suite#timeout(ms). Closes #599
+  * update growl dependency to 1.6.x
+  * fix encoding of test-case ?grep. Closes #637
+  * fix unicode chars on windows
+  * fix dom globals in Opera/IE. Closes #243
+  * fix markdown reporter a tags
+  * fix `this.timeout("5s")` support
+
+1.6.0 / 2012-10-02
+==================
+
+  * add object diffs when `err.showDiff` is present
+  * add hiding of empty suites when pass/failures are toggled
+  * add faster `.length` checks to `checkGlobals()` before performing the filter
+
+1.5.0 / 2012-09-21
+==================
+
+  * add `ms()` to `.slow()` and `.timeout()`
+  * add `Mocha#checkLeaks()` to re-enable global leak checks
+  * add `this.slow()` option [aheckmann]
+  * add tab, CR, LF to error diffs for now
+  * add faster `.checkGlobals()` solution [guille]
+  * remove `fn.call()` from reduce util
+  * remove `fn.call()` from filter util
+  * fix forEach. Closes #582
+  * fix relaying of signals [TooTallNate]
+  * fix TAP reporter grep number
+
+1.4.2 / 2012-09-01
+==================
+
+  * add support to multiple `Mocha#globals()` calls, and strings
+  * add `mocha.reporter()` constructor support [jfirebaugh]
+  * add `mocha.timeout()`
+  * move query-string parser to utils.js
+  * move highlight code to utils.js
+  * fix third-party reporter support [exogen]
+  * fix client-side API to match node-side [jfirebaugh]
+  * fix mocha in iframe [joliss]
+
+1.4.1 / 2012-08-28
+==================
+
+  * add missing `Markdown` export
+  * fix `Mocha#grep()`, escape regexp strings
+  * fix reference error when `devicePixelRatio` is not defined. Closes #549
+
+1.4.0 / 2012-08-22
+==================
+
+  * add mkdir -p to `mocha init`. Closes #539
+  * add `.only()`. Closes #524
+  * add `.skip()`. Closes #524
+  * change str.trim() to use utils.trim(). Closes #533
+  * fix HTML progress indicator retina display
+  * fix url-encoding of click-to-grep HTML functionality
+
+1.3.2 / 2012-08-01
+==================
+
+  * fix exports double-execution regression. Closes #531
+
+1.3.1 / 2012-08-01
+==================
+
+  * add passes/failures toggling to HTML reporter
+  * add pending state to `xit()` and `xdescribe()` [Brian Moore]
+  * add the @charset "UTF-8"; to fix #522 with FireFox. [Jonathan Creamer]
+  * add border-bottom to #stats links
+  * add check for runnable in `Runner#uncaught()`. Closes #494
+  * add 0.4 and 0.6 back to travis.yml
+  * add `-E, --growl-errors` to growl on failures only
+  * add prefixes to debug() names. Closes #497
+  * add `Mocha#invert()` to js api
+  * change dot reporter to use sexy unicode dots
+  * fix error when clicking pending test in HTML reporter
+  * fix `make tm`
+
+1.3.0 / 2012-07-05
+==================
+
+  * add window scrolling to `HTML` reporter
+  * add v8 `--trace-*` option support
+  * add support for custom reports via `--reporter MODULE`
+  * add `--invert` switch to invert `--grep` matches
+  * fix export of `Nyan` reporter. Closes #495
+  * fix escaping of `HTML` suite titles. Closes #486
+  * fix `done()` called multiple times with an error test
+  * change `--grep` - regexp escape the input
+
+1.2.2 / 2012-06-28
+==================
+
+  * Added 0.8.0 support
+
+1.2.1 / 2012-06-25
+==================
+
+  * Added `this.test.error(err)` support to after each hooks. Closes #287
+  * Added: export top-level suite on global mocha object (mocha.suite). Closes #448
+  * Fixed `js` code block format error in markdown reporter
+  * Fixed deprecation warning when using `path.existsSync`
+  * Fixed --globals with wildcard
+  * Fixed chars in nyan when his head moves back
+  * Remove `--growl` from test/mocha.opts. Closes #289
+
+1.2.0 / 2012-06-17
+==================
+
+  * Added `nyan` reporter [Atsuya Takagi]
+  * Added `mocha init <path>` to copy client files
+  * Added "specify" synonym for "it" [domenic]
+  * Added global leak wildcard support [nathanbowser]
+  * Fixed runner emitter leak. closes #432
+  * Fixed omission of .js extension. Closes #454
+
+1.1.0 / 2012-05-30
+==================
+
+  * Added: check each `mocha(1)` arg for directories to walk
+  * Added `--recursive` [tricknotes]
+  * Added `context` for BDD [hokaccha]
+  * Added styling for new clickable titles
+  * Added clickable suite titles to HTML reporter
+  * Added warning when strings are thrown as errors
+  * Changed: green arrows again in HTML reporter styling
+  * Changed ul/li elements instead of divs for better copy-and-pasting [joliss]
+  * Fixed issue #325 - add better grep support to js api
+  * Fixed: save timer references to avoid Sinon interfering.
+
+1.0.3 / 2012-04-30
+==================
+
+  * Fixed string diff newlines
+  * Fixed: removed mocha.css target. Closes #401
+
+1.0.2 / 2012-04-25
+==================
+
+  * Added HTML reporter duration. Closes #47
+  * Fixed: one postMessage event listener [exogen]
+  * Fixed: allow --globals to be used multiple times. Closes #100 [brendannee]
+  * Fixed #158: removes jquery include from browser tests
+  * Fixed grep. Closes #372 [brendannee]
+  * Fixed #166 - When grepping don't display the empty suites
+  * Removed test/browser/style.css. Closes #385
+
+1.0.1 / 2012-04-04
+==================
+
+  * Fixed `.timeout()` in hooks
+  * Fixed: allow callback for `mocha.run()` in client version
+  * Fixed browser hook error display. Closes #361
+
+1.0.0 / 2012-03-24
+==================
+
+  * Added js API. Closes #265
+  * Added: initial run of tests with `--watch`. Closes #345
+  * Added: mark `location` as a global on the CS. Closes #311
+  * Added `markdown` reporter (github flavour)
+  * Added: scrolling menu to coverage.html. Closes #335
+  * Added source line to html report for Safari [Tyson Tate]
+  * Added "min" reporter, useful for `--watch` [Jakub Nešetřil]
+  * Added support for arbitrary compilers via . Closes #338 [Ian Young]
+  * Added Teamcity export to lib/reporters/index [Michael Riley]
+  * Fixed chopping of first char in error reporting. Closes #334 [reported by topfunky]
+  * Fixed terrible FF / Opera stack traces
+
+0.14.1 / 2012-03-06
+==================
+
+  * Added lib-cov to _.npmignore_
+  * Added reporter to `mocha.run([reporter])` as argument
+  * Added some margin-top to the HTML reporter
+  * Removed jQuery dependency
+  * Fixed `--watch`: purge require cache. Closes #266
+
+0.14.0 / 2012-03-01
+==================
+
+  * Added string diff support for terminal reporters
+
+0.13.0 / 2012-02-23
+==================
+
+  * Added preliminary test coverage support. Closes #5
+  * Added `HTMLCov` reporter
+  * Added `JSONCov` reporter [kunklejr]
+  * Added `xdescribe()` and `xit()` to the BDD interface. Closes #263 (docs   * Changed: make json reporter output pretty json
+  * Fixed node-inspector support, swapped `--debug` for `debug` to match node.
+needed)
+Closes #247
+
+0.12.1 / 2012-02-14
+==================
+
+  * Added `npm docs mocha` support [TooTallNate]
+  * Added a `Context` object used for hook and test-case this. Closes #253
+  * Fixed `Suite#clone()` `.ctx` reference. Closes #262
+
+0.12.0 / 2012-02-02
+==================
+
+  * Added .coffee `--watch` support. Closes #242
+  * Added support to `--require` files relative to the CWD. Closes #241
+  * Added quick n dirty syntax highlighting. Closes #248
+  * Changed: made HTML progress indicator smaller
+  * Fixed xunit errors attribute [dhendo]
+
+0.10.2 / 2012-01-21
+==================
+
+  * Fixed suite count in reporter stats. Closes #222
+  * Fixed `done()` after timeout error reporting [Phil Sung]
+  * Changed the 0-based errors to 1
+
+0.10.1 / 2012-01-17
+==================
+
+  * Added support for node 0.7.x
+  * Fixed absolute path support. Closes #215 [kompiro]
+  * Fixed `--no-colors` option [Jussi Virtanen]
+  * Fixed Arial CSS typo in the correct file
+
+0.10.0 / 2012-01-13
+==================
+
+  * Added `-b, --bail` to exit on first exception [guillermo]
+  * Added support for `-gc` / `--expose-gc` [TooTallNate]
+  * Added `qunit`-inspired interface
+  * Added MIT LICENSE. Closes #194
+  * Added: `--watch` all .js in the CWD. Closes #139
+  * Fixed `self.test` reference in runner. Closes #189
+  * Fixed double reporting of uncaught exceptions after timeout. Closes #195
+
+0.8.2 / 2012-01-05
+==================
+
+  * Added test-case context support. Closes #113
+  * Fixed exit status. Closes #187
+  * Update commander. Closes #190
+
+0.8.1 / 2011-12-30
+==================
+
+  * Fixed reporting of uncaught exceptions. Closes #183
+  * Fixed error message defaulting [indutny]
+  * Changed mocha(1) from bash to node for windows [Nathan Rajlich]
+
+0.8.0 / 2011-12-28
+==================
+
+  * Added `XUnit` reporter [FeeFighters/visionmedia]
+  * Added `say(1)` notification support [Maciej Małecki]
+  * Changed: fail when done() is invoked with a non-Error. Closes #171
+  * Fixed `err.stack`, defaulting to message. Closes #180
+  * Fixed: `make tm` mkdir -p the dest. Closes #137
+  * Fixed mocha(1) --help bin name
+  * Fixed `-d` for `--debug` support
+
+0.7.1 / 2011-12-22
+==================
+
+  * Removed `mocha-debug(1)`, use `mocha --debug`
+  * Fixed CWD relative requires
+  * Fixed growl issue on windows [Raynos]
+  * Fixed: platform specific line endings [TooTallNate]
+  * Fixed: escape strings in HTML reporter. Closes #164
+
+0.7.0 / 2011-12-18
+==================
+
+  * Added support for IE{7,8} [guille]
+  * Changed: better browser nextTick implementation [guille]
+
+0.6.0 / 2011-12-18
+==================
+
+  * Added setZeroTimeout timeout for browser (nicer stack traces). Closes #153
+  * Added "view source" on hover for HTML reporter to make it obvious
+  * Changed: replace custom growl with growl lib
+  * Fixed duplicate reporting for HTML reporter. Closes #154
+  * Fixed silent hook errors in the HTML reporter. Closes #150
+
+0.5.0 / 2011-12-14
+==================
+
+  * Added: push node_modules directory onto module.paths for relative require Closes #93
+  * Added teamcity reporter [blindsey]
+  * Fixed: recover from uncaught exceptions for tests. Closes #94
+  * Fixed: only emit "test end" for uncaught within test, not hook
+
+0.4.0 / 2011-12-14
+==================
+
+  * Added support for test-specific timeouts via `this.timeout(0)`. Closes #134
+  * Added guillermo's client-side EventEmitter. Closes #132
+  * Added progress indicator to the HTML reporter
+  * Fixed slow browser tests. Closes #135
+  * Fixed "suite" color for light terminals
+  * Fixed `require()` leak spotted by [guillermo]
+
+0.3.6 / 2011-12-09
+==================
+
+  * Removed suite merging (for now)
+
+0.3.5 / 2011-12-08
+==================
+
+  * Added support for `window.onerror` [guillermo]
+  * Fixed: clear timeout on uncaught exceptions. Closes #131 [guillermo]
+  * Added `mocha.css` to PHONY list.
+  * Added `mocha.js` to PHONY list.
+
+0.3.4 / 2011-12-08
+==================
+
+  * Added: allow `done()` to be called with non-Error
+  * Added: return Runner from `mocha.run()`. Closes #126
+  * Fixed: run afterEach even on failures. Closes #125
+  * Fixed clobbering of current runnable. Closes #121
+
+0.3.3 / 2011-12-08
+==================
+
+  * Fixed hook timeouts. Closes #120
+  * Fixed uncaught exceptions in hooks
+
+0.3.2 / 2011-12-05
+==================
+
+  * Fixed weird reporting when `err.message` is not present
+
+0.3.1 / 2011-12-04
+==================
+
+  * Fixed hook event emitter leak. Closes #117
+  * Fixed: export `Spec` constructor. Closes #116
+
+0.3.0 / 2011-12-04
+==================
+
+  * Added `-w, --watch`. Closes #72
+  * Added `--ignore-leaks` to ignore global leak checking
+  * Added browser `?grep=pattern` support
+  * Added `--globals <names>` to specify accepted globals. Closes #99
+  * Fixed `mocha-debug(1)` on some systems. Closes #232
+  * Fixed growl total, use `runner.total`
+
+0.2.0 / 2011-11-30
+==================
+
+  * Added `--globals <names>` to specify accepted globals. Closes #99
+  * Fixed funky highlighting of messages. Closes #97
+  * Fixed `mocha-debug(1)`. Closes #232
+  * Fixed growl total, use runner.total
+
+0.1.0 / 2011-11-29
+==================
+
+  * Added `suiteSetup` and `suiteTeardown` to TDD interface [David Henderson]
+  * Added growl icons. Closes #84
+  * Fixed coffee-script support
+
+0.0.8 / 2011-11-25
+==================
+
+  * Fixed: use `Runner#total` for accurate reporting
+
+0.0.7 / 2011-11-25
+==================
+
+  * Added `Hook`
+  * Added `Runnable`
+  * Changed: `Test` is `Runnable`
+  * Fixed global leak reporting in hooks
+  * Fixed: > 2 calls to done() only report the error once
+  * Fixed: clear timer on failure. Closes #80
+
+0.0.6 / 2011-11-25
+==================
+
+  * Fixed return on immediate async error. Closes #80
+
+0.0.5 / 2011-11-24
+==================
+
+  * Fixed: make mocha.opts whitespace less picky [kkaefer]
+
+0.0.4 / 2011-11-24
+==================
+
+  * Added `--interfaces`
+  * Added `--reporters`
+  * Added `-c, --colors`. Closes #69
+  * Fixed hook timeouts
+
+0.0.3 / 2011-11-23
+==================
+
+  * Added `-C, --no-colors` to explicitly disable
+  * Added coffee-script support
+
+0.0.2 / 2011-11-22
+==================
+
+  * Fixed global leak detection due to Safari bind() change
+  * Fixed: escape html entities in Doc reporter
+  * Fixed: escape html entities in HTML reporter
+  * Fixed pending test support for HTML reporter. Closes #66
+
+0.0.1 / 2011-11-22
+==================
+
+  * Added `--timeout` second shorthand support, ex `--timeout 3s`.
+  * Fixed "test end" event for uncaughtExceptions. Closes #61
+
+0.0.1-alpha6 / 2011-11-19
+==================
+
+  * Added travis CI support (needs enabling when public)
+  * Added preliminary browser support
+  * Added `make mocha.css` target. Closes #45
+  * Added stack trace to TAP errors. Closes #52
+  * Renamed tearDown to teardown. Closes #49
+  * Fixed: cascading hooksc. Closes #30
+  * Fixed some colors for non-tty
+  * Fixed errors thrown in sync test-cases due to nextTick
+  * Fixed Base.window.width... again give precedence to 0.6.x
+
+0.0.1-alpha5 / 2011-11-17
+==================
+
+  * Added `doc` reporter. Closes #33
+  * Added suite merging. Closes #28
+  * Added TextMate bundle and `make tm`. Closes #20
+
+0.0.1-alpha4 / 2011-11-15
+==================
+
+  * Fixed getWindowSize() for 0.4.x
+
+0.0.1-alpha3 / 2011-11-15
+==================
+
+  * Added `-s, --slow <ms>` to specify "slow" test threshold
+  * Added `mocha-debug(1)`
+  * Added `mocha.opts` support. Closes #31
+  * Added: default [files] to _test/*.js_
+  * Added protection against multiple calls to `done()`. Closes #35
+  * Changed: bright yellow for slow Dot reporter tests
+
+0.0.1-alpha1 / 2011-11-08
+==================
+
+  * Missed this one :)
+
+0.0.1-alpha1 / 2011-11-08
+==================
+
+  * Initial release
diff --git a/packages/planner/node_modules/deepcopy/bower_components/mocha/LICENSE b/packages/planner/node_modules/deepcopy/bower_components/mocha/LICENSE
new file mode 100644
index 00000000..1c5d7fa8
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/mocha/LICENSE
@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2011-2014 TJ Holowaychuk <tj@vision-media.ca>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/packages/planner/node_modules/deepcopy/bower_components/mocha/README.md b/packages/planner/node_modules/deepcopy/bower_components/mocha/README.md
new file mode 100644
index 00000000..1a3a9489
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/mocha/README.md
@@ -0,0 +1,226 @@
+ [![Build Status](https://secure.travis-ci.org/mochajs/mocha.png)](http://travis-ci.org/mochajs/mocha)
+
+  [![Mocha test framework](http://f.cl.ly/items/3l1k0n2A1U3M1I1L210p/Screen%20Shot%202012-02-24%20at%202.21.43%20PM.png)](http://mochajs.org)
+
+  Mocha is a simple, flexible, fun JavaScript test framework for node.js and the browser. For more information view the [documentation](http://mochajs.org).
+
+## Contributors
+
+```
+ project  : mocha
+ repo age : 3 years, 4 months
+ active   : 509 days
+ commits  : 1575
+ files    : 153
+ authors  :
+   977	TJ Holowaychuk          62.0%
+   132	Travis Jeffery          8.4%
+    63	Christopher Hiller      4.0%
+    31	Guillermo Rauch         2.0%
+    27	Joshua Appelman         1.7%
+    13	Attila Domokos          0.8%
+    10	John Firebaugh          0.6%
+     8	Nathan Rajlich          0.5%
+     8	Jo Liss                 0.5%
+     6	Mike Pennisi            0.4%
+     6	Brendan Nee             0.4%
+     6	James Carr              0.4%
+     5	Aaron Heckmann          0.3%
+     5	Raynos                  0.3%
+     5	Ryunosuke SATO          0.3%
+     4	hokaccha                0.3%
+     4	Jonathan Ong            0.3%
+     4	Joshua Krall            0.3%
+     4	Domenic Denicola        0.3%
+     4	Forbes Lindesay         0.3%
+     4	Xavier Antoviaque       0.3%
+     4	David da Silva          0.3%
+     3	Ariel Mashraki          0.2%
+     3	Ben Bradley             0.2%
+     3	Merrick Christensen     0.2%
+     3	Andreas Lind Petersen   0.2%
+     3	Nathan Bowser           0.2%
+     3	Cory Thomas             0.2%
+     3	Benjie Gillam           0.2%
+     3	Wil Moore III           0.2%
+     3	Ben Lindsey             0.2%
+     3	Tyson Tate              0.2%
+     3	Paul Miller             0.2%
+     3	eiji.ienaga             0.2%
+     3	Mathieu Desvé           0.2%
+     3	Jesse Dailey            0.2%
+     3	fool2fish               0.2%
+     3	Fredrik Enestad         0.2%
+     3	Sindre Sorhus           0.2%
+     3	Valentin Agachi         0.2%
+     2	jsdevel                 0.1%
+     2	Arian Stolwijk          0.1%
+     2	Juzer Ali               0.1%
+     2	David Henderson         0.1%
+     2	Justin DuJardin         0.1%
+     2	Paul Armstrong          0.1%
+     2	Pete Hawkins            0.1%
+     2	Jonas Westerlund        0.1%
+     2	Quang Van               0.1%
+     2	Simon Gaeremynck        0.1%
+     2	travis jeffery          0.1%
+     2	Dominique Quatravaux    0.1%
+     2	Jacob Wejendorp         0.1%
+     2	Shawn Krisman           0.1%
+     2	FARKAS Máté             0.1%
+     2	Konstantin Käfer        0.1%
+     2	Timo Tijhof             0.1%
+     2	Sean Lang               0.1%
+     2	Quanlong He             0.1%
+     2	Glen Mailer             0.1%
+     2	Alexander Early         0.1%
+     2	Ian Storm Taylor        0.1%
+     2	Brian Beck              0.1%
+     2	Michael Riley           0.1%
+     2	Michael Schoonmaker     0.1%
+     2	domenic                 0.1%
+     2	fcrisci                 0.1%
+     2	Buck Doyle              0.1%
+     2	Nathan Alderson         0.1%
+     1	Mal Graty               0.1%
+     1	Marc Kuo                0.1%
+     1	Matija Marohnić         0.1%
+     1	Matt Robenolt           0.1%
+     1	Matt Smith              0.1%
+     1	Matthew Shanley         0.1%
+     1	Mattias Tidlund         0.1%
+     1	Michael Jackson         0.1%
+     1	Michael Olson           0.1%
+     1	Michal Charemza         0.1%
+     1	Nathan Black            0.1%
+     1	Nick Fitzgerald         0.1%
+     1	Noshir Patel            0.1%
+     1	Panu Horsmalahti        0.1%
+     1	Phil Sung               0.1%
+     1	R56                     0.1%
+     1	Refael Ackermann        0.1%
+     1	Richard Dingwall        0.1%
+     1	Richard Knop            0.1%
+     1	Rob Wu                  0.1%
+     1	Romain Prieto           0.1%
+     1	Roman Neuhauser         0.1%
+     1	Roman Shtylman          0.1%
+     1	Russ Bradberry          0.1%
+     1	Russell Munson          0.1%
+     1	Rustem Mustafin         0.1%
+     1	Salehen Shovon Rahman   0.1%
+     1	Sasha Koss              0.1%
+     1	Seiya Konno             0.1%
+     1	Shaine Hatch            0.1%
+     1	Simon Goumaz            0.1%
+     1	Standa Opichal          0.1%
+     1	Stephen Mathieson       0.1%
+     1	Steve Mason             0.1%
+     1	Tapiwa Kelvin           0.1%
+     1	Teddy Zeenny            0.1%
+     1	Tim Ehat                0.1%
+     1	Vadim Nikitin           0.1%
+     1	Victor Costan           0.1%
+     1	Will Langstroth         0.1%
+     1	Yanis Wang              0.1%
+     1	Yuest Wang              0.1%
+     1	Zsolt Takács            0.1%
+     1	abrkn                   0.1%
+     1	airportyh               0.1%
+     1	badunk                  0.1%
+     1	claudyus                0.1%
+     1	dasilvacontin           0.1%
+     1	fengmk2                 0.1%
+     1	gaye                    0.1%
+     1	grasGendarme            0.1%
+     1	lakmeer                 0.1%
+     1	lodr                    0.1%
+     1	mrShturman              0.1%
+     1	nishigori               0.1%
+     1	omardelarosa            0.1%
+     1	qiuzuhui                0.1%
+     1	samuel goldszmidt       0.1%
+     1	sebv                    0.1%
+     1	startswithaj            0.1%
+     1	tgautier@yahoo.com      0.1%
+     1	traleig1                0.1%
+     1	vlad                    0.1%
+     1	yuitest                 0.1%
+     1	zhiyelee                0.1%
+     1	Adam Crabtree           0.1%
+     1	Andreas Brekken         0.1%
+     1	Andrew Nesbitt          0.1%
+     1	Andrey Popp             0.1%
+     1	Arnaud Brousseau        0.1%
+     1	Atsuya Takagi           0.1%
+     1	Austin Birch            0.1%
+     1	Ben Noordhuis           0.1%
+     1	Bjørge Næss             0.1%
+     1	Brian Lalor             0.1%
+     1	Brian M. Carlson        0.1%
+     1	Brian Moore             0.1%
+     1	Bryan Donovan           0.1%
+     1	C. Scott Ananian        0.1%
+     1	Casey Foster            0.1%
+     1	ChrisWren               0.1%
+     1	Connor Dunn             0.1%
+     1	Corey Butler            0.1%
+     1	Daniel Stockman         0.1%
+     1	Dave McKenna            0.1%
+     1	Denis Bardadym          0.1%
+     1	Devin Weaver            0.1%
+     1	Di Wu                   0.1%
+     1	Diogo Monteiro          0.1%
+     1	Dmitry Shirokov         0.1%
+     1	Dr. Travis Jeffery      0.1%
+     1	Fedor Indutny           0.1%
+     1	Florian Margaine        0.1%
+     1	Frederico Silva         0.1%
+     1	Fredrik Lindin          0.1%
+     1	Gareth Aye              0.1%
+     1	Gareth Murphy           0.1%
+     1	Gavin Mogan             0.1%
+     1	Giovanni Bassi          0.1%
+     1	Glen Huang              0.1%
+     1	Greg Perkins            0.1%
+     1	Harish                  0.1%
+     1	Harry Brundage          0.1%
+     1	Herman Junge            0.1%
+     1	Ian Young               0.1%
+     1	Ivan                    0.1%
+     1	JP Bochi                0.1%
+     1	Jaakko Salonen          0.1%
+     1	Jakub Nešetřil          0.1%
+     1	James Bowes             0.1%
+     1	James Lal               0.1%
+     1	Jan Kopriva             0.1%
+     1	Jason Barry             0.1%
+     1	Javier Aranda           0.1%
+     1	Jean Ponchon            0.1%
+     1	Jeff Kunkle             0.1%
+     1	Jeremy Martin           0.1%
+     1	Jimmy Cuadra            0.1%
+     1	John Doty               0.1%
+     1	Jonathan Creamer        0.1%
+     1	Jonathan Park           0.1%
+     1	Jussi Virtanen          0.1%
+     1	Katie Gengler           0.1%
+     1	Kazuhito Hokamura       0.1%
+     1	Kent C. Dodds           0.1%
+     1	Kevin Conway            0.1%
+     1	Kirill Korolyov         0.1%
+     1	Koen Punt               0.1%
+     1	Laszlo Bacsi            0.1%
+     1	Liam Newman             0.1%
+     1	Linus Unnebäck          0.1%
+     1	László Bácsi            0.1%
+     1	Maciej Małecki          0.1%
+```
+
+## Links
+
+  - [Google Group](http://groups.google.com/group/mochajs)
+  - [Wiki](https://github.com/mochajs/mocha/wiki)
+  - Mocha [Extensions and reporters](https://github.com/mochajs/mocha/wiki)
+
+Mocha also has a chat room on [Slack](https://slack.com). If you'd like to join, [shoot us an email](mailto:tj@travisjeffery.com?subject=mocha%20slack%20room%20invite) from the address you want us to invite you under and we'll happily send you an invite!
diff --git a/packages/planner/node_modules/deepcopy/bower_components/mocha/bower.json b/packages/planner/node_modules/deepcopy/bower_components/mocha/bower.json
new file mode 100644
index 00000000..3ec9d019
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/mocha/bower.json
@@ -0,0 +1,47 @@
+{
+  "name": "mocha",
+  "version": "2.1.0",
+  "homepage": "http://mocha.github.io/mocha",
+  "description": "simple, flexible, fun test framework",
+  "authors": [
+    "TJ Holowaychuk <tj@vision-media.ca>",
+    "Joshua Appelman <joshua@jbna.nl>",
+    "Oleg Gaidarenko <markelog@gmail.com>",
+    "Christoffer Hallas <christoffer.hallas@gmail.com>",
+    "Christopher Hiller <chiller@badwing.com>",
+    "Travis Jeffery <tj@travisjeffery.com>",
+    "Johnathan Ong <me@jongleberry.com>",
+    "Guillermo Rauch <rauchg@gmail.com>"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/mochajs/mocha.git"
+  },
+  "main": [
+    "mocha.js",
+    "mocha.css"
+  ],
+  "ignore": [
+    "bin",
+    "editors",
+    "images",
+    "lib",
+    "support",
+    "test",
+    ".gitignore",
+    ".npmignore",
+    ".travis.yml",
+    "component.json",
+    "index.js",
+    "Makefile",
+    "package.json"
+  ],
+  "keywords": [
+    "mocha",
+    "test",
+    "bdd",
+    "tdd",
+    "tap"
+  ],
+  "license": "MIT"
+}
\ No newline at end of file
diff --git a/packages/planner/node_modules/deepcopy/bower_components/mocha/media/logo.svg b/packages/planner/node_modules/deepcopy/bower_components/mocha/media/logo.svg
new file mode 100644
index 00000000..1bed0ce1
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/mocha/media/logo.svg
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 17.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="612px" height="792px" viewBox="0 0 612 792" enable-background="new 0 0 612 792" xml:space="preserve">
+<circle fill="#8A6343" cx="306" cy="396" r="306"/>
+<text transform="matrix(1 0 0 1 72.1431 424.7633)" fill="#FFFFFF" font-family="'HelveticaNeue'" font-size="153">mocha</text>
+</svg>
diff --git a/packages/planner/node_modules/deepcopy/bower_components/mocha/mocha.css b/packages/planner/node_modules/deepcopy/bower_components/mocha/mocha.css
new file mode 100644
index 00000000..42b9798f
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/mocha/mocha.css
@@ -0,0 +1,270 @@
+@charset "utf-8";
+
+body {
+  margin:0;
+}
+
+#mocha {
+  font: 20px/1.5 "Helvetica Neue", Helvetica, Arial, sans-serif;
+  margin: 60px 50px;
+}
+
+#mocha ul,
+#mocha li {
+  margin: 0;
+  padding: 0;
+}
+
+#mocha ul {
+  list-style: none;
+}
+
+#mocha h1,
+#mocha h2 {
+  margin: 0;
+}
+
+#mocha h1 {
+  margin-top: 15px;
+  font-size: 1em;
+  font-weight: 200;
+}
+
+#mocha h1 a {
+  text-decoration: none;
+  color: inherit;
+}
+
+#mocha h1 a:hover {
+  text-decoration: underline;
+}
+
+#mocha .suite .suite h1 {
+  margin-top: 0;
+  font-size: .8em;
+}
+
+#mocha .hidden {
+  display: none;
+}
+
+#mocha h2 {
+  font-size: 12px;
+  font-weight: normal;
+  cursor: pointer;
+}
+
+#mocha .suite {
+  margin-left: 15px;
+}
+
+#mocha .test {
+  margin-left: 15px;
+  overflow: hidden;
+}
+
+#mocha .test.pending:hover h2::after {
+  content: '(pending)';
+  font-family: arial, sans-serif;
+}
+
+#mocha .test.pass.medium .duration {
+  background: #c09853;
+}
+
+#mocha .test.pass.slow .duration {
+  background: #b94a48;
+}
+
+#mocha .test.pass::before {
+  content: '✓';
+  font-size: 12px;
+  display: block;
+  float: left;
+  margin-right: 5px;
+  color: #00d6b2;
+}
+
+#mocha .test.pass .duration {
+  font-size: 9px;
+  margin-left: 5px;
+  padding: 2px 5px;
+  color: #fff;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0,0,0,.2);
+  -moz-box-shadow: inset 0 1px 1px rgba(0,0,0,.2);
+  box-shadow: inset 0 1px 1px rgba(0,0,0,.2);
+  -webkit-border-radius: 5px;
+  -moz-border-radius: 5px;
+  -ms-border-radius: 5px;
+  -o-border-radius: 5px;
+  border-radius: 5px;
+}
+
+#mocha .test.pass.fast .duration {
+  display: none;
+}
+
+#mocha .test.pending {
+  color: #0b97c4;
+}
+
+#mocha .test.pending::before {
+  content: '◦';
+  color: #0b97c4;
+}
+
+#mocha .test.fail {
+  color: #c00;
+}
+
+#mocha .test.fail pre {
+  color: black;
+}
+
+#mocha .test.fail::before {
+  content: '✖';
+  font-size: 12px;
+  display: block;
+  float: left;
+  margin-right: 5px;
+  color: #c00;
+}
+
+#mocha .test pre.error {
+  color: #c00;
+  max-height: 300px;
+  overflow: auto;
+}
+
+/**
+ * (1): approximate for browsers not supporting calc
+ * (2): 42 = 2*15 + 2*10 + 2*1 (padding + margin + border)
+ *      ^^ seriously
+ */
+#mocha .test pre {
+  display: block;
+  float: left;
+  clear: left;
+  font: 12px/1.5 monaco, monospace;
+  margin: 5px;
+  padding: 15px;
+  border: 1px solid #eee;
+  max-width: 85%; /*(1)*/
+  max-width: calc(100% - 42px); /*(2)*/
+  word-wrap: break-word;
+  border-bottom-color: #ddd;
+  -webkit-border-radius: 3px;
+  -webkit-box-shadow: 0 1px 3px #eee;
+  -moz-border-radius: 3px;
+  -moz-box-shadow: 0 1px 3px #eee;
+  border-radius: 3px;
+}
+
+#mocha .test h2 {
+  position: relative;
+}
+
+#mocha .test a.replay {
+  position: absolute;
+  top: 3px;
+  right: 0;
+  text-decoration: none;
+  vertical-align: middle;
+  display: block;
+  width: 15px;
+  height: 15px;
+  line-height: 15px;
+  text-align: center;
+  background: #eee;
+  font-size: 15px;
+  -moz-border-radius: 15px;
+  border-radius: 15px;
+  -webkit-transition: opacity 200ms;
+  -moz-transition: opacity 200ms;
+  transition: opacity 200ms;
+  opacity: 0.3;
+  color: #888;
+}
+
+#mocha .test:hover a.replay {
+  opacity: 1;
+}
+
+#mocha-report.pass .test.fail {
+  display: none;
+}
+
+#mocha-report.fail .test.pass {
+  display: none;
+}
+
+#mocha-report.pending .test.pass,
+#mocha-report.pending .test.fail {
+  display: none;
+}
+#mocha-report.pending .test.pass.pending {
+  display: block;
+}
+
+#mocha-error {
+  color: #c00;
+  font-size: 1.5em;
+  font-weight: 100;
+  letter-spacing: 1px;
+}
+
+#mocha-stats {
+  position: fixed;
+  top: 15px;
+  right: 10px;
+  font-size: 12px;
+  margin: 0;
+  color: #888;
+  z-index: 1;
+}
+
+#mocha-stats .progress {
+  float: right;
+  padding-top: 0;
+}
+
+#mocha-stats em {
+  color: black;
+}
+
+#mocha-stats a {
+  text-decoration: none;
+  color: inherit;
+}
+
+#mocha-stats a:hover {
+  border-bottom: 1px solid #eee;
+}
+
+#mocha-stats li {
+  display: inline-block;
+  margin: 0 5px;
+  list-style: none;
+  padding-top: 11px;
+}
+
+#mocha-stats canvas {
+  width: 40px;
+  height: 40px;
+}
+
+#mocha code .comment { color: #ddd; }
+#mocha code .init { color: #2f6fad; }
+#mocha code .string { color: #5890ad; }
+#mocha code .keyword { color: #8a6343; }
+#mocha code .number { color: #2f6fad; }
+
+@media screen and (max-device-width: 480px) {
+  #mocha {
+    margin: 60px 0px;
+  }
+
+  #mocha #stats {
+    position: absolute;
+  }
+}
diff --git a/packages/planner/node_modules/deepcopy/bower_components/mocha/mocha.js b/packages/planner/node_modules/deepcopy/bower_components/mocha/mocha.js
new file mode 100644
index 00000000..22d1a9f3
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/mocha/mocha.js
@@ -0,0 +1,6298 @@
+;(function(){
+
+// CommonJS require()
+
+function require(p){
+    var path = require.resolve(p)
+      , mod = require.modules[path];
+    if (!mod) throw new Error('failed to require "' + p + '"');
+    if (!mod.exports) {
+      mod.exports = {};
+      mod.call(mod.exports, mod, mod.exports, require.relative(path));
+    }
+    return mod.exports;
+  }
+
+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.register = function (path, fn){
+    require.modules[path] = fn;
+  };
+
+require.relative = function (parent) {
+    return function(p){
+      if ('.' != p.charAt(0)) 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('/'));
+    };
+  };
+
+
+require.register("browser/debug.js", function(module, exports, require){
+module.exports = function(type){
+  return function(){
+  }
+};
+
+}); // module: browser/debug.js
+
+require.register("browser/diff.js", function(module, exports, require){
+/* See LICENSE file for terms of use */
+
+/*
+ * Text diff implementation.
+ *
+ * This library supports the following APIS:
+ * JsDiff.diffChars: Character by character diff
+ * JsDiff.diffWords: Word (as defined by \b regex) diff which ignores whitespace
+ * JsDiff.diffLines: Line based diff
+ *
+ * JsDiff.diffCss: Diff targeted at CSS content
+ *
+ * These methods are based on the implementation proposed in
+ * "An O(ND) Difference Algorithm and its Variations" (Myers, 1986).
+ * http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.4.6927
+ */
+var JsDiff = (function() {
+  /*jshint maxparams: 5*/
+  function clonePath(path) {
+    return { newPos: path.newPos, components: path.components.slice(0) };
+  }
+  function removeEmpty(array) {
+    var ret = [];
+    for (var i = 0; i < array.length; i++) {
+      if (array[i]) {
+        ret.push(array[i]);
+      }
+    }
+    return ret;
+  }
+  function escapeHTML(s) {
+    var n = s;
+    n = n.replace(/&/g, '&amp;');
+    n = n.replace(/</g, '&lt;');
+    n = n.replace(/>/g, '&gt;');
+    n = n.replace(/"/g, '&quot;');
+
+    return n;
+  }
+
+  var Diff = function(ignoreWhitespace) {
+    this.ignoreWhitespace = ignoreWhitespace;
+  };
+  Diff.prototype = {
+      diff: function(oldString, newString) {
+        // Handle the identity case (this is due to unrolling editLength == 0
+        if (newString === oldString) {
+          return [{ value: newString }];
+        }
+        if (!newString) {
+          return [{ value: oldString, removed: true }];
+        }
+        if (!oldString) {
+          return [{ value: newString, added: true }];
+        }
+
+        newString = this.tokenize(newString);
+        oldString = this.tokenize(oldString);
+
+        var newLen = newString.length, oldLen = oldString.length;
+        var maxEditLength = newLen + oldLen;
+        var bestPath = [{ newPos: -1, components: [] }];
+
+        // Seed editLength = 0
+        var oldPos = this.extractCommon(bestPath[0], newString, oldString, 0);
+        if (bestPath[0].newPos+1 >= newLen && oldPos+1 >= oldLen) {
+          return bestPath[0].components;
+        }
+
+        for (var editLength = 1; editLength <= maxEditLength; editLength++) {
+          for (var diagonalPath = -1*editLength; diagonalPath <= editLength; diagonalPath+=2) {
+            var basePath;
+            var addPath = bestPath[diagonalPath-1],
+                removePath = bestPath[diagonalPath+1];
+            oldPos = (removePath ? removePath.newPos : 0) - diagonalPath;
+            if (addPath) {
+              // No one else is going to attempt to use this value, clear it
+              bestPath[diagonalPath-1] = undefined;
+            }
+
+            var canAdd = addPath && addPath.newPos+1 < newLen;
+            var canRemove = removePath && 0 <= oldPos && oldPos < oldLen;
+            if (!canAdd && !canRemove) {
+              bestPath[diagonalPath] = undefined;
+              continue;
+            }
+
+            // Select the diagonal that we want to branch from. We select the prior
+            // path whose position in the new string is the farthest from the origin
+            // and does not pass the bounds of the diff graph
+            if (!canAdd || (canRemove && addPath.newPos < removePath.newPos)) {
+              basePath = clonePath(removePath);
+              this.pushComponent(basePath.components, oldString[oldPos], undefined, true);
+            } else {
+              basePath = clonePath(addPath);
+              basePath.newPos++;
+              this.pushComponent(basePath.components, newString[basePath.newPos], true, undefined);
+            }
+
+            var oldPos = this.extractCommon(basePath, newString, oldString, diagonalPath);
+
+            if (basePath.newPos+1 >= newLen && oldPos+1 >= oldLen) {
+              return basePath.components;
+            } else {
+              bestPath[diagonalPath] = basePath;
+            }
+          }
+        }
+      },
+
+      pushComponent: function(components, value, added, removed) {
+        var last = components[components.length-1];
+        if (last && last.added === added && last.removed === removed) {
+          // We need to clone here as the component clone operation is just
+          // as shallow array clone
+          components[components.length-1] =
+            {value: this.join(last.value, value), added: added, removed: removed };
+        } else {
+          components.push({value: value, added: added, removed: removed });
+        }
+      },
+      extractCommon: function(basePath, newString, oldString, diagonalPath) {
+        var newLen = newString.length,
+            oldLen = oldString.length,
+            newPos = basePath.newPos,
+            oldPos = newPos - diagonalPath;
+        while (newPos+1 < newLen && oldPos+1 < oldLen && this.equals(newString[newPos+1], oldString[oldPos+1])) {
+          newPos++;
+          oldPos++;
+
+          this.pushComponent(basePath.components, newString[newPos], undefined, undefined);
+        }
+        basePath.newPos = newPos;
+        return oldPos;
+      },
+
+      equals: function(left, right) {
+        var reWhitespace = /\S/;
+        if (this.ignoreWhitespace && !reWhitespace.test(left) && !reWhitespace.test(right)) {
+          return true;
+        } else {
+          return left === right;
+        }
+      },
+      join: function(left, right) {
+        return left + right;
+      },
+      tokenize: function(value) {
+        return value;
+      }
+  };
+
+  var CharDiff = new Diff();
+
+  var WordDiff = new Diff(true);
+  var WordWithSpaceDiff = new Diff();
+  WordDiff.tokenize = WordWithSpaceDiff.tokenize = function(value) {
+    return removeEmpty(value.split(/(\s+|\b)/));
+  };
+
+  var CssDiff = new Diff(true);
+  CssDiff.tokenize = function(value) {
+    return removeEmpty(value.split(/([{}:;,]|\s+)/));
+  };
+
+  var LineDiff = new Diff();
+  LineDiff.tokenize = function(value) {
+    var retLines = [],
+        lines = value.split(/^/m);
+
+    for(var i = 0; i < lines.length; i++) {
+      var line = lines[i],
+          lastLine = lines[i - 1];
+
+      // Merge lines that may contain windows new lines
+      if (line == '\n' && lastLine && lastLine[lastLine.length - 1] === '\r') {
+        retLines[retLines.length - 1] += '\n';
+      } else if (line) {
+        retLines.push(line);
+      }
+    }
+
+    return retLines;
+  };
+
+  return {
+    Diff: Diff,
+
+    diffChars: function(oldStr, newStr) { return CharDiff.diff(oldStr, newStr); },
+    diffWords: function(oldStr, newStr) { return WordDiff.diff(oldStr, newStr); },
+    diffWordsWithSpace: function(oldStr, newStr) { return WordWithSpaceDiff.diff(oldStr, newStr); },
+    diffLines: function(oldStr, newStr) { return LineDiff.diff(oldStr, newStr); },
+
+    diffCss: function(oldStr, newStr) { return CssDiff.diff(oldStr, newStr); },
+
+    createPatch: function(fileName, oldStr, newStr, oldHeader, newHeader) {
+      var ret = [];
+
+      ret.push('Index: ' + fileName);
+      ret.push('===================================================================');
+      ret.push('--- ' + fileName + (typeof oldHeader === 'undefined' ? '' : '\t' + oldHeader));
+      ret.push('+++ ' + fileName + (typeof newHeader === 'undefined' ? '' : '\t' + newHeader));
+
+      var diff = LineDiff.diff(oldStr, newStr);
+      if (!diff[diff.length-1].value) {
+        diff.pop();   // Remove trailing newline add
+      }
+      diff.push({value: '', lines: []});   // Append an empty value to make cleanup easier
+
+      function contextLines(lines) {
+        return lines.map(function(entry) { return ' ' + entry; });
+      }
+      function eofNL(curRange, i, current) {
+        var last = diff[diff.length-2],
+            isLast = i === diff.length-2,
+            isLastOfType = i === diff.length-3 && (current.added !== last.added || current.removed !== last.removed);
+
+        // Figure out if this is the last line for the given file and missing NL
+        if (!/\n$/.test(current.value) && (isLast || isLastOfType)) {
+          curRange.push('\\ No newline at end of file');
+        }
+      }
+
+      var oldRangeStart = 0, newRangeStart = 0, curRange = [],
+          oldLine = 1, newLine = 1;
+      for (var i = 0; i < diff.length; i++) {
+        var current = diff[i],
+            lines = current.lines || current.value.replace(/\n$/, '').split('\n');
+        current.lines = lines;
+
+        if (current.added || current.removed) {
+          if (!oldRangeStart) {
+            var prev = diff[i-1];
+            oldRangeStart = oldLine;
+            newRangeStart = newLine;
+
+            if (prev) {
+              curRange = contextLines(prev.lines.slice(-4));
+              oldRangeStart -= curRange.length;
+              newRangeStart -= curRange.length;
+            }
+          }
+          curRange.push.apply(curRange, lines.map(function(entry) { return (current.added?'+':'-') + entry; }));
+          eofNL(curRange, i, current);
+
+          if (current.added) {
+            newLine += lines.length;
+          } else {
+            oldLine += lines.length;
+          }
+        } else {
+          if (oldRangeStart) {
+            // Close out any changes that have been output (or join overlapping)
+            if (lines.length <= 8 && i < diff.length-2) {
+              // Overlapping
+              curRange.push.apply(curRange, contextLines(lines));
+            } else {
+              // end the range and output
+              var contextSize = Math.min(lines.length, 4);
+              ret.push(
+                  '@@ -' + oldRangeStart + ',' + (oldLine-oldRangeStart+contextSize)
+                  + ' +' + newRangeStart + ',' + (newLine-newRangeStart+contextSize)
+                  + ' @@');
+              ret.push.apply(ret, curRange);
+              ret.push.apply(ret, contextLines(lines.slice(0, contextSize)));
+              if (lines.length <= 4) {
+                eofNL(ret, i, current);
+              }
+
+              oldRangeStart = 0;  newRangeStart = 0; curRange = [];
+            }
+          }
+          oldLine += lines.length;
+          newLine += lines.length;
+        }
+      }
+
+      return ret.join('\n') + '\n';
+    },
+
+    applyPatch: function(oldStr, uniDiff) {
+      var diffstr = uniDiff.split('\n');
+      var diff = [];
+      var remEOFNL = false,
+          addEOFNL = false;
+
+      for (var i = (diffstr[0][0]==='I'?4:0); i < diffstr.length; i++) {
+        if(diffstr[i][0] === '@') {
+          var meh = diffstr[i].split(/@@ -(\d+),(\d+) \+(\d+),(\d+) @@/);
+          diff.unshift({
+            start:meh[3],
+            oldlength:meh[2],
+            oldlines:[],
+            newlength:meh[4],
+            newlines:[]
+          });
+        } else if(diffstr[i][0] === '+') {
+          diff[0].newlines.push(diffstr[i].substr(1));
+        } else if(diffstr[i][0] === '-') {
+          diff[0].oldlines.push(diffstr[i].substr(1));
+        } else if(diffstr[i][0] === ' ') {
+          diff[0].newlines.push(diffstr[i].substr(1));
+          diff[0].oldlines.push(diffstr[i].substr(1));
+        } else if(diffstr[i][0] === '\\') {
+          if (diffstr[i-1][0] === '+') {
+            remEOFNL = true;
+          } else if(diffstr[i-1][0] === '-') {
+            addEOFNL = true;
+          }
+        }
+      }
+
+      var str = oldStr.split('\n');
+      for (var i = diff.length - 1; i >= 0; i--) {
+        var d = diff[i];
+        for (var j = 0; j < d.oldlength; j++) {
+          if(str[d.start-1+j] !== d.oldlines[j]) {
+            return false;
+          }
+        }
+        Array.prototype.splice.apply(str,[d.start-1,+d.oldlength].concat(d.newlines));
+      }
+
+      if (remEOFNL) {
+        while (!str[str.length-1]) {
+          str.pop();
+        }
+      } else if (addEOFNL) {
+        str.push('');
+      }
+      return str.join('\n');
+    },
+
+    convertChangesToXML: function(changes){
+      var ret = [];
+      for ( var i = 0; i < changes.length; i++) {
+        var change = changes[i];
+        if (change.added) {
+          ret.push('<ins>');
+        } else if (change.removed) {
+          ret.push('<del>');
+        }
+
+        ret.push(escapeHTML(change.value));
+
+        if (change.added) {
+          ret.push('</ins>');
+        } else if (change.removed) {
+          ret.push('</del>');
+        }
+      }
+      return ret.join('');
+    },
+
+    // See: http://code.google.com/p/google-diff-match-patch/wiki/API
+    convertChangesToDMP: function(changes){
+      var ret = [], change;
+      for ( var i = 0; i < changes.length; i++) {
+        change = changes[i];
+        ret.push([(change.added ? 1 : change.removed ? -1 : 0), change.value]);
+      }
+      return ret;
+    }
+  };
+})();
+
+if (typeof module !== 'undefined') {
+    module.exports = JsDiff;
+}
+
+}); // module: browser/diff.js
+
+require.register("browser/escape-string-regexp.js", function(module, exports, require){
+'use strict';
+
+var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
+
+module.exports = function (str) {
+  if (typeof str !== 'string') {
+    throw new TypeError('Expected a string');
+  }
+
+  return str.replace(matchOperatorsRe,  '\\$&');
+};
+
+}); // module: browser/escape-string-regexp.js
+
+require.register("browser/events.js", function(module, exports, require){
+/**
+ * Module exports.
+ */
+
+exports.EventEmitter = EventEmitter;
+
+/**
+ * Check if `obj` is an array.
+ */
+
+function isArray(obj) {
+  return '[object Array]' == {}.toString.call(obj);
+}
+
+/**
+ * Event emitter constructor.
+ *
+ * @api public
+ */
+
+function EventEmitter(){};
+
+/**
+ * Adds a listener.
+ *
+ * @api public
+ */
+
+EventEmitter.prototype.on = function (name, fn) {
+  if (!this.$events) {
+    this.$events = {};
+  }
+
+  if (!this.$events[name]) {
+    this.$events[name] = fn;
+  } else if (isArray(this.$events[name])) {
+    this.$events[name].push(fn);
+  } else {
+    this.$events[name] = [this.$events[name], fn];
+  }
+
+  return this;
+};
+
+EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+
+/**
+ * Adds a volatile listener.
+ *
+ * @api public
+ */
+
+EventEmitter.prototype.once = function (name, fn) {
+  var self = this;
+
+  function on () {
+    self.removeListener(name, on);
+    fn.apply(this, arguments);
+  };
+
+  on.listener = fn;
+  this.on(name, on);
+
+  return this;
+};
+
+/**
+ * Removes a listener.
+ *
+ * @api public
+ */
+
+EventEmitter.prototype.removeListener = function (name, fn) {
+  if (this.$events && this.$events[name]) {
+    var list = this.$events[name];
+
+    if (isArray(list)) {
+      var pos = -1;
+
+      for (var i = 0, l = list.length; i < l; i++) {
+        if (list[i] === fn || (list[i].listener && list[i].listener === fn)) {
+          pos = i;
+          break;
+        }
+      }
+
+      if (pos < 0) {
+        return this;
+      }
+
+      list.splice(pos, 1);
+
+      if (!list.length) {
+        delete this.$events[name];
+      }
+    } else if (list === fn || (list.listener && list.listener === fn)) {
+      delete this.$events[name];
+    }
+  }
+
+  return this;
+};
+
+/**
+ * Removes all listeners for an event.
+ *
+ * @api public
+ */
+
+EventEmitter.prototype.removeAllListeners = function (name) {
+  if (name === undefined) {
+    this.$events = {};
+    return this;
+  }
+
+  if (this.$events && this.$events[name]) {
+    this.$events[name] = null;
+  }
+
+  return this;
+};
+
+/**
+ * Gets all listeners for a certain event.
+ *
+ * @api public
+ */
+
+EventEmitter.prototype.listeners = function (name) {
+  if (!this.$events) {
+    this.$events = {};
+  }
+
+  if (!this.$events[name]) {
+    this.$events[name] = [];
+  }
+
+  if (!isArray(this.$events[name])) {
+    this.$events[name] = [this.$events[name]];
+  }
+
+  return this.$events[name];
+};
+
+/**
+ * Emits an event.
+ *
+ * @api public
+ */
+
+EventEmitter.prototype.emit = function (name) {
+  if (!this.$events) {
+    return false;
+  }
+
+  var handler = this.$events[name];
+
+  if (!handler) {
+    return false;
+  }
+
+  var args = [].slice.call(arguments, 1);
+
+  if ('function' == typeof handler) {
+    handler.apply(this, args);
+  } else if (isArray(handler)) {
+    var listeners = handler.slice();
+
+    for (var i = 0, l = listeners.length; i < l; i++) {
+      listeners[i].apply(this, args);
+    }
+  } else {
+    return false;
+  }
+
+  return true;
+};
+
+}); // module: browser/events.js
+
+require.register("browser/fs.js", function(module, exports, require){
+
+}); // module: browser/fs.js
+
+require.register("browser/glob.js", function(module, exports, require){
+
+}); // module: browser/glob.js
+
+require.register("browser/path.js", function(module, exports, require){
+
+}); // module: browser/path.js
+
+require.register("browser/progress.js", function(module, exports, require){
+/**
+ * Expose `Progress`.
+ */
+
+module.exports = Progress;
+
+/**
+ * Initialize a new `Progress` indicator.
+ */
+
+function Progress() {
+  this.percent = 0;
+  this.size(0);
+  this.fontSize(11);
+  this.font('helvetica, arial, sans-serif');
+}
+
+/**
+ * Set progress size to `n`.
+ *
+ * @param {Number} n
+ * @return {Progress} for chaining
+ * @api public
+ */
+
+Progress.prototype.size = function(n){
+  this._size = n;
+  return this;
+};
+
+/**
+ * Set text to `str`.
+ *
+ * @param {String} str
+ * @return {Progress} for chaining
+ * @api public
+ */
+
+Progress.prototype.text = function(str){
+  this._text = str;
+  return this;
+};
+
+/**
+ * Set font size to `n`.
+ *
+ * @param {Number} n
+ * @return {Progress} for chaining
+ * @api public
+ */
+
+Progress.prototype.fontSize = function(n){
+  this._fontSize = n;
+  return this;
+};
+
+/**
+ * Set font `family`.
+ *
+ * @param {String} family
+ * @return {Progress} for chaining
+ */
+
+Progress.prototype.font = function(family){
+  this._font = family;
+  return this;
+};
+
+/**
+ * Update percentage to `n`.
+ *
+ * @param {Number} n
+ * @return {Progress} for chaining
+ */
+
+Progress.prototype.update = function(n){
+  this.percent = n;
+  return this;
+};
+
+/**
+ * Draw on `ctx`.
+ *
+ * @param {CanvasRenderingContext2d} ctx
+ * @return {Progress} for chaining
+ */
+
+Progress.prototype.draw = function(ctx){
+  try {
+    var percent = Math.min(this.percent, 100)
+      , size = this._size
+      , half = size / 2
+      , x = half
+      , y = half
+      , rad = half - 1
+      , fontSize = this._fontSize;
+
+    ctx.font = fontSize + 'px ' + this._font;
+
+    var angle = Math.PI * 2 * (percent / 100);
+    ctx.clearRect(0, 0, size, size);
+
+    // outer circle
+    ctx.strokeStyle = '#9f9f9f';
+    ctx.beginPath();
+    ctx.arc(x, y, rad, 0, angle, false);
+    ctx.stroke();
+
+    // inner circle
+    ctx.strokeStyle = '#eee';
+    ctx.beginPath();
+    ctx.arc(x, y, rad - 1, 0, angle, true);
+    ctx.stroke();
+
+    // text
+    var text = this._text || (percent | 0) + '%'
+      , w = ctx.measureText(text).width;
+
+    ctx.fillText(
+        text
+      , x - w / 2 + 1
+      , y + fontSize / 2 - 1);
+  } catch (ex) {} //don't fail if we can't render progress
+  return this;
+};
+
+}); // module: browser/progress.js
+
+require.register("browser/tty.js", function(module, exports, require){
+exports.isatty = function(){
+  return true;
+};
+
+exports.getWindowSize = function(){
+  if ('innerHeight' in global) {
+    return [global.innerHeight, global.innerWidth];
+  } else {
+    // In a Web Worker, the DOM Window is not available.
+    return [640, 480];
+  }
+};
+
+}); // module: browser/tty.js
+
+require.register("context.js", function(module, exports, require){
+/**
+ * Expose `Context`.
+ */
+
+module.exports = Context;
+
+/**
+ * Initialize a new `Context`.
+ *
+ * @api private
+ */
+
+function Context(){}
+
+/**
+ * Set or get the context `Runnable` to `runnable`.
+ *
+ * @param {Runnable} runnable
+ * @return {Context}
+ * @api private
+ */
+
+Context.prototype.runnable = function(runnable){
+  if (0 == arguments.length) return this._runnable;
+  this.test = this._runnable = runnable;
+  return this;
+};
+
+/**
+ * Set test timeout `ms`.
+ *
+ * @param {Number} ms
+ * @return {Context} self
+ * @api private
+ */
+
+Context.prototype.timeout = function(ms){
+  if (arguments.length === 0) return this.runnable().timeout();
+  this.runnable().timeout(ms);
+  return this;
+};
+
+/**
+ * Set test timeout `enabled`.
+ *
+ * @param {Boolean} enabled
+ * @return {Context} self
+ * @api private
+ */
+
+Context.prototype.enableTimeouts = function (enabled) {
+  this.runnable().enableTimeouts(enabled);
+  return this;
+};
+
+
+/**
+ * Set test slowness threshold `ms`.
+ *
+ * @param {Number} ms
+ * @return {Context} self
+ * @api private
+ */
+
+Context.prototype.slow = function(ms){
+  this.runnable().slow(ms);
+  return this;
+};
+
+/**
+ * Inspect the context void of `._runnable`.
+ *
+ * @return {String}
+ * @api private
+ */
+
+Context.prototype.inspect = function(){
+  return JSON.stringify(this, function(key, val){
+    if ('_runnable' == key) return;
+    if ('test' == key) return;
+    return val;
+  }, 2);
+};
+
+}); // module: context.js
+
+require.register("hook.js", function(module, exports, require){
+/**
+ * Module dependencies.
+ */
+
+var Runnable = require('./runnable');
+
+/**
+ * Expose `Hook`.
+ */
+
+module.exports = Hook;
+
+/**
+ * Initialize a new `Hook` with the given `title` and callback `fn`.
+ *
+ * @param {String} title
+ * @param {Function} fn
+ * @api private
+ */
+
+function Hook(title, fn) {
+  Runnable.call(this, title, fn);
+  this.type = 'hook';
+}
+
+/**
+ * Inherit from `Runnable.prototype`.
+ */
+
+function F(){};
+F.prototype = Runnable.prototype;
+Hook.prototype = new F;
+Hook.prototype.constructor = Hook;
+
+
+/**
+ * Get or set the test `err`.
+ *
+ * @param {Error} err
+ * @return {Error}
+ * @api public
+ */
+
+Hook.prototype.error = function(err){
+  if (0 == arguments.length) {
+    var err = this._error;
+    this._error = null;
+    return err;
+  }
+
+  this._error = err;
+};
+
+}); // module: hook.js
+
+require.register("interfaces/bdd.js", function(module, exports, require){
+/**
+ * Module dependencies.
+ */
+
+var Suite = require('../suite')
+  , Test = require('../test')
+  , utils = require('../utils')
+  , escapeRe = require('browser/escape-string-regexp');
+
+/**
+ * BDD-style interface:
+ *
+ *      describe('Array', function(){
+ *        describe('#indexOf()', function(){
+ *          it('should return -1 when not present', function(){
+ *
+ *          });
+ *
+ *          it('should return the index when present', function(){
+ *
+ *          });
+ *        });
+ *      });
+ *
+ */
+
+module.exports = function(suite){
+  var suites = [suite];
+
+  suite.on('pre-require', function(context, file, mocha){
+
+    /**
+     * Execute before running tests.
+     */
+
+    context.before = function(name, fn){
+      suites[0].beforeAll(name, fn);
+    };
+
+    /**
+     * Execute after running tests.
+     */
+
+    context.after = function(name, fn){
+      suites[0].afterAll(name, fn);
+    };
+
+    /**
+     * Execute before each test case.
+     */
+
+    context.beforeEach = function(name, fn){
+      suites[0].beforeEach(name, fn);
+    };
+
+    /**
+     * Execute after each test case.
+     */
+
+    context.afterEach = function(name, fn){
+      suites[0].afterEach(name, fn);
+    };
+
+    /**
+     * Describe a "suite" with the given `title`
+     * and callback `fn` containing nested suites
+     * and/or tests.
+     */
+
+    context.describe = context.context = function(title, fn){
+      var suite = Suite.create(suites[0], title);
+      suite.file = file;
+      suites.unshift(suite);
+      fn.call(suite);
+      suites.shift();
+      return suite;
+    };
+
+    /**
+     * Pending describe.
+     */
+
+    context.xdescribe =
+    context.xcontext =
+    context.describe.skip = function(title, fn){
+      var suite = Suite.create(suites[0], title);
+      suite.pending = true;
+      suites.unshift(suite);
+      fn.call(suite);
+      suites.shift();
+    };
+
+    /**
+     * Exclusive suite.
+     */
+
+    context.describe.only = function(title, fn){
+      var suite = context.describe(title, fn);
+      mocha.grep(suite.fullTitle());
+      return suite;
+    };
+
+    /**
+     * Describe a specification or test-case
+     * with the given `title` and callback `fn`
+     * acting as a thunk.
+     */
+
+    context.it = context.specify = function(title, fn){
+      var suite = suites[0];
+      if (suite.pending) fn = null;
+      var test = new Test(title, fn);
+      test.file = file;
+      suite.addTest(test);
+      return test;
+    };
+
+    /**
+     * Exclusive test-case.
+     */
+
+    context.it.only = function(title, fn){
+      var test = context.it(title, fn);
+      var reString = '^' + escapeRe(test.fullTitle()) + '$';
+      mocha.grep(new RegExp(reString));
+      return test;
+    };
+
+    /**
+     * Pending test case.
+     */
+
+    context.xit =
+    context.xspecify =
+    context.it.skip = function(title){
+      context.it(title);
+    };
+  });
+};
+
+}); // module: interfaces/bdd.js
+
+require.register("interfaces/exports.js", function(module, exports, require){
+/**
+ * Module dependencies.
+ */
+
+var Suite = require('../suite')
+  , Test = require('../test');
+
+/**
+ * TDD-style interface:
+ *
+ *     exports.Array = {
+ *       '#indexOf()': {
+ *         'should return -1 when the value is not present': function(){
+ *
+ *         },
+ *
+ *         'should return the correct index when the value is present': function(){
+ *
+ *         }
+ *       }
+ *     };
+ *
+ */
+
+module.exports = function(suite){
+  var suites = [suite];
+
+  suite.on('require', visit);
+
+  function visit(obj, file) {
+    var suite;
+    for (var key in obj) {
+      if ('function' == typeof obj[key]) {
+        var fn = obj[key];
+        switch (key) {
+          case 'before':
+            suites[0].beforeAll(fn);
+            break;
+          case 'after':
+            suites[0].afterAll(fn);
+            break;
+          case 'beforeEach':
+            suites[0].beforeEach(fn);
+            break;
+          case 'afterEach':
+            suites[0].afterEach(fn);
+            break;
+          default:
+            var test = new Test(key, fn);
+            test.file = file;
+            suites[0].addTest(test);
+        }
+      } else {
+        suite = Suite.create(suites[0], key);
+        suites.unshift(suite);
+        visit(obj[key]);
+        suites.shift();
+      }
+    }
+  }
+};
+
+}); // module: interfaces/exports.js
+
+require.register("interfaces/index.js", function(module, exports, require){
+exports.bdd = require('./bdd');
+exports.tdd = require('./tdd');
+exports.qunit = require('./qunit');
+exports.exports = require('./exports');
+
+}); // module: interfaces/index.js
+
+require.register("interfaces/qunit.js", function(module, exports, require){
+/**
+ * Module dependencies.
+ */
+
+var Suite = require('../suite')
+  , Test = require('../test')
+  , escapeRe = require('browser/escape-string-regexp')
+  , utils = require('../utils');
+
+/**
+ * QUnit-style interface:
+ *
+ *     suite('Array');
+ *
+ *     test('#length', function(){
+ *       var arr = [1,2,3];
+ *       ok(arr.length == 3);
+ *     });
+ *
+ *     test('#indexOf()', function(){
+ *       var arr = [1,2,3];
+ *       ok(arr.indexOf(1) == 0);
+ *       ok(arr.indexOf(2) == 1);
+ *       ok(arr.indexOf(3) == 2);
+ *     });
+ *
+ *     suite('String');
+ *
+ *     test('#length', function(){
+ *       ok('foo'.length == 3);
+ *     });
+ *
+ */
+
+module.exports = function(suite){
+  var suites = [suite];
+
+  suite.on('pre-require', function(context, file, mocha){
+
+    /**
+     * Execute before running tests.
+     */
+
+    context.before = function(name, fn){
+      suites[0].beforeAll(name, fn);
+    };
+
+    /**
+     * Execute after running tests.
+     */
+
+    context.after = function(name, fn){
+      suites[0].afterAll(name, fn);
+    };
+
+    /**
+     * Execute before each test case.
+     */
+
+    context.beforeEach = function(name, fn){
+      suites[0].beforeEach(name, fn);
+    };
+
+    /**
+     * Execute after each test case.
+     */
+
+    context.afterEach = function(name, fn){
+      suites[0].afterEach(name, fn);
+    };
+
+    /**
+     * Describe a "suite" with the given `title`.
+     */
+
+    context.suite = function(title){
+      if (suites.length > 1) suites.shift();
+      var suite = Suite.create(suites[0], title);
+      suite.file = file;
+      suites.unshift(suite);
+      return suite;
+    };
+
+    /**
+     * Exclusive test-case.
+     */
+
+    context.suite.only = function(title, fn){
+      var suite = context.suite(title, fn);
+      mocha.grep(suite.fullTitle());
+    };
+
+    /**
+     * Describe a specification or test-case
+     * with the given `title` and callback `fn`
+     * acting as a thunk.
+     */
+
+    context.test = function(title, fn){
+      var test = new Test(title, fn);
+      test.file = file;
+      suites[0].addTest(test);
+      return test;
+    };
+
+    /**
+     * Exclusive test-case.
+     */
+
+    context.test.only = function(title, fn){
+      var test = context.test(title, fn);
+      var reString = '^' + escapeRe(test.fullTitle()) + '$';
+      mocha.grep(new RegExp(reString));
+    };
+
+    /**
+     * Pending test case.
+     */
+
+    context.test.skip = function(title){
+      context.test(title);
+    };
+  });
+};
+
+}); // module: interfaces/qunit.js
+
+require.register("interfaces/tdd.js", function(module, exports, require){
+/**
+ * Module dependencies.
+ */
+
+var Suite = require('../suite')
+  , Test = require('../test')
+  , escapeRe = require('browser/escape-string-regexp')
+  , utils = require('../utils');
+
+/**
+ * TDD-style interface:
+ *
+ *      suite('Array', function(){
+ *        suite('#indexOf()', function(){
+ *          suiteSetup(function(){
+ *
+ *          });
+ *
+ *          test('should return -1 when not present', function(){
+ *
+ *          });
+ *
+ *          test('should return the index when present', function(){
+ *
+ *          });
+ *
+ *          suiteTeardown(function(){
+ *
+ *          });
+ *        });
+ *      });
+ *
+ */
+
+module.exports = function(suite){
+  var suites = [suite];
+
+  suite.on('pre-require', function(context, file, mocha){
+
+    /**
+     * Execute before each test case.
+     */
+
+    context.setup = function(name, fn){
+      suites[0].beforeEach(name, fn);
+    };
+
+    /**
+     * Execute after each test case.
+     */
+
+    context.teardown = function(name, fn){
+      suites[0].afterEach(name, fn);
+    };
+
+    /**
+     * Execute before the suite.
+     */
+
+    context.suiteSetup = function(name, fn){
+      suites[0].beforeAll(name, fn);
+    };
+
+    /**
+     * Execute after the suite.
+     */
+
+    context.suiteTeardown = function(name, fn){
+      suites[0].afterAll(name, fn);
+    };
+
+    /**
+     * Describe a "suite" with the given `title`
+     * and callback `fn` containing nested suites
+     * and/or tests.
+     */
+
+    context.suite = function(title, fn){
+      var suite = Suite.create(suites[0], title);
+      suite.file = file;
+      suites.unshift(suite);
+      fn.call(suite);
+      suites.shift();
+      return suite;
+    };
+
+    /**
+     * Pending suite.
+     */
+    context.suite.skip = function(title, fn) {
+      var suite = Suite.create(suites[0], title);
+      suite.pending = true;
+      suites.unshift(suite);
+      fn.call(suite);
+      suites.shift();
+    };
+
+    /**
+     * Exclusive test-case.
+     */
+
+    context.suite.only = function(title, fn){
+      var suite = context.suite(title, fn);
+      mocha.grep(suite.fullTitle());
+    };
+
+    /**
+     * Describe a specification or test-case
+     * with the given `title` and callback `fn`
+     * acting as a thunk.
+     */
+
+    context.test = function(title, fn){
+      var suite = suites[0];
+      if (suite.pending) fn = null;
+      var test = new Test(title, fn);
+      test.file = file;
+      suite.addTest(test);
+      return test;
+    };
+
+    /**
+     * Exclusive test-case.
+     */
+
+    context.test.only = function(title, fn){
+      var test = context.test(title, fn);
+      var reString = '^' + escapeRe(test.fullTitle()) + '$';
+      mocha.grep(new RegExp(reString));
+    };
+
+    /**
+     * Pending test case.
+     */
+
+    context.test.skip = function(title){
+      context.test(title);
+    };
+  });
+};
+
+}); // module: interfaces/tdd.js
+
+require.register("mocha.js", function(module, exports, require){
+/*!
+ * mocha
+ * Copyright(c) 2011 TJ Holowaychuk <tj@vision-media.ca>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var path = require('browser/path')
+  , escapeRe = require('browser/escape-string-regexp')
+  , utils = require('./utils');
+
+/**
+ * Expose `Mocha`.
+ */
+
+exports = module.exports = Mocha;
+
+/**
+ * To require local UIs and reporters when running in node.
+ */
+
+if (typeof process !== 'undefined' && typeof process.cwd === 'function') {
+  var join = path.join
+    , cwd = process.cwd();
+  module.paths.push(cwd, join(cwd, 'node_modules'));
+}
+
+/**
+ * Expose internals.
+ */
+
+exports.utils = utils;
+exports.interfaces = require('./interfaces');
+exports.reporters = require('./reporters');
+exports.Runnable = require('./runnable');
+exports.Context = require('./context');
+exports.Runner = require('./runner');
+exports.Suite = require('./suite');
+exports.Hook = require('./hook');
+exports.Test = require('./test');
+
+/**
+ * Return image `name` path.
+ *
+ * @param {String} name
+ * @return {String}
+ * @api private
+ */
+
+function image(name) {
+  return __dirname + '/../images/' + name + '.png';
+}
+
+/**
+ * Setup mocha with `options`.
+ *
+ * Options:
+ *
+ *   - `ui` name "bdd", "tdd", "exports" etc
+ *   - `reporter` reporter instance, defaults to `mocha.reporters.spec`
+ *   - `globals` array of accepted globals
+ *   - `timeout` timeout in milliseconds
+ *   - `bail` bail on the first test failure
+ *   - `slow` milliseconds to wait before considering a test slow
+ *   - `ignoreLeaks` ignore global leaks
+ *   - `grep` string or regexp to filter tests with
+ *
+ * @param {Object} options
+ * @api public
+ */
+
+function Mocha(options) {
+  options = options || {};
+  this.files = [];
+  this.options = options;
+  this.grep(options.grep);
+  this.suite = new exports.Suite('', new exports.Context);
+  this.ui(options.ui);
+  this.bail(options.bail);
+  this.reporter(options.reporter, options.reporterOptions);
+  if (null != options.timeout) this.timeout(options.timeout);
+  this.useColors(options.useColors)
+  if (options.enableTimeouts !== null) this.enableTimeouts(options.enableTimeouts);
+  if (options.slow) this.slow(options.slow);
+
+  this.suite.on('pre-require', function (context) {
+    exports.afterEach = context.afterEach || context.teardown;
+    exports.after = context.after || context.suiteTeardown;
+    exports.beforeEach = context.beforeEach || context.setup;
+    exports.before = context.before || context.suiteSetup;
+    exports.describe = context.describe || context.suite;
+    exports.it = context.it || context.test;
+    exports.setup = context.setup || context.beforeEach;
+    exports.suiteSetup = context.suiteSetup || context.before;
+    exports.suiteTeardown = context.suiteTeardown || context.after;
+    exports.suite = context.suite || context.describe;
+    exports.teardown = context.teardown || context.afterEach;
+    exports.test = context.test || context.it;
+  });
+}
+
+/**
+ * Enable or disable bailing on the first failure.
+ *
+ * @param {Boolean} [bail]
+ * @api public
+ */
+
+Mocha.prototype.bail = function(bail){
+  if (0 == arguments.length) bail = true;
+  this.suite.bail(bail);
+  return this;
+};
+
+/**
+ * Add test `file`.
+ *
+ * @param {String} file
+ * @api public
+ */
+
+Mocha.prototype.addFile = function(file){
+  this.files.push(file);
+  return this;
+};
+
+/**
+ * Set reporter to `reporter`, defaults to "spec".
+ *
+ * @param {String|Function} reporter name or constructor
+ * @param {Object} reporterOptions optional options
+ * @api public
+ */
+Mocha.prototype.reporter = function(reporter, reporterOptions){
+  if ('function' == typeof reporter) {
+    this._reporter = reporter;
+  } else {
+    reporter = reporter || 'spec';
+    var _reporter;
+    try { _reporter = require('./reporters/' + reporter); } catch (err) {};
+    if (!_reporter) try { _reporter = require(reporter); } catch (err) {};
+    if (!_reporter && reporter === 'teamcity')
+      console.warn('The Teamcity reporter was moved to a package named ' +
+        'mocha-teamcity-reporter ' +
+        '(https://npmjs.org/package/mocha-teamcity-reporter).');
+    if (!_reporter) throw new Error('invalid reporter "' + reporter + '"');
+    this._reporter = _reporter;
+  }
+  this.options.reporterOptions = reporterOptions;
+  return this;
+};
+
+/**
+ * Set test UI `name`, defaults to "bdd".
+ *
+ * @param {String} bdd
+ * @api public
+ */
+
+Mocha.prototype.ui = function(name){
+  name = name || 'bdd';
+  this._ui = exports.interfaces[name];
+  if (!this._ui) try { this._ui = require(name); } catch (err) {};
+  if (!this._ui) throw new Error('invalid interface "' + name + '"');
+  this._ui = this._ui(this.suite);
+  return this;
+};
+
+/**
+ * Load registered files.
+ *
+ * @api private
+ */
+
+Mocha.prototype.loadFiles = function(fn){
+  var self = this;
+  var suite = this.suite;
+  var pending = this.files.length;
+  this.files.forEach(function(file){
+    file = path.resolve(file);
+    suite.emit('pre-require', global, file, self);
+    suite.emit('require', require(file), file, self);
+    suite.emit('post-require', global, file, self);
+    --pending || (fn && fn());
+  });
+};
+
+/**
+ * Enable growl support.
+ *
+ * @api private
+ */
+
+Mocha.prototype._growl = function(runner, reporter) {
+  var notify = require('growl');
+
+  runner.on('end', function(){
+    var stats = reporter.stats;
+    if (stats.failures) {
+      var msg = stats.failures + ' of ' + runner.total + ' tests failed';
+      notify(msg, { name: 'mocha', title: 'Failed', image: image('error') });
+    } else {
+      notify(stats.passes + ' tests passed in ' + stats.duration + 'ms', {
+          name: 'mocha'
+        , title: 'Passed'
+        , image: image('ok')
+      });
+    }
+  });
+};
+
+/**
+ * Add regexp to grep, if `re` is a string it is escaped.
+ *
+ * @param {RegExp|String} re
+ * @return {Mocha}
+ * @api public
+ */
+
+Mocha.prototype.grep = function(re){
+  this.options.grep = 'string' == typeof re
+    ? new RegExp(escapeRe(re))
+    : re;
+  return this;
+};
+
+/**
+ * Invert `.grep()` matches.
+ *
+ * @return {Mocha}
+ * @api public
+ */
+
+Mocha.prototype.invert = function(){
+  this.options.invert = true;
+  return this;
+};
+
+/**
+ * Ignore global leaks.
+ *
+ * @param {Boolean} ignore
+ * @return {Mocha}
+ * @api public
+ */
+
+Mocha.prototype.ignoreLeaks = function(ignore){
+  this.options.ignoreLeaks = !!ignore;
+  return this;
+};
+
+/**
+ * Enable global leak checking.
+ *
+ * @return {Mocha}
+ * @api public
+ */
+
+Mocha.prototype.checkLeaks = function(){
+  this.options.ignoreLeaks = false;
+  return this;
+};
+
+/**
+ * Enable growl support.
+ *
+ * @return {Mocha}
+ * @api public
+ */
+
+Mocha.prototype.growl = function(){
+  this.options.growl = true;
+  return this;
+};
+
+/**
+ * Ignore `globals` array or string.
+ *
+ * @param {Array|String} globals
+ * @return {Mocha}
+ * @api public
+ */
+
+Mocha.prototype.globals = function(globals){
+  this.options.globals = (this.options.globals || []).concat(globals);
+  return this;
+};
+
+/**
+ * Emit color output.
+ *
+ * @param {Boolean} colors
+ * @return {Mocha}
+ * @api public
+ */
+
+Mocha.prototype.useColors = function(colors){
+  if (colors !== undefined) {
+    this.options.useColors = colors;
+  }
+  return this;
+};
+
+/**
+ * Use inline diffs rather than +/-.
+ *
+ * @param {Boolean} inlineDiffs
+ * @return {Mocha}
+ * @api public
+ */
+
+Mocha.prototype.useInlineDiffs = function(inlineDiffs) {
+  this.options.useInlineDiffs = arguments.length && inlineDiffs != undefined
+  ? inlineDiffs
+  : false;
+  return this;
+};
+
+/**
+ * Set the timeout in milliseconds.
+ *
+ * @param {Number} timeout
+ * @return {Mocha}
+ * @api public
+ */
+
+Mocha.prototype.timeout = function(timeout){
+  this.suite.timeout(timeout);
+  return this;
+};
+
+/**
+ * Set slowness threshold in milliseconds.
+ *
+ * @param {Number} slow
+ * @return {Mocha}
+ * @api public
+ */
+
+Mocha.prototype.slow = function(slow){
+  this.suite.slow(slow);
+  return this;
+};
+
+/**
+ * Enable timeouts.
+ *
+ * @param {Boolean} enabled
+ * @return {Mocha}
+ * @api public
+ */
+
+Mocha.prototype.enableTimeouts = function(enabled) {
+  this.suite.enableTimeouts(arguments.length && enabled !== undefined
+    ? enabled
+    : true);
+  return this
+};
+
+/**
+ * Makes all tests async (accepting a callback)
+ *
+ * @return {Mocha}
+ * @api public
+ */
+
+Mocha.prototype.asyncOnly = function(){
+  this.options.asyncOnly = true;
+  return this;
+};
+
+/**
+ * Disable syntax highlighting (in browser).
+ * @returns {Mocha}
+ * @api public
+ */
+Mocha.prototype.noHighlighting = function() {
+  this.options.noHighlighting = true;
+  return this;
+};
+
+/**
+ * Run tests and invoke `fn()` when complete.
+ *
+ * @param {Function} fn
+ * @return {Runner}
+ * @api public
+ */
+
+Mocha.prototype.run = function(fn){
+  if (this.files.length) this.loadFiles();
+  var suite = this.suite;
+  var options = this.options;
+  options.files = this.files;
+  var runner = new exports.Runner(suite);
+  var reporter = new this._reporter(runner, options);
+  runner.ignoreLeaks = false !== options.ignoreLeaks;
+  runner.asyncOnly = options.asyncOnly;
+  if (options.grep) runner.grep(options.grep, options.invert);
+  if (options.globals) runner.globals(options.globals);
+  if (options.growl) this._growl(runner, reporter);
+  if (options.useColors !== undefined) {
+    exports.reporters.Base.useColors = options.useColors;
+  }
+  exports.reporters.Base.inlineDiffs = options.useInlineDiffs;
+
+  function done(failures) {
+      if (reporter.done) {
+          reporter.done(failures, fn);
+      } else {
+          fn(failures);
+      }
+  }
+
+  return runner.run(done);
+};
+
+}); // module: mocha.js
+
+require.register("ms.js", function(module, exports, require){
+/**
+ * Helpers.
+ */
+
+var s = 1000;
+var m = s * 60;
+var h = m * 60;
+var d = h * 24;
+var y = d * 365.25;
+
+/**
+ * Parse or format the given `val`.
+ *
+ * Options:
+ *
+ *  - `long` verbose formatting [false]
+ *
+ * @param {String|Number} val
+ * @param {Object} options
+ * @return {String|Number}
+ * @api public
+ */
+
+module.exports = function(val, options){
+  options = options || {};
+  if ('string' == typeof val) return parse(val);
+  return options['long'] ? longFormat(val) : shortFormat(val);
+};
+
+/**
+ * Parse the given `str` and return milliseconds.
+ *
+ * @param {String} str
+ * @return {Number}
+ * @api private
+ */
+
+function parse(str) {
+  var match = /^((?:\d+)?\.?\d+) *(ms|seconds?|s|minutes?|m|hours?|h|days?|d|years?|y)?$/i.exec(str);
+  if (!match) return;
+  var n = parseFloat(match[1]);
+  var type = (match[2] || 'ms').toLowerCase();
+  switch (type) {
+    case 'years':
+    case 'year':
+    case 'y':
+      return n * y;
+    case 'days':
+    case 'day':
+    case 'd':
+      return n * d;
+    case 'hours':
+    case 'hour':
+    case 'h':
+      return n * h;
+    case 'minutes':
+    case 'minute':
+    case 'm':
+      return n * m;
+    case 'seconds':
+    case 'second':
+    case 's':
+      return n * s;
+    case 'ms':
+      return n;
+  }
+}
+
+/**
+ * Short format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
+
+function shortFormat(ms) {
+  if (ms >= d) return Math.round(ms / d) + 'd';
+  if (ms >= h) return Math.round(ms / h) + 'h';
+  if (ms >= m) return Math.round(ms / m) + 'm';
+  if (ms >= s) return Math.round(ms / s) + 's';
+  return ms + 'ms';
+}
+
+/**
+ * Long format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
+
+function longFormat(ms) {
+  return plural(ms, d, 'day')
+    || plural(ms, h, 'hour')
+    || plural(ms, m, 'minute')
+    || plural(ms, s, 'second')
+    || ms + ' ms';
+}
+
+/**
+ * Pluralization helper.
+ */
+
+function plural(ms, n, name) {
+  if (ms < n) return;
+  if (ms < n * 1.5) return Math.floor(ms / n) + ' ' + name;
+  return Math.ceil(ms / n) + ' ' + name + 's';
+}
+
+}); // module: ms.js
+
+require.register("reporters/base.js", function(module, exports, require){
+/**
+ * Module dependencies.
+ */
+
+var tty = require('browser/tty')
+  , diff = require('browser/diff')
+  , ms = require('../ms')
+  , utils = require('../utils');
+
+/**
+ * Save timer references to avoid Sinon interfering (see GH-237).
+ */
+
+var Date = global.Date
+  , setTimeout = global.setTimeout
+  , setInterval = global.setInterval
+  , clearTimeout = global.clearTimeout
+  , clearInterval = global.clearInterval;
+
+/**
+ * Check if both stdio streams are associated with a tty.
+ */
+
+var isatty = tty.isatty(1) && tty.isatty(2);
+
+/**
+ * Expose `Base`.
+ */
+
+exports = module.exports = Base;
+
+/**
+ * Enable coloring by default.
+ */
+
+exports.useColors = isatty || (process.env.MOCHA_COLORS !== undefined);
+
+/**
+ * Inline diffs instead of +/-
+ */
+
+exports.inlineDiffs = false;
+
+/**
+ * Default color map.
+ */
+
+exports.colors = {
+    'pass': 90
+  , 'fail': 31
+  , 'bright pass': 92
+  , 'bright fail': 91
+  , 'bright yellow': 93
+  , 'pending': 36
+  , 'suite': 0
+  , 'error title': 0
+  , 'error message': 31
+  , 'error stack': 90
+  , 'checkmark': 32
+  , 'fast': 90
+  , 'medium': 33
+  , 'slow': 31
+  , 'green': 32
+  , 'light': 90
+  , 'diff gutter': 90
+  , 'diff added': 42
+  , 'diff removed': 41
+};
+
+/**
+ * Default symbol map.
+ */
+
+exports.symbols = {
+  ok: '✓',
+  err: '✖',
+  dot: '․'
+};
+
+// With node.js on Windows: use symbols available in terminal default fonts
+if ('win32' == process.platform) {
+  exports.symbols.ok = '\u221A';
+  exports.symbols.err = '\u00D7';
+  exports.symbols.dot = '.';
+}
+
+/**
+ * Color `str` with the given `type`,
+ * allowing colors to be disabled,
+ * as well as user-defined color
+ * schemes.
+ *
+ * @param {String} type
+ * @param {String} str
+ * @return {String}
+ * @api private
+ */
+
+var color = exports.color = function(type, str) {
+  if (!exports.useColors) return String(str);
+  return '\u001b[' + exports.colors[type] + 'm' + str + '\u001b[0m';
+};
+
+/**
+ * Expose term window size, with some
+ * defaults for when stderr is not a tty.
+ */
+
+exports.window = {
+  width: isatty
+    ? process.stdout.getWindowSize
+      ? process.stdout.getWindowSize(1)[0]
+      : tty.getWindowSize()[1]
+    : 75
+};
+
+/**
+ * Expose some basic cursor interactions
+ * that are common among reporters.
+ */
+
+exports.cursor = {
+  hide: function(){
+    isatty && process.stdout.write('\u001b[?25l');
+  },
+
+  show: function(){
+    isatty && process.stdout.write('\u001b[?25h');
+  },
+
+  deleteLine: function(){
+    isatty && process.stdout.write('\u001b[2K');
+  },
+
+  beginningOfLine: function(){
+    isatty && process.stdout.write('\u001b[0G');
+  },
+
+  CR: function(){
+    if (isatty) {
+      exports.cursor.deleteLine();
+      exports.cursor.beginningOfLine();
+    } else {
+      process.stdout.write('\r');
+    }
+  }
+};
+
+/**
+ * Outut the given `failures` as a list.
+ *
+ * @param {Array} failures
+ * @api public
+ */
+
+exports.list = function(failures){
+  console.log();
+  failures.forEach(function(test, i){
+    // format
+    var fmt = color('error title', '  %s) %s:\n')
+      + color('error message', '     %s')
+      + color('error stack', '\n%s\n');
+
+    // msg
+    var err = test.err
+      , message = err.message || ''
+      , stack = err.stack || message
+      , index = stack.indexOf(message) + message.length
+      , msg = stack.slice(0, index)
+      , actual = err.actual
+      , expected = err.expected
+      , escape = true;
+
+    // uncaught
+    if (err.uncaught) {
+      msg = 'Uncaught ' + msg;
+    }
+
+    // explicitly show diff
+    if (err.showDiff && sameType(actual, expected)) {
+
+      if ('string' !== typeof actual) {
+        escape = false;
+        err.actual = actual = utils.stringify(actual);
+        err.expected = expected = utils.stringify(expected);
+      }
+
+      fmt = color('error title', '  %s) %s:\n%s') + color('error stack', '\n%s\n');
+      var match = message.match(/^([^:]+): expected/);
+      msg = '\n      ' + color('error message', match ? match[1] : msg);
+
+      if (exports.inlineDiffs) {
+        msg += inlineDiff(err, escape);
+      } else {
+        msg += unifiedDiff(err, escape);
+      }
+    }
+
+    // indent stack trace without msg
+    stack = stack.slice(index ? index + 1 : index)
+      .replace(/^/gm, '  ');
+
+    console.log(fmt, (i + 1), test.fullTitle(), msg, stack);
+  });
+};
+
+/**
+ * Initialize a new `Base` reporter.
+ *
+ * All other reporters generally
+ * inherit from this reporter, providing
+ * stats such as test duration, number
+ * of tests passed / failed etc.
+ *
+ * @param {Runner} runner
+ * @api public
+ */
+
+function Base(runner) {
+  var self = this
+    , stats = this.stats = { suites: 0, tests: 0, passes: 0, pending: 0, failures: 0 }
+    , failures = this.failures = [];
+
+  if (!runner) return;
+  this.runner = runner;
+
+  runner.stats = stats;
+
+  runner.on('start', function(){
+    stats.start = new Date;
+  });
+
+  runner.on('suite', function(suite){
+    stats.suites = stats.suites || 0;
+    suite.root || stats.suites++;
+  });
+
+  runner.on('test end', function(test){
+    stats.tests = stats.tests || 0;
+    stats.tests++;
+  });
+
+  runner.on('pass', function(test){
+    stats.passes = stats.passes || 0;
+
+    var medium = test.slow() / 2;
+    test.speed = test.duration > test.slow()
+      ? 'slow'
+      : test.duration > medium
+        ? 'medium'
+        : 'fast';
+
+    stats.passes++;
+  });
+
+  runner.on('fail', function(test, err){
+    stats.failures = stats.failures || 0;
+    stats.failures++;
+    test.err = err;
+    failures.push(test);
+  });
+
+  runner.on('end', function(){
+    stats.end = new Date;
+    stats.duration = new Date - stats.start;
+  });
+
+  runner.on('pending', function(){
+    stats.pending++;
+  });
+}
+
+/**
+ * Output common epilogue used by many of
+ * the bundled reporters.
+ *
+ * @api public
+ */
+
+Base.prototype.epilogue = function(){
+  var stats = this.stats;
+  var tests;
+  var fmt;
+
+  console.log();
+
+  // passes
+  fmt = color('bright pass', ' ')
+    + color('green', ' %d passing')
+    + color('light', ' (%s)');
+
+  console.log(fmt,
+    stats.passes || 0,
+    ms(stats.duration));
+
+  // pending
+  if (stats.pending) {
+    fmt = color('pending', ' ')
+      + color('pending', ' %d pending');
+
+    console.log(fmt, stats.pending);
+  }
+
+  // failures
+  if (stats.failures) {
+    fmt = color('fail', '  %d failing');
+
+    console.log(fmt, stats.failures);
+
+    Base.list(this.failures);
+    console.log();
+  }
+
+  console.log();
+};
+
+/**
+ * Pad the given `str` to `len`.
+ *
+ * @param {String} str
+ * @param {String} len
+ * @return {String}
+ * @api private
+ */
+
+function pad(str, len) {
+  str = String(str);
+  return Array(len - str.length + 1).join(' ') + str;
+}
+
+
+/**
+ * Returns an inline diff between 2 strings with coloured ANSI output
+ *
+ * @param {Error} Error with actual/expected
+ * @return {String} Diff
+ * @api private
+ */
+
+function inlineDiff(err, escape) {
+  var msg = errorDiff(err, 'WordsWithSpace', escape);
+
+  // linenos
+  var lines = msg.split('\n');
+  if (lines.length > 4) {
+    var width = String(lines.length).length;
+    msg = lines.map(function(str, i){
+      return pad(++i, width) + ' |' + ' ' + str;
+    }).join('\n');
+  }
+
+  // legend
+  msg = '\n'
+    + color('diff removed', 'actual')
+    + ' '
+    + color('diff added', 'expected')
+    + '\n\n'
+    + msg
+    + '\n';
+
+  // indent
+  msg = msg.replace(/^/gm, '      ');
+  return msg;
+}
+
+/**
+ * Returns a unified diff between 2 strings
+ *
+ * @param {Error} Error with actual/expected
+ * @return {String} Diff
+ * @api private
+ */
+
+function unifiedDiff(err, escape) {
+  var indent = '      ';
+  function cleanUp(line) {
+    if (escape) {
+      line = escapeInvisibles(line);
+    }
+    if (line[0] === '+') return indent + colorLines('diff added', line);
+    if (line[0] === '-') return indent + colorLines('diff removed', line);
+    if (line.match(/\@\@/)) return null;
+    if (line.match(/\\ No newline/)) return null;
+    else return indent + line;
+  }
+  function notBlank(line) {
+    return line != null;
+  }
+  msg = diff.createPatch('string', err.actual, err.expected);
+  var lines = msg.split('\n').splice(4);
+  return '\n      '
+         + colorLines('diff added',   '+ expected') + ' '
+         + colorLines('diff removed', '- actual')
+         + '\n\n'
+         + lines.map(cleanUp).filter(notBlank).join('\n');
+}
+
+/**
+ * Return a character diff for `err`.
+ *
+ * @param {Error} err
+ * @return {String}
+ * @api private
+ */
+
+function errorDiff(err, type, escape) {
+  var actual   = escape ? escapeInvisibles(err.actual)   : err.actual;
+  var expected = escape ? escapeInvisibles(err.expected) : err.expected;
+  return diff['diff' + type](actual, expected).map(function(str){
+    if (str.added) return colorLines('diff added', str.value);
+    if (str.removed) return colorLines('diff removed', str.value);
+    return str.value;
+  }).join('');
+}
+
+/**
+ * Returns a string with all invisible characters in plain text
+ *
+ * @param {String} line
+ * @return {String}
+ * @api private
+ */
+function escapeInvisibles(line) {
+    return line.replace(/\t/g, '<tab>')
+               .replace(/\r/g, '<CR>')
+               .replace(/\n/g, '<LF>\n');
+}
+
+/**
+ * Color lines for `str`, using the color `name`.
+ *
+ * @param {String} name
+ * @param {String} str
+ * @return {String}
+ * @api private
+ */
+
+function colorLines(name, str) {
+  return str.split('\n').map(function(str){
+    return color(name, str);
+  }).join('\n');
+}
+
+/**
+ * Check that a / b have the same type.
+ *
+ * @param {Object} a
+ * @param {Object} b
+ * @return {Boolean}
+ * @api private
+ */
+
+function sameType(a, b) {
+  a = Object.prototype.toString.call(a);
+  b = Object.prototype.toString.call(b);
+  return a == b;
+}
+
+}); // module: reporters/base.js
+
+require.register("reporters/doc.js", function(module, exports, require){
+/**
+ * Module dependencies.
+ */
+
+var Base = require('./base')
+  , utils = require('../utils');
+
+/**
+ * Expose `Doc`.
+ */
+
+exports = module.exports = Doc;
+
+/**
+ * Initialize a new `Doc` reporter.
+ *
+ * @param {Runner} runner
+ * @api public
+ */
+
+function Doc(runner) {
+  Base.call(this, runner);
+
+  var self = this
+    , stats = this.stats
+    , total = runner.total
+    , indents = 2;
+
+  function indent() {
+    return Array(indents).join('  ');
+  }
+
+  runner.on('suite', function(suite){
+    if (suite.root) return;
+    ++indents;
+    console.log('%s<section class="suite">', indent());
+    ++indents;
+    console.log('%s<h1>%s</h1>', indent(), utils.escape(suite.title));
+    console.log('%s<dl>', indent());
+  });
+
+  runner.on('suite end', function(suite){
+    if (suite.root) return;
+    console.log('%s</dl>', indent());
+    --indents;
+    console.log('%s</section>', indent());
+    --indents;
+  });
+
+  runner.on('pass', function(test){
+    console.log('%s  <dt>%s</dt>', indent(), utils.escape(test.title));
+    var code = utils.escape(utils.clean(test.fn.toString()));
+    console.log('%s  <dd><pre><code>%s</code></pre></dd>', indent(), code);
+  });
+
+  runner.on('fail', function(test, err){
+    console.log('%s  <dt class="error">%s</dt>', indent(), utils.escape(test.title));
+    var code = utils.escape(utils.clean(test.fn.toString()));
+    console.log('%s  <dd class="error"><pre><code>%s</code></pre></dd>', indent(), code);
+    console.log('%s  <dd class="error">%s</dd>', indent(), utils.escape(err));
+  });
+}
+
+}); // module: reporters/doc.js
+
+require.register("reporters/dot.js", function(module, exports, require){
+/**
+ * Module dependencies.
+ */
+
+var Base = require('./base')
+  , color = Base.color;
+
+/**
+ * Expose `Dot`.
+ */
+
+exports = module.exports = Dot;
+
+/**
+ * Initialize a new `Dot` matrix test reporter.
+ *
+ * @param {Runner} runner
+ * @api public
+ */
+
+function Dot(runner) {
+  Base.call(this, runner);
+
+  var self = this
+    , stats = this.stats
+    , width = Base.window.width * .75 | 0
+    , n = -1;
+
+  runner.on('start', function(){
+    process.stdout.write('\n  ');
+  });
+
+  runner.on('pending', function(test){
+    if (++n % width == 0) process.stdout.write('\n  ');
+    process.stdout.write(color('pending', Base.symbols.dot));
+  });
+
+  runner.on('pass', function(test){
+    if (++n % width == 0) process.stdout.write('\n  ');
+    if ('slow' == test.speed) {
+      process.stdout.write(color('bright yellow', Base.symbols.dot));
+    } else {
+      process.stdout.write(color(test.speed, Base.symbols.dot));
+    }
+  });
+
+  runner.on('fail', function(test, err){
+    if (++n % width == 0) process.stdout.write('\n  ');
+    process.stdout.write(color('fail', Base.symbols.dot));
+  });
+
+  runner.on('end', function(){
+    console.log();
+    self.epilogue();
+  });
+}
+
+/**
+ * Inherit from `Base.prototype`.
+ */
+
+function F(){};
+F.prototype = Base.prototype;
+Dot.prototype = new F;
+Dot.prototype.constructor = Dot;
+
+
+}); // module: reporters/dot.js
+
+require.register("reporters/html-cov.js", function(module, exports, require){
+/**
+ * Module dependencies.
+ */
+
+var JSONCov = require('./json-cov')
+  , fs = require('browser/fs');
+
+/**
+ * Expose `HTMLCov`.
+ */
+
+exports = module.exports = HTMLCov;
+
+/**
+ * Initialize a new `JsCoverage` reporter.
+ *
+ * @param {Runner} runner
+ * @api public
+ */
+
+function HTMLCov(runner) {
+  var jade = require('jade')
+    , file = __dirname + '/templates/coverage.jade'
+    , str = fs.readFileSync(file, 'utf8')
+    , fn = jade.compile(str, { filename: file })
+    , self = this;
+
+  JSONCov.call(this, runner, false);
+
+  runner.on('end', function(){
+    process.stdout.write(fn({
+        cov: self.cov
+      , coverageClass: coverageClass
+    }));
+  });
+}
+
+/**
+ * Return coverage class for `n`.
+ *
+ * @return {String}
+ * @api private
+ */
+
+function coverageClass(n) {
+  if (n >= 75) return 'high';
+  if (n >= 50) return 'medium';
+  if (n >= 25) return 'low';
+  return 'terrible';
+}
+
+}); // module: reporters/html-cov.js
+
+require.register("reporters/html.js", function(module, exports, require){
+/**
+ * Module dependencies.
+ */
+
+var Base = require('./base')
+  , utils = require('../utils')
+  , Progress = require('../browser/progress')
+  , escape = utils.escape;
+
+/**
+ * Save timer references to avoid Sinon interfering (see GH-237).
+ */
+
+var Date = global.Date
+  , setTimeout = global.setTimeout
+  , setInterval = global.setInterval
+  , clearTimeout = global.clearTimeout
+  , clearInterval = global.clearInterval;
+
+/**
+ * Expose `HTML`.
+ */
+
+exports = module.exports = HTML;
+
+/**
+ * Stats template.
+ */
+
+var statsTemplate = '<ul id="mocha-stats">'
+  + '<li class="progress"><canvas width="40" height="40"></canvas></li>'
+  + '<li class="passes"><a href="#">passes:</a> <em>0</em></li>'
+  + '<li class="failures"><a href="#">failures:</a> <em>0</em></li>'
+  + '<li class="duration">duration: <em>0</em>s</li>'
+  + '</ul>';
+
+/**
+ * Initialize a new `HTML` reporter.
+ *
+ * @param {Runner} runner
+ * @api public
+ */
+
+function HTML(runner) {
+  Base.call(this, runner);
+
+  var self = this
+    , stats = this.stats
+    , total = runner.total
+    , stat = fragment(statsTemplate)
+    , items = stat.getElementsByTagName('li')
+    , passes = items[1].getElementsByTagName('em')[0]
+    , passesLink = items[1].getElementsByTagName('a')[0]
+    , failures = items[2].getElementsByTagName('em')[0]
+    , failuresLink = items[2].getElementsByTagName('a')[0]
+    , duration = items[3].getElementsByTagName('em')[0]
+    , canvas = stat.getElementsByTagName('canvas')[0]
+    , report = fragment('<ul id="mocha-report"></ul>')
+    , stack = [report]
+    , progress
+    , ctx
+    , root = document.getElementById('mocha');
+
+  if (canvas.getContext) {
+    var ratio = window.devicePixelRatio || 1;
+    canvas.style.width = canvas.width;
+    canvas.style.height = canvas.height;
+    canvas.width *= ratio;
+    canvas.height *= ratio;
+    ctx = canvas.getContext('2d');
+    ctx.scale(ratio, ratio);
+    progress = new Progress;
+  }
+
+  if (!root) return error('#mocha div missing, add it to your document');
+
+  // pass toggle
+  on(passesLink, 'click', function(){
+    unhide();
+    var name = /pass/.test(report.className) ? '' : ' pass';
+    report.className = report.className.replace(/fail|pass/g, '') + name;
+    if (report.className.trim()) hideSuitesWithout('test pass');
+  });
+
+  // failure toggle
+  on(failuresLink, 'click', function(){
+    unhide();
+    var name = /fail/.test(report.className) ? '' : ' fail';
+    report.className = report.className.replace(/fail|pass/g, '') + name;
+    if (report.className.trim()) hideSuitesWithout('test fail');
+  });
+
+  root.appendChild(stat);
+  root.appendChild(report);
+
+  if (progress) progress.size(40);
+
+  runner.on('suite', function(suite){
+    if (suite.root) return;
+
+    // suite
+    var url = self.suiteURL(suite);
+    var el = fragment('<li class="suite"><h1><a href="%s">%s</a></h1></li>', url, escape(suite.title));
+
+    // container
+    stack[0].appendChild(el);
+    stack.unshift(document.createElement('ul'));
+    el.appendChild(stack[0]);
+  });
+
+  runner.on('suite end', function(suite){
+    if (suite.root) return;
+    stack.shift();
+  });
+
+  runner.on('fail', function(test, err){
+    if ('hook' == test.type) runner.emit('test end', test);
+  });
+
+  runner.on('test end', function(test){
+    // TODO: add to stats
+    var percent = stats.tests / this.total * 100 | 0;
+    if (progress) progress.update(percent).draw(ctx);
+
+    // update stats
+    var ms = new Date - stats.start;
+    text(passes, stats.passes);
+    text(failures, stats.failures);
+    text(duration, (ms / 1000).toFixed(2));
+
+    // test
+    if ('passed' == test.state) {
+      var url = self.testURL(test);
+      var el = fragment('<li class="test pass %e"><h2>%e<span class="duration">%ems</span> <a href="%s" class="replay">‣</a></h2></li>', test.speed, test.title, test.duration, url);
+    } else if (test.pending) {
+      var el = fragment('<li class="test pass pending"><h2>%e</h2></li>', test.title);
+    } else {
+      var el = fragment('<li class="test fail"><h2>%e <a href="%e" class="replay">‣</a></h2></li>', test.title, self.testURL(test));
+      var str = test.err.stack || test.err.toString();
+
+      // FF / Opera do not add the message
+      if (!~str.indexOf(test.err.message)) {
+        str = test.err.message + '\n' + str;
+      }
+
+      // <=IE7 stringifies to [Object Error]. Since it can be overloaded, we
+      // check for the result of the stringifying.
+      if ('[object Error]' == str) str = test.err.message;
+
+      // Safari doesn't give you a stack. Let's at least provide a source line.
+      if (!test.err.stack && test.err.sourceURL && test.err.line !== undefined) {
+        str += "\n(" + test.err.sourceURL + ":" + test.err.line + ")";
+      }
+
+      el.appendChild(fragment('<pre class="error">%e</pre>', str));
+    }
+
+    // toggle code
+    // TODO: defer
+    if (!test.pending) {
+      var h2 = el.getElementsByTagName('h2')[0];
+
+      on(h2, 'click', function(){
+        pre.style.display = 'none' == pre.style.display
+          ? 'block'
+          : 'none';
+      });
+
+      var pre = fragment('<pre><code>%e</code></pre>', utils.clean(test.fn.toString()));
+      el.appendChild(pre);
+      pre.style.display = 'none';
+    }
+
+    // Don't call .appendChild if #mocha-report was already .shift()'ed off the stack.
+    if (stack[0]) stack[0].appendChild(el);
+  });
+}
+
+/**
+ * Makes a URL, preserving querystring ("search") parameters.
+ * @param {string} s
+ * @returns {string} your new URL
+ */
+var makeUrl = function makeUrl(s) {
+  var search = window.location.search;
+  return window.location.pathname + (search ? search + '&' : '?' ) + 'grep=' + encodeURIComponent(s);
+};
+
+/**
+ * Provide suite URL
+ *
+ * @param {Object} [suite]
+ */
+HTML.prototype.suiteURL = function(suite){
+  return makeUrl(suite.fullTitle());
+};
+
+/**
+ * Provide test URL
+ *
+ * @param {Object} [test]
+ */
+
+HTML.prototype.testURL = function(test){
+  return makeUrl(test.fullTitle());
+};
+
+/**
+ * Display error `msg`.
+ */
+
+function error(msg) {
+  document.body.appendChild(fragment('<div id="mocha-error">%s</div>', msg));
+}
+
+/**
+ * Return a DOM fragment from `html`.
+ */
+
+function fragment(html) {
+  var args = arguments
+    , div = document.createElement('div')
+    , i = 1;
+
+  div.innerHTML = html.replace(/%([se])/g, function(_, type){
+    switch (type) {
+      case 's': return String(args[i++]);
+      case 'e': return escape(args[i++]);
+    }
+  });
+
+  return div.firstChild;
+}
+
+/**
+ * Check for suites that do not have elements
+ * with `classname`, and hide them.
+ */
+
+function hideSuitesWithout(classname) {
+  var suites = document.getElementsByClassName('suite');
+  for (var i = 0; i < suites.length; i++) {
+    var els = suites[i].getElementsByClassName(classname);
+    if (0 == els.length) suites[i].className += ' hidden';
+  }
+}
+
+/**
+ * Unhide .hidden suites.
+ */
+
+function unhide() {
+  var els = document.getElementsByClassName('suite hidden');
+  for (var i = 0; i < els.length; ++i) {
+    els[i].className = els[i].className.replace('suite hidden', 'suite');
+  }
+}
+
+/**
+ * Set `el` text to `str`.
+ */
+
+function text(el, str) {
+  if (el.textContent) {
+    el.textContent = str;
+  } else {
+    el.innerText = str;
+  }
+}
+
+/**
+ * Listen on `event` with callback `fn`.
+ */
+
+function on(el, event, fn) {
+  if (el.addEventListener) {
+    el.addEventListener(event, fn, false);
+  } else {
+    el.attachEvent('on' + event, fn);
+  }
+}
+
+}); // module: reporters/html.js
+
+require.register("reporters/index.js", function(module, exports, require){
+exports.Base = require('./base');
+exports.Dot = require('./dot');
+exports.Doc = require('./doc');
+exports.TAP = require('./tap');
+exports.JSON = require('./json');
+exports.HTML = require('./html');
+exports.List = require('./list');
+exports.Min = require('./min');
+exports.Spec = require('./spec');
+exports.Nyan = require('./nyan');
+exports.XUnit = require('./xunit');
+exports.Markdown = require('./markdown');
+exports.Progress = require('./progress');
+exports.Landing = require('./landing');
+exports.JSONCov = require('./json-cov');
+exports.HTMLCov = require('./html-cov');
+exports.JSONStream = require('./json-stream');
+
+}); // module: reporters/index.js
+
+require.register("reporters/json-cov.js", function(module, exports, require){
+/**
+ * Module dependencies.
+ */
+
+var Base = require('./base');
+
+/**
+ * Expose `JSONCov`.
+ */
+
+exports = module.exports = JSONCov;
+
+/**
+ * Initialize a new `JsCoverage` reporter.
+ *
+ * @param {Runner} runner
+ * @param {Boolean} output
+ * @api public
+ */
+
+function JSONCov(runner, output) {
+  var self = this
+    , output = 1 == arguments.length ? true : output;
+
+  Base.call(this, runner);
+
+  var tests = []
+    , failures = []
+    , passes = [];
+
+  runner.on('test end', function(test){
+    tests.push(test);
+  });
+
+  runner.on('pass', function(test){
+    passes.push(test);
+  });
+
+  runner.on('fail', function(test){
+    failures.push(test);
+  });
+
+  runner.on('end', function(){
+    var cov = global._$jscoverage || {};
+    var result = self.cov = map(cov);
+    result.stats = self.stats;
+    result.tests = tests.map(clean);
+    result.failures = failures.map(clean);
+    result.passes = passes.map(clean);
+    if (!output) return;
+    process.stdout.write(JSON.stringify(result, null, 2 ));
+  });
+}
+
+/**
+ * Map jscoverage data to a JSON structure
+ * suitable for reporting.
+ *
+ * @param {Object} cov
+ * @return {Object}
+ * @api private
+ */
+
+function map(cov) {
+  var ret = {
+      instrumentation: 'node-jscoverage'
+    , sloc: 0
+    , hits: 0
+    , misses: 0
+    , coverage: 0
+    , files: []
+  };
+
+  for (var filename in cov) {
+    var data = coverage(filename, cov[filename]);
+    ret.files.push(data);
+    ret.hits += data.hits;
+    ret.misses += data.misses;
+    ret.sloc += data.sloc;
+  }
+
+  ret.files.sort(function(a, b) {
+    return a.filename.localeCompare(b.filename);
+  });
+
+  if (ret.sloc > 0) {
+    ret.coverage = (ret.hits / ret.sloc) * 100;
+  }
+
+  return ret;
+}
+
+/**
+ * Map jscoverage data for a single source file
+ * to a JSON structure suitable for reporting.
+ *
+ * @param {String} filename name of the source file
+ * @param {Object} data jscoverage coverage data
+ * @return {Object}
+ * @api private
+ */
+
+function coverage(filename, data) {
+  var ret = {
+    filename: filename,
+    coverage: 0,
+    hits: 0,
+    misses: 0,
+    sloc: 0,
+    source: {}
+  };
+
+  data.source.forEach(function(line, num){
+    num++;
+
+    if (data[num] === 0) {
+      ret.misses++;
+      ret.sloc++;
+    } else if (data[num] !== undefined) {
+      ret.hits++;
+      ret.sloc++;
+    }
+
+    ret.source[num] = {
+        source: line
+      , coverage: data[num] === undefined
+        ? ''
+        : data[num]
+    };
+  });
+
+  ret.coverage = ret.hits / ret.sloc * 100;
+
+  return ret;
+}
+
+/**
+ * Return a plain-object representation of `test`
+ * free of cyclic properties etc.
+ *
+ * @param {Object} test
+ * @return {Object}
+ * @api private
+ */
+
+function clean(test) {
+  return {
+      title: test.title
+    , fullTitle: test.fullTitle()
+    , duration: test.duration
+  }
+}
+
+}); // module: reporters/json-cov.js
+
+require.register("reporters/json-stream.js", function(module, exports, require){
+/**
+ * Module dependencies.
+ */
+
+var Base = require('./base')
+  , color = Base.color;
+
+/**
+ * Expose `List`.
+ */
+
+exports = module.exports = List;
+
+/**
+ * Initialize a new `List` test reporter.
+ *
+ * @param {Runner} runner
+ * @api public
+ */
+
+function List(runner) {
+  Base.call(this, runner);
+
+  var self = this
+    , stats = this.stats
+    , total = runner.total;
+
+  runner.on('start', function(){
+    console.log(JSON.stringify(['start', { total: total }]));
+  });
+
+  runner.on('pass', function(test){
+    console.log(JSON.stringify(['pass', clean(test)]));
+  });
+
+  runner.on('fail', function(test, err){
+    test = clean(test);
+    test.err = err.message;
+    console.log(JSON.stringify(['fail', test]));
+  });
+
+  runner.on('end', function(){
+    process.stdout.write(JSON.stringify(['end', self.stats]));
+  });
+}
+
+/**
+ * Return a plain-object representation of `test`
+ * free of cyclic properties etc.
+ *
+ * @param {Object} test
+ * @return {Object}
+ * @api private
+ */
+
+function clean(test) {
+  return {
+      title: test.title
+    , fullTitle: test.fullTitle()
+    , duration: test.duration
+  }
+}
+
+}); // module: reporters/json-stream.js
+
+require.register("reporters/json.js", function(module, exports, require){
+/**
+ * Module dependencies.
+ */
+
+var Base = require('./base')
+  , cursor = Base.cursor
+  , color = Base.color;
+
+/**
+ * Expose `JSON`.
+ */
+
+exports = module.exports = JSONReporter;
+
+/**
+ * Initialize a new `JSON` reporter.
+ *
+ * @param {Runner} runner
+ * @api public
+ */
+
+function JSONReporter(runner) {
+  var self = this;
+  Base.call(this, runner);
+
+  var tests = []
+    , pending = []
+    , failures = []
+    , passes = [];
+
+  runner.on('test end', function(test){
+    tests.push(test);
+  });
+
+  runner.on('pass', function(test){
+    passes.push(test);
+  });
+
+  runner.on('fail', function(test){
+    failures.push(test);
+  });
+
+  runner.on('pending', function(test){
+    pending.push(test);
+  });
+
+  runner.on('end', function(){
+    var obj = {
+      stats: self.stats,
+      tests: tests.map(clean),
+      pending: pending.map(clean),
+      failures: failures.map(clean),
+      passes: passes.map(clean)
+    };
+
+    runner.testResults = obj;
+
+    process.stdout.write(JSON.stringify(obj, null, 2));
+  });
+}
+
+/**
+ * Return a plain-object representation of `test`
+ * free of cyclic properties etc.
+ *
+ * @param {Object} test
+ * @return {Object}
+ * @api private
+ */
+
+function clean(test) {
+  return {
+    title: test.title,
+    fullTitle: test.fullTitle(),
+    duration: test.duration,
+    err: errorJSON(test.err || {})
+  }
+}
+
+/**
+ * Transform `error` into a JSON object.
+ * @param {Error} err
+ * @return {Object}
+ */
+
+function errorJSON(err) {
+  var res = {};
+  Object.getOwnPropertyNames(err).forEach(function(key) {
+    res[key] = err[key];
+  }, err);
+  return res;
+}
+
+}); // module: reporters/json.js
+
+require.register("reporters/landing.js", function(module, exports, require){
+/**
+ * Module dependencies.
+ */
+
+var Base = require('./base')
+  , cursor = Base.cursor
+  , color = Base.color;
+
+/**
+ * Expose `Landing`.
+ */
+
+exports = module.exports = Landing;
+
+/**
+ * Airplane color.
+ */
+
+Base.colors.plane = 0;
+
+/**
+ * Airplane crash color.
+ */
+
+Base.colors['plane crash'] = 31;
+
+/**
+ * Runway color.
+ */
+
+Base.colors.runway = 90;
+
+/**
+ * Initialize a new `Landing` reporter.
+ *
+ * @param {Runner} runner
+ * @api public
+ */
+
+function Landing(runner) {
+  Base.call(this, runner);
+
+  var self = this
+    , stats = this.stats
+    , width = Base.window.width * .75 | 0
+    , total = runner.total
+    , stream = process.stdout
+    , plane = color('plane', '✈')
+    , crashed = -1
+    , n = 0;
+
+  function runway() {
+    var buf = Array(width).join('-');
+    return '  ' + color('runway', buf);
+  }
+
+  runner.on('start', function(){
+    stream.write('\n\n\n  ');
+    cursor.hide();
+  });
+
+  runner.on('test end', function(test){
+    // check if the plane crashed
+    var col = -1 == crashed
+      ? width * ++n / total | 0
+      : crashed;
+
+    // show the crash
+    if ('failed' == test.state) {
+      plane = color('plane crash', '✈');
+      crashed = col;
+    }
+
+    // render landing strip
+    stream.write('\u001b['+(width+1)+'D\u001b[2A');
+    stream.write(runway());
+    stream.write('\n  ');
+    stream.write(color('runway', Array(col).join('⋅')));
+    stream.write(plane)
+    stream.write(color('runway', Array(width - col).join('⋅') + '\n'));
+    stream.write(runway());
+    stream.write('\u001b[0m');
+  });
+
+  runner.on('end', function(){
+    cursor.show();
+    console.log();
+    self.epilogue();
+  });
+}
+
+/**
+ * Inherit from `Base.prototype`.
+ */
+
+function F(){};
+F.prototype = Base.prototype;
+Landing.prototype = new F;
+Landing.prototype.constructor = Landing;
+
+
+}); // module: reporters/landing.js
+
+require.register("reporters/list.js", function(module, exports, require){
+/**
+ * Module dependencies.
+ */
+
+var Base = require('./base')
+  , cursor = Base.cursor
+  , color = Base.color;
+
+/**
+ * Expose `List`.
+ */
+
+exports = module.exports = List;
+
+/**
+ * Initialize a new `List` test reporter.
+ *
+ * @param {Runner} runner
+ * @api public
+ */
+
+function List(runner) {
+  Base.call(this, runner);
+
+  var self = this
+    , stats = this.stats
+    , n = 0;
+
+  runner.on('start', function(){
+    console.log();
+  });
+
+  runner.on('test', function(test){
+    process.stdout.write(color('pass', '    ' + test.fullTitle() + ': '));
+  });
+
+  runner.on('pending', function(test){
+    var fmt = color('checkmark', '  -')
+      + color('pending', ' %s');
+    console.log(fmt, test.fullTitle());
+  });
+
+  runner.on('pass', function(test){
+    var fmt = color('checkmark', '  '+Base.symbols.dot)
+      + color('pass', ' %s: ')
+      + color(test.speed, '%dms');
+    cursor.CR();
+    console.log(fmt, test.fullTitle(), test.duration);
+  });
+
+  runner.on('fail', function(test, err){
+    cursor.CR();
+    console.log(color('fail', '  %d) %s'), ++n, test.fullTitle());
+  });
+
+  runner.on('end', self.epilogue.bind(self));
+}
+
+/**
+ * Inherit from `Base.prototype`.
+ */
+
+function F(){};
+F.prototype = Base.prototype;
+List.prototype = new F;
+List.prototype.constructor = List;
+
+
+}); // module: reporters/list.js
+
+require.register("reporters/markdown.js", function(module, exports, require){
+/**
+ * Module dependencies.
+ */
+
+var Base = require('./base')
+  , utils = require('../utils');
+
+/**
+ * Constants
+ */
+
+var SUITE_PREFIX = '$';
+
+/**
+ * Expose `Markdown`.
+ */
+
+exports = module.exports = Markdown;
+
+/**
+ * Initialize a new `Markdown` reporter.
+ *
+ * @param {Runner} runner
+ * @api public
+ */
+
+function Markdown(runner) {
+  Base.call(this, runner);
+
+  var self = this
+    , stats = this.stats
+    , level = 0
+    , buf = '';
+
+  function title(str) {
+    return Array(level).join('#') + ' ' + str;
+  }
+
+  function indent() {
+    return Array(level).join('  ');
+  }
+
+  function mapTOC(suite, obj) {
+    var ret = obj,
+        key = SUITE_PREFIX + suite.title;
+    obj = obj[key] = obj[key] || { suite: suite };
+    suite.suites.forEach(function(suite){
+      mapTOC(suite, obj);
+    });
+    return ret;
+  }
+
+  function stringifyTOC(obj, level) {
+    ++level;
+    var buf = '';
+    var link;
+    for (var key in obj) {
+      if ('suite' == key) continue;
+      if (key !== SUITE_PREFIX) {
+        link = ' - [' + key.substring(1) + ']';
+        link += '(#' + utils.slug(obj[key].suite.fullTitle()) + ')\n';
+        buf += Array(level).join('  ') + link;
+      }
+      buf += stringifyTOC(obj[key], level);
+    }
+    return buf;
+  }
+
+  function generateTOC(suite) {
+    var obj = mapTOC(suite, {});
+    return stringifyTOC(obj, 0);
+  }
+
+  generateTOC(runner.suite);
+
+  runner.on('suite', function(suite){
+    ++level;
+    var slug = utils.slug(suite.fullTitle());
+    buf += '<a name="' + slug + '"></a>' + '\n';
+    buf += title(suite.title) + '\n';
+  });
+
+  runner.on('suite end', function(suite){
+    --level;
+  });
+
+  runner.on('pass', function(test){
+    var code = utils.clean(test.fn.toString());
+    buf += test.title + '.\n';
+    buf += '\n```js\n';
+    buf += code + '\n';
+    buf += '```\n\n';
+  });
+
+  runner.on('end', function(){
+    process.stdout.write('# TOC\n');
+    process.stdout.write(generateTOC(runner.suite));
+    process.stdout.write(buf);
+  });
+}
+
+}); // module: reporters/markdown.js
+
+require.register("reporters/min.js", function(module, exports, require){
+/**
+ * Module dependencies.
+ */
+
+var Base = require('./base');
+
+/**
+ * Expose `Min`.
+ */
+
+exports = module.exports = Min;
+
+/**
+ * Initialize a new `Min` minimal test reporter (best used with --watch).
+ *
+ * @param {Runner} runner
+ * @api public
+ */
+
+function Min(runner) {
+  Base.call(this, runner);
+
+  runner.on('start', function(){
+    // clear screen
+    process.stdout.write('\u001b[2J');
+    // set cursor position
+    process.stdout.write('\u001b[1;3H');
+  });
+
+  runner.on('end', this.epilogue.bind(this));
+}
+
+/**
+ * Inherit from `Base.prototype`.
+ */
+
+function F(){};
+F.prototype = Base.prototype;
+Min.prototype = new F;
+Min.prototype.constructor = Min;
+
+
+}); // module: reporters/min.js
+
+require.register("reporters/nyan.js", function(module, exports, require){
+/**
+ * Module dependencies.
+ */
+
+var Base = require('./base');
+
+/**
+ * Expose `Dot`.
+ */
+
+exports = module.exports = NyanCat;
+
+/**
+ * Initialize a new `Dot` matrix test reporter.
+ *
+ * @param {Runner} runner
+ * @api public
+ */
+
+function NyanCat(runner) {
+  Base.call(this, runner);
+  var self = this
+    , stats = this.stats
+    , width = Base.window.width * .75 | 0
+    , rainbowColors = this.rainbowColors = self.generateColors()
+    , colorIndex = this.colorIndex = 0
+    , numerOfLines = this.numberOfLines = 4
+    , trajectories = this.trajectories = [[], [], [], []]
+    , nyanCatWidth = this.nyanCatWidth = 11
+    , trajectoryWidthMax = this.trajectoryWidthMax = (width - nyanCatWidth)
+    , scoreboardWidth = this.scoreboardWidth = 5
+    , tick = this.tick = 0
+    , n = 0;
+
+  runner.on('start', function(){
+    Base.cursor.hide();
+    self.draw();
+  });
+
+  runner.on('pending', function(test){
+    self.draw();
+  });
+
+  runner.on('pass', function(test){
+    self.draw();
+  });
+
+  runner.on('fail', function(test, err){
+    self.draw();
+  });
+
+  runner.on('end', function(){
+    Base.cursor.show();
+    for (var i = 0; i < self.numberOfLines; i++) write('\n');
+    self.epilogue();
+  });
+}
+
+/**
+ * Draw the nyan cat
+ *
+ * @api private
+ */
+
+NyanCat.prototype.draw = function(){
+  this.appendRainbow();
+  this.drawScoreboard();
+  this.drawRainbow();
+  this.drawNyanCat();
+  this.tick = !this.tick;
+};
+
+/**
+ * Draw the "scoreboard" showing the number
+ * of passes, failures and pending tests.
+ *
+ * @api private
+ */
+
+NyanCat.prototype.drawScoreboard = function(){
+  var stats = this.stats;
+
+  function draw(type, n) {
+    write(' ');
+    write(Base.color(type, n));
+    write('\n');
+  }
+
+  draw('green', stats.passes);
+  draw('fail', stats.failures);
+  draw('pending', stats.pending);
+  write('\n');
+
+  this.cursorUp(this.numberOfLines);
+};
+
+/**
+ * Append the rainbow.
+ *
+ * @api private
+ */
+
+NyanCat.prototype.appendRainbow = function(){
+  var segment = this.tick ? '_' : '-';
+  var rainbowified = this.rainbowify(segment);
+
+  for (var index = 0; index < this.numberOfLines; index++) {
+    var trajectory = this.trajectories[index];
+    if (trajectory.length >= this.trajectoryWidthMax) trajectory.shift();
+    trajectory.push(rainbowified);
+  }
+};
+
+/**
+ * Draw the rainbow.
+ *
+ * @api private
+ */
+
+NyanCat.prototype.drawRainbow = function(){
+  var self = this;
+
+  this.trajectories.forEach(function(line, index) {
+    write('\u001b[' + self.scoreboardWidth + 'C');
+    write(line.join(''));
+    write('\n');
+  });
+
+  this.cursorUp(this.numberOfLines);
+};
+
+/**
+ * Draw the nyan cat
+ *
+ * @api private
+ */
+
+NyanCat.prototype.drawNyanCat = function() {
+  var self = this;
+  var startWidth = this.scoreboardWidth + this.trajectories[0].length;
+  var dist = '\u001b[' + startWidth + 'C';
+  var padding = '';
+
+  write(dist);
+  write('_,------,');
+  write('\n');
+
+  write(dist);
+  padding = self.tick ? '  ' : '   ';
+  write('_|' + padding + '/\\_/\\ ');
+  write('\n');
+
+  write(dist);
+  padding = self.tick ? '_' : '__';
+  var tail = self.tick ? '~' : '^';
+  var face;
+  write(tail + '|' + padding + this.face() + ' ');
+  write('\n');
+
+  write(dist);
+  padding = self.tick ? ' ' : '  ';
+  write(padding + '""  "" ');
+  write('\n');
+
+  this.cursorUp(this.numberOfLines);
+};
+
+/**
+ * Draw nyan cat face.
+ *
+ * @return {String}
+ * @api private
+ */
+
+NyanCat.prototype.face = function() {
+  var stats = this.stats;
+  if (stats.failures) {
+    return '( x .x)';
+  } else if (stats.pending) {
+    return '( o .o)';
+  } else if(stats.passes) {
+    return '( ^ .^)';
+  } else {
+    return '( - .-)';
+  }
+};
+
+/**
+ * Move cursor up `n`.
+ *
+ * @param {Number} n
+ * @api private
+ */
+
+NyanCat.prototype.cursorUp = function(n) {
+  write('\u001b[' + n + 'A');
+};
+
+/**
+ * Move cursor down `n`.
+ *
+ * @param {Number} n
+ * @api private
+ */
+
+NyanCat.prototype.cursorDown = function(n) {
+  write('\u001b[' + n + 'B');
+};
+
+/**
+ * Generate rainbow colors.
+ *
+ * @return {Array}
+ * @api private
+ */
+
+NyanCat.prototype.generateColors = function(){
+  var colors = [];
+
+  for (var i = 0; i < (6 * 7); i++) {
+    var pi3 = Math.floor(Math.PI / 3);
+    var n = (i * (1.0 / 6));
+    var r = Math.floor(3 * Math.sin(n) + 3);
+    var g = Math.floor(3 * Math.sin(n + 2 * pi3) + 3);
+    var b = Math.floor(3 * Math.sin(n + 4 * pi3) + 3);
+    colors.push(36 * r + 6 * g + b + 16);
+  }
+
+  return colors;
+};
+
+/**
+ * Apply rainbow to the given `str`.
+ *
+ * @param {String} str
+ * @return {String}
+ * @api private
+ */
+
+NyanCat.prototype.rainbowify = function(str){
+  if (!Base.useColors)
+    return str;
+  var color = this.rainbowColors[this.colorIndex % this.rainbowColors.length];
+  this.colorIndex += 1;
+  return '\u001b[38;5;' + color + 'm' + str + '\u001b[0m';
+};
+
+/**
+ * Stdout helper.
+ */
+
+function write(string) {
+  process.stdout.write(string);
+}
+
+/**
+ * Inherit from `Base.prototype`.
+ */
+
+function F(){};
+F.prototype = Base.prototype;
+NyanCat.prototype = new F;
+NyanCat.prototype.constructor = NyanCat;
+
+
+}); // module: reporters/nyan.js
+
+require.register("reporters/progress.js", function(module, exports, require){
+/**
+ * Module dependencies.
+ */
+
+var Base = require('./base')
+  , cursor = Base.cursor
+  , color = Base.color;
+
+/**
+ * Expose `Progress`.
+ */
+
+exports = module.exports = Progress;
+
+/**
+ * General progress bar color.
+ */
+
+Base.colors.progress = 90;
+
+/**
+ * Initialize a new `Progress` bar test reporter.
+ *
+ * @param {Runner} runner
+ * @param {Object} options
+ * @api public
+ */
+
+function Progress(runner, options) {
+  Base.call(this, runner);
+
+  var self = this
+    , options = options || {}
+    , stats = this.stats
+    , width = Base.window.width * .50 | 0
+    , total = runner.total
+    , complete = 0
+    , max = Math.max
+    , lastN = -1;
+
+  // default chars
+  options.open = options.open || '[';
+  options.complete = options.complete || '▬';
+  options.incomplete = options.incomplete || Base.symbols.dot;
+  options.close = options.close || ']';
+  options.verbose = false;
+
+  // tests started
+  runner.on('start', function(){
+    console.log();
+    cursor.hide();
+  });
+
+  // tests complete
+  runner.on('test end', function(){
+    complete++;
+    var incomplete = total - complete
+      , percent = complete / total
+      , n = width * percent | 0
+      , i = width - n;
+
+    if (lastN === n && !options.verbose) {
+      // Don't re-render the line if it hasn't changed
+      return;
+    }
+    lastN = n;
+
+    cursor.CR();
+    process.stdout.write('\u001b[J');
+    process.stdout.write(color('progress', '  ' + options.open));
+    process.stdout.write(Array(n).join(options.complete));
+    process.stdout.write(Array(i).join(options.incomplete));
+    process.stdout.write(color('progress', options.close));
+    if (options.verbose) {
+      process.stdout.write(color('progress', ' ' + complete + ' of ' + total));
+    }
+  });
+
+  // tests are complete, output some stats
+  // and the failures if any
+  runner.on('end', function(){
+    cursor.show();
+    console.log();
+    self.epilogue();
+  });
+}
+
+/**
+ * Inherit from `Base.prototype`.
+ */
+
+function F(){};
+F.prototype = Base.prototype;
+Progress.prototype = new F;
+Progress.prototype.constructor = Progress;
+
+
+}); // module: reporters/progress.js
+
+require.register("reporters/spec.js", function(module, exports, require){
+/**
+ * Module dependencies.
+ */
+
+var Base = require('./base')
+  , cursor = Base.cursor
+  , color = Base.color;
+
+/**
+ * Expose `Spec`.
+ */
+
+exports = module.exports = Spec;
+
+/**
+ * Initialize a new `Spec` test reporter.
+ *
+ * @param {Runner} runner
+ * @api public
+ */
+
+function Spec(runner) {
+  Base.call(this, runner);
+
+  var self = this
+    , stats = this.stats
+    , indents = 0
+    , n = 0;
+
+  function indent() {
+    return Array(indents).join('  ')
+  }
+
+  runner.on('start', function(){
+    console.log();
+  });
+
+  runner.on('suite', function(suite){
+    ++indents;
+    console.log(color('suite', '%s%s'), indent(), suite.title);
+  });
+
+  runner.on('suite end', function(suite){
+    --indents;
+    if (1 == indents) console.log();
+  });
+
+  runner.on('pending', function(test){
+    var fmt = indent() + color('pending', '  - %s');
+    console.log(fmt, test.title);
+  });
+
+  runner.on('pass', function(test){
+    if ('fast' == test.speed) {
+      var fmt = indent()
+        + color('checkmark', '  ' + Base.symbols.ok)
+        + color('pass', ' %s ');
+      cursor.CR();
+      console.log(fmt, test.title);
+    } else {
+      var fmt = indent()
+        + color('checkmark', '  ' + Base.symbols.ok)
+        + color('pass', ' %s ')
+        + color(test.speed, '(%dms)');
+      cursor.CR();
+      console.log(fmt, test.title, test.duration);
+    }
+  });
+
+  runner.on('fail', function(test, err){
+    cursor.CR();
+    console.log(indent() + color('fail', '  %d) %s'), ++n, test.title);
+  });
+
+  runner.on('end', self.epilogue.bind(self));
+}
+
+/**
+ * Inherit from `Base.prototype`.
+ */
+
+function F(){};
+F.prototype = Base.prototype;
+Spec.prototype = new F;
+Spec.prototype.constructor = Spec;
+
+
+}); // module: reporters/spec.js
+
+require.register("reporters/tap.js", function(module, exports, require){
+/**
+ * Module dependencies.
+ */
+
+var Base = require('./base')
+  , cursor = Base.cursor
+  , color = Base.color;
+
+/**
+ * Expose `TAP`.
+ */
+
+exports = module.exports = TAP;
+
+/**
+ * Initialize a new `TAP` reporter.
+ *
+ * @param {Runner} runner
+ * @api public
+ */
+
+function TAP(runner) {
+  Base.call(this, runner);
+
+  var self = this
+    , stats = this.stats
+    , n = 1
+    , passes = 0
+    , failures = 0;
+
+  runner.on('start', function(){
+    var total = runner.grepTotal(runner.suite);
+    console.log('%d..%d', 1, total);
+  });
+
+  runner.on('test end', function(){
+    ++n;
+  });
+
+  runner.on('pending', function(test){
+    console.log('ok %d %s # SKIP -', n, title(test));
+  });
+
+  runner.on('pass', function(test){
+    passes++;
+    console.log('ok %d %s', n, title(test));
+  });
+
+  runner.on('fail', function(test, err){
+    failures++;
+    console.log('not ok %d %s', n, title(test));
+    if (err.stack) console.log(err.stack.replace(/^/gm, '  '));
+  });
+
+  runner.on('end', function(){
+    console.log('# tests ' + (passes + failures));
+    console.log('# pass ' + passes);
+    console.log('# fail ' + failures);
+  });
+}
+
+/**
+ * Return a TAP-safe title of `test`
+ *
+ * @param {Object} test
+ * @return {String}
+ * @api private
+ */
+
+function title(test) {
+  return test.fullTitle().replace(/#/g, '');
+}
+
+}); // module: reporters/tap.js
+
+require.register("reporters/xunit.js", function(module, exports, require){
+/**
+ * Module dependencies.
+ */
+
+var Base = require('./base')
+  , utils = require('../utils')
+  , fs = require('browser/fs')
+  , escape = utils.escape;
+
+/**
+ * Save timer references to avoid Sinon interfering (see GH-237).
+ */
+
+var Date = global.Date
+  , setTimeout = global.setTimeout
+  , setInterval = global.setInterval
+  , clearTimeout = global.clearTimeout
+  , clearInterval = global.clearInterval;
+
+/**
+ * Expose `XUnit`.
+ */
+
+exports = module.exports = XUnit;
+
+/**
+ * Initialize a new `XUnit` reporter.
+ *
+ * @param {Runner} runner
+ * @api public
+ */
+
+function XUnit(runner, options) {
+  Base.call(this, runner);
+  var stats = this.stats
+    , tests = []
+    , self = this;
+
+  if (options.reporterOptions && options.reporterOptions.output) {
+      if (! fs.createWriteStream) {
+          throw new Error('file output not supported in browser');
+      }
+      self.fileStream = fs.createWriteStream(options.reporterOptions.output);
+  }
+
+  runner.on('pending', function(test){
+    tests.push(test);
+  });
+
+  runner.on('pass', function(test){
+    tests.push(test);
+  });
+
+  runner.on('fail', function(test){
+    tests.push(test);
+  });
+
+  runner.on('end', function(){
+    self.write(tag('testsuite', {
+        name: 'Mocha Tests'
+      , tests: stats.tests
+      , failures: stats.failures
+      , errors: stats.failures
+      , skipped: stats.tests - stats.failures - stats.passes
+      , timestamp: (new Date).toUTCString()
+      , time: (stats.duration / 1000) || 0
+    }, false));
+
+    tests.forEach(function(t) { self.test(t); });
+    self.write('</testsuite>');
+  });
+}
+
+/**
+ * Override done to close the stream (if it's a file).
+ */
+XUnit.prototype.done = function(failures, fn) {
+    if (this.fileStream) {
+        this.fileStream.end(function() {
+            fn(failures);
+        });
+    } else {
+        fn(failures);
+    }
+};
+
+/**
+ * Inherit from `Base.prototype`.
+ */
+
+function F(){};
+F.prototype = Base.prototype;
+XUnit.prototype = new F;
+XUnit.prototype.constructor = XUnit;
+
+
+/**
+ * Write out the given line
+ */
+XUnit.prototype.write = function(line) {
+    if (this.fileStream) {
+        this.fileStream.write(line + '\n');
+    } else {
+        console.log(line);
+    }
+};
+
+/**
+ * Output tag for the given `test.`
+ */
+
+XUnit.prototype.test = function(test, ostream) {
+  var attrs = {
+      classname: test.parent.fullTitle()
+    , name: test.title
+    , time: (test.duration / 1000) || 0
+  };
+
+  if ('failed' == test.state) {
+    var err = test.err;
+    this.write(tag('testcase', attrs, false, tag('failure', {}, false, cdata(escape(err.message) + "\n" + err.stack))));
+  } else if (test.pending) {
+    this.write(tag('testcase', attrs, false, tag('skipped', {}, true)));
+  } else {
+    this.write(tag('testcase', attrs, true) );
+  }
+};
+
+/**
+ * HTML tag helper.
+ */
+
+function tag(name, attrs, close, content) {
+  var end = close ? '/>' : '>'
+    , pairs = []
+    , tag;
+
+  for (var key in attrs) {
+    pairs.push(key + '="' + escape(attrs[key]) + '"');
+  }
+
+  tag = '<' + name + (pairs.length ? ' ' + pairs.join(' ') : '') + end;
+  if (content) tag += content + '</' + name + end;
+  return tag;
+}
+
+/**
+ * Return cdata escaped CDATA `str`.
+ */
+
+function cdata(str) {
+  return '<![CDATA[' + escape(str) + ']]>';
+}
+
+}); // module: reporters/xunit.js
+
+require.register("runnable.js", function(module, exports, require){
+/**
+ * Module dependencies.
+ */
+
+var EventEmitter = require('browser/events').EventEmitter
+  , debug = require('browser/debug')('mocha:runnable')
+  , milliseconds = require('./ms')
+  , utils = require('./utils');
+
+/**
+ * Save timer references to avoid Sinon interfering (see GH-237).
+ */
+
+var Date = global.Date
+  , setTimeout = global.setTimeout
+  , setInterval = global.setInterval
+  , clearTimeout = global.clearTimeout
+  , clearInterval = global.clearInterval;
+
+/**
+ * Object#toString().
+ */
+
+var toString = Object.prototype.toString;
+
+/**
+ * Expose `Runnable`.
+ */
+
+module.exports = Runnable;
+
+/**
+ * Initialize a new `Runnable` with the given `title` and callback `fn`.
+ *
+ * @param {String} title
+ * @param {Function} fn
+ * @api private
+ */
+
+function Runnable(title, fn) {
+  this.title = title;
+  this.fn = fn;
+  this.async = fn && fn.length;
+  this.sync = ! this.async;
+  this._timeout = 2000;
+  this._slow = 75;
+  this._enableTimeouts = true;
+  this.timedOut = false;
+  this._trace = new Error('done() called multiple times')
+}
+
+/**
+ * Inherit from `EventEmitter.prototype`.
+ */
+
+function F(){};
+F.prototype = EventEmitter.prototype;
+Runnable.prototype = new F;
+Runnable.prototype.constructor = Runnable;
+
+
+/**
+ * Set & get timeout `ms`.
+ *
+ * @param {Number|String} ms
+ * @return {Runnable|Number} ms or self
+ * @api private
+ */
+
+Runnable.prototype.timeout = function(ms){
+  if (0 == arguments.length) return this._timeout;
+  if (ms === 0) this._enableTimeouts = false;
+  if ('string' == typeof ms) ms = milliseconds(ms);
+  debug('timeout %d', ms);
+  this._timeout = ms;
+  if (this.timer) this.resetTimeout();
+  return this;
+};
+
+/**
+ * Set & get slow `ms`.
+ *
+ * @param {Number|String} ms
+ * @return {Runnable|Number} ms or self
+ * @api private
+ */
+
+Runnable.prototype.slow = function(ms){
+  if (0 === arguments.length) return this._slow;
+  if ('string' == typeof ms) ms = milliseconds(ms);
+  debug('timeout %d', ms);
+  this._slow = ms;
+  return this;
+};
+
+/**
+ * Set and & get timeout `enabled`.
+ *
+ * @param {Boolean} enabled
+ * @return {Runnable|Boolean} enabled or self
+ * @api private
+ */
+
+Runnable.prototype.enableTimeouts = function(enabled){
+  if (arguments.length === 0) return this._enableTimeouts;
+  debug('enableTimeouts %s', enabled);
+  this._enableTimeouts = enabled;
+  return this;
+};
+
+/**
+ * Return the full title generated by recursively
+ * concatenating the parent's full title.
+ *
+ * @return {String}
+ * @api public
+ */
+
+Runnable.prototype.fullTitle = function(){
+  return this.parent.fullTitle() + ' ' + this.title;
+};
+
+/**
+ * Clear the timeout.
+ *
+ * @api private
+ */
+
+Runnable.prototype.clearTimeout = function(){
+  clearTimeout(this.timer);
+};
+
+/**
+ * Inspect the runnable void of private properties.
+ *
+ * @return {String}
+ * @api private
+ */
+
+Runnable.prototype.inspect = function(){
+  return JSON.stringify(this, function(key, val){
+    if ('_' == key[0]) return;
+    if ('parent' == key) return '#<Suite>';
+    if ('ctx' == key) return '#<Context>';
+    return val;
+  }, 2);
+};
+
+/**
+ * Reset the timeout.
+ *
+ * @api private
+ */
+
+Runnable.prototype.resetTimeout = function(){
+  var self = this;
+  var ms = this.timeout() || 1e9;
+
+  if (!this._enableTimeouts) return;
+  this.clearTimeout();
+  this.timer = setTimeout(function(){
+    if (!self._enableTimeouts) return;
+    self.callback(new Error('timeout of ' + ms + 'ms exceeded'));
+    self.timedOut = true;
+  }, ms);
+};
+
+/**
+ * Whitelist these globals for this test run
+ *
+ * @api private
+ */
+Runnable.prototype.globals = function(arr){
+  var self = this;
+  this._allowedGlobals = arr;
+};
+
+/**
+ * Run the test and invoke `fn(err)`.
+ *
+ * @param {Function} fn
+ * @api private
+ */
+
+Runnable.prototype.run = function(fn){
+  var self = this
+    , start = new Date
+    , ctx = this.ctx
+    , finished
+    , emitted;
+
+  // Some times the ctx exists but it is not runnable
+  if (ctx && ctx.runnable) ctx.runnable(this);
+
+  // called multiple times
+  function multiple(err) {
+    if (emitted) return;
+    emitted = true;
+    self.emit('error', err || new Error('done() called multiple times; stacktrace may be inaccurate'));
+  }
+
+  // finished
+  function done(err) {
+    var ms = self.timeout();
+    if (self.timedOut) return;
+    if (finished) return multiple(err || self._trace);
+    self.clearTimeout();
+    self.duration = new Date - start;
+    finished = true;
+    if (!err && self.duration > ms && self._enableTimeouts) err = new Error('timeout of ' + ms + 'ms exceeded');
+    fn(err);
+  }
+
+  // for .resetTimeout()
+  this.callback = done;
+
+  // explicit async with `done` argument
+  if (this.async) {
+    this.resetTimeout();
+
+    try {
+      this.fn.call(ctx, function(err){
+        if (err instanceof Error || toString.call(err) === "[object Error]") return done(err);
+        if (null != err) {
+          if (Object.prototype.toString.call(err) === '[object Object]') {
+            return done(new Error('done() invoked with non-Error: ' + JSON.stringify(err)));
+          } else {
+            return done(new Error('done() invoked with non-Error: ' + err));
+          }
+        }
+        done();
+      });
+    } catch (err) {
+      done(utils.getError(err));
+    }
+    return;
+  }
+
+  if (this.asyncOnly) {
+    return done(new Error('--async-only option in use without declaring `done()`'));
+  }
+
+  // sync or promise-returning
+  try {
+    if (this.pending) {
+      done();
+    } else {
+      callFn(this.fn);
+    }
+  } catch (err) {
+    done(utils.getError(err));
+  }
+
+  function callFn(fn) {
+    var result = fn.call(ctx);
+    if (result && typeof result.then === 'function') {
+      self.resetTimeout();
+      result
+        .then(function() {
+          done()
+        },
+        function(reason) {
+          done(reason || new Error('Promise rejected with no or falsy reason'))
+        });
+    } else {
+      done();
+    }
+  }
+};
+
+}); // module: runnable.js
+
+require.register("runner.js", function(module, exports, require){
+/**
+ * Module dependencies.
+ */
+
+var EventEmitter = require('browser/events').EventEmitter
+  , debug = require('browser/debug')('mocha:runner')
+  , Test = require('./test')
+  , utils = require('./utils')
+  , filter = utils.filter
+  , keys = utils.keys;
+
+/**
+ * Non-enumerable globals.
+ */
+
+var globals = [
+  'setTimeout',
+  'clearTimeout',
+  'setInterval',
+  'clearInterval',
+  'XMLHttpRequest',
+  'Date',
+  'setImmediate',
+  'clearImmediate'
+];
+
+/**
+ * Expose `Runner`.
+ */
+
+module.exports = Runner;
+
+/**
+ * Initialize a `Runner` for the given `suite`.
+ *
+ * Events:
+ *
+ *   - `start`  execution started
+ *   - `end`  execution complete
+ *   - `suite`  (suite) test suite execution started
+ *   - `suite end`  (suite) all tests (and sub-suites) have finished
+ *   - `test`  (test) test execution started
+ *   - `test end`  (test) test completed
+ *   - `hook`  (hook) hook execution started
+ *   - `hook end`  (hook) hook complete
+ *   - `pass`  (test) test passed
+ *   - `fail`  (test, err) test failed
+ *   - `pending`  (test) test pending
+ *
+ * @api public
+ */
+
+function Runner(suite) {
+  var self = this;
+  this._globals = [];
+  this._abort = false;
+  this.suite = suite;
+  this.total = suite.total();
+  this.failures = 0;
+  this.on('test end', function(test){ self.checkGlobals(test); });
+  this.on('hook end', function(hook){ self.checkGlobals(hook); });
+  this.grep(/.*/);
+  this.globals(this.globalProps().concat(extraGlobals()));
+}
+
+/**
+ * Wrapper for setImmediate, process.nextTick, or browser polyfill.
+ *
+ * @param {Function} fn
+ * @api private
+ */
+
+Runner.immediately = global.setImmediate || process.nextTick;
+
+/**
+ * Inherit from `EventEmitter.prototype`.
+ */
+
+function F(){};
+F.prototype = EventEmitter.prototype;
+Runner.prototype = new F;
+Runner.prototype.constructor = Runner;
+
+
+/**
+ * Run tests with full titles matching `re`. Updates runner.total
+ * with number of tests matched.
+ *
+ * @param {RegExp} re
+ * @param {Boolean} invert
+ * @return {Runner} for chaining
+ * @api public
+ */
+
+Runner.prototype.grep = function(re, invert){
+  debug('grep %s', re);
+  this._grep = re;
+  this._invert = invert;
+  this.total = this.grepTotal(this.suite);
+  return this;
+};
+
+/**
+ * Returns the number of tests matching the grep search for the
+ * given suite.
+ *
+ * @param {Suite} suite
+ * @return {Number}
+ * @api public
+ */
+
+Runner.prototype.grepTotal = function(suite) {
+  var self = this;
+  var total = 0;
+
+  suite.eachTest(function(test){
+    var match = self._grep.test(test.fullTitle());
+    if (self._invert) match = !match;
+    if (match) total++;
+  });
+
+  return total;
+};
+
+/**
+ * Return a list of global properties.
+ *
+ * @return {Array}
+ * @api private
+ */
+
+Runner.prototype.globalProps = function() {
+  var props = utils.keys(global);
+
+  // non-enumerables
+  for (var i = 0; i < globals.length; ++i) {
+    if (~utils.indexOf(props, globals[i])) continue;
+    props.push(globals[i]);
+  }
+
+  return props;
+};
+
+/**
+ * Allow the given `arr` of globals.
+ *
+ * @param {Array} arr
+ * @return {Runner} for chaining
+ * @api public
+ */
+
+Runner.prototype.globals = function(arr){
+  if (0 == arguments.length) return this._globals;
+  debug('globals %j', arr);
+  this._globals = this._globals.concat(arr);
+  return this;
+};
+
+/**
+ * Check for global variable leaks.
+ *
+ * @api private
+ */
+
+Runner.prototype.checkGlobals = function(test){
+  if (this.ignoreLeaks) return;
+  var ok = this._globals;
+
+  var globals = this.globalProps();
+  var leaks;
+
+  if (test) {
+    ok = ok.concat(test._allowedGlobals || []);
+  }
+
+  if(this.prevGlobalsLength == globals.length) return;
+  this.prevGlobalsLength = globals.length;
+
+  leaks = filterLeaks(ok, globals);
+  this._globals = this._globals.concat(leaks);
+
+  if (leaks.length > 1) {
+    this.fail(test, new Error('global leaks detected: ' + leaks.join(', ') + ''));
+  } else if (leaks.length) {
+    this.fail(test, new Error('global leak detected: ' + leaks[0]));
+  }
+};
+
+/**
+ * Fail the given `test`.
+ *
+ * @param {Test} test
+ * @param {Error} err
+ * @api private
+ */
+
+Runner.prototype.fail = function(test, err){
+  ++this.failures;
+  test.state = 'failed';
+
+  if ('string' == typeof err) {
+    err = new Error('the string "' + err + '" was thrown, throw an Error :)');
+  }
+
+  this.emit('fail', test, err);
+};
+
+/**
+ * Fail the given `hook` with `err`.
+ *
+ * Hook failures work in the following pattern:
+ * - If bail, then exit
+ * - Failed `before` hook skips all tests in a suite and subsuites,
+ *   but jumps to corresponding `after` hook
+ * - Failed `before each` hook skips remaining tests in a
+ *   suite and jumps to corresponding `after each` hook,
+ *   which is run only once
+ * - Failed `after` hook does not alter
+ *   execution order
+ * - Failed `after each` hook skips remaining tests in a
+ *   suite and subsuites, but executes other `after each`
+ *   hooks
+ *
+ * @param {Hook} hook
+ * @param {Error} err
+ * @api private
+ */
+
+Runner.prototype.failHook = function(hook, err){
+  this.fail(hook, err);
+  if (this.suite.bail()) {
+    this.emit('end');
+  }
+};
+
+/**
+ * Run hook `name` callbacks and then invoke `fn()`.
+ *
+ * @param {String} name
+ * @param {Function} function
+ * @api private
+ */
+
+Runner.prototype.hook = function(name, fn){
+  var suite = this.suite
+    , hooks = suite['_' + name]
+    , self = this
+    , timer;
+
+  function next(i) {
+    var hook = hooks[i];
+    if (!hook) return fn();
+    self.currentRunnable = hook;
+
+    hook.ctx.currentTest = self.test;
+
+    self.emit('hook', hook);
+
+    hook.on('error', function(err){
+      self.failHook(hook, err);
+    });
+
+    hook.run(function(err){
+      hook.removeAllListeners('error');
+      var testError = hook.error();
+      if (testError) self.fail(self.test, testError);
+      if (err) {
+        self.failHook(hook, err);
+
+        // stop executing hooks, notify callee of hook err
+        return fn(err);
+      }
+      self.emit('hook end', hook);
+      delete hook.ctx.currentTest;
+      next(++i);
+    });
+  }
+
+  Runner.immediately(function(){
+    next(0);
+  });
+};
+
+/**
+ * Run hook `name` for the given array of `suites`
+ * in order, and callback `fn(err, errSuite)`.
+ *
+ * @param {String} name
+ * @param {Array} suites
+ * @param {Function} fn
+ * @api private
+ */
+
+Runner.prototype.hooks = function(name, suites, fn){
+  var self = this
+    , orig = this.suite;
+
+  function next(suite) {
+    self.suite = suite;
+
+    if (!suite) {
+      self.suite = orig;
+      return fn();
+    }
+
+    self.hook(name, function(err){
+      if (err) {
+        var errSuite = self.suite;
+        self.suite = orig;
+        return fn(err, errSuite);
+      }
+
+      next(suites.pop());
+    });
+  }
+
+  next(suites.pop());
+};
+
+/**
+ * Run hooks from the top level down.
+ *
+ * @param {String} name
+ * @param {Function} fn
+ * @api private
+ */
+
+Runner.prototype.hookUp = function(name, fn){
+  var suites = [this.suite].concat(this.parents()).reverse();
+  this.hooks(name, suites, fn);
+};
+
+/**
+ * Run hooks from the bottom up.
+ *
+ * @param {String} name
+ * @param {Function} fn
+ * @api private
+ */
+
+Runner.prototype.hookDown = function(name, fn){
+  var suites = [this.suite].concat(this.parents());
+  this.hooks(name, suites, fn);
+};
+
+/**
+ * Return an array of parent Suites from
+ * closest to furthest.
+ *
+ * @return {Array}
+ * @api private
+ */
+
+Runner.prototype.parents = function(){
+  var suite = this.suite
+    , suites = [];
+  while (suite = suite.parent) suites.push(suite);
+  return suites;
+};
+
+/**
+ * Run the current test and callback `fn(err)`.
+ *
+ * @param {Function} fn
+ * @api private
+ */
+
+Runner.prototype.runTest = function(fn){
+  var test = this.test
+    , self = this;
+
+  if (this.asyncOnly) test.asyncOnly = true;
+
+  try {
+    test.on('error', function(err){
+      self.fail(test, err);
+    });
+    test.run(fn);
+  } catch (err) {
+    fn(err);
+  }
+};
+
+/**
+ * Run tests in the given `suite` and invoke
+ * the callback `fn()` when complete.
+ *
+ * @param {Suite} suite
+ * @param {Function} fn
+ * @api private
+ */
+
+Runner.prototype.runTests = function(suite, fn){
+  var self = this
+    , tests = suite.tests.slice()
+    , test;
+
+
+  function hookErr(err, errSuite, after) {
+    // before/after Each hook for errSuite failed:
+    var orig = self.suite;
+
+    // for failed 'after each' hook start from errSuite parent,
+    // otherwise start from errSuite itself
+    self.suite = after ? errSuite.parent : errSuite;
+
+    if (self.suite) {
+      // call hookUp afterEach
+      self.hookUp('afterEach', function(err2, errSuite2) {
+        self.suite = orig;
+        // some hooks may fail even now
+        if (err2) return hookErr(err2, errSuite2, true);
+        // report error suite
+        fn(errSuite);
+      });
+    } else {
+      // there is no need calling other 'after each' hooks
+      self.suite = orig;
+      fn(errSuite);
+    }
+  }
+
+  function next(err, errSuite) {
+    // if we bail after first err
+    if (self.failures && suite._bail) return fn();
+
+    if (self._abort) return fn();
+
+    if (err) return hookErr(err, errSuite, true);
+
+    // next test
+    test = tests.shift();
+
+    // all done
+    if (!test) return fn();
+
+    // grep
+    var match = self._grep.test(test.fullTitle());
+    if (self._invert) match = !match;
+    if (!match) return next();
+
+    // pending
+    if (test.pending) {
+      self.emit('pending', test);
+      self.emit('test end', test);
+      return next();
+    }
+
+    // execute test and hook(s)
+    self.emit('test', self.test = test);
+    self.hookDown('beforeEach', function(err, errSuite){
+
+      if (err) return hookErr(err, errSuite, false);
+
+      self.currentRunnable = self.test;
+      self.runTest(function(err){
+        test = self.test;
+
+        if (err) {
+          self.fail(test, err);
+          self.emit('test end', test);
+          return self.hookUp('afterEach', next);
+        }
+
+        test.state = 'passed';
+        self.emit('pass', test);
+        self.emit('test end', test);
+        self.hookUp('afterEach', next);
+      });
+    });
+  }
+
+  this.next = next;
+  next();
+};
+
+/**
+ * Run the given `suite` and invoke the
+ * callback `fn()` when complete.
+ *
+ * @param {Suite} suite
+ * @param {Function} fn
+ * @api private
+ */
+
+Runner.prototype.runSuite = function(suite, fn){
+  var total = this.grepTotal(suite)
+    , self = this
+    , i = 0;
+
+  debug('run suite %s', suite.fullTitle());
+
+  if (!total) return fn();
+
+  this.emit('suite', this.suite = suite);
+
+  function next(errSuite) {
+    if (errSuite) {
+      // current suite failed on a hook from errSuite
+      if (errSuite == suite) {
+        // if errSuite is current suite
+        // continue to the next sibling suite
+        return done();
+      } else {
+        // errSuite is among the parents of current suite
+        // stop execution of errSuite and all sub-suites
+        return done(errSuite);
+      }
+    }
+
+    if (self._abort) return done();
+
+    var curr = suite.suites[i++];
+    if (!curr) return done();
+    self.runSuite(curr, next);
+  }
+
+  function done(errSuite) {
+    self.suite = suite;
+    self.hook('afterAll', function(){
+      self.emit('suite end', suite);
+      fn(errSuite);
+    });
+  }
+
+  this.hook('beforeAll', function(err){
+    if (err) return done();
+    self.runTests(suite, next);
+  });
+};
+
+/**
+ * Handle uncaught exceptions.
+ *
+ * @param {Error} err
+ * @api private
+ */
+
+Runner.prototype.uncaught = function(err){
+  if (err) {
+    debug('uncaught exception %s', err !== function () {
+      return this;
+    }.call(err) ? err : ( err.message || err ));
+  } else {
+    debug('uncaught undefined exception');
+    err = utils.undefinedError();
+  }
+  err.uncaught = true;
+
+  var runnable = this.currentRunnable;
+  if (!runnable) return;
+
+  var wasAlreadyDone = runnable.state;
+  this.fail(runnable, err);
+
+  runnable.clearTimeout();
+
+  if (wasAlreadyDone) return;
+
+  // recover from test
+  if ('test' == runnable.type) {
+    this.emit('test end', runnable);
+    this.hookUp('afterEach', this.next);
+    return;
+  }
+
+  // bail on hooks
+  this.emit('end');
+};
+
+/**
+ * Run the root suite and invoke `fn(failures)`
+ * on completion.
+ *
+ * @param {Function} fn
+ * @return {Runner} for chaining
+ * @api public
+ */
+
+Runner.prototype.run = function(fn){
+  var self = this
+    , fn = fn || function(){};
+
+  function uncaught(err){
+    self.uncaught(err);
+  }
+
+  debug('start');
+
+  // callback
+  this.on('end', function(){
+    debug('end');
+    process.removeListener('uncaughtException', uncaught);
+    fn(self.failures);
+  });
+
+  // run suites
+  this.emit('start');
+  this.runSuite(this.suite, function(){
+    debug('finished running');
+    self.emit('end');
+  });
+
+  // uncaught exception
+  process.on('uncaughtException', uncaught);
+
+  return this;
+};
+
+/**
+ * Cleanly abort execution
+ *
+ * @return {Runner} for chaining
+ * @api public
+ */
+Runner.prototype.abort = function(){
+  debug('aborting');
+  this._abort = true;
+};
+
+/**
+ * Filter leaks with the given globals flagged as `ok`.
+ *
+ * @param {Array} ok
+ * @param {Array} globals
+ * @return {Array}
+ * @api private
+ */
+
+function filterLeaks(ok, globals) {
+  return filter(globals, function(key){
+    // Firefox and Chrome exposes iframes as index inside the window object
+    if (/^d+/.test(key)) return false;
+
+    // in firefox
+    // if runner runs in an iframe, this iframe's window.getInterface method not init at first
+    // it is assigned in some seconds
+    if (global.navigator && /^getInterface/.test(key)) return false;
+
+    // an iframe could be approached by window[iframeIndex]
+    // in ie6,7,8 and opera, iframeIndex is enumerable, this could cause leak
+    if (global.navigator && /^\d+/.test(key)) return false;
+
+    // Opera and IE expose global variables for HTML element IDs (issue #243)
+    if (/^mocha-/.test(key)) return false;
+
+    var matched = filter(ok, function(ok){
+      if (~ok.indexOf('*')) return 0 == key.indexOf(ok.split('*')[0]);
+      return key == ok;
+    });
+    return matched.length == 0 && (!global.navigator || 'onerror' !== key);
+  });
+}
+
+/**
+ * Array of globals dependent on the environment.
+ *
+ * @return {Array}
+ * @api private
+ */
+
+ function extraGlobals() {
+  if (typeof(process) === 'object' &&
+      typeof(process.version) === 'string') {
+
+    var nodeVersion = process.version.split('.').reduce(function(a, v) {
+      return a << 8 | v;
+    });
+
+    // 'errno' was renamed to process._errno in v0.9.11.
+
+    if (nodeVersion < 0x00090B) {
+      return ['errno'];
+    }
+  }
+
+  return [];
+ }
+
+}); // module: runner.js
+
+require.register("suite.js", function(module, exports, require){
+/**
+ * Module dependencies.
+ */
+
+var EventEmitter = require('browser/events').EventEmitter
+  , debug = require('browser/debug')('mocha:suite')
+  , milliseconds = require('./ms')
+  , utils = require('./utils')
+  , Hook = require('./hook');
+
+/**
+ * Expose `Suite`.
+ */
+
+exports = module.exports = Suite;
+
+/**
+ * Create a new `Suite` with the given `title`
+ * and parent `Suite`. When a suite with the
+ * same title is already present, that suite
+ * is returned to provide nicer reporter
+ * and more flexible meta-testing.
+ *
+ * @param {Suite} parent
+ * @param {String} title
+ * @return {Suite}
+ * @api public
+ */
+
+exports.create = function(parent, title){
+  var suite = new Suite(title, parent.ctx);
+  suite.parent = parent;
+  if (parent.pending) suite.pending = true;
+  title = suite.fullTitle();
+  parent.addSuite(suite);
+  return suite;
+};
+
+/**
+ * Initialize a new `Suite` with the given
+ * `title` and `ctx`.
+ *
+ * @param {String} title
+ * @param {Context} ctx
+ * @api private
+ */
+
+function Suite(title, parentContext) {
+  this.title = title;
+  var context = function() {};
+  context.prototype = parentContext;
+  this.ctx = new context();
+  this.suites = [];
+  this.tests = [];
+  this.pending = false;
+  this._beforeEach = [];
+  this._beforeAll = [];
+  this._afterEach = [];
+  this._afterAll = [];
+  this.root = !title;
+  this._timeout = 2000;
+  this._enableTimeouts = true;
+  this._slow = 75;
+  this._bail = false;
+}
+
+/**
+ * Inherit from `EventEmitter.prototype`.
+ */
+
+function F(){};
+F.prototype = EventEmitter.prototype;
+Suite.prototype = new F;
+Suite.prototype.constructor = Suite;
+
+
+/**
+ * Return a clone of this `Suite`.
+ *
+ * @return {Suite}
+ * @api private
+ */
+
+Suite.prototype.clone = function(){
+  var suite = new Suite(this.title);
+  debug('clone');
+  suite.ctx = this.ctx;
+  suite.timeout(this.timeout());
+  suite.enableTimeouts(this.enableTimeouts());
+  suite.slow(this.slow());
+  suite.bail(this.bail());
+  return suite;
+};
+
+/**
+ * Set timeout `ms` or short-hand such as "2s".
+ *
+ * @param {Number|String} ms
+ * @return {Suite|Number} for chaining
+ * @api private
+ */
+
+Suite.prototype.timeout = function(ms){
+  if (0 == arguments.length) return this._timeout;
+  if (ms.toString() === '0') this._enableTimeouts = false;
+  if ('string' == typeof ms) ms = milliseconds(ms);
+  debug('timeout %d', ms);
+  this._timeout = parseInt(ms, 10);
+  return this;
+};
+
+/**
+  * Set timeout `enabled`.
+  *
+  * @param {Boolean} enabled
+  * @return {Suite|Boolean} self or enabled
+  * @api private
+  */
+
+Suite.prototype.enableTimeouts = function(enabled){
+  if (arguments.length === 0) return this._enableTimeouts;
+  debug('enableTimeouts %s', enabled);
+  this._enableTimeouts = enabled;
+  return this;
+};
+
+/**
+ * Set slow `ms` or short-hand such as "2s".
+ *
+ * @param {Number|String} ms
+ * @return {Suite|Number} for chaining
+ * @api private
+ */
+
+Suite.prototype.slow = function(ms){
+  if (0 === arguments.length) return this._slow;
+  if ('string' == typeof ms) ms = milliseconds(ms);
+  debug('slow %d', ms);
+  this._slow = ms;
+  return this;
+};
+
+/**
+ * Sets whether to bail after first error.
+ *
+ * @param {Boolean} bail
+ * @return {Suite|Number} for chaining
+ * @api private
+ */
+
+Suite.prototype.bail = function(bail){
+  if (0 == arguments.length) return this._bail;
+  debug('bail %s', bail);
+  this._bail = bail;
+  return this;
+};
+
+/**
+ * Run `fn(test[, done])` before running tests.
+ *
+ * @param {Function} fn
+ * @return {Suite} for chaining
+ * @api private
+ */
+
+Suite.prototype.beforeAll = function(title, fn){
+  if (this.pending) return this;
+  if ('function' === typeof title) {
+    fn = title;
+    title = fn.name;
+  }
+  title = '"before all" hook' + (title ? ': ' + title : '');
+
+  var hook = new Hook(title, fn);
+  hook.parent = this;
+  hook.timeout(this.timeout());
+  hook.enableTimeouts(this.enableTimeouts());
+  hook.slow(this.slow());
+  hook.ctx = this.ctx;
+  this._beforeAll.push(hook);
+  this.emit('beforeAll', hook);
+  return this;
+};
+
+/**
+ * Run `fn(test[, done])` after running tests.
+ *
+ * @param {Function} fn
+ * @return {Suite} for chaining
+ * @api private
+ */
+
+Suite.prototype.afterAll = function(title, fn){
+  if (this.pending) return this;
+  if ('function' === typeof title) {
+    fn = title;
+    title = fn.name;
+  }
+  title = '"after all" hook' + (title ? ': ' + title : '');
+
+  var hook = new Hook(title, fn);
+  hook.parent = this;
+  hook.timeout(this.timeout());
+  hook.enableTimeouts(this.enableTimeouts());
+  hook.slow(this.slow());
+  hook.ctx = this.ctx;
+  this._afterAll.push(hook);
+  this.emit('afterAll', hook);
+  return this;
+};
+
+/**
+ * Run `fn(test[, done])` before each test case.
+ *
+ * @param {Function} fn
+ * @return {Suite} for chaining
+ * @api private
+ */
+
+Suite.prototype.beforeEach = function(title, fn){
+  if (this.pending) return this;
+  if ('function' === typeof title) {
+    fn = title;
+    title = fn.name;
+  }
+  title = '"before each" hook' + (title ? ': ' + title : '');
+
+  var hook = new Hook(title, fn);
+  hook.parent = this;
+  hook.timeout(this.timeout());
+  hook.enableTimeouts(this.enableTimeouts());
+  hook.slow(this.slow());
+  hook.ctx = this.ctx;
+  this._beforeEach.push(hook);
+  this.emit('beforeEach', hook);
+  return this;
+};
+
+/**
+ * Run `fn(test[, done])` after each test case.
+ *
+ * @param {Function} fn
+ * @return {Suite} for chaining
+ * @api private
+ */
+
+Suite.prototype.afterEach = function(title, fn){
+  if (this.pending) return this;
+  if ('function' === typeof title) {
+    fn = title;
+    title = fn.name;
+  }
+  title = '"after each" hook' + (title ? ': ' + title : '');
+
+  var hook = new Hook(title, fn);
+  hook.parent = this;
+  hook.timeout(this.timeout());
+  hook.enableTimeouts(this.enableTimeouts());
+  hook.slow(this.slow());
+  hook.ctx = this.ctx;
+  this._afterEach.push(hook);
+  this.emit('afterEach', hook);
+  return this;
+};
+
+/**
+ * Add a test `suite`.
+ *
+ * @param {Suite} suite
+ * @return {Suite} for chaining
+ * @api private
+ */
+
+Suite.prototype.addSuite = function(suite){
+  suite.parent = this;
+  suite.timeout(this.timeout());
+  suite.enableTimeouts(this.enableTimeouts());
+  suite.slow(this.slow());
+  suite.bail(this.bail());
+  this.suites.push(suite);
+  this.emit('suite', suite);
+  return this;
+};
+
+/**
+ * Add a `test` to this suite.
+ *
+ * @param {Test} test
+ * @return {Suite} for chaining
+ * @api private
+ */
+
+Suite.prototype.addTest = function(test){
+  test.parent = this;
+  test.timeout(this.timeout());
+  test.enableTimeouts(this.enableTimeouts());
+  test.slow(this.slow());
+  test.ctx = this.ctx;
+  this.tests.push(test);
+  this.emit('test', test);
+  return this;
+};
+
+/**
+ * Return the full title generated by recursively
+ * concatenating the parent's full title.
+ *
+ * @return {String}
+ * @api public
+ */
+
+Suite.prototype.fullTitle = function(){
+  if (this.parent) {
+    var full = this.parent.fullTitle();
+    if (full) return full + ' ' + this.title;
+  }
+  return this.title;
+};
+
+/**
+ * Return the total number of tests.
+ *
+ * @return {Number}
+ * @api public
+ */
+
+Suite.prototype.total = function(){
+  return utils.reduce(this.suites, function(sum, suite){
+    return sum + suite.total();
+  }, 0) + this.tests.length;
+};
+
+/**
+ * Iterates through each suite recursively to find
+ * all tests. Applies a function in the format
+ * `fn(test)`.
+ *
+ * @param {Function} fn
+ * @return {Suite}
+ * @api private
+ */
+
+Suite.prototype.eachTest = function(fn){
+  utils.forEach(this.tests, fn);
+  utils.forEach(this.suites, function(suite){
+    suite.eachTest(fn);
+  });
+  return this;
+};
+
+}); // module: suite.js
+
+require.register("test.js", function(module, exports, require){
+/**
+ * Module dependencies.
+ */
+
+var Runnable = require('./runnable');
+
+/**
+ * Expose `Test`.
+ */
+
+module.exports = Test;
+
+/**
+ * Initialize a new `Test` with the given `title` and callback `fn`.
+ *
+ * @param {String} title
+ * @param {Function} fn
+ * @api private
+ */
+
+function Test(title, fn) {
+  Runnable.call(this, title, fn);
+  this.pending = !fn;
+  this.type = 'test';
+}
+
+/**
+ * Inherit from `Runnable.prototype`.
+ */
+
+function F(){};
+F.prototype = Runnable.prototype;
+Test.prototype = new F;
+Test.prototype.constructor = Test;
+
+
+}); // module: test.js
+
+require.register("utils.js", function(module, exports, require){
+/**
+ * Module dependencies.
+ */
+
+var fs = require('browser/fs')
+  , path = require('browser/path')
+  , basename = path.basename
+  , exists = fs.existsSync || path.existsSync
+  , glob = require('browser/glob')
+  , join = path.join
+  , debug = require('browser/debug')('mocha:watch');
+
+/**
+ * Ignored directories.
+ */
+
+var ignore = ['node_modules', '.git'];
+
+/**
+ * Escape special characters in the given string of html.
+ *
+ * @param  {String} html
+ * @return {String}
+ * @api private
+ */
+
+exports.escape = function(html){
+  return String(html)
+    .replace(/&/g, '&amp;')
+    .replace(/"/g, '&quot;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
+};
+
+/**
+ * Array#forEach (<=IE8)
+ *
+ * @param {Array} array
+ * @param {Function} fn
+ * @param {Object} scope
+ * @api private
+ */
+
+exports.forEach = function(arr, fn, scope){
+  for (var i = 0, l = arr.length; i < l; i++)
+    fn.call(scope, arr[i], i);
+};
+
+/**
+ * Array#map (<=IE8)
+ *
+ * @param {Array} array
+ * @param {Function} fn
+ * @param {Object} scope
+ * @api private
+ */
+
+exports.map = function(arr, fn, scope){
+  var result = [];
+  for (var i = 0, l = arr.length; i < l; i++)
+    result.push(fn.call(scope, arr[i], i));
+  return result;
+};
+
+/**
+ * Array#indexOf (<=IE8)
+ *
+ * @parma {Array} arr
+ * @param {Object} obj to find index of
+ * @param {Number} start
+ * @api private
+ */
+
+exports.indexOf = function(arr, obj, start){
+  for (var i = start || 0, l = arr.length; i < l; i++) {
+    if (arr[i] === obj)
+      return i;
+  }
+  return -1;
+};
+
+/**
+ * Array#reduce (<=IE8)
+ *
+ * @param {Array} array
+ * @param {Function} fn
+ * @param {Object} initial value
+ * @api private
+ */
+
+exports.reduce = function(arr, fn, val){
+  var rval = val;
+
+  for (var i = 0, l = arr.length; i < l; i++) {
+    rval = fn(rval, arr[i], i, arr);
+  }
+
+  return rval;
+};
+
+/**
+ * Array#filter (<=IE8)
+ *
+ * @param {Array} array
+ * @param {Function} fn
+ * @api private
+ */
+
+exports.filter = function(arr, fn){
+  var ret = [];
+
+  for (var i = 0, l = arr.length; i < l; i++) {
+    var val = arr[i];
+    if (fn(val, i, arr)) ret.push(val);
+  }
+
+  return ret;
+};
+
+/**
+ * Object.keys (<=IE8)
+ *
+ * @param {Object} obj
+ * @return {Array} keys
+ * @api private
+ */
+
+exports.keys = Object.keys || function(obj) {
+  var keys = []
+    , has = Object.prototype.hasOwnProperty // for `window` on <=IE8
+
+  for (var key in obj) {
+    if (has.call(obj, key)) {
+      keys.push(key);
+    }
+  }
+
+  return keys;
+};
+
+/**
+ * Watch the given `files` for changes
+ * and invoke `fn(file)` on modification.
+ *
+ * @param {Array} files
+ * @param {Function} fn
+ * @api private
+ */
+
+exports.watch = function(files, fn){
+  var options = { interval: 100 };
+  files.forEach(function(file){
+    debug('file %s', file);
+    fs.watchFile(file, options, function(curr, prev){
+      if (prev.mtime < curr.mtime) fn(file);
+    });
+  });
+};
+
+/**
+ * Ignored files.
+ */
+
+function ignored(path){
+  return !~ignore.indexOf(path);
+}
+
+/**
+ * Lookup files in the given `dir`.
+ *
+ * @return {Array}
+ * @api private
+ */
+
+exports.files = function(dir, ext, ret){
+  ret = ret || [];
+  ext = ext || ['js'];
+
+  var re = new RegExp('\\.(' + ext.join('|') + ')$');
+
+  fs.readdirSync(dir)
+  .filter(ignored)
+  .forEach(function(path){
+    path = join(dir, path);
+    if (fs.statSync(path).isDirectory()) {
+      exports.files(path, ext, ret);
+    } else if (path.match(re)) {
+      ret.push(path);
+    }
+  });
+
+  return ret;
+};
+
+/**
+ * Compute a slug from the given `str`.
+ *
+ * @param {String} str
+ * @return {String}
+ * @api private
+ */
+
+exports.slug = function(str){
+  return str
+    .toLowerCase()
+    .replace(/ +/g, '-')
+    .replace(/[^-\w]/g, '');
+};
+
+/**
+ * Strip the function definition from `str`,
+ * and re-indent for pre whitespace.
+ */
+
+exports.clean = function(str) {
+  str = str
+    .replace(/\r\n?|[\n\u2028\u2029]/g, "\n").replace(/^\uFEFF/, '')
+    .replace(/^function *\(.*\) *{|\(.*\) *=> *{?/, '')
+    .replace(/\s+\}$/, '');
+
+  var spaces = str.match(/^\n?( *)/)[1].length
+    , tabs = str.match(/^\n?(\t*)/)[1].length
+    , re = new RegExp('^\n?' + (tabs ? '\t' : ' ') + '{' + (tabs ? tabs : spaces) + '}', 'gm');
+
+  str = str.replace(re, '');
+
+  return exports.trim(str);
+};
+
+/**
+ * Trim the given `str`.
+ *
+ * @param {String} str
+ * @return {String}
+ * @api private
+ */
+
+exports.trim = function(str){
+  return str.replace(/^\s+|\s+$/g, '');
+};
+
+/**
+ * Parse the given `qs`.
+ *
+ * @param {String} qs
+ * @return {Object}
+ * @api private
+ */
+
+exports.parseQuery = function(qs){
+  return exports.reduce(qs.replace('?', '').split('&'), function(obj, pair){
+    var i = pair.indexOf('=')
+      , key = pair.slice(0, i)
+      , val = pair.slice(++i);
+
+    obj[key] = decodeURIComponent(val);
+    return obj;
+  }, {});
+};
+
+/**
+ * Highlight the given string of `js`.
+ *
+ * @param {String} js
+ * @return {String}
+ * @api private
+ */
+
+function highlight(js) {
+  return js
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/\/\/(.*)/gm, '<span class="comment">//$1</span>')
+    .replace(/('.*?')/gm, '<span class="string">$1</span>')
+    .replace(/(\d+\.\d+)/gm, '<span class="number">$1</span>')
+    .replace(/(\d+)/gm, '<span class="number">$1</span>')
+    .replace(/\bnew[ \t]+(\w+)/gm, '<span class="keyword">new</span> <span class="init">$1</span>')
+    .replace(/\b(function|new|throw|return|var|if|else)\b/gm, '<span class="keyword">$1</span>')
+}
+
+/**
+ * Highlight the contents of tag `name`.
+ *
+ * @param {String} name
+ * @api private
+ */
+
+exports.highlightTags = function(name) {
+  var code = document.getElementById('mocha').getElementsByTagName(name);
+  for (var i = 0, len = code.length; i < len; ++i) {
+    code[i].innerHTML = highlight(code[i].innerHTML);
+  }
+};
+
+/**
+ * If a value could have properties, and has none, this function is called, which returns
+ * a string representation of the empty value.
+ *
+ * Functions w/ no properties return `'[Function]'`
+ * Arrays w/ length === 0 return `'[]'`
+ * Objects w/ no properties return `'{}'`
+ * All else: return result of `value.toString()`
+ *
+ * @param {*} value Value to inspect
+ * @param {string} [type] The type of the value, if known.
+ * @returns {string}
+ */
+var emptyRepresentation = function emptyRepresentation(value, type) {
+  type = type || exports.type(value);
+
+  switch(type) {
+    case 'function':
+      return '[Function]';
+    case 'object':
+      return '{}';
+    case 'array':
+      return '[]';
+    default:
+      return value.toString();
+  }
+};
+
+/**
+ * Takes some variable and asks `{}.toString()` what it thinks it is.
+ * @param {*} value Anything
+ * @example
+ * type({}) // 'object'
+ * type([]) // 'array'
+ * type(1) // 'number'
+ * type(false) // 'boolean'
+ * type(Infinity) // 'number'
+ * type(null) // 'null'
+ * type(new Date()) // 'date'
+ * type(/foo/) // 'regexp'
+ * type('type') // 'string'
+ * type(global) // 'global'
+ * @api private
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toString
+ * @returns {string}
+ */
+exports.type = function type(value) {
+  if (typeof Buffer !== 'undefined' && Buffer.isBuffer(value)) {
+    return 'buffer';
+  }
+  return Object.prototype.toString.call(value)
+    .replace(/^\[.+\s(.+?)\]$/, '$1')
+    .toLowerCase();
+};
+
+/**
+ * @summary Stringify `value`.
+ * @description Different behavior depending on type of value.
+ * - If `value` is undefined or null, return `'[undefined]'` or `'[null]'`, respectively.
+ * - If `value` is not an object, function or array, return result of `value.toString()` wrapped in double-quotes.
+ * - If `value` is an *empty* object, function, or array, return result of function
+ *   {@link emptyRepresentation}.
+ * - If `value` has properties, call {@link exports.canonicalize} on it, then return result of
+ *   JSON.stringify().
+ *
+ * @see exports.type
+ * @param {*} value
+ * @return {string}
+ * @api private
+ */
+
+exports.stringify = function(value) {
+  var prop,
+    type = exports.type(value);
+
+  if (type === 'null' || type === 'undefined') {
+    return '[' + type + ']';
+  }
+
+  if (type === 'date') {
+    return '[Date: ' + value.toISOString() + ']';
+  }
+
+  if (!~exports.indexOf(['object', 'array', 'function'], type)) {
+    return value.toString();
+  }
+
+  for (prop in value) {
+    if (value.hasOwnProperty(prop)) {
+      return JSON.stringify(exports.canonicalize(value), null, 2).replace(/,(\n|$)/g, '$1');
+    }
+  }
+
+  return emptyRepresentation(value, type);
+};
+
+/**
+ * Return if obj is a Buffer
+ * @param {Object} arg
+ * @return {Boolean}
+ * @api private
+ */
+exports.isBuffer = function (arg) {
+  return typeof Buffer !== 'undefined' && Buffer.isBuffer(arg);
+};
+
+/**
+ * @summary Return a new Thing that has the keys in sorted order.  Recursive.
+ * @description If the Thing...
+ * - has already been seen, return string `'[Circular]'`
+ * - is `undefined`, return string `'[undefined]'`
+ * - is `null`, return value `null`
+ * - is some other primitive, return the value
+ * - is not a primitive or an `Array`, `Object`, or `Function`, return the value of the Thing's `toString()` method
+ * - is a non-empty `Array`, `Object`, or `Function`, return the result of calling this function again.
+ * - is an empty `Array`, `Object`, or `Function`, return the result of calling `emptyRepresentation()`
+ *
+ * @param {*} value Thing to inspect.  May or may not have properties.
+ * @param {Array} [stack=[]] Stack of seen values
+ * @return {(Object|Array|Function|string|undefined)}
+ * @see {@link exports.stringify}
+ * @api private
+ */
+
+exports.canonicalize = function(value, stack) {
+  var canonicalizedObj,
+    type = exports.type(value),
+    prop,
+    withStack = function withStack(value, fn) {
+      stack.push(value);
+      fn();
+      stack.pop();
+    };
+
+  stack = stack || [];
+
+  if (exports.indexOf(stack, value) !== -1) {
+    return '[Circular]';
+  }
+
+  switch(type) {
+    case 'undefined':
+      canonicalizedObj = '[undefined]';
+      break;
+    case 'buffer':
+    case 'null':
+      canonicalizedObj = value;
+      break;
+    case 'array':
+      withStack(value, function () {
+        canonicalizedObj = exports.map(value, function (item) {
+          return exports.canonicalize(item, stack);
+        });
+      });
+      break;
+    case 'date':
+      canonicalizedObj = '[Date: ' + value.toISOString() + ']';
+      break;
+    case 'function':
+      for (prop in value) {
+        canonicalizedObj = {};
+        break;
+      }
+      if (!canonicalizedObj) {
+        canonicalizedObj = emptyRepresentation(value, type);
+        break;
+      }
+    /* falls through */
+    case 'object':
+      canonicalizedObj = canonicalizedObj || {};
+      withStack(value, function () {
+        exports.forEach(exports.keys(value).sort(), function (key) {
+          canonicalizedObj[key] = exports.canonicalize(value[key], stack);
+        });
+      });
+      break;
+    case 'number':
+    case 'boolean':
+      canonicalizedObj = value;
+      break;
+    default:
+      canonicalizedObj = value.toString();
+  }
+
+  return canonicalizedObj;
+};
+
+/**
+ * Lookup file names at the given `path`.
+ */
+exports.lookupFiles = function lookupFiles(path, extensions, recursive) {
+  var files = [];
+  var re = new RegExp('\\.(' + extensions.join('|') + ')$');
+
+  if (!exists(path)) {
+    if (exists(path + '.js')) {
+      path += '.js';
+    } else {
+      files = glob.sync(path);
+      if (!files.length) throw new Error("cannot resolve path (or pattern) '" + path + "'");
+      return files;
+    }
+  }
+
+  try {
+    var stat = fs.statSync(path);
+    if (stat.isFile()) return path;
+  }
+  catch (ignored) {
+    return;
+  }
+
+  fs.readdirSync(path).forEach(function(file){
+    file = join(path, file);
+    try {
+      var stat = fs.statSync(file);
+      if (stat.isDirectory()) {
+        if (recursive) {
+          files = files.concat(lookupFiles(file, extensions, recursive));
+        }
+        return;
+      }
+    }
+    catch (ignored) {
+      return;
+    }
+    if (!stat.isFile() || !re.test(file) || basename(file)[0] === '.') return;
+    files.push(file);
+  });
+
+  return files;
+};
+
+/**
+ * Generate an undefined error with a message warning the user.
+ *
+ * @return {Error}
+ */
+
+exports.undefinedError = function(){
+  return new Error('Caught undefined error, did you throw without specifying what?');
+};
+
+/**
+ * Generate an undefined error if `err` is not defined.
+ *
+ * @param {Error} err
+ * @return {Error}
+ */
+
+exports.getError = function(err){
+  return err || exports.undefinedError();
+};
+
+
+}); // module: utils.js
+// The global object is "self" in Web Workers.
+var global = (function() { return this; })();
+
+/**
+ * Save timer references to avoid Sinon interfering (see GH-237).
+ */
+
+var Date = global.Date;
+var setTimeout = global.setTimeout;
+var setInterval = global.setInterval;
+var clearTimeout = global.clearTimeout;
+var clearInterval = global.clearInterval;
+
+/**
+ * Node shims.
+ *
+ * These are meant only to allow
+ * mocha.js to run untouched, not
+ * to allow running node code in
+ * the browser.
+ */
+
+var process = {};
+process.exit = function(status){};
+process.stdout = {};
+
+var uncaughtExceptionHandlers = [];
+
+var originalOnerrorHandler = global.onerror;
+
+/**
+ * Remove uncaughtException listener.
+ * Revert to original onerror handler if previously defined.
+ */
+
+process.removeListener = function(e, fn){
+  if ('uncaughtException' == e) {
+    if (originalOnerrorHandler) {
+      global.onerror = originalOnerrorHandler;
+    } else {
+      global.onerror = function() {};
+    }
+    var i = Mocha.utils.indexOf(uncaughtExceptionHandlers, fn);
+    if (i != -1) { uncaughtExceptionHandlers.splice(i, 1); }
+  }
+};
+
+/**
+ * Implements uncaughtException listener.
+ */
+
+process.on = function(e, fn){
+  if ('uncaughtException' == e) {
+    global.onerror = function(err, url, line){
+      fn(new Error(err + ' (' + url + ':' + line + ')'));
+      return true;
+    };
+    uncaughtExceptionHandlers.push(fn);
+  }
+};
+
+/**
+ * Expose mocha.
+ */
+
+var Mocha = global.Mocha = require('mocha'),
+    mocha = global.mocha = new Mocha({ reporter: 'html' });
+
+// The BDD UI is registered by default, but no UI will be functional in the
+// browser without an explicit call to the overridden `mocha.ui` (see below).
+// Ensure that this default UI does not expose its methods to the global scope.
+mocha.suite.removeAllListeners('pre-require');
+
+var immediateQueue = []
+  , immediateTimeout;
+
+function timeslice() {
+  var immediateStart = new Date().getTime();
+  while (immediateQueue.length && (new Date().getTime() - immediateStart) < 100) {
+    immediateQueue.shift()();
+  }
+  if (immediateQueue.length) {
+    immediateTimeout = setTimeout(timeslice, 0);
+  } else {
+    immediateTimeout = null;
+  }
+}
+
+/**
+ * High-performance override of Runner.immediately.
+ */
+
+Mocha.Runner.immediately = function(callback) {
+  immediateQueue.push(callback);
+  if (!immediateTimeout) {
+    immediateTimeout = setTimeout(timeslice, 0);
+  }
+};
+
+/**
+ * Function to allow assertion libraries to throw errors directly into mocha.
+ * This is useful when running tests in a browser because window.onerror will
+ * only receive the 'message' attribute of the Error.
+ */
+mocha.throwError = function(err) {
+  Mocha.utils.forEach(uncaughtExceptionHandlers, function (fn) {
+    fn(err);
+  });
+  throw err;
+};
+
+/**
+ * Override ui to ensure that the ui functions are initialized.
+ * Normally this would happen in Mocha.prototype.loadFiles.
+ */
+
+mocha.ui = function(ui){
+  Mocha.prototype.ui.call(this, ui);
+  this.suite.emit('pre-require', global, null, this);
+  return this;
+};
+
+/**
+ * Setup mocha with the given setting options.
+ */
+
+mocha.setup = function(opts){
+  if ('string' == typeof opts) opts = { ui: opts };
+  for (var opt in opts) this[opt](opts[opt]);
+  return this;
+};
+
+/**
+ * Run mocha, returning the Runner.
+ */
+
+mocha.run = function(fn){
+  var options = mocha.options;
+  mocha.globals('location');
+
+  var query = Mocha.utils.parseQuery(global.location.search || '');
+  if (query.grep) mocha.grep(query.grep);
+  if (query.invert) mocha.invert();
+
+  return Mocha.prototype.run.call(mocha, function(err){
+    // The DOM Document is not available in Web Workers.
+    var document = global.document;
+    if (document && document.getElementById('mocha') && options.noHighlighting !== true) {
+      Mocha.utils.highlightTags('code');
+    }
+    if (fn) fn(err);
+  });
+};
+
+/**
+ * Expose the process shim.
+ */
+
+Mocha.process = process;
+})();
diff --git a/packages/planner/node_modules/deepcopy/bower_components/power-assert/.bower.json b/packages/planner/node_modules/deepcopy/bower_components/power-assert/.bower.json
new file mode 100644
index 00000000..c721f682
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/power-assert/.bower.json
@@ -0,0 +1,56 @@
+{
+  "name": "power-assert",
+  "description": "Power Assert in JavaScript",
+  "main": "build/power-assert.js",
+  "license": "MIT",
+  "ignore": [
+    "**/.*",
+    "package.json",
+    "index.js",
+    "test",
+    "enable_power_assert.js"
+  ],
+  "keywords": [
+    "power-assert",
+    "test",
+    "assert",
+    "testing",
+    "ecmascript",
+    "ast"
+  ],
+  "authors": [
+    {
+      "name": "Takuto Wada",
+      "email": "takuto.wada@gmail.com",
+      "homepage": "https://github.com/twada"
+    },
+    {
+      "name": "azu",
+      "url": "https://github.com/azu"
+    },
+    {
+      "name": "vvakame",
+      "url": "https://github.com/vvakame"
+    }
+  ],
+  "homepage": "https://github.com/twada/power-assert",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/twada/power-assert.git"
+  },
+  "devDependencies": {
+    "expect": "~0.3.1",
+    "mocha": "~2.1.0",
+    "requirejs": "~2.1.15"
+  },
+  "version": "0.10.2",
+  "_release": "0.10.2",
+  "_resolution": {
+    "type": "version",
+    "tag": "v0.10.2",
+    "commit": "dae8b2b1dd7896e2167b043ca5a5625b7e1c0c3d"
+  },
+  "_source": "git://github.com/twada/power-assert.git",
+  "_target": "~0.10",
+  "_originalSource": "power-assert"
+}
\ No newline at end of file
diff --git a/packages/planner/node_modules/deepcopy/bower_components/power-assert/CHANGELOG.md b/packages/planner/node_modules/deepcopy/bower_components/power-assert/CHANGELOG.md
new file mode 100644
index 00000000..33b6aba4
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/power-assert/CHANGELOG.md
@@ -0,0 +1,217 @@
+### [0.10.2](https://github.com/twada/power-assert/releases/tag/v0.10.2) (2015-02-16)
+
+
+#### Bug Fixes
+
+* **power-assert:**
+  * update power-assert-formatter to 0.10.2 ([2c0f9624](https://github.com/twada/power-assert/commit/2c0f962415d60e59affb8f009ae4822f7b503c92)) to apply [stringifier fix]([67a9fa72](https://github.com/twada/stringifier/commit/67a9fa725c7602f948772f4f5f5a74806809ee34))
+
+
+#### Features
+
+* **power-assert:**
+  * ship npm module with built bundle for browsers ([431769f3](https://github.com/twada/power-assert/commit/431769f3d5da68c279ebf59b0cfd1231fa385361))
+  * add Node 0.12 and io.js to Travis build ([dd9629f9](https://github.com/twada/power-assert/commit/dd9629f96f3a204f6c24156f648b172f7c6abd4c))
+
+
+### [0.10.1](https://github.com/twada/power-assert/releases/tag/v0.10.1) (2015-01-09)
+
+
+#### Bug Fixes
+
+* **power-assert:**
+  * apply [assert.deepEqual fix](https://github.com/substack/node-browserify/pull/1041) in browserify 8.1.0 ([96302406](https://github.com/twada/power-assert/commit/963024062e6c144f2d5487d788e883f418a9c746))
+  * apply [dereserve](https://github.com/twada/dereserve) to browser build
+
+
+## [0.10.0](https://github.com/twada/power-assert/releases/tag/v0.10.0) (2014-11-12)
+
+
+#### Features
+
+* **power-assert:**
+  * [provide API for customization](https://github.com/twada/power-assert/pull/14) (see [CUSTOMIZATION API](https://github.com/twada/power-assert#customization-api))
+
+* **power-assert-formatter:**
+  * [diff option to make string diff function pluggable](https://github.com/twada/power-assert-formatter/pull/11) (new option [options.diff](https://github.com/twada/power-assert-formatter#optionsdiff))
+  * [outputOffset option to configure number of spaces inserted at the left](https://github.com/twada/power-assert-formatter/pull/12) (new option [options.outputOffset](https://github.com/twada/power-assert-formatter#optionsoutputoffset))
+  * [ambiguousEastAsianCharWidth option to make ambiguous east asian character width configurable](https://github.com/twada/power-assert-formatter/pull/13) (new option [options.ambiguousEastAsianCharWidth](https://github.com/twada/power-assert-formatter#optionsambiguouseastasiancharwidth))
+
+* **espowerify:**
+  * [transform file if and only if it is listed in browserify entries](https://github.com/twada/espowerify/pull/5)
+
+
+### 0.9.1 (2014-10-08)
+
+
+#### Bug Fixes
+
+* **empower:**
+  * power-assert output doesn't appear in Node 0.11.x ([53e882e0](https://github.com/twada/empower/commit/53e882e00ad3dd8b45f262ab14ac782ed582b954))
+
+
+## 0.9.0 (2014-09-02)
+
+
+#### Features
+
+Now power-assert 0.9.0 supports multi-stage sourcemaps.
+
+* **power-assert:**
+  * update empower and power-assert-formatter to 0.9.0 ([a84ca4e1](https://github.com/twada/power-assert/commit/a84ca4e1e67e6146452622743915bd78a5f417d0))
+
+* **empower:**
+  * There's no significant changes
+
+* **power-assert-formatter:**
+  * [Customizable Renderers](https://github.com/twada/power-assert-formatter/pull/10)
+  * move built-in renderers to ./built-in/ ([acf85109](https://github.com/twada/power-assert-formatter/commit/acf85109bcb579109b80a36a8a6439c4e028066d))
+  * customize rendering by using custom renderer constructor in `renderers` option ([265d3539](https://github.com/twada/power-assert-formatter/commit/265d353997f7321e9e24c5252c7aa0f4c696624a))
+  * use EventEmitter to make renderers customizable ([7c190e11](https://github.com/twada/power-assert-formatter/commit/7c190e1170de8c96129a2ccd3e67fd9f14623732))
+
+* **espower:**
+  * [SourceMap support](https://github.com/twada/espower/pull/11)
+  * adjust filepath in power-assert output if sourceMap option is given ([f919d59d](https://github.com/twada/espower/commit/f919d59d6eea764881e0266f562724b7142f7695))
+  * adjust line number in power-assert output if sourceMap option is given ([8c035d89](https://github.com/twada/espower/commit/8c035d89ae88c8554cb8ca0b6bd0f7d6fe2008b0))
+
+* **espower-source:**
+  * backport espowerify to support multi-stage sourcemaps ([71de737c](https://github.com/twada/espower-source/commit/71de737cb16231db852a44592e896a43c447298b))
+
+* **espower-loader:**
+  * use espower-source 0.9.0 ([c5329f39](https://github.com/twada/espower-loader/commit/c5329f397d4ab8e434a1788d0fa1c2eb7670a25c))
+
+* **grunt-espower:**
+  * [support multistage sourcemap by @vvakame](https://github.com/twada/grunt-espower/pull/2)
+  * Thanks @vvakame for the great contribution!
+
+* **gulp-espower:**
+  * [support gulp-sourcemaps](https://github.com/twada/gulp-espower/pull/2)
+
+* **espowerify:**
+  * use espower-source directly since espower-source 0.9.0 is backported from espowerify ([625cf55d](https://github.com/twada/espowerify/commit/625cf55d5b73893f4babd00c07489590ef786be0))
+  * use multi-stage-sourcemap module to generate more accurate sourcemaps ([b1f939fa](https://github.com/twada/espowerify/commit/b1f939faa84be7f4fde82313b2257042b336d25c))
+  * if upstream SourceMap is given, decode and offset it ([a1683475](https://github.com/twada/espowerify/commit/a1683475a588b0a5b0aee040f23dfb04ad902b11))
+
+* **espower-coffee:**
+  * interact with coffeescript compiler to adjust line number in power-assert output ([9c159205](https://github.com/twada/espower-coffee/commit/9c159205608e6a556f61167d1fb65123ae2421ab))
+
+
+#### Breaking Changes
+
+**No change is required if you are using default configuration.**
+
+* **power-assert-formatter:**
+  * built-in renderers are listed as relative path
+
+If you are customizing renderers by `options.renderers`, you may have to migrate.
+
+To migrate, change your code from the following:
+
+```
+[
+    'file',
+    'assertion',
+    'diagram',
+    'binary-expression'
+]
+```
+
+To:
+
+```
+ [
+    './built-in/file',
+    './built-in/assertion',
+    './built-in/diagram',
+    './built-in/binary-expression'
+ ]
+```
+
+ ([265d3539](https://github.com/twada/power-assert-formatter/commit/265d353997f7321e9e24c5252c7aa0f4c696624a)), ([acf85109](https://github.com/twada/power-assert-formatter/commit/acf85109bcb579109b80a36a8a6439c4e028066d))
+
+
+## 0.8.0 (2014-08-12)
+
+
+#### Features
+
+* **power-assert:**
+  * use single index.js ([e8fa666a](https://github.com/twada/power-assert/commit/e8fa666aa8197747ae56ca1a55fb171d30d7534c))
+  * update empower and power-assert-formatter to 0.8.0 ([8f760aa0](https://github.com/twada/power-assert/commit/8f760aa07271f3bcd52576dc503f3d301d67110c))
+
+* **empower:**
+  * [built and modularized by browserify](https://github.com/twada/empower/pull/12)
+  * use `escallmatch` module to describe target patterns ([533a21a0](https://github.com/twada/empower/commit/533a21a0374f23f5ca4e198c17d1e20f10d705fa))
+  * support assertion methods with three or more arguments ([d31dca86](https://github.com/twada/empower/commit/d31dca86de2b05ee88ca5df15579308368657d43))
+  * if not in patterns, do not empower assertion function itself ([1d73a756](https://github.com/twada/empower/commit/1d73a7560ef586a45a0a9259e57c143b3b60caaa))
+  * option `targetMethods` does not required any more ([8ffcc49f](https://github.com/twada/empower/commit/8ffcc49fcdb5523eb38e63a0e7cca34f752d9302))
+  * rename `saveContextOnFail` option to `saveContextOnRethrow` ([1f6133b2](https://github.com/twada/empower/commit/1f6133b24be672f32cfd3b66522a7d14ca5d22e1))
+  * rename `modifyMessageOnFail` option to `modifyMessageOnRethrow` ([0c8a88f0](https://github.com/twada/empower/commit/0c8a88f0592917ba15ac0c1bf21c8f39f39ab350))
+
+* **power-assert-formatter:**
+  * [built and modularized by browserify](https://github.com/twada/power-assert-formatter/pull/8)
+  * [use spun-off stringifier module](https://github.com/twada/power-assert-formatter/pull/9)
+
+* **espower:**
+  * [built and modularized by browserify](https://github.com/twada/espower/pull/9)
+  * [use escallmatch module to describe instrumentation target patterns](https://github.com/twada/espower/pull/10)
+  * support chained callee like `browser.assert.element(selector)` ([ea0a3ce9](https://github.com/twada/espower/commit/ea0a3ce96f56034ab6735365184e1e397f6561c0))
+
+* **espower-source:**
+  * update espower to 0.8.0 ([ae15a229](https://github.com/twada/espower-source/commit/ae15a229367c65a7a590104f3fb0fc0b2a7582d0))
+  * simple xtend would be better for options handling ([6bea0a92](https://github.com/twada/espower-source/commit/6bea0a9241aba71f2dcae9c285561e68d91531bb))
+
+* **espower-loader:**
+  * update espower-source to 0.8.0 ([54c2143b](https://github.com/twada/espower-loader/commit/54c2143bba3966aaf61f1a4d331f3543257f9222))
+
+* **grunt-espower:**
+  * update espower-source to 0.8.0 ([55110fa4](https://github.com/twada/grunt-espower/commit/55110fa4bffab62045d207d0460eaa864cc9fa8e))
+
+* **gulp-espower:**
+  * update espower-source to 0.8.0 ([a9ab1f7d](https://github.com/twada/gulp-espower/commit/a9ab1f7de7275b717589bd8eb8048b89bc575763))
+  * now supports streams as well ([ada19f90](https://github.com/twada/gulp-espower/commit/ada19f90f0dfc674405342310259e31ddd3a6dd0))
+
+* **espowerify:**
+  * update espower-source to 0.8.0 ([026bd0c6](https://github.com/twada/espowerify/commit/026bd0c6e2d1200084051612dc262ab5509a5652))
+
+* **espower-coffee:**
+  * update espower-source to 0.8.0 ([8702d847](https://github.com/twada/espower-coffee/commit/8702d84704d659919e96801014c4653539b7b3f0))
+  * [now in beta stage](https://github.com/twada/espower-coffee/commit/a357b3d35460b9abd17517375d737a8a0bce98dd)
+
+
+#### Breaking Changes
+
+First of all, **No change is required if you are using default configuration.**
+
+* **instrumentors:**
+
+  Version 0.8.0 introduces [escallmatch](https://github.com/twada/escallmatch) syntax for configuration.
+  
+  If you are:
+    * using instrumentors such as `espower-loader`, `grunt-espower`, `gulp-espower`, `espowerify` and `espower-coffee`
+    * or using `espower-source` or `espower` directly
+
+  And
+
+    * having custom instrumentation pattern using `powerAssertVariableName` or `targetMethods` property
+  
+  Then you need to migarte. To migrate, please see CHANGELOG for the instrumentor you choose.
+
+  * [espower-loader CHANGELOG](https://github.com/twada/espower-loader/blob/master/CHANGELOG.md)
+  * [grunt-espower CHANGELOG](https://github.com/twada/grunt-espower/blob/master/CHANGELOG.md)
+  * [gulp-espower CHANGELOG](https://github.com/twada/gulp-espower/blob/master/CHANGELOG.md)
+  * [espowerify CHANGELOG](https://github.com/twada/espowerify/blob/master/CHANGELOG.md)
+  * [espower-coffee CHANGELOG](https://github.com/twada/espower-coffee/blob/master/CHANGELOG.md)
+  * [espower-source CHANGELOG](https://github.com/twada/espower-source/blob/master/CHANGELOG.md)
+  * [espower CHANGELOG](https://github.com/twada/espower/blob/master/CHANGELOG.md)
+
+
+* **empower:**
+  * `saveContextOnFail` option is renamed to `saveContextOnRethrow`
+  * `modifyMessageOnFail` option is renamed to `modifyMessageOnRethrow`
+  * option `targetMethods` does not required any more
+  * Please see [empower CHANGELOG](https://github.com/twada/empower/blob/master/CHANGELOG.md) for more details.
+
+* **power-assert-formatter:**
+  * option `stringifyDepth` does not supported any more. use `maxDepth` option instead.
+  * Please see [power-assert-formatter CHANGELOG](https://github.com/twada/power-assert-formatter/blob/master/CHANGELOG.md) for more details.
diff --git a/packages/planner/node_modules/deepcopy/bower_components/power-assert/MIT-LICENSE.txt b/packages/planner/node_modules/deepcopy/bower_components/power-assert/MIT-LICENSE.txt
new file mode 100644
index 00000000..60e64e43
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/power-assert/MIT-LICENSE.txt
@@ -0,0 +1,20 @@
+Copyright (c) 2013-2015 Takuto Wada, https://github.com/twada/power-assert
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/packages/planner/node_modules/deepcopy/bower_components/power-assert/README.md b/packages/planner/node_modules/deepcopy/bower_components/power-assert/README.md
new file mode 100644
index 00000000..00a1558f
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/power-assert/README.md
@@ -0,0 +1,982 @@
+power-assert
+================================
+
+Power Assert in JavaScript. Provides descriptive assertion messages through standard [assert](http://nodejs.org/api/assert.html) interface.
+
+[![Build Status][travis-image]][travis-url]
+[![NPM package][npm-image]][npm-url]
+[![Bower package][bower-image]][bower-url]
+[![Dependency Status][depstat-image]][depstat-url]
+[![License][license-image]][license-url]
+
+
+DESCRIPTION
+---------------------------------------
+
+What is `power-assert`?
+
+ * is an implementation of "Power Assert" concept in JavaScript.
+ * provides descriptive assertion messages through standard [assert](http://nodejs.org/api/assert.html) interface.
+ * see slides: ["power-assert, mechanism and philosophy"](http://www.slideshare.net/t_wada/power-assert-nodefest-2014) -- talk at NodeFest 2014.
+ * to use power-assert, you need to transform your test code to show power-assert output.
+ * with power-assert, you don't need to learn many assertion library APIs. It's just [assert](http://nodejs.org/api/assert.html).
+ * fully compatible with [assert](http://nodejs.org/api/assert.html). So you can stop using power-assert and back to assert easily.
+ * has [online demo site](http://azu.github.io/power-assert-demo/).
+ * works both on server side and browser side.
+ * available via [npm](https://www.npmjs.com/package/power-assert) and [bower](http://bower.io/search/?q=power-assert). 
+ * supports sourcemaps so you can debug as usual.
+ * provides [browserify transform](http://github.com/twada/espowerify).
+ * provides [webpack loader](https://github.com/zoncoen/webpack-espower-loader).
+ * provides [grunt task](http://github.com/twada/grunt-espower) and [gulp plugin](http://github.com/twada/gulp-espower).
+ * provides [command](http://github.com/twada/espower-cli).
+ * provides [custom module loader](http://github.com/twada/espower-loader) and its [convenient config module](https://github.com/azu/intelli-espower-loader).
+ * provides [karma preprocessor](https://github.com/vvakame/karma-espower-preprocessor).
+ * supports ES6 through [Traceur Compiler](https://github.com/yosuke-furukawa/espower-traceur) or [Babel](https://github.com/azu/espower-babel).
+ * supports [CoffeeScript](http://github.com/twada/espower-coffee).
+ * has [TypeScript type definition](https://github.com/borisyankov/DefinitelyTyped/blob/master/power-assert/power-assert.d.ts)
+ * is a beta version product. Pull-requests, issue reports and patches are always welcomed.
+
+
+`power-assert` provides descriptive assertion messages for your tests, like this.
+
+      1) Array #indexOf() should return index when the value is present:
+         AssertionError: # /path/to/test/mocha_node.js:10
+    
+      assert(this.ary.indexOf(zero) === two)
+                  |   |       |     |   |
+                  |   |       |     |   2
+                  |   -1      0     false
+                  [1,2,3]
+    
+      [number] two
+      => 2
+      [number] this.ary.indexOf(zero)
+      => -1
+
+
+API
+---------------------------------------
+
+power-assert enhances these assert functions. Produces descriptive message when assertion is failed.
+
+* `assert(value, [message])`
+* `assert.ok(value, [message])`
+* `assert.equal(actual, expected, [message])`
+* `assert.notEqual(actual, expected, [message])`
+* `assert.strictEqual(actual, expected, [message])`
+* `assert.notStrictEqual(actual, expected, [message])`
+* `assert.deepEqual(actual, expected, [message])`
+* `assert.notDeepEqual(actual, expected, [message])`
+
+power-assert is fully compatible with [assert](http://nodejs.org/api/assert.html). So functions below are also available though they are not enhanced (does not produce descriptive message).
+
+* `assert.fail(actual, expected, message, operator)`
+* `assert.throws(block, [error], [message])`
+* `assert.doesNotThrow(block, [message])`
+* `assert.ifError(value)`
+
+power-assert provides an [API for customization](https://github.com/twada/power-assert#customization-api).
+
+* `assert.customize(options)`
+
+As written below, power-assert is constructed with many family modules. See more details of [empower](http://github.com/twada/empower) and others.
+
+
+CHANGELOG
+---------------------------------------
+See [CHANGELOG](https://github.com/twada/power-assert/blob/master/CHANGELOG.md)
+
+
+EXAMPLE
+---------------------------------------
+
+See [HOW TO USE](https://github.com/twada/power-assert#how-to-use) section for more details.
+
+__Note:__ There is an [online demo site](http://azu.github.io/power-assert-demo/) available.
+
+
+### Target test code (using Mocha in this example)
+
+```javascript
+var assert = require('power-assert');
+
+describe('Array', function(){
+    beforeEach(function(){
+        this.ary = [1,2,3];
+    });
+    describe('#indexOf()', function(){
+        it('should return index when the value is present', function(){
+            var zero = 0, two = 2;
+            assert(this.ary.indexOf(zero) === two);
+        });
+        it('should return -1 when the value is not present', function(){
+            var minusOne = -1, two = 2;
+            assert.ok(this.ary.indexOf(two) === minusOne, 'THIS IS AN ASSERTION MESSAGE');
+        });
+    });
+});
+
+describe('various types', function(){
+    function Person(name, age) {
+        this.name = name;
+        this.age = age;
+    }
+    beforeEach(function(){
+        this.types = [
+            'string', 98.6, true, false, null, undefined,
+            ['nested', 'array'],
+            {object: true},
+            NaN, Infinity,
+            /^not/,
+            new Person('alice', 3)
+        ];
+    });
+    it('demo', function(){
+        var index = this.types.length -1,
+            bob = new Person('bob', 5);
+        assert(this.types[index].name === bob.name);
+    });
+});
+```
+
+### Be sure to transform test code
+
+To use power-assert, you need to transform your test code for power-assert output.
+
+Code transform is done by instrumentors below:
+
+ - [espower-loader](http://github.com/twada/espower-loader) (with [intelli-espower-loader](https://github.com/azu/intelli-espower-loader))
+ - [espower-cli](http://github.com/twada/espower-cli)
+ - [espowerify](http://github.com/twada/espowerify)
+ - [webpack-espower-loader](https://github.com/zoncoen/webpack-espower-loader).
+ - [grunt-espower](http://github.com/twada/grunt-espower)
+ - [gulp-espower](http://github.com/twada/gulp-espower)
+ - [karma-espower-preprocessor](https://github.com/vvakame/karma-espower-preprocessor)
+ - [espower-coffee](http://github.com/twada/espower-coffee)
+ - [espower-traceur](https://github.com/yosuke-furukawa/espower-traceur)
+ - [espower-babel](https://github.com/azu/espower-babel)
+
+If you are using Node.js only, the easiest way is to use [intelli-espower-loader](https://github.com/azu/intelli-espower-loader). Steps are as follows.
+
+
+### Setup
+
+`npm install --save-dev mocha power-assert intelli-espower-loader`
+
+### Add directories to package.json
+
+```json
+  "directories": {
+    "test": "test/"
+  },
+```
+
+### See the power-assert output appears.
+
+      $ mocha --require intelli-espower-loader /path/to/test/mocha_node.js
+    
+      Array
+        #indexOf()
+          1) should return index when the value is present
+          2) should return -1 when the value is not present
+      
+      various types
+        3) demo    
+    
+      0 passing (14 ms)
+      3 failing
+    
+      1) Array #indexOf() should return index when the value is present:
+         AssertionError: # /path/to/test/mocha_node.js:10
+      
+        assert(this.ary.indexOf(zero) === two)
+                    |   |       |     |   |
+                    |   |       |     |   2
+                    |   -1      0     false
+                    [1,2,3]
+        
+        [number] two
+        => 2
+        [number] this.ary.indexOf(zero)
+        => -1
+
+          at decoratedAssert (/path/to/node_modules/power-assert/node_modules/empower/lib/decorate.js:44:26)
+          at powerAssert (/path/to/node_modules/power-assert/node_modules/empower/index.js:57:32)
+          at Context.<anonymous> (/path/to/test/mocha_node.js:13:13)
+      
+      
+      2) Array #indexOf() should return -1 when the value is not present:
+         AssertionError: THIS IS AN ASSERTION MESSAGE # /path/to/test/mocha_node.js:14
+    
+        assert.ok(this.ary.indexOf(two) === minusOne, 'THIS IS AN ASSERTION MESSAGE')
+                       |   |       |    |   |
+                       |   |       |    |   -1
+                       |   1       2    false
+                       [1,2,3]
+        
+        [number] minusOne
+        => -1
+        [number] this.ary.indexOf(two)
+        => 1
+      
+          at Function.decoratedAssert [as ok] (/path/to/node_modules/power-assert/node_modules/empower/lib/decorate.js:44:26)
+          at Context.<anonymous> (/path/to/test/mocha_node.js:21:20)
+      
+      
+      3) various types demo:
+         AssertionError: # /path/to/test/mocha_node.js:37
+    
+        assert(this.types[index].name === bob.name)
+                    |    ||      |    |   |   |
+                    |    ||      |    |   |   "bob"
+                    |    ||      |    |   Person{name:"bob",age:5}
+                    |    ||      |    false
+                    |    |11     "alice"
+                    |    Person{name:"alice",age:3}
+                    ["string",98.6,true,false,null,undefined,#Array#,#Object#,NaN,Infinity,/^not/,#Person#]
+        
+        --- [string] bob.name
+        +++ [string] this.types[index].name
+        @@ -1,3 +1,5 @@
+        -bob
+        +alice
+        
+        
+          at decoratedAssert (/path/to/node_modules/power-assert/node_modules/empower/lib/decorate.js:44:26)
+          at powerAssert (/path/to/node_modules/power-assert/node_modules/empower/index.js:57:32)
+          at Context.<anonymous> (/path/to/test/mocha_node.js:55:9)
+
+
+SEED PROJECTS
+---------------------------------------
+
+Some seed projects are available to help you start with power-assert.
+
+| module | env | tech stack |
+|:-------|:------------|:------------|
+| [power-assert-node-seed](https://github.com/azu/power-assert-node-seed) | Node.js | power-assert + [intelli-espower-loader](https://github.com/azu/intelli-espower-loader) |
+| [power-assert-testem-seed](https://github.com/azu/power-assert-testem-seed) | Browsers(by [testem](https://github.com/airportyh/testem)) | power-assert + [gulp-espower](http://github.com/twada/gulp-espower) + [testem](https://github.com/airportyh/testem). |
+| [power-assert-karma-seed](https://github.com/azu/power-assert-karma-seed) | Browsers(by [Karma](http://karma-runner.github.io/)) | power-assert + [espowerify](http://github.com/twada/espowerify) + [browserify](http://browserify.org/) + [Karma](http://karma-runner.github.io/). |
+
+
+HOW TO USE
+---------------------------------------
+
+There are four ways to use power-assert. (If you want to see running examples, see [SEED PROJECTS](#seed-projects))
+
+1. `power-assert` + `espower-loader`: Highly recommended but only works under Node.
+2. `power-assert` + `espower-coffee` or `espower-traceur` or `espower-babel` : Use power-assert through transpilers. Recommended but only works under Node.
+3. `power-assert` + `espowerify` or `webpack-espower-loader`: Recommended if you are using [browserify](http://browserify.org/) or [webpack](http://webpack.github.io/).
+4. `power-assert` + `espower-cli` or `grunt-espower` or `gulp-espower` : Generate instrumented code so works anywhere.
+
+
+### using `espower-loader`
+
+If you are writing Node.js app/module, you can instrument Power Assert feature without code generation by using `espower-loader`.
+
+First, install `power-assert` and `espower-loader` via npm.
+
+    $ npm install --save-dev power-assert espower-loader
+
+Second, require `power-assert` in your test.
+
+    --- a/test/your_test.js
+    +++ b/test/your_test.js
+    @@ -1,4 +1,4 @@
+    -var assert = require('assert');
+    +var assert = require('power-assert');
+
+
+Third, put `enable-power-assert.js` somewhere in your project, where `pattern` matches to target test files.
+
+```javascript
+require('espower-loader')({
+    // directory where match starts with
+    cwd: process.cwd(),
+    // glob pattern using minimatch module
+    pattern: 'test/**/*.js'
+});
+```
+
+Then run mocha, with `--require` option. No code generation required.
+
+    $ mocha --require ./path/to/enable-power-assert test/your_test.js
+
+
+FYI: You may be interested in [intelli-espower-loader](https://github.com/azu/intelli-espower-loader) to go one step further. With [intelli-espower-loader](https://github.com/azu/intelli-espower-loader), you don't need to create loader file (like `enable-power-assert.js`). Just define test directory in `package.json` wow!
+
+
+### using `espower-coffee`
+
+If you are writing Node.js app/module in CoffeeScript, you can instrument Power Assert feature without code generation by using `espower-coffee`.
+
+see [espower-coffee README](https://github.com/twada/espower-coffee).
+
+
+### using `espower-traceur` or `espower-babel`
+
+If you are writing Node.js app/module in ES6, you can instrument Power Assert feature without code generation by using `espower-traceur` or `espower-babel`. `espower-traceur` uses [Traceur Compiler](https://github.com/google/traceur-compiler/), `espower-babel` uses [Babel](https://babeljs.io/).
+
+see [espower-traceur README](https://github.com/yosuke-furukawa/espower-traceur) or [espower-babel README](https://github.com/azu/espower-babel).
+
+
+### using `espowerify`
+
+On the browser side and you are using [browserify](http://browserify.org/), you can instrument Power Assert feature via `espowerify`.
+
+see [espowerify README](https://github.com/twada/espowerify).
+
+
+### using `webpack-espower-loader`
+
+If you are using [webpack](http://webpack.github.io/), you can instrument Power Assert feature via `webpack-espower-loader`.
+
+see [webpack-espower-loader README](https://github.com/zoncoen/webpack-espower-loader).
+
+
+
+### using `espower-cli`
+
+On the browser side and you don't want to use grunt,gulp or browserify, you can use `power-assert` via bower, with generated code by `espower-cli`
+
+First, install `power-assert` via bower and `espower-cli` via npm. This means that you run `espower` command (on Node), then run tests on browser.
+
+    $ bower install --save-dev power-assert
+    $ npm install --save-dev espower-cli
+
+Second, require `build/power-assert.js` (all-in-one build for browsers) in your test html.
+
+    <script type="text/javascript" src="./path/to/bower_components/power-assert/build/power-assert.js"></script>
+
+Then, generate espowered code.
+
+    $ espower test/your_test.js > powered/your_test.js
+
+Lastly, run your test in your way. For example,
+
+    $ mocha-phantomjs path/to/test.html
+
+
+
+### using `grunt-espower`
+
+On the browser side and you are not using [browserify](http://browserify.org/) but [bower](http://bower.io/) and [Grunt](http://gruntjs.com/), you can use `power-assert` via bower, with generated code by `grunt-espower`
+
+First, install `power-assert` via bower and `grunt-espower` via npm. This means that you run grunt (on Node), then run tests on browser.
+
+    $ bower install --save-dev power-assert
+    $ npm install --save-dev grunt-espower
+
+Second, require `build/power-assert.js` (all-in-one build for browsers) in your test html.
+
+    <script type="text/javascript" src="./path/to/bower_components/power-assert/build/power-assert.js"></script>
+
+Third, configure `grunt-espower` task to  generate espowered code.
+
+```javascript
+grunt.initConfig({
+
+  . . . 
+
+  espower: {
+    test: {
+      files: [
+        {
+          expand: true,        // Enable dynamic expansion.
+          cwd: 'test/',        // Src matches are relative to this path.
+          src: ['**/*.js'],    // Actual pattern(s) to match.
+          dest: 'espowered/',  // Destination path prefix.
+          ext: '.js'           // Dest filepaths will have this extension.
+        }
+      ]
+    },
+  },
+
+  . . . 
+
+})
+```
+
+Then, generate espowered code using `espower` task.
+
+    $ grunt espower:test
+
+Lastly, run your test in your way. For example,
+
+    $ grunt test
+
+
+
+
+### using `gulp-espower`
+
+On the browser side and you are not using [browserify](http://browserify.org/) but [bower](http://bower.io/) and [gulp](http://gulpjs.com/), you can use `power-assert` via bower, with generated code by `gulp-espower`
+
+First, install `power-assert` via bower and `gulp-espower` via npm. This means that you run gulp (on Node), then run tests on browser.
+
+    $ bower install --save-dev power-assert
+    $ npm install --save-dev gulp-espower
+
+Second, require `build/power-assert.js` (all-in-one build for browsers) in your test html.
+
+    <script type="text/javascript" src="./path/to/bower_components/power-assert/build/power-assert.js"></script>
+
+Third, configure `gulp-espower` task to generate espowered code.
+
+```javascript
+var gulp = require('gulp'),
+    espower = require('gulp-espower');
+  . . . 
+gulp.task('espower', function() {
+    return gulp
+        .src('test/**/*_test.js', {base: './test/'})
+        .pipe(espower())
+        .pipe(gulp.dest('espowered'));
+});
+  . . . 
+})
+```
+
+Then, generate espowered code (in this example, using `espower` task).
+
+    $ gulp espower
+
+Lastly, run your test in your way. For example,
+
+    $ gulp test
+
+
+
+
+CUSTOMIZATION API
+---------------------------------------
+
+`power-assert` provides an API for customization.
+
+### var assert = assert.customize(options)
+
+Through this API, you can customize power-assert by changing some options.
+
+```javascript
+var assert = require('power-assert').customize({
+    output: {
+        maxDepth: 2
+    }
+});
+```
+
+### options
+
+`options` has two top-level keys. `assertion` and `output`.
+
+#### options.assertion
+
+customization options for [empower](http://github.com/twada/empower) module. See [empower API documentation](https://github.com/twada/empower#api) for details. Note that some default values are different from `empower`'s (`modifyMessageOnRethrow: true` and `saveContextOnRethrow: true`).
+
+#### options.output
+
+customization options for [power-assert-formatter](http://github.com/twada/power-assert-formatter) module. See [power-assert-formatter API documentation](https://github.com/twada/power-assert-formatter#api) for details.
+
+#### default values
+
+customizable properties and their default values are as follows.
+
+```
+var assert = require('power-assert').customize({
+    assertion: {
+        destructive: false,
+        modifyMessageOnRethrow: true,
+        saveContextOnRethrow: true,
+        patterns: [
+            'assert(value, [message])',
+            'assert.ok(value, [message])',
+            'assert.equal(actual, expected, [message])',
+            'assert.notEqual(actual, expected, [message])',
+            'assert.strictEqual(actual, expected, [message])',
+            'assert.notStrictEqual(actual, expected, [message])',
+            'assert.deepEqual(actual, expected, [message])',
+            'assert.notDeepEqual(actual, expected, [message])'
+        ]
+    },
+    output: {
+        lineDiffThreshold: 5,
+        maxDepth: 1,
+        anonymous: 'Object',
+        circular: '#@Circular#',
+        lineSeparator: '\n',
+        ambiguousEastAsianCharWidth: 2,
+        widthOf: (Function to calculate width of string. Please see power-assert-formatter's documentation)
+        stringify: (Function to stringify any target value. Please see power-assert-formatter's documentation)
+        diff: (Function to create diff string between two strings. Please see power-assert-formatter's documentation)
+        writerClass: (Constructor Function for output writer class. Please see power-assert-formatter's documentation)
+        renderers: [
+            './built-in/file',
+            './built-in/assertion',
+            './built-in/diagram',
+            './built-in/binary-expression'
+        ]
+    }
+});
+```
+
+
+INTERNAL DESIGN
+---------------------------------------
+
+`power-assert` family provides 1 main module, 4 core modules and many more instrumentors.
+
+
+Main (facade) module is,
+
+| module | description |
+|:-------|:------------|
+| [power-assert](http://github.com/twada/power-assert) | Standard `assert` function on top of `empower` and `power-assert-formatter` |
+
+core modules are,
+
+| module | description |
+|:-------|:------------|
+| [empower](http://github.com/twada/empower) | Power Assert feature enhancer for assert function/object. |
+| [power-assert-formatter](http://github.com/twada/power-assert-formatter) | Power Assert output formatter. |
+| [espower](http://github.com/twada/espower) | Power Assert feature instrumentor core based on the [Mozilla JavaScript AST](https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API). |
+| [espower-source](http://github.com/twada/espower-source) | Power Assert instrumentor from source to source, with source-map. (Thin wrapper of `espower`). |
+
+and instrumentors are,
+
+| module | description |
+|:-------|:------------|
+| [espower-cli](http://github.com/twada/espower-cli) | Command line tool for power-assert. |
+| [espower-loader](http://github.com/twada/espower-loader) | Node module loader to apply `espower` on the fly. |
+| [intelli-espower-loader](https://github.com/azu/intelli-espower-loader) | configure `espower-loader` with ease. |
+| [espowerify](http://github.com/twada/espowerify) | [Browserify](http://browserify.org/) transform to apply `espower` to target files. |
+| [webpack-espower-loader](https://github.com/zoncoen/webpack-espower-loader) | Power Assert instrumentor module for [webpack](http://webpack.github.io/). |
+| [grunt-espower](http://github.com/twada/grunt-espower) | Grunt task to apply `espower` to target files. |
+| [gulp-espower](http://github.com/twada/gulp-espower) | Gulp plugin to apply `espower` to target files. |
+| [karma-espower-preprocessor](https://github.com/vvakame/karma-espower-preprocessor) | karma-preprocessor for power-assert. |
+| [espower-coffee](http://github.com/twada/espower-coffee) | power-assert instrumentor for CoffeeScript. |
+| [espower-traceur](https://github.com/yosuke-furukawa/espower-traceur) | power-assert instrumentor for ES6 using [Traceur Compiler](https://github.com/google/traceur-compiler/). |
+| [espower-babel](https://github.com/azu/espower-babel) | power-assert instrumentor for ES6 using [Babel](https://babeljs.io/). |
+
+
+`power-assert` provides standard [assert](http://nodejs.org/api/assert.html) compatible function with Power Assert feature.
+(Best fit with [Mocha](http://visionmedia.github.io/mocha/). If you use assert-like objects provided by various testing frameworks such as [QUnit](http://qunitjs.com/) or [nodeunit](https://github.com/caolan/nodeunit). Please use [empower](http://github.com/twada/empower) and [power-assert-formatter](http://github.com/twada/power-assert-formatter) modules directly).
+
+
+Internally, `power-assert` uses [empower](http://github.com/twada/empower) module to enhance power assert feature into the standard [assert](http://nodejs.org/api/assert.html) module, to run with the power assert feature added code by [espower](http://github.com/twada/espower) module, and prettify output using [power-assert-formatter](http://github.com/twada/power-assert-formatter).
+
+
+See [power-assert-demo](http://github.com/twada/power-assert-demo) project for power-assert Demo running with mocha.
+
+
+TESTED FRAMEWORKS
+---------------------------------------
+* [Mocha](http://visionmedia.github.io/mocha/)
+* [QUnit](http://qunitjs.com/)
+* [nodeunit](https://github.com/caolan/nodeunit)
+* [buster-assertions](http://docs.busterjs.org/en/latest/modules/buster-assertions/)
+
+
+TESTED ENVIRONMENTS
+---------------------------------------
+* [Node.js](http://nodejs.org/)
+* [Rhino](https://developer.mozilla.org/en/Rhino)
+* [PhantomJS](http://phantomjs.org/)
+* [RequireJS](http://requirejs.org/)
+* [Browserify](http://browserify.org/)
+
+
+AUTHOR
+---------------------------------------
+* [Takuto Wada](http://github.com/twada)
+
+
+CONTRIBUTORS
+---------------------------------------
+* [azu](https://github.com/azu)
+* [vvakame](https://github.com/vvakame)
+
+
+LICENSE
+---------------------------------------
+Licensed under the [MIT](https://github.com/twada/power-assert/blob/master/MIT-LICENSE.txt) license.
+
+
+
+MORE OUTPUT EXAMPLES
+---------------------------------------
+
+### Target test code (using QUnit in this example)
+
+```javascript
+var q = require('qunitjs');
+
+(function () {
+    var empower = require('empower'),
+        formatter = require('power-assert-formatter'),
+        qunitTap = require("qunit-tap");
+    empower(q.assert, formatter(), {destructive: true});
+    qunitTap(q, require('util').puts, {showSourceOnFailure: false});
+    q.config.autorun = false;
+})();
+
+q.test('spike', function (assert) {
+    assert.ok(true);
+
+    var hoge = 'foo';
+    var fuga = 'bar';
+    assert.ok(hoge === fuga, 'comment');
+
+    var piyo = 3;
+    assert.ok(fuga === piyo);
+
+    var longString = 'very very loooooooooooooooooooooooooooooooooooooooooooooooooooong message';
+    var anotherLongString = 'yet another loooooooooooooooooooooooooooooooooooooooooooooooooooong message';
+    assert.ok(longString === anotherLongString);
+
+    assert.ok(4 === piyo);
+
+    assert.ok(4 !== 4);
+
+    var falsyStr = '';
+    assert.ok(falsyStr);
+
+    var falsyNum = 0;
+    assert.ok(falsyNum);
+
+    var ary1 = ['foo', 'bar'];
+    var ary2 = ['aaa', 'bbb', 'ccc'];
+    assert.ok(ary1.length === ary2.length);
+    assert.deepEqual(ary1, ary2);
+
+    var actual = 16;
+    assert.ok(5 < actual && actual < 13);
+
+    actual = 4;
+    assert.ok(5 < actual && actual < 13);
+
+    actual = 10;
+    assert.ok(actual < 5 || 13 < actual);
+
+
+    var propName = 'bar',
+        foo = {
+            bar: {
+                baz: false
+            }
+        };
+
+    assert.ok(foo.bar.baz);
+    assert.ok(foo['bar'].baz);
+    assert.ok(foo[propName]['baz']);
+
+
+    var truth = true;
+    assert.ok(!truth);
+
+
+    var func = function () { return false; };
+    assert.ok(func());
+
+
+    var obj = {
+        age: function () {
+            return 0;
+        }
+    };
+    assert.ok(obj.age());
+
+
+    var isFalsy = function (arg) {
+        return !(arg);
+    };
+    var positiveInt = 50;
+    assert.ok(isFalsy(positiveInt));
+
+
+    var sum = function () {
+        var result = 0;
+        for (var i = 0; i < arguments.length; i += 1) {
+            result += arguments[i];
+        }
+        return result;
+    };
+    var one = 1, two = 2, three = 3, seven = 7, ten = 10;
+    assert.ok(sum(one, two, three) === seven);
+    assert.ok(sum(sum(one, two), three) === sum(sum(two, three), seven));
+    assert.ok((three * (seven * ten)) === three);
+
+
+    var math = {
+        calc: {
+            sum: function () {
+                var result = 0;
+                for (var i = 0; i < arguments.length; i += 1) {
+                    result += arguments[i];
+                }
+                return result;
+            }
+        }
+    };
+    assert.ok(math.calc.sum(one, two, three) === seven);
+});
+
+q.load();
+```
+
+
+### `espower` code above then running under Node.js
+    
+```
+# module: undefined
+# test: spike
+ok 1 - okay
+not ok 2 - comment # /path/to/examples/qunit_node.js:17
+#
+# assert.ok(hoge === fuga, 'comment')
+#           |    |   |
+#           |    |   "bar"
+#           |    false
+#           "foo"
+#
+# --- [string] fuga
+# +++ [string] hoge
+# @@ -1,3 +1,3 @@
+# -bar
+# +foo
+#
+# , test: spike
+not ok 3 - # /path/to/examples/qunit_node.js:20
+#
+# assert.ok(fuga === piyo)
+#           |    |   |
+#           |    |   3
+#           |    false
+#           "bar"
+#
+# [number] piyo
+# => 3
+# [string] fuga
+# => "bar"
+
+# , test: spike
+not ok 4 - # /path/to/examples/qunit_node.js:24
+#
+# assert.ok(longString === anotherLongString)
+#           |          |   |
+#           |          |   "yet another loooooooooooooooooooooooooooooooooooooooooooooooooooong message"
+#           |          false
+#           "very very loooooooooooooooooooooooooooooooooooooooooooooooooooong message"
+#
+# --- [string] anotherLongString
+# +++ [string] longString
+# @@ -1,15 +1,13 @@
+# -yet anoth
+# +very v
+#  er
+# +y
+#   loo
+#
+# , test: spike
+not ok 5 - # /path/to/examples/qunit_node.js:26
+#
+# assert.ok(4 === piyo)
+#             |   |
+#             |   3
+#             false
+#
+# [number] piyo
+# => 3
+# [number] 4
+# => 4
+# , test: spike
+not ok 6 - # /path/to/examples/qunit_node.js:28
+#
+# assert.ok(4 !== 4)
+#             |
+#             false
+# , test: spike
+not ok 7 - # /path/to/examples/qunit_node.js:31
+#
+# assert.ok(falsyStr)
+#           |
+#           ""
+# , test: spike
+not ok 8 - # /path/to/examples/qunit_node.js:34
+#
+# assert.ok(falsyNum)
+#           |
+#           0
+# , test: spike
+not ok 9 - # /path/to/examples/qunit_node.js:38
+#
+# assert.ok(ary1.length === ary2.length)
+#           |    |      |   |    |
+#           |    |      |   |    3
+#           |    |      |   ["aaa","bbb","ccc"]
+#           |    2      false
+#           ["foo","bar"]
+#
+# [number] ary2.length
+# => 3
+# [number] ary1.length
+# => 2
+# , test: spike
+not ok 10 - # /path/to/examples/qunit_node.js:39
+#
+# assert.deepEqual(ary1, ary2)
+#                  |     |
+#                  |     ["aaa","bbb","ccc"]
+#                  ["foo","bar"]
+# , expected: [
+#   "aaa",
+#   "bbb",
+#   "ccc"
+# ], got: [
+#   "foo",
+#   "bar"
+# ], test: spike
+not ok 11 - # /path/to/examples/qunit_node.js:42
+#
+# assert.ok(5 < actual && actual < 13)
+#             | |      |  |      |
+#             | |      |  16     false
+#             | 16     false
+#             true
+# , test: spike
+not ok 12 - # /path/to/examples/qunit_node.js:45
+#
+# assert.ok(5 < actual && actual < 13)
+#             | |      |
+#             | 4      false
+#             false
+# , test: spike
+not ok 13 - # /path/to/examples/qunit_node.js:48
+#
+# assert.ok(actual < 5 || 13 < actual)
+#           |      |   |     | |
+#           |      |   |     | 10
+#           |      |   false false
+#           10     false
+# , test: spike
+not ok 14 - # /path/to/examples/qunit_node.js:58
+#
+# assert.ok(foo.bar.baz)
+#           |   |   |
+#           |   |   false
+#           |   Object{baz:false}
+#           Object{bar:#Object#}
+# , test: spike
+not ok 15 - # /path/to/examples/qunit_node.js:59
+#
+# assert.ok(foo['bar'].baz)
+#           |  |       |
+#           |  |       false
+#           |  Object{baz:false}
+#           Object{bar:#Object#}
+# , test: spike
+not ok 16 - # /path/to/examples/qunit_node.js:60
+#
+# assert.ok(foo[propName]['baz'])
+#           |  ||        |
+#           |  |"bar"    false
+#           |  Object{baz:false}
+#           Object{bar:#Object#}
+# , test: spike
+not ok 17 - # /path/to/examples/qunit_node.js:64
+#
+# assert.ok(!truth)
+#           ||
+#           |true
+#           false
+# , test: spike
+not ok 18 - # /path/to/examples/qunit_node.js:68
+#
+# assert.ok(func())
+#           |
+#           false
+# , test: spike
+not ok 19 - # /path/to/examples/qunit_node.js:76
+#
+# assert.ok(obj.age())
+#           |   |
+#           |   0
+#           Object{age:#function#}
+# , test: spike
+not ok 20 - # /path/to/examples/qunit_node.js:83
+#
+# assert.ok(isFalsy(positiveInt))
+#           |       |
+#           false   50
+# , test: spike
+not ok 21 - # /path/to/examples/qunit_node.js:94
+#
+# assert.ok(sum(one, two, three) === seven)
+#           |   |    |    |      |   |
+#           |   |    |    |      |   7
+#           6   1    2    3      false
+#
+# [number] seven
+# => 7
+# [number] sum(one, two, three)
+# => 6
+# , test: spike
+not ok 22 - # /path/to/examples/qunit_node.js:95
+#
+# assert.ok(sum(sum(one, two), three) === sum(sum(two, three), seven))
+#           |   |   |    |     |      |   |   |   |    |       |
+#           |   |   |    |     |      |   12  5   2    3       7
+#           6   3   1    2     3      false
+#
+# [number] sum(sum(two, three), seven)
+# => 12
+# [number] sum(sum(one, two), three)
+# => 6
+# , test: spike
+not ok 23 - # /path/to/examples/qunit_node.js:96
+#
+# assert.ok(three * (seven * ten) === three)
+#           |     |  |     | |    |   |
+#           |     |  |     | |    |   3
+#           |     |  |     | 10   false
+#           |     |  7     70
+#           3     210
+#
+# [number] three
+# => 3
+# [number] three * (seven * ten)
+# => 210
+# , test: spike
+not ok 24 - # /path/to/examples/qunit_node.js:110
+#
+# assert.ok(math.calc.sum(one, two, three) === seven)
+#           |    |    |   |    |    |      |   |
+#           |    |    |   |    |    |      |   7
+#           |    |    6   1    2    3      false
+#           |    Object{sum:#function#}
+#           Object{calc:#Object#}
+#
+# [number] seven
+# => 7
+# [number] math.calc.sum(one, two, three)
+# => 6
+# , test: spike
+1..24
+```
+
+Have fun!
+
+
+[npm-url]: https://npmjs.org/package/power-assert
+[npm-image]: https://badge.fury.io/js/power-assert.svg
+
+[bower-url]: http://badge.fury.io/bo/power-assert
+[bower-image]: https://badge.fury.io/bo/power-assert.svg
+
+[travis-url]: http://travis-ci.org/twada/power-assert
+[travis-image]: https://secure.travis-ci.org/twada/power-assert.svg?branch=master
+
+[depstat-url]: https://gemnasium.com/twada/power-assert
+[depstat-image]: https://gemnasium.com/twada/power-assert.svg
+
+[license-url]: https://github.com/twada/power-assert/blob/master/MIT-LICENSE.txt
+[license-image]: http://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat
diff --git a/packages/planner/node_modules/deepcopy/bower_components/power-assert/bower.json b/packages/planner/node_modules/deepcopy/bower_components/power-assert/bower.json
new file mode 100644
index 00000000..5cf8cdf8
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/power-assert/bower.json
@@ -0,0 +1,46 @@
+{
+  "name": "power-assert",
+  "description": "Power Assert in JavaScript",
+  "main": "build/power-assert.js",
+  "license": "MIT",
+  "ignore": [
+    "**/.*",
+    "package.json",
+    "index.js",
+    "test",
+    "enable_power_assert.js"
+  ],
+  "keywords": [
+    "power-assert",
+    "test",
+    "assert",
+    "testing",
+    "ecmascript",
+    "ast"
+  ],
+  "authors": [
+    {
+      "name": "Takuto Wada",
+      "email": "takuto.wada@gmail.com",
+      "homepage": "https://github.com/twada"
+    },
+    {
+      "name": "azu",
+      "url": "https://github.com/azu"
+    },
+    {
+      "name": "vvakame",
+      "url": "https://github.com/vvakame"
+    }
+  ],
+  "homepage": "https://github.com/twada/power-assert",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/twada/power-assert.git"
+  },
+  "devDependencies": {
+    "expect": "~0.3.1",
+    "mocha": "~2.1.0",
+    "requirejs": "~2.1.15"
+  }
+}
diff --git a/packages/planner/node_modules/deepcopy/bower_components/power-assert/build/power-assert.js b/packages/planner/node_modules/deepcopy/bower_components/power-assert/build/power-assert.js
new file mode 100644
index 00000000..113289bb
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/bower_components/power-assert/build/power-assert.js
@@ -0,0 +1,11647 @@
+!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.assert=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw (f.code="MODULE_NOT_FOUND", f)}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
+// http://wiki.commonjs.org/wiki/Unit_Testing/1.0
+//
+// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!
+//
+// Originally from narwhal.js (http://narwhaljs.org)
+// Copyright (c) 2009 Thomas Robinson <280north.com>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the 'Software'), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// when used in node, this will actually load the util module we depend on
+// versus loading the builtin util module as happens otherwise
+// this is a bug in node module loading as far as I am concerned
+var util = _dereq_('util/');
+
+var pSlice = Array.prototype.slice;
+var hasOwn = Object.prototype.hasOwnProperty;
+
+// 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;
+
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(this, stackStartFunction);
+  }
+  else {
+    // non v8 browsers so we can have a stacktrace
+    var err = new Error();
+    if (err.stack) {
+      var out = err.stack;
+
+      // try to strip useless frames
+      var fn_name = stackStartFunction.name;
+      var idx = out.indexOf('\n' + fn_name);
+      if (idx >= 0) {
+        // once we have located the function frame
+        // we need to strip out everything before it (and its line)
+        var next_line = out.indexOf('\n', idx + 1);
+        out = out.substring(next_line + 1);
+      }
+
+      this.stack = out;
+    }
+  }
+};
+
+// assert.AssertionError instanceof Error
+util.inherits(assert.AssertionError, Error);
+
+function replacer(key, value) {
+  if (util.isUndefined(value)) {
+    return '' + value;
+  }
+  if (util.isNumber(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.isBuffer(actual) && util.isBuffer(expected)) {
+    if (actual.length != expected.length) return false;
+
+    for (var i = 0; i < actual.length; i++) {
+      if (actual[i] !== expected[i]) return false;
+    }
+
+    return true;
+
+  // 7.2. If the expected value is a Date object, the actual value is
+  // equivalent if it is also a Date object that refers to the same time.
+  } 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;
+  // if one is a primitive, the other must be same
+  if (util.isPrimitive(a) || util.isPrimitive(b)) {
+    return a === b;
+  }
+  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);
+  }
+  var ka = objectKeys(a),
+      kb = objectKeys(b),
+      key, i;
+  // 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;}};
+
+var objectKeys = Object.keys || function (obj) {
+  var keys = [];
+  for (var key in obj) {
+    if (hasOwn.call(obj, key)) keys.push(key);
+  }
+  return keys;
+};
+
+},{"util/":6}],2:[function(_dereq_,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+function EventEmitter() {
+  this._events = this._events || {};
+  this._maxListeners = this._maxListeners || undefined;
+}
+module.exports = EventEmitter;
+
+// Backwards-compat with node 0.10.x
+EventEmitter.EventEmitter = EventEmitter;
+
+EventEmitter.prototype._events = undefined;
+EventEmitter.prototype._maxListeners = undefined;
+
+// By default EventEmitters will print a warning if more than 10 listeners are
+// added to it. This is a useful default which helps finding memory leaks.
+EventEmitter.defaultMaxListeners = 10;
+
+// Obviously not all Emitters should be limited to 10. This function allows
+// that to be increased. Set to zero for unlimited.
+EventEmitter.prototype.setMaxListeners = function(n) {
+  if (!isNumber(n) || n < 0 || isNaN(n))
+    throw TypeError('n must be a positive number');
+  this._maxListeners = n;
+  return this;
+};
+
+EventEmitter.prototype.emit = function(type) {
+  var er, handler, len, args, i, listeners;
+
+  if (!this._events)
+    this._events = {};
+
+  // If there is no 'error' event listener then throw.
+  if (type === 'error') {
+    if (!this._events.error ||
+        (isObject(this._events.error) && !this._events.error.length)) {
+      er = arguments[1];
+      if (er instanceof Error) {
+        throw er; // Unhandled 'error' event
+      }
+      throw TypeError('Uncaught, unspecified "error" event.');
+    }
+  }
+
+  handler = this._events[type];
+
+  if (isUndefined(handler))
+    return false;
+
+  if (isFunction(handler)) {
+    switch (arguments.length) {
+      // fast cases
+      case 1:
+        handler.call(this);
+        break;
+      case 2:
+        handler.call(this, arguments[1]);
+        break;
+      case 3:
+        handler.call(this, arguments[1], arguments[2]);
+        break;
+      // slower
+      default:
+        len = arguments.length;
+        args = new Array(len - 1);
+        for (i = 1; i < len; i++)
+          args[i - 1] = arguments[i];
+        handler.apply(this, args);
+    }
+  } else if (isObject(handler)) {
+    len = arguments.length;
+    args = new Array(len - 1);
+    for (i = 1; i < len; i++)
+      args[i - 1] = arguments[i];
+
+    listeners = handler.slice();
+    len = listeners.length;
+    for (i = 0; i < len; i++)
+      listeners[i].apply(this, args);
+  }
+
+  return true;
+};
+
+EventEmitter.prototype.addListener = function(type, listener) {
+  var m;
+
+  if (!isFunction(listener))
+    throw TypeError('listener must be a function');
+
+  if (!this._events)
+    this._events = {};
+
+  // To avoid recursion in the case that type === "newListener"! Before
+  // adding it to the listeners, first emit "newListener".
+  if (this._events.newListener)
+    this.emit('newListener', type,
+              isFunction(listener.listener) ?
+              listener.listener : listener);
+
+  if (!this._events[type])
+    // Optimize the case of one listener. Don't need the extra array object.
+    this._events[type] = listener;
+  else if (isObject(this._events[type]))
+    // If we've already got an array, just append.
+    this._events[type].push(listener);
+  else
+    // Adding the second element, need to change to array.
+    this._events[type] = [this._events[type], listener];
+
+  // Check for listener leak
+  if (isObject(this._events[type]) && !this._events[type].warned) {
+    var m;
+    if (!isUndefined(this._maxListeners)) {
+      m = this._maxListeners;
+    } else {
+      m = EventEmitter.defaultMaxListeners;
+    }
+
+    if (m && m > 0 && this._events[type].length > m) {
+      this._events[type].warned = true;
+      console.error('(node) warning: possible EventEmitter memory ' +
+                    'leak detected. %d listeners added. ' +
+                    'Use emitter.setMaxListeners() to increase limit.',
+                    this._events[type].length);
+      if (typeof console.trace === 'function') {
+        // not supported in IE 10
+        console.trace();
+      }
+    }
+  }
+
+  return this;
+};
+
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+EventEmitter.prototype.once = function(type, listener) {
+  if (!isFunction(listener))
+    throw TypeError('listener must be a function');
+
+  var fired = false;
+
+  function g() {
+    this.removeListener(type, g);
+
+    if (!fired) {
+      fired = true;
+      listener.apply(this, arguments);
+    }
+  }
+
+  g.listener = listener;
+  this.on(type, g);
+
+  return this;
+};
+
+// emits a 'removeListener' event iff the listener was removed
+EventEmitter.prototype.removeListener = function(type, listener) {
+  var list, position, length, i;
+
+  if (!isFunction(listener))
+    throw TypeError('listener must be a function');
+
+  if (!this._events || !this._events[type])
+    return this;
+
+  list = this._events[type];
+  length = list.length;
+  position = -1;
+
+  if (list === listener ||
+      (isFunction(list.listener) && list.listener === listener)) {
+    delete this._events[type];
+    if (this._events.removeListener)
+      this.emit('removeListener', type, listener);
+
+  } else if (isObject(list)) {
+    for (i = length; i-- > 0;) {
+      if (list[i] === listener ||
+          (list[i].listener && list[i].listener === listener)) {
+        position = i;
+        break;
+      }
+    }
+
+    if (position < 0)
+      return this;
+
+    if (list.length === 1) {
+      list.length = 0;
+      delete this._events[type];
+    } else {
+      list.splice(position, 1);
+    }
+
+    if (this._events.removeListener)
+      this.emit('removeListener', type, listener);
+  }
+
+  return this;
+};
+
+EventEmitter.prototype.removeAllListeners = function(type) {
+  var key, listeners;
+
+  if (!this._events)
+    return this;
+
+  // not listening for removeListener, no need to emit
+  if (!this._events.removeListener) {
+    if (arguments.length === 0)
+      this._events = {};
+    else if (this._events[type])
+      delete this._events[type];
+    return this;
+  }
+
+  // emit removeListener for all listeners on all events
+  if (arguments.length === 0) {
+    for (key in this._events) {
+      if (key === 'removeListener') continue;
+      this.removeAllListeners(key);
+    }
+    this.removeAllListeners('removeListener');
+    this._events = {};
+    return this;
+  }
+
+  listeners = this._events[type];
+
+  if (isFunction(listeners)) {
+    this.removeListener(type, listeners);
+  } else {
+    // LIFO order
+    while (listeners.length)
+      this.removeListener(type, listeners[listeners.length - 1]);
+  }
+  delete this._events[type];
+
+  return this;
+};
+
+EventEmitter.prototype.listeners = function(type) {
+  var ret;
+  if (!this._events || !this._events[type])
+    ret = [];
+  else if (isFunction(this._events[type]))
+    ret = [this._events[type]];
+  else
+    ret = this._events[type].slice();
+  return ret;
+};
+
+EventEmitter.listenerCount = function(emitter, type) {
+  var ret;
+  if (!emitter._events || !emitter._events[type])
+    ret = 0;
+  else if (isFunction(emitter._events[type]))
+    ret = 1;
+  else
+    ret = emitter._events[type].length;
+  return ret;
+};
+
+function isFunction(arg) {
+  return typeof arg === 'function';
+}
+
+function isNumber(arg) {
+  return typeof arg === 'number';
+}
+
+function isObject(arg) {
+  return typeof arg === 'object' && arg !== null;
+}
+
+function isUndefined(arg) {
+  return arg === void 0;
+}
+
+},{}],3:[function(_dereq_,module,exports){
+if (typeof Object.create === 'function') {
+  // implementation from standard node.js 'util' module
+  module.exports = function inherits(ctor, superCtor) {
+    ctor.super_ = superCtor
+    ctor.prototype = Object.create(superCtor.prototype, {
+      constructor: {
+        value: ctor,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+  };
+} else {
+  // old school shim for old browsers
+  module.exports = function inherits(ctor, superCtor) {
+    ctor.super_ = superCtor
+    var TempCtor = function () {}
+    TempCtor.prototype = superCtor.prototype
+    ctor.prototype = new TempCtor()
+    ctor.prototype.constructor = ctor
+  }
+}
+
+},{}],4:[function(_dereq_,module,exports){
+// shim for using process in browser
+
+var process = module.exports = {};
+var queue = [];
+var draining = false;
+
+function drainQueue() {
+    if (draining) {
+        return;
+    }
+    draining = true;
+    var currentQueue;
+    var len = queue.length;
+    while(len) {
+        currentQueue = queue;
+        queue = [];
+        var i = -1;
+        while (++i < len) {
+            currentQueue[i]();
+        }
+        len = queue.length;
+    }
+    draining = false;
+}
+process.nextTick = function (fun) {
+    queue.push(fun);
+    if (!draining) {
+        setTimeout(drainQueue, 0);
+    }
+};
+
+process.title = 'browser';
+process.browser = true;
+process.env = {};
+process.argv = [];
+process.version = ''; // empty string to avoid regexp issues
+
+function noop() {}
+
+process.on = noop;
+process.addListener = noop;
+process.once = noop;
+process.off = noop;
+process.removeListener = noop;
+process.removeAllListeners = noop;
+process.emit = noop;
+
+process.binding = function (name) {
+    throw new Error('process.binding is not supported');
+};
+
+// TODO(shtylman)
+process.cwd = function () { return '/' };
+process.chdir = function (dir) {
+    throw new Error('process.chdir is not supported');
+};
+process.umask = function() { return 0; };
+
+},{}],5:[function(_dereq_,module,exports){
+module.exports = function isBuffer(arg) {
+  return arg && typeof arg === 'object'
+    && typeof arg.copy === 'function'
+    && typeof arg.fill === 'function'
+    && typeof arg.readUInt8 === 'function';
+}
+},{}],6:[function(_dereq_,module,exports){
+(function (process,global){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+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);
+  }
+
+  // IE doesn't make error fields non-enumerable
+  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
+  if (isError(value)
+      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
+    return formatError(value);
+  }
+
+  // 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);
+    }
+  }
+
+  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);
+  }
+
+  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))
+    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 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, "'");
+      name = ctx.stylize(name, 'string');
+    }
+  }
+
+  return name + ': ' + str;
+}
+
+
+function reduceToSingleString(output, base, braces) {
+  var numLinesEst = 0;
+  var length = output.reduce(function(prev, cur) {
+    numLinesEst++;
+    if (cur.indexOf('\n') >= 0) numLinesEst++;
+    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()`.
+function isArray(ar) {
+  return Array.isArray(ar);
+}
+exports.isArray = 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;
+
+exports.isBuffer = _dereq_('./support/isBuffer');
+
+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));
+};
+
+
+/**
+ * Inherit the prototype methods from one constructor into another.
+ *
+ * The Function.prototype.inherits from lang.js rewritten as a standalone
+ * function (not on Function.prototype). NOTE: If this file is to be loaded
+ * during bootstrapping this function needs to be rewritten using some native
+ * functions as prototype setup using normal JavaScript does not work as
+ * expected during bootstrapping (see mirror.js in r114903).
+ *
+ * @param {function} ctor Constructor function which needs to inherit the
+ *     prototype.
+ * @param {function} superCtor Constructor function to inherit prototype from.
+ */
+exports.inherits = _dereq_('inherits');
+
+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);
+}
+
+}).call(this,_dereq_('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./support/isBuffer":5,"_process":4,"inherits":3}],7:[function(_dereq_,module,exports){
+/**
+ * power-assert.js - Power Assert in JavaScript.
+ *
+ * https://github.com/twada/power-assert
+ *
+ * Copyright (c) 2013-2015 Takuto Wada
+ * Licensed under the MIT license.
+ *   https://github.com/twada/power-assert/blob/master/MIT-LICENSE.txt
+ */
+'use strict';
+
+var baseAssert = _dereq_('assert'),
+    empower = _dereq_('empower'),
+    formatter = _dereq_('power-assert-formatter'),
+    extend = _dereq_('xtend'),
+    empowerOptions = {modifyMessageOnRethrow: true, saveContextOnRethrow: true};
+
+function customize (customOptions) {
+    var options = customOptions || {};
+    var poweredAssert = empower(
+        baseAssert,
+        formatter(options.output),
+        extend(empowerOptions, options.assertion)
+    );
+    poweredAssert.customize = customize;
+    return poweredAssert;
+}
+
+module.exports = customize();
+
+},{"assert":1,"empower":8,"power-assert-formatter":22,"xtend":45}],8:[function(_dereq_,module,exports){
+/**
+ * empower - Power Assert feature enhancer for assert function/object.
+ *
+ * https://github.com/twada/empower
+ *
+ * Copyright (c) 2013-2014 Takuto Wada
+ * Licensed under the MIT license.
+ *   https://github.com/twada/empower/blob/master/MIT-LICENSE.txt
+ */
+var defaultOptions = _dereq_('./lib/default-options'),
+    Decorator = _dereq_('./lib/decorator'),
+    slice = Array.prototype.slice,
+    extend = _dereq_('xtend/mutable');
+
+/**
+ * Enhance Power Assert feature to assert function/object.
+ * @param assert target assert function or object to enhance
+ * @param formatter power assert format function
+ * @param options enhancement options
+ * @return enhanced assert function/object
+ */
+function empower (assert, formatter, options) {
+    var typeOfAssert = (typeof assert),
+        config;
+    if ((typeOfAssert !== 'object' && typeOfAssert !== 'function') || assert === null) {
+        throw new TypeError('empower argument should be a function or object.');
+    }
+    if (isEmpowered(assert)) {
+        return assert;
+    }
+    config = extend(defaultOptions(), options);
+    switch (typeOfAssert) {
+    case 'function':
+        return empowerAssertFunction(assert, formatter, config);
+    case 'object':
+        return empowerAssertObject(assert, formatter, config);
+    default:
+        throw new Error('Cannot be here');
+    }
+}
+
+function empowerAssertObject (assertObject, formatter, config) {
+    var target = config.destructive ? assertObject : Object.create(assertObject);
+    var decorator = new Decorator(target, formatter, config);
+    return extend(target, decorator.enhancement());
+}
+
+function empowerAssertFunction (assertFunction, formatter, config) {
+    if (config.destructive) {
+        throw new Error('cannot use destructive:true to function.');
+    }
+    var decorator = new Decorator(assertFunction, formatter, config);
+    var enhancement = decorator.enhancement();
+    var powerAssert;
+    if (typeof enhancement === 'function') {
+        powerAssert = function powerAssert () {
+            return enhancement.apply(null, slice.apply(arguments));
+        };
+    } else {
+        powerAssert = function powerAssert () {
+            return assertFunction.apply(null, slice.apply(arguments));
+        };
+    }
+    extend(powerAssert, assertFunction);
+    return extend(powerAssert, enhancement);
+}
+
+function isEmpowered (assertObjectOrFunction) {
+    return (typeof assertObjectOrFunction._capt === 'function') && (typeof assertObjectOrFunction._expr === 'function');
+}
+
+empower.defaultOptions = defaultOptions;
+module.exports = empower;
+
+},{"./lib/decorator":11,"./lib/default-options":12,"xtend/mutable":46}],9:[function(_dereq_,module,exports){
+'use strict';
+
+module.exports = function capturable () {
+    var events = [];
+
+    function _capt (value, espath) {
+        events.push({value: value, espath: espath});
+        return value;
+    }
+
+    function _expr (value, args) {
+        var captured = events;
+        events = [];
+        return {
+            powerAssertContext: {
+                value: value,
+                events: captured
+            },
+            source: {
+                content: args.content,
+                filepath: args.filepath,
+                line: args.line
+            }
+        };
+    }
+
+    return {
+        _capt: _capt,
+        _expr: _expr
+    };
+};
+
+},{}],10:[function(_dereq_,module,exports){
+'use strict';
+
+var slice = Array.prototype.slice;
+
+function decorate (callSpec, decorator) {
+    var func = callSpec.func,
+        thisObj = callSpec.thisObj,
+        numArgsToCapture = callSpec.numArgsToCapture;
+
+    return function decoratedAssert () {
+        var context, message, args = slice.apply(arguments);
+
+        if (args.every(isNotCaptured)) {
+            return func.apply(thisObj, args);
+        }
+
+        var values = args.slice(0, numArgsToCapture).map(function (arg) {
+            if (isNotCaptured(arg)) {
+                return arg;
+            }
+            if (!context) {
+                context = {
+                    source: arg.source,
+                    args: []
+                };
+            }
+            context.args.push({
+                value: arg.powerAssertContext.value,
+                events: arg.powerAssertContext.events
+            });
+            return arg.powerAssertContext.value;
+        });
+
+        if (numArgsToCapture === (args.length - 1)) {
+            message = args[args.length - 1];
+        }
+
+        var invocation = {
+            thisObj: thisObj,
+            func: func,
+            values: values,
+            message: message
+        };
+        return decorator.concreteAssert(invocation, context);
+    };
+}
+
+function isNotCaptured (value) {
+    return !isCaptured(value);
+}
+
+function isCaptured (value) {
+    return (typeof value === 'object') &&
+        (value !== null) &&
+        (typeof value.powerAssertContext !== 'undefined');
+}
+
+module.exports = decorate;
+
+},{}],11:[function(_dereq_,module,exports){
+'use strict';
+
+var escallmatch = _dereq_('escallmatch'),
+    extend = _dereq_('xtend/mutable'),
+    capturable = _dereq_('./capturable'),
+    decorate = _dereq_('./decorate');
+
+
+function Decorator (receiver, formatter, config) {
+    this.receiver = receiver;
+    this.formatter = formatter;
+    this.config = config;
+    this.matchers = config.patterns.map(escallmatch);
+    this.eagerEvaluation = !(config.modifyMessageOnRethrow || config.saveContextOnRethrow);
+}
+
+Decorator.prototype.enhancement = function () {
+    var that = this;
+    var container = this.container();
+    this.matchers.filter(methodCall).forEach(function (matcher) {
+        var methodName = detectMethodName(matcher.calleeAst());
+        if (typeof that.receiver[methodName] === 'function') {
+            var callSpec = {
+                thisObj: that.receiver,
+                func: that.receiver[methodName],
+                numArgsToCapture: numberOfArgumentsToCapture(matcher)
+            };
+            container[methodName] = decorate(callSpec, that);
+        }
+    });
+    extend(container, capturable());
+    return container;
+};
+
+Decorator.prototype.container = function () {
+    var basement = {};
+    if (typeof this.receiver === 'function') {
+        var candidates = this.matchers.filter(functionCall);
+        if (candidates.length === 1) {
+            var callSpec = {
+                thisObj: null,
+                func: this.receiver,
+                numArgsToCapture: numberOfArgumentsToCapture(candidates[0])
+            };
+            basement = decorate(callSpec, this);
+        }
+    }
+    return basement;
+};
+
+Decorator.prototype.concreteAssert = function (invocation, context) {
+    var func = invocation.func,
+        thisObj = invocation.thisObj,
+        args = invocation.values,
+        message = invocation.message;
+    if (this.eagerEvaluation) {
+        var poweredMessage = this.buildPowerAssertText(message, context);
+        return func.apply(thisObj, args.concat(poweredMessage));
+    }
+    try {
+        return func.apply(thisObj, args.concat(message));
+    } catch (e) {
+        throw this.errorToRethrow(e, message, context);
+    }
+};
+
+Decorator.prototype.errorToRethrow = function (e, originalMessage, context) {
+    if (e.name !== 'AssertionError') {
+        return e;
+    }
+    if (typeof this.receiver.AssertionError !== 'function') {
+        return e;
+    }
+    var f = new this.receiver.AssertionError({
+        actual: e.actual,
+        expected: e.expected,
+        operator: e.operator,
+        message: this.config.modifyMessageOnRethrow ? this.buildPowerAssertText(originalMessage, context) : e.message,
+        stackStartFunction: Decorator.prototype.concreteAssert
+    });
+    if (this.config.saveContextOnRethrow) {
+        f.powerAssertContext = context;
+    }
+    return f;
+};
+
+Decorator.prototype.buildPowerAssertText = function (message, context) {
+    var powerAssertText = this.formatter(context);
+    return message ? message + ' ' + powerAssertText : powerAssertText;
+};
+
+
+function numberOfArgumentsToCapture (matcher) {
+    var argSpecs = matcher.argumentSignatures(),
+        len = argSpecs.length,
+        lastArg;
+    if (0 < len) {
+        lastArg = argSpecs[len - 1];
+        if (lastArg.name === 'message' && lastArg.kind === 'optional') {
+            len -= 1;
+        }
+    }
+    return len;
+}
+
+
+function detectMethodName (node) {
+    if (node.type === 'MemberExpression') {
+        return node.property.name;
+    }
+    return null;
+}
+
+
+function functionCall (matcher) {
+    return matcher.calleeAst().type === 'Identifier';
+}
+
+
+function methodCall (matcher) {
+    return matcher.calleeAst().type === 'MemberExpression';
+}
+
+
+module.exports = Decorator;
+
+},{"./capturable":9,"./decorate":10,"escallmatch":13,"xtend/mutable":46}],12:[function(_dereq_,module,exports){
+'use strict';
+
+module.exports = function defaultOptions () {
+    return {
+        destructive: false,
+        modifyMessageOnRethrow: false,
+        saveContextOnRethrow: false,
+        patterns: [
+            'assert(value, [message])',
+            'assert.ok(value, [message])',
+            'assert.equal(actual, expected, [message])',
+            'assert.notEqual(actual, expected, [message])',
+            'assert.strictEqual(actual, expected, [message])',
+            'assert.notStrictEqual(actual, expected, [message])',
+            'assert.deepEqual(actual, expected, [message])',
+            'assert.notDeepEqual(actual, expected, [message])'
+        ]
+    };
+};
+
+},{}],13:[function(_dereq_,module,exports){
+/**
+ * escallmatch:
+ *   ECMAScript CallExpression matcher made from function/method signature
+ * 
+ * https://github.com/twada/escallmatch
+ *
+ * Copyright (c) 2014 Takuto Wada
+ * Licensed under the MIT license.
+ *   http://twada.mit-license.org/
+ */
+'use strict';
+/* jshint -W024 */
+
+var esprima = _dereq_('esprima'),
+    estraverse = _dereq_('estraverse'),
+    espurify = _dereq_('espurify'),
+    syntax = estraverse.Syntax,
+    hasOwn = Object.prototype.hasOwnProperty,
+    deepEqual = _dereq_('deep-equal'),
+    notCallExprMessage = 'Argument should be in the form of CallExpression',
+    duplicatedArgMessage = 'Duplicate argument name: ',
+    invalidFormMessage = 'Argument should be in the form of `name` or `[name]`';
+
+function createMatcher (signatureStr) {
+    var ast = extractExpressionFrom(esprima.parse(signatureStr));
+    return new Matcher(ast);
+}
+
+function Matcher (signatureAst) {
+    this.signatureAst = signatureAst;
+    this.signatureCalleeDepth = astDepth(signatureAst.callee);
+    this.numMaxArgs = this.signatureAst.arguments.length;
+    this.numMinArgs = this.signatureAst.arguments.filter(identifiers).length;
+}
+
+Matcher.prototype.test = function (currentNode) {
+    var calleeMatched = isCalleeMatched(this.signatureAst, this.signatureCalleeDepth, currentNode),
+        numArgs;
+    if (calleeMatched) {
+        numArgs = currentNode.arguments.length;
+        return this.numMinArgs <= numArgs && numArgs <= this.numMaxArgs;
+    }
+    return false;
+};
+
+Matcher.prototype.matchArgument = function (currentNode, parentNode) {
+    if (isCalleeOfParent(currentNode, parentNode)) {
+        return null;
+    }
+    if (this.test(parentNode)) {
+        var indexOfCurrentArg = parentNode.arguments.indexOf(currentNode);
+        var numOptional = parentNode.arguments.length - this.numMinArgs;
+        var matchedSignatures = this.argumentSignatures().reduce(function (accum, argSig) {
+            if (argSig.kind === 'mandatory') {
+                accum.push(argSig);
+            }
+            if (argSig.kind === 'optional' && 0 < numOptional) {
+                numOptional -= 1;
+                accum.push(argSig);
+            }
+            return accum;
+        }, []);
+        return matchedSignatures[indexOfCurrentArg];
+    }
+    return null;
+};
+
+Matcher.prototype.calleeAst = function () {
+    return espurify(this.signatureAst.callee);
+};
+
+Matcher.prototype.argumentSignatures = function () {
+    return this.signatureAst.arguments.map(toArgumentSignature);
+};
+
+function toArgumentSignature (argSignatureNode) {
+    switch(argSignatureNode.type) {
+    case syntax.Identifier:
+        return {
+            name: argSignatureNode.name,
+            kind: 'mandatory'
+        };
+    case syntax.ArrayExpression:
+        return {
+            name: argSignatureNode.elements[0].name,
+            kind: 'optional'
+        };
+    default:
+        return null;
+    }
+}
+
+function isCalleeMatched(callSignature, signatureCalleeDepth, node) {
+    if (!isCallExpression(node)) {
+        return false;
+    }
+    if (!isSameAstDepth(node.callee, signatureCalleeDepth)) {
+        return false;
+    }
+    return deepEqual(espurify(callSignature.callee), espurify(node.callee));
+}
+
+function isSameAstDepth (ast, depth) {
+    var currentDepth = 0;
+    estraverse.traverse(ast, {
+        enter: function (currentNode, parentNode) {
+            var path = this.path(),
+                pathDepth = path ? path.length : 0;
+            if (currentDepth < pathDepth) {
+                currentDepth = pathDepth;
+            }
+            if (depth < currentDepth) {
+                this['break']();
+            }
+        }
+    });
+    return (depth === currentDepth);
+}
+
+function astDepth (ast) {
+    var maxDepth = 0;
+    estraverse.traverse(ast, {
+        enter: function (currentNode, parentNode) {
+            var path = this.path(),
+                pathDepth = path ? path.length : 0;
+            if (maxDepth < pathDepth) {
+                maxDepth = pathDepth;
+            }
+        }
+    });
+    return maxDepth;
+}
+
+function isCallExpression (node) {
+    return node && node.type === syntax.CallExpression;
+}
+
+function isCalleeOfParent(currentNode, parentNode) {
+    return parentNode && currentNode &&
+        parentNode.type === syntax.CallExpression &&
+        parentNode.callee === currentNode;
+}
+
+function identifiers (node) {
+    return node.type === syntax.Identifier;
+}
+
+function validateApiExpression (callExpression) {
+    if (callExpression.type !== syntax.CallExpression) {
+        throw new Error(notCallExprMessage);
+    }
+    var names = {};
+    callExpression.arguments.forEach(function (arg) {
+        var name = validateArg(arg);
+        if (hasOwn.call(names, name)) {
+            throw new Error(duplicatedArgMessage + name);
+        } else {
+            names[name] = name;
+        }
+    });
+}
+
+function validateArg (arg) {
+    var inner;
+    switch(arg.type) {
+    case syntax.Identifier:
+        return arg.name;
+    case syntax.ArrayExpression:
+        if (arg.elements.length !== 1) {
+            throw new Error(invalidFormMessage);
+        }
+        inner = arg.elements[0];
+        if (inner.type !== syntax.Identifier) {
+            throw new Error(invalidFormMessage);
+        }
+        return inner.name;
+    default:
+        throw new Error(invalidFormMessage);
+    }
+}
+
+function extractExpressionFrom (tree) {
+    var statement, expression;
+    statement = tree.body[0];
+    if (statement.type !== syntax.ExpressionStatement) {
+        throw new Error(notCallExprMessage);
+    }
+    expression = statement.expression;
+    validateApiExpression(expression);
+    return expression;
+}
+
+module.exports = createMatcher;
+
+},{"deep-equal":14,"esprima":21,"espurify":17,"estraverse":20}],14:[function(_dereq_,module,exports){
+var pSlice = Array.prototype.slice;
+var objectKeys = _dereq_('./lib/keys.js');
+var isArguments = _dereq_('./lib/is_arguments.js');
+
+var deepEqual = module.exports = function (actual, expected, opts) {
+  if (!opts) opts = {};
+  // 7.1. All identical values are equivalent, as determined by ===.
+  if (actual === expected) {
+    return true;
+
+  } else if (actual instanceof Date && expected instanceof Date) {
+    return actual.getTime() === expected.getTime();
+
+  // 7.3. Other pairs that do not both pass typeof value == 'object',
+  // equivalence is determined by ==.
+  } else if (typeof actual != 'object' && typeof expected != 'object') {
+    return opts.strict ? actual === expected : actual == expected;
+
+  // 7.4. 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, opts);
+  }
+}
+
+function isUndefinedOrNull(value) {
+  return value === null || value === undefined;
+}
+
+function isBuffer (x) {
+  if (!x || typeof x !== 'object' || typeof x.length !== 'number') return false;
+  if (typeof x.copy !== 'function' || typeof x.slice !== 'function') {
+    return false;
+  }
+  if (x.length > 0 && typeof x[0] !== 'number') return false;
+  return true;
+}
+
+function objEquiv(a, b, opts) {
+  var i, key;
+  if (isUndefinedOrNull(a) || isUndefinedOrNull(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.
+  if (isArguments(a)) {
+    if (!isArguments(b)) {
+      return false;
+    }
+    a = pSlice.call(a);
+    b = pSlice.call(b);
+    return deepEqual(a, b, opts);
+  }
+  if (isBuffer(a)) {
+    if (!isBuffer(b)) {
+      return false;
+    }
+    if (a.length !== b.length) return false;
+    for (i = 0; i < a.length; i++) {
+      if (a[i] !== b[i]) return false;
+    }
+    return true;
+  }
+  try {
+    var ka = objectKeys(a),
+        kb = objectKeys(b);
+  } 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], opts)) return false;
+  }
+  return typeof a === typeof b;
+}
+
+},{"./lib/is_arguments.js":15,"./lib/keys.js":16}],15:[function(_dereq_,module,exports){
+var supportsArgumentsClass = (function(){
+  return Object.prototype.toString.call(arguments)
+})() == '[object Arguments]';
+
+exports = module.exports = supportsArgumentsClass ? supported : unsupported;
+
+exports.supported = supported;
+function supported(object) {
+  return Object.prototype.toString.call(object) == '[object Arguments]';
+};
+
+exports.unsupported = unsupported;
+function unsupported(object){
+  return object &&
+    typeof object == 'object' &&
+    typeof object.length == 'number' &&
+    Object.prototype.hasOwnProperty.call(object, 'callee') &&
+    !Object.prototype.propertyIsEnumerable.call(object, 'callee') ||
+    false;
+};
+
+},{}],16:[function(_dereq_,module,exports){
+exports = module.exports = typeof Object.keys === 'function'
+  ? Object.keys : shim;
+
+exports.shim = shim;
+function shim (obj) {
+  var keys = [];
+  for (var key in obj) keys.push(key);
+  return keys;
+}
+
+},{}],17:[function(_dereq_,module,exports){
+/**
+ * espurify - Clone new AST without extra properties
+ * 
+ * https://github.com/twada/espurify
+ *
+ * Copyright (c) 2014 Takuto Wada
+ * Licensed under the MIT license.
+ *   http://twada.mit-license.org/
+ */
+'use strict';
+
+var traverse = _dereq_('traverse'),
+    deepCopy = _dereq_('./lib/ast-deepcopy'),
+    astProps = _dereq_('./lib/ast-properties'),
+    hasOwn = Object.prototype.hasOwnProperty;
+
+function espurify (node) {
+    var result = deepCopy(node);
+    traverse(result).forEach(function (x) {
+        if (this.parent &&
+            this.parent.node &&
+            this.parent.node.type &&
+            isSupportedNodeType(this.parent.node.type) &&
+            !isSupportedKey(this.parent.node.type, this.key))
+        {
+            this.remove(true);
+        }
+    });
+    return result;
+}
+
+function isSupportedNodeType (type) {
+    return hasOwn.call(astProps, type);
+}
+
+function isSupportedKey (type, key) {
+    return astProps[type].indexOf(key) !== -1;
+}
+
+module.exports = espurify;
+
+},{"./lib/ast-deepcopy":18,"./lib/ast-properties":19,"traverse":44}],18:[function(_dereq_,module,exports){
+/**
+ * Copyright (C) 2012 Yusuke Suzuki (twitter: @Constellation) and other contributors.
+ * Released under the BSD license.
+ * https://github.com/Constellation/esmangle/blob/master/LICENSE.BSD
+ */
+'use strict';
+
+var isArray = Array.isArray || function isArray (array) {
+    return Object.prototype.toString.call(array) === '[object Array]';
+};
+
+function deepCopyInternal (obj, result) {
+    var key, val;
+    for (key in obj) {
+        if (key.lastIndexOf('__', 0) === 0) {
+            continue;
+        }
+        if (obj.hasOwnProperty(key)) {
+            val = obj[key];
+            if (typeof val === 'object' && val !== null) {
+                if (val instanceof RegExp) {
+                    val = new RegExp(val);
+                } else {
+                    val = deepCopyInternal(val, isArray(val) ? [] : {});
+                }
+            }
+            result[key] = val;
+        }
+    }
+    return result;
+}
+
+function deepCopy (obj) {
+    return deepCopyInternal(obj, isArray(obj) ? [] : {});
+}
+
+module.exports = deepCopy;
+
+},{}],19:[function(_dereq_,module,exports){
+module.exports = {
+    AssignmentExpression: ['type', 'operator', 'left', 'right'],
+    ArrayExpression: ['type', 'elements'],
+    ArrayPattern: ['type', 'elements'],
+    // ArrowFunctionExpression: ['type', 'params', 'defaults', 'rest', 'body', 'generator', 'expression'],
+    BlockStatement: ['type', 'body'],
+    BinaryExpression: ['type', 'operator', 'left', 'right'],
+    BreakStatement: ['type', 'label'],
+    CallExpression: ['type', 'callee', 'arguments'],
+    CatchClause: ['type', 'param', 'guard', 'body'],
+    // ClassBody: ['type', 'body'],
+    // ClassDeclaration: ['type', 'id', 'body', 'superClass'],
+    // ClassExpression: ['type', 'id', 'body', 'superClass'],
+    ConditionalExpression: ['type', 'test', 'consequent', 'alternate'],
+    ContinueStatement: ['type', 'label'],
+    DebuggerStatement: ['type'],
+    // DirectiveStatement: ['type'],
+    DoWhileStatement: ['type', 'body', 'test'],
+    EmptyStatement: ['type'],
+    ExpressionStatement: ['type', 'expression'],
+    ForStatement: ['type', 'init', 'test', 'update', 'body'],
+    ForInStatement: ['type', 'left', 'right', 'body', 'each'],
+    FunctionDeclaration: ['type', 'id', 'params', 'defaults', 'rest', 'body', 'generator', 'expression'],
+    FunctionExpression: ['type', 'id', 'params', 'defaults', 'rest', 'body', 'generator', 'expression'],
+    Identifier: ['type', 'name'],
+    IfStatement: ['type', 'test', 'consequent', 'alternate'],
+    Literal: ['type', 'value'],
+    LabeledStatement: ['type', 'label', 'body'],
+    LogicalExpression: ['type', 'operator', 'left', 'right'],
+    MemberExpression: ['type', 'object', 'property', 'computed'],
+    // MethodDefinition: ['type', 'key', 'value'],
+    NewExpression: ['type', 'callee', 'arguments'],
+    ObjectExpression: ['type', 'properties'],
+    ObjectPattern: ['type', 'properties'],
+    Program: ['type', 'body'],
+    Property: ['type', 'key', 'value', 'kind'],
+    ReturnStatement: ['type', 'argument'],
+    SequenceExpression: ['type', 'expressions'],
+    SwitchStatement: ['type', 'discriminant', 'cases', 'lexical'],
+    SwitchCase: ['type', 'test', 'consequent'],
+    ThisExpression: ['type'],
+    ThrowStatement: ['type', 'argument'],
+    TryStatement: ['type', 'block', 'handlers', 'handler', 'guardedHandlers', 'finalizer'],
+    UnaryExpression: ['type', 'operator', 'prefix', 'argument'],
+    UpdateExpression: ['type', 'operator', 'argument', 'prefix'],
+    VariableDeclaration: ['type', 'declarations', 'kind'],
+    VariableDeclarator: ['type', 'id', 'init'],
+    WhileStatement: ['type', 'test', 'body'],
+    WithStatement: ['type', 'object', 'body'],
+    YieldExpression: ['type', 'argument']
+};
+
+},{}],20:[function(_dereq_,module,exports){
+/*
+  Copyright (C) 2012-2013 Yusuke Suzuki <utatane.tea@gmail.com>
+  Copyright (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com>
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+/*jslint vars:false, bitwise:true*/
+/*jshint indent:4*/
+/*global exports:true, define:true*/
+(function (root, factory) {
+    'use strict';
+
+    // Universal Module Definition (UMD) to support AMD, CommonJS/Node.js,
+    // and plain browser loading,
+    if (typeof define === 'function' && define.amd) {
+        define(['exports'], factory);
+    } else if (typeof exports !== 'undefined') {
+        factory(exports);
+    } else {
+        factory((root.estraverse = {}));
+    }
+}(this, function (exports) {
+    'use strict';
+
+    var Syntax,
+        isArray,
+        VisitorOption,
+        VisitorKeys,
+        objectCreate,
+        objectKeys,
+        BREAK,
+        SKIP,
+        REMOVE;
+
+    function ignoreJSHintError() { }
+
+    isArray = Array.isArray;
+    if (!isArray) {
+        isArray = function isArray(array) {
+            return Object.prototype.toString.call(array) === '[object Array]';
+        };
+    }
+
+    function deepCopy(obj) {
+        var ret = {}, key, val;
+        for (key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                val = obj[key];
+                if (typeof val === 'object' && val !== null) {
+                    ret[key] = deepCopy(val);
+                } else {
+                    ret[key] = val;
+                }
+            }
+        }
+        return ret;
+    }
+
+    function shallowCopy(obj) {
+        var ret = {}, key;
+        for (key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                ret[key] = obj[key];
+            }
+        }
+        return ret;
+    }
+    ignoreJSHintError(shallowCopy);
+
+    // based on LLVM libc++ upper_bound / lower_bound
+    // MIT License
+
+    function upperBound(array, func) {
+        var diff, len, i, current;
+
+        len = array.length;
+        i = 0;
+
+        while (len) {
+            diff = len >>> 1;
+            current = i + diff;
+            if (func(array[current])) {
+                len = diff;
+            } else {
+                i = current + 1;
+                len -= diff + 1;
+            }
+        }
+        return i;
+    }
+
+    function lowerBound(array, func) {
+        var diff, len, i, current;
+
+        len = array.length;
+        i = 0;
+
+        while (len) {
+            diff = len >>> 1;
+            current = i + diff;
+            if (func(array[current])) {
+                i = current + 1;
+                len -= diff + 1;
+            } else {
+                len = diff;
+            }
+        }
+        return i;
+    }
+    ignoreJSHintError(lowerBound);
+
+    objectCreate = Object.create || (function () {
+        function F() { }
+
+        return function (o) {
+            F.prototype = o;
+            return new F();
+        };
+    })();
+
+    objectKeys = Object.keys || function (o) {
+        var keys = [], key;
+        for (key in o) {
+            keys.push(key);
+        }
+        return keys;
+    };
+
+    function extend(to, from) {
+        objectKeys(from).forEach(function (key) {
+            to[key] = from[key];
+        });
+        return to;
+    }
+
+    Syntax = {
+        AssignmentExpression: 'AssignmentExpression',
+        ArrayExpression: 'ArrayExpression',
+        ArrayPattern: 'ArrayPattern',
+        ArrowFunctionExpression: 'ArrowFunctionExpression',
+        BlockStatement: 'BlockStatement',
+        BinaryExpression: 'BinaryExpression',
+        BreakStatement: 'BreakStatement',
+        CallExpression: 'CallExpression',
+        CatchClause: 'CatchClause',
+        ClassBody: 'ClassBody',
+        ClassDeclaration: 'ClassDeclaration',
+        ClassExpression: 'ClassExpression',
+        ComprehensionBlock: 'ComprehensionBlock',  // CAUTION: It's deferred to ES7.
+        ComprehensionExpression: 'ComprehensionExpression',  // CAUTION: It's deferred to ES7.
+        ConditionalExpression: 'ConditionalExpression',
+        ContinueStatement: 'ContinueStatement',
+        DebuggerStatement: 'DebuggerStatement',
+        DirectiveStatement: 'DirectiveStatement',
+        DoWhileStatement: 'DoWhileStatement',
+        EmptyStatement: 'EmptyStatement',
+        ExportBatchSpecifier: 'ExportBatchSpecifier',
+        ExportDeclaration: 'ExportDeclaration',
+        ExportSpecifier: 'ExportSpecifier',
+        ExpressionStatement: 'ExpressionStatement',
+        ForStatement: 'ForStatement',
+        ForInStatement: 'ForInStatement',
+        ForOfStatement: 'ForOfStatement',
+        FunctionDeclaration: 'FunctionDeclaration',
+        FunctionExpression: 'FunctionExpression',
+        GeneratorExpression: 'GeneratorExpression',  // CAUTION: It's deferred to ES7.
+        Identifier: 'Identifier',
+        IfStatement: 'IfStatement',
+        ImportDeclaration: 'ImportDeclaration',
+        ImportDefaultSpecifier: 'ImportDefaultSpecifier',
+        ImportNamespaceSpecifier: 'ImportNamespaceSpecifier',
+        ImportSpecifier: 'ImportSpecifier',
+        Literal: 'Literal',
+        LabeledStatement: 'LabeledStatement',
+        LogicalExpression: 'LogicalExpression',
+        MemberExpression: 'MemberExpression',
+        MethodDefinition: 'MethodDefinition',
+        ModuleSpecifier: 'ModuleSpecifier',
+        NewExpression: 'NewExpression',
+        ObjectExpression: 'ObjectExpression',
+        ObjectPattern: 'ObjectPattern',
+        Program: 'Program',
+        Property: 'Property',
+        ReturnStatement: 'ReturnStatement',
+        SequenceExpression: 'SequenceExpression',
+        SpreadElement: 'SpreadElement',
+        SwitchStatement: 'SwitchStatement',
+        SwitchCase: 'SwitchCase',
+        TaggedTemplateExpression: 'TaggedTemplateExpression',
+        TemplateElement: 'TemplateElement',
+        TemplateLiteral: 'TemplateLiteral',
+        ThisExpression: 'ThisExpression',
+        ThrowStatement: 'ThrowStatement',
+        TryStatement: 'TryStatement',
+        UnaryExpression: 'UnaryExpression',
+        UpdateExpression: 'UpdateExpression',
+        VariableDeclaration: 'VariableDeclaration',
+        VariableDeclarator: 'VariableDeclarator',
+        WhileStatement: 'WhileStatement',
+        WithStatement: 'WithStatement',
+        YieldExpression: 'YieldExpression'
+    };
+
+    VisitorKeys = {
+        AssignmentExpression: ['left', 'right'],
+        ArrayExpression: ['elements'],
+        ArrayPattern: ['elements'],
+        ArrowFunctionExpression: ['params', 'defaults', 'rest', 'body'],
+        BlockStatement: ['body'],
+        BinaryExpression: ['left', 'right'],
+        BreakStatement: ['label'],
+        CallExpression: ['callee', 'arguments'],
+        CatchClause: ['param', 'body'],
+        ClassBody: ['body'],
+        ClassDeclaration: ['id', 'body', 'superClass'],
+        ClassExpression: ['id', 'body', 'superClass'],
+        ComprehensionBlock: ['left', 'right'],  // CAUTION: It's deferred to ES7.
+        ComprehensionExpression: ['blocks', 'filter', 'body'],  // CAUTION: It's deferred to ES7.
+        ConditionalExpression: ['test', 'consequent', 'alternate'],
+        ContinueStatement: ['label'],
+        DebuggerStatement: [],
+        DirectiveStatement: [],
+        DoWhileStatement: ['body', 'test'],
+        EmptyStatement: [],
+        ExportBatchSpecifier: [],
+        ExportDeclaration: ['declaration', 'specifiers', 'source'],
+        ExportSpecifier: ['id', 'name'],
+        ExpressionStatement: ['expression'],
+        ForStatement: ['init', 'test', 'update', 'body'],
+        ForInStatement: ['left', 'right', 'body'],
+        ForOfStatement: ['left', 'right', 'body'],
+        FunctionDeclaration: ['id', 'params', 'defaults', 'rest', 'body'],
+        FunctionExpression: ['id', 'params', 'defaults', 'rest', 'body'],
+        GeneratorExpression: ['blocks', 'filter', 'body'],  // CAUTION: It's deferred to ES7.
+        Identifier: [],
+        IfStatement: ['test', 'consequent', 'alternate'],
+        ImportDeclaration: ['specifiers', 'source'],
+        ImportDefaultSpecifier: ['id'],
+        ImportNamespaceSpecifier: ['id'],
+        ImportSpecifier: ['id', 'name'],
+        Literal: [],
+        LabeledStatement: ['label', 'body'],
+        LogicalExpression: ['left', 'right'],
+        MemberExpression: ['object', 'property'],
+        MethodDefinition: ['key', 'value'],
+        ModuleSpecifier: [],
+        NewExpression: ['callee', 'arguments'],
+        ObjectExpression: ['properties'],
+        ObjectPattern: ['properties'],
+        Program: ['body'],
+        Property: ['key', 'value'],
+        ReturnStatement: ['argument'],
+        SequenceExpression: ['expressions'],
+        SpreadElement: ['argument'],
+        SwitchStatement: ['discriminant', 'cases'],
+        SwitchCase: ['test', 'consequent'],
+        TaggedTemplateExpression: ['tag', 'quasi'],
+        TemplateElement: [],
+        TemplateLiteral: ['quasis', 'expressions'],
+        ThisExpression: [],
+        ThrowStatement: ['argument'],
+        TryStatement: ['block', 'handlers', 'handler', 'guardedHandlers', 'finalizer'],
+        UnaryExpression: ['argument'],
+        UpdateExpression: ['argument'],
+        VariableDeclaration: ['declarations'],
+        VariableDeclarator: ['id', 'init'],
+        WhileStatement: ['test', 'body'],
+        WithStatement: ['object', 'body'],
+        YieldExpression: ['argument']
+    };
+
+    // unique id
+    BREAK = {};
+    SKIP = {};
+    REMOVE = {};
+
+    VisitorOption = {
+        Break: BREAK,
+        Skip: SKIP,
+        Remove: REMOVE
+    };
+
+    function Reference(parent, key) {
+        this.parent = parent;
+        this.key = key;
+    }
+
+    Reference.prototype.replace = function replace(node) {
+        this.parent[this.key] = node;
+    };
+
+    Reference.prototype.remove = function remove() {
+        if (isArray(this.parent)) {
+            this.parent.splice(this.key, 1);
+            return true;
+        } else {
+            this.replace(null);
+            return false;
+        }
+    };
+
+    function Element(node, path, wrap, ref) {
+        this.node = node;
+        this.path = path;
+        this.wrap = wrap;
+        this.ref = ref;
+    }
+
+    function Controller() { }
+
+    // API:
+    // return property path array from root to current node
+    Controller.prototype.path = function path() {
+        var i, iz, j, jz, result, element;
+
+        function addToPath(result, path) {
+            if (isArray(path)) {
+                for (j = 0, jz = path.length; j < jz; ++j) {
+                    result.push(path[j]);
+                }
+            } else {
+                result.push(path);
+            }
+        }
+
+        // root node
+        if (!this.__current.path) {
+            return null;
+        }
+
+        // first node is sentinel, second node is root element
+        result = [];
+        for (i = 2, iz = this.__leavelist.length; i < iz; ++i) {
+            element = this.__leavelist[i];
+            addToPath(result, element.path);
+        }
+        addToPath(result, this.__current.path);
+        return result;
+    };
+
+    // API:
+    // return type of current node
+    Controller.prototype.type = function () {
+        var node = this.current();
+        return node.type || this.__current.wrap;
+    };
+
+    // API:
+    // return array of parent elements
+    Controller.prototype.parents = function parents() {
+        var i, iz, result;
+
+        // first node is sentinel
+        result = [];
+        for (i = 1, iz = this.__leavelist.length; i < iz; ++i) {
+            result.push(this.__leavelist[i].node);
+        }
+
+        return result;
+    };
+
+    // API:
+    // return current node
+    Controller.prototype.current = function current() {
+        return this.__current.node;
+    };
+
+    Controller.prototype.__execute = function __execute(callback, element) {
+        var previous, result;
+
+        result = undefined;
+
+        previous  = this.__current;
+        this.__current = element;
+        this.__state = null;
+        if (callback) {
+            result = callback.call(this, element.node, this.__leavelist[this.__leavelist.length - 1].node);
+        }
+        this.__current = previous;
+
+        return result;
+    };
+
+    // API:
+    // notify control skip / break
+    Controller.prototype.notify = function notify(flag) {
+        this.__state = flag;
+    };
+
+    // API:
+    // skip child nodes of current node
+    Controller.prototype.skip = function () {
+        this.notify(SKIP);
+    };
+
+    // API:
+    // break traversals
+    Controller.prototype['break'] = function () {
+        this.notify(BREAK);
+    };
+
+    // API:
+    // remove node
+    Controller.prototype.remove = function () {
+        this.notify(REMOVE);
+    };
+
+    Controller.prototype.__initialize = function(root, visitor) {
+        this.visitor = visitor;
+        this.root = root;
+        this.__worklist = [];
+        this.__leavelist = [];
+        this.__current = null;
+        this.__state = null;
+        this.__fallback = visitor.fallback === 'iteration';
+        this.__keys = VisitorKeys;
+        if (visitor.keys) {
+            this.__keys = extend(objectCreate(this.__keys), visitor.keys);
+        }
+    };
+
+    function isNode(node) {
+        if (node == null) {
+            return false;
+        }
+        return typeof node === 'object' && typeof node.type === 'string';
+    }
+
+    function isProperty(nodeType, key) {
+        return (nodeType === Syntax.ObjectExpression || nodeType === Syntax.ObjectPattern) && 'properties' === key;
+    }
+
+    Controller.prototype.traverse = function traverse(root, visitor) {
+        var worklist,
+            leavelist,
+            element,
+            node,
+            nodeType,
+            ret,
+            key,
+            current,
+            current2,
+            candidates,
+            candidate,
+            sentinel;
+
+        this.__initialize(root, visitor);
+
+        sentinel = {};
+
+        // reference
+        worklist = this.__worklist;
+        leavelist = this.__leavelist;
+
+        // initialize
+        worklist.push(new Element(root, null, null, null));
+        leavelist.push(new Element(null, null, null, null));
+
+        while (worklist.length) {
+            element = worklist.pop();
+
+            if (element === sentinel) {
+                element = leavelist.pop();
+
+                ret = this.__execute(visitor.leave, element);
+
+                if (this.__state === BREAK || ret === BREAK) {
+                    return;
+                }
+                continue;
+            }
+
+            if (element.node) {
+
+                ret = this.__execute(visitor.enter, element);
+
+                if (this.__state === BREAK || ret === BREAK) {
+                    return;
+                }
+
+                worklist.push(sentinel);
+                leavelist.push(element);
+
+                if (this.__state === SKIP || ret === SKIP) {
+                    continue;
+                }
+
+                node = element.node;
+                nodeType = element.wrap || node.type;
+                candidates = this.__keys[nodeType];
+                if (!candidates) {
+                    if (this.__fallback) {
+                        candidates = objectKeys(node);
+                    } else {
+                        throw new Error('Unknown node type ' + nodeType + '.');
+                    }
+                }
+
+                current = candidates.length;
+                while ((current -= 1) >= 0) {
+                    key = candidates[current];
+                    candidate = node[key];
+                    if (!candidate) {
+                        continue;
+                    }
+
+                    if (isArray(candidate)) {
+                        current2 = candidate.length;
+                        while ((current2 -= 1) >= 0) {
+                            if (!candidate[current2]) {
+                                continue;
+                            }
+                            if (isProperty(nodeType, candidates[current])) {
+                                element = new Element(candidate[current2], [key, current2], 'Property', null);
+                            } else if (isNode(candidate[current2])) {
+                                element = new Element(candidate[current2], [key, current2], null, null);
+                            } else {
+                                continue;
+                            }
+                            worklist.push(element);
+                        }
+                    } else if (isNode(candidate)) {
+                        worklist.push(new Element(candidate, key, null, null));
+                    }
+                }
+            }
+        }
+    };
+
+    Controller.prototype.replace = function replace(root, visitor) {
+        function removeElem(element) {
+            var i,
+                key,
+                nextElem,
+                parent;
+
+            if (element.ref.remove()) {
+                // When the reference is an element of an array.
+                key = element.ref.key;
+                parent = element.ref.parent;
+
+                // If removed from array, then decrease following items' keys.
+                i = worklist.length;
+                while (i--) {
+                    nextElem = worklist[i];
+                    if (nextElem.ref && nextElem.ref.parent === parent) {
+                        if  (nextElem.ref.key < key) {
+                            break;
+                        }
+                        --nextElem.ref.key;
+                    }
+                }
+            }
+        }
+
+        var worklist,
+            leavelist,
+            node,
+            nodeType,
+            target,
+            element,
+            current,
+            current2,
+            candidates,
+            candidate,
+            sentinel,
+            outer,
+            key;
+
+        this.__initialize(root, visitor);
+
+        sentinel = {};
+
+        // reference
+        worklist = this.__worklist;
+        leavelist = this.__leavelist;
+
+        // initialize
+        outer = {
+            root: root
+        };
+        element = new Element(root, null, null, new Reference(outer, 'root'));
+        worklist.push(element);
+        leavelist.push(element);
+
+        while (worklist.length) {
+            element = worklist.pop();
+
+            if (element === sentinel) {
+                element = leavelist.pop();
+
+                target = this.__execute(visitor.leave, element);
+
+                // node may be replaced with null,
+                // so distinguish between undefined and null in this place
+                if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
+                    // replace
+                    element.ref.replace(target);
+                }
+
+                if (this.__state === REMOVE || target === REMOVE) {
+                    removeElem(element);
+                }
+
+                if (this.__state === BREAK || target === BREAK) {
+                    return outer.root;
+                }
+                continue;
+            }
+
+            target = this.__execute(visitor.enter, element);
+
+            // node may be replaced with null,
+            // so distinguish between undefined and null in this place
+            if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
+                // replace
+                element.ref.replace(target);
+                element.node = target;
+            }
+
+            if (this.__state === REMOVE || target === REMOVE) {
+                removeElem(element);
+                element.node = null;
+            }
+
+            if (this.__state === BREAK || target === BREAK) {
+                return outer.root;
+            }
+
+            // node may be null
+            node = element.node;
+            if (!node) {
+                continue;
+            }
+
+            worklist.push(sentinel);
+            leavelist.push(element);
+
+            if (this.__state === SKIP || target === SKIP) {
+                continue;
+            }
+
+            nodeType = element.wrap || node.type;
+            candidates = this.__keys[nodeType];
+            if (!candidates) {
+                if (this.__fallback) {
+                    candidates = objectKeys(node);
+                } else {
+                    throw new Error('Unknown node type ' + nodeType + '.');
+                }
+            }
+
+            current = candidates.length;
+            while ((current -= 1) >= 0) {
+                key = candidates[current];
+                candidate = node[key];
+                if (!candidate) {
+                    continue;
+                }
+
+                if (isArray(candidate)) {
+                    current2 = candidate.length;
+                    while ((current2 -= 1) >= 0) {
+                        if (!candidate[current2]) {
+                            continue;
+                        }
+                        if (isProperty(nodeType, candidates[current])) {
+                            element = new Element(candidate[current2], [key, current2], 'Property', new Reference(candidate, current2));
+                        } else if (isNode(candidate[current2])) {
+                            element = new Element(candidate[current2], [key, current2], null, new Reference(candidate, current2));
+                        } else {
+                            continue;
+                        }
+                        worklist.push(element);
+                    }
+                } else if (isNode(candidate)) {
+                    worklist.push(new Element(candidate, key, null, new Reference(node, key)));
+                }
+            }
+        }
+
+        return outer.root;
+    };
+
+    function traverse(root, visitor) {
+        var controller = new Controller();
+        return controller.traverse(root, visitor);
+    }
+
+    function replace(root, visitor) {
+        var controller = new Controller();
+        return controller.replace(root, visitor);
+    }
+
+    function extendCommentRange(comment, tokens) {
+        var target;
+
+        target = upperBound(tokens, function search(token) {
+            return token.range[0] > comment.range[0];
+        });
+
+        comment.extendedRange = [comment.range[0], comment.range[1]];
+
+        if (target !== tokens.length) {
+            comment.extendedRange[1] = tokens[target].range[0];
+        }
+
+        target -= 1;
+        if (target >= 0) {
+            comment.extendedRange[0] = tokens[target].range[1];
+        }
+
+        return comment;
+    }
+
+    function attachComments(tree, providedComments, tokens) {
+        // At first, we should calculate extended comment ranges.
+        var comments = [], comment, len, i, cursor;
+
+        if (!tree.range) {
+            throw new Error('attachComments needs range information');
+        }
+
+        // tokens array is empty, we attach comments to tree as 'leadingComments'
+        if (!tokens.length) {
+            if (providedComments.length) {
+                for (i = 0, len = providedComments.length; i < len; i += 1) {
+                    comment = deepCopy(providedComments[i]);
+                    comment.extendedRange = [0, tree.range[0]];
+                    comments.push(comment);
+                }
+                tree.leadingComments = comments;
+            }
+            return tree;
+        }
+
+        for (i = 0, len = providedComments.length; i < len; i += 1) {
+            comments.push(extendCommentRange(deepCopy(providedComments[i]), tokens));
+        }
+
+        // This is based on John Freeman's implementation.
+        cursor = 0;
+        traverse(tree, {
+            enter: function (node) {
+                var comment;
+
+                while (cursor < comments.length) {
+                    comment = comments[cursor];
+                    if (comment.extendedRange[1] > node.range[0]) {
+                        break;
+                    }
+
+                    if (comment.extendedRange[1] === node.range[0]) {
+                        if (!node.leadingComments) {
+                            node.leadingComments = [];
+                        }
+                        node.leadingComments.push(comment);
+                        comments.splice(cursor, 1);
+                    } else {
+                        cursor += 1;
+                    }
+                }
+
+                // already out of owned node
+                if (cursor === comments.length) {
+                    return VisitorOption.Break;
+                }
+
+                if (comments[cursor].extendedRange[0] > node.range[1]) {
+                    return VisitorOption.Skip;
+                }
+            }
+        });
+
+        cursor = 0;
+        traverse(tree, {
+            leave: function (node) {
+                var comment;
+
+                while (cursor < comments.length) {
+                    comment = comments[cursor];
+                    if (node.range[1] < comment.extendedRange[0]) {
+                        break;
+                    }
+
+                    if (node.range[1] === comment.extendedRange[0]) {
+                        if (!node.trailingComments) {
+                            node.trailingComments = [];
+                        }
+                        node.trailingComments.push(comment);
+                        comments.splice(cursor, 1);
+                    } else {
+                        cursor += 1;
+                    }
+                }
+
+                // already out of owned node
+                if (cursor === comments.length) {
+                    return VisitorOption.Break;
+                }
+
+                if (comments[cursor].extendedRange[0] > node.range[1]) {
+                    return VisitorOption.Skip;
+                }
+            }
+        });
+
+        return tree;
+    }
+
+    exports.version = '1.8.0';
+    exports.Syntax = Syntax;
+    exports.traverse = traverse;
+    exports.replace = replace;
+    exports.attachComments = attachComments;
+    exports.VisitorKeys = VisitorKeys;
+    exports.VisitorOption = VisitorOption;
+    exports.Controller = Controller;
+}));
+/* vim: set sw=4 ts=4 et tw=80 : */
+
+},{}],21:[function(_dereq_,module,exports){
+/*
+  Copyright (C) 2013 Ariya Hidayat <ariya.hidayat@gmail.com>
+  Copyright (C) 2013 Thaddee Tyl <thaddee.tyl@gmail.com>
+  Copyright (C) 2013 Mathias Bynens <mathias@qiwi.be>
+  Copyright (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com>
+  Copyright (C) 2012 Mathias Bynens <mathias@qiwi.be>
+  Copyright (C) 2012 Joost-Wim Boekesteijn <joost-wim@boekesteijn.nl>
+  Copyright (C) 2012 Kris Kowal <kris.kowal@cixar.com>
+  Copyright (C) 2012 Yusuke Suzuki <utatane.tea@gmail.com>
+  Copyright (C) 2012 Arpad Borsos <arpad.borsos@googlemail.com>
+  Copyright (C) 2011 Ariya Hidayat <ariya.hidayat@gmail.com>
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*jslint bitwise:true plusplus:true */
+/*global esprima:true, define:true, exports:true, window: true,
+throwErrorTolerant: true,
+throwError: true, generateStatement: true, peek: true,
+parseAssignmentExpression: true, parseBlock: true, parseExpression: true,
+parseFunctionDeclaration: true, parseFunctionExpression: true,
+parseFunctionSourceElements: true, parseVariableIdentifier: true,
+parseLeftHandSideExpression: true,
+parseUnaryExpression: true,
+parseStatement: true, parseSourceElement: true */
+
+(function (root, factory) {
+    'use strict';
+
+    // Universal Module Definition (UMD) to support AMD, CommonJS/Node.js,
+    // Rhino, and plain browser loading.
+
+    /* istanbul ignore next */
+    if (typeof define === 'function' && define.amd) {
+        define(['exports'], factory);
+    } else if (typeof exports !== 'undefined') {
+        factory(exports);
+    } else {
+        factory((root.esprima = {}));
+    }
+}(this, function (exports) {
+    'use strict';
+
+    var Token,
+        TokenName,
+        FnExprTokens,
+        Syntax,
+        PropertyKind,
+        Messages,
+        Regex,
+        SyntaxTreeDelegate,
+        source,
+        strict,
+        index,
+        lineNumber,
+        lineStart,
+        length,
+        delegate,
+        lookahead,
+        state,
+        extra;
+
+    Token = {
+        BooleanLiteral: 1,
+        EOF: 2,
+        Identifier: 3,
+        Keyword: 4,
+        NullLiteral: 5,
+        NumericLiteral: 6,
+        Punctuator: 7,
+        StringLiteral: 8,
+        RegularExpression: 9
+    };
+
+    TokenName = {};
+    TokenName[Token.BooleanLiteral] = 'Boolean';
+    TokenName[Token.EOF] = '<end>';
+    TokenName[Token.Identifier] = 'Identifier';
+    TokenName[Token.Keyword] = 'Keyword';
+    TokenName[Token.NullLiteral] = 'Null';
+    TokenName[Token.NumericLiteral] = 'Numeric';
+    TokenName[Token.Punctuator] = 'Punctuator';
+    TokenName[Token.StringLiteral] = 'String';
+    TokenName[Token.RegularExpression] = 'RegularExpression';
+
+    // A function following one of those tokens is an expression.
+    FnExprTokens = ['(', '{', '[', 'in', 'typeof', 'instanceof', 'new',
+                    'return', 'case', 'delete', 'throw', 'void',
+                    // assignment operators
+                    '=', '+=', '-=', '*=', '/=', '%=', '<<=', '>>=', '>>>=',
+                    '&=', '|=', '^=', ',',
+                    // binary/unary operators
+                    '+', '-', '*', '/', '%', '++', '--', '<<', '>>', '>>>', '&',
+                    '|', '^', '!', '~', '&&', '||', '?', ':', '===', '==', '>=',
+                    '<=', '<', '>', '!=', '!=='];
+
+    Syntax = {
+        AssignmentExpression: 'AssignmentExpression',
+        ArrayExpression: 'ArrayExpression',
+        BlockStatement: 'BlockStatement',
+        BinaryExpression: 'BinaryExpression',
+        BreakStatement: 'BreakStatement',
+        CallExpression: 'CallExpression',
+        CatchClause: 'CatchClause',
+        ConditionalExpression: 'ConditionalExpression',
+        ContinueStatement: 'ContinueStatement',
+        DoWhileStatement: 'DoWhileStatement',
+        DebuggerStatement: 'DebuggerStatement',
+        EmptyStatement: 'EmptyStatement',
+        ExpressionStatement: 'ExpressionStatement',
+        ForStatement: 'ForStatement',
+        ForInStatement: 'ForInStatement',
+        FunctionDeclaration: 'FunctionDeclaration',
+        FunctionExpression: 'FunctionExpression',
+        Identifier: 'Identifier',
+        IfStatement: 'IfStatement',
+        Literal: 'Literal',
+        LabeledStatement: 'LabeledStatement',
+        LogicalExpression: 'LogicalExpression',
+        MemberExpression: 'MemberExpression',
+        NewExpression: 'NewExpression',
+        ObjectExpression: 'ObjectExpression',
+        Program: 'Program',
+        Property: 'Property',
+        ReturnStatement: 'ReturnStatement',
+        SequenceExpression: 'SequenceExpression',
+        SwitchStatement: 'SwitchStatement',
+        SwitchCase: 'SwitchCase',
+        ThisExpression: 'ThisExpression',
+        ThrowStatement: 'ThrowStatement',
+        TryStatement: 'TryStatement',
+        UnaryExpression: 'UnaryExpression',
+        UpdateExpression: 'UpdateExpression',
+        VariableDeclaration: 'VariableDeclaration',
+        VariableDeclarator: 'VariableDeclarator',
+        WhileStatement: 'WhileStatement',
+        WithStatement: 'WithStatement'
+    };
+
+    PropertyKind = {
+        Data: 1,
+        Get: 2,
+        Set: 4
+    };
+
+    // Error messages should be identical to V8.
+    Messages = {
+        UnexpectedToken:  'Unexpected token %0',
+        UnexpectedNumber:  'Unexpected number',
+        UnexpectedString:  'Unexpected string',
+        UnexpectedIdentifier:  'Unexpected identifier',
+        UnexpectedReserved:  'Unexpected reserved word',
+        UnexpectedEOS:  'Unexpected end of input',
+        NewlineAfterThrow:  'Illegal newline after throw',
+        InvalidRegExp: 'Invalid regular expression',
+        UnterminatedRegExp:  'Invalid regular expression: missing /',
+        InvalidLHSInAssignment:  'Invalid left-hand side in assignment',
+        InvalidLHSInForIn:  'Invalid left-hand side in for-in',
+        MultipleDefaultsInSwitch: 'More than one default clause in switch statement',
+        NoCatchOrFinally:  'Missing catch or finally after try',
+        UnknownLabel: 'Undefined label \'%0\'',
+        Redeclaration: '%0 \'%1\' has already been declared',
+        IllegalContinue: 'Illegal continue statement',
+        IllegalBreak: 'Illegal break statement',
+        IllegalReturn: 'Illegal return statement',
+        StrictModeWith:  'Strict mode code may not include a with statement',
+        StrictCatchVariable:  'Catch variable may not be eval or arguments in strict mode',
+        StrictVarName:  'Variable name may not be eval or arguments in strict mode',
+        StrictParamName:  'Parameter name eval or arguments is not allowed in strict mode',
+        StrictParamDupe: 'Strict mode function may not have duplicate parameter names',
+        StrictFunctionName:  'Function name may not be eval or arguments in strict mode',
+        StrictOctalLiteral:  'Octal literals are not allowed in strict mode.',
+        StrictDelete:  'Delete of an unqualified identifier in strict mode.',
+        StrictDuplicateProperty:  'Duplicate data property in object literal not allowed in strict mode',
+        AccessorDataProperty:  'Object literal may not have data and accessor property with the same name',
+        AccessorGetSet:  'Object literal may not have multiple get/set accessors with the same name',
+        StrictLHSAssignment:  'Assignment to eval or arguments is not allowed in strict mode',
+        StrictLHSPostfix:  'Postfix increment/decrement may not have eval or arguments operand in strict mode',
+        StrictLHSPrefix:  'Prefix increment/decrement may not have eval or arguments operand in strict mode',
+        StrictReservedWord:  'Use of future reserved word in strict mode'
+    };
+
+    // See also tools/generate-unicode-regex.py.
+    Regex = {
+        NonAsciiIdentifierStart: new RegExp('[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0\u08A2-\u08AC\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097F\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C33\u0C35-\u0C39\u0C3D\u0C58\u0C59\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D60\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F0\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191C\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19C1-\u19C7\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA697\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA793\uA7A0-\uA7AA\uA7F8-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA80-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]'),
+        NonAsciiIdentifierPart: new RegExp('[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u0527\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0\u08A2-\u08AC\u08E4-\u08FE\u0900-\u0963\u0966-\u096F\u0971-\u0977\u0979-\u097F\u0981-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C01-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C33\u0C35-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58\u0C59\u0C60-\u0C63\u0C66-\u0C6F\u0C82\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D02\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D57\u0D60-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F0\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191C\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19D9\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1CD0-\u1CD2\u1CD4-\u1CF6\u1D00-\u1DE6\u1DFC-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u2E2F\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099\u309A\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA697\uA69F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA793\uA7A0-\uA7AA\uA7F8-\uA827\uA840-\uA873\uA880-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A\uAA7B\uAA80-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uABC0-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE26\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]')
+    };
+
+    // Ensure the condition is true, otherwise throw an error.
+    // This is only to have a better contract semantic, i.e. another safety net
+    // to catch a logic error. The condition shall be fulfilled in normal case.
+    // Do NOT use this to enforce a certain condition on any user input.
+
+    function assert(condition, message) {
+        /* istanbul ignore if */
+        if (!condition) {
+            throw new Error('ASSERT: ' + message);
+        }
+    }
+
+    function isDecimalDigit(ch) {
+        return (ch >= 48 && ch <= 57);   // 0..9
+    }
+
+    function isHexDigit(ch) {
+        return '0123456789abcdefABCDEF'.indexOf(ch) >= 0;
+    }
+
+    function isOctalDigit(ch) {
+        return '01234567'.indexOf(ch) >= 0;
+    }
+
+
+    // 7.2 White Space
+
+    function isWhiteSpace(ch) {
+        return (ch === 0x20) || (ch === 0x09) || (ch === 0x0B) || (ch === 0x0C) || (ch === 0xA0) ||
+            (ch >= 0x1680 && [0x1680, 0x180E, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200A, 0x202F, 0x205F, 0x3000, 0xFEFF].indexOf(ch) >= 0);
+    }
+
+    // 7.3 Line Terminators
+
+    function isLineTerminator(ch) {
+        return (ch === 0x0A) || (ch === 0x0D) || (ch === 0x2028) || (ch === 0x2029);
+    }
+
+    // 7.6 Identifier Names and Identifiers
+
+    function isIdentifierStart(ch) {
+        return (ch === 0x24) || (ch === 0x5F) ||  // $ (dollar) and _ (underscore)
+            (ch >= 0x41 && ch <= 0x5A) ||         // A..Z
+            (ch >= 0x61 && ch <= 0x7A) ||         // a..z
+            (ch === 0x5C) ||                      // \ (backslash)
+            ((ch >= 0x80) && Regex.NonAsciiIdentifierStart.test(String.fromCharCode(ch)));
+    }
+
+    function isIdentifierPart(ch) {
+        return (ch === 0x24) || (ch === 0x5F) ||  // $ (dollar) and _ (underscore)
+            (ch >= 0x41 && ch <= 0x5A) ||         // A..Z
+            (ch >= 0x61 && ch <= 0x7A) ||         // a..z
+            (ch >= 0x30 && ch <= 0x39) ||         // 0..9
+            (ch === 0x5C) ||                      // \ (backslash)
+            ((ch >= 0x80) && Regex.NonAsciiIdentifierPart.test(String.fromCharCode(ch)));
+    }
+
+    // 7.6.1.2 Future Reserved Words
+
+    function isFutureReservedWord(id) {
+        switch (id) {
+        case 'class':
+        case 'enum':
+        case 'export':
+        case 'extends':
+        case 'import':
+        case 'super':
+            return true;
+        default:
+            return false;
+        }
+    }
+
+    function isStrictModeReservedWord(id) {
+        switch (id) {
+        case 'implements':
+        case 'interface':
+        case 'package':
+        case 'private':
+        case 'protected':
+        case 'public':
+        case 'static':
+        case 'yield':
+        case 'let':
+            return true;
+        default:
+            return false;
+        }
+    }
+
+    function isRestrictedWord(id) {
+        return id === 'eval' || id === 'arguments';
+    }
+
+    // 7.6.1.1 Keywords
+
+    function isKeyword(id) {
+        if (strict && isStrictModeReservedWord(id)) {
+            return true;
+        }
+
+        // 'const' is specialized as Keyword in V8.
+        // 'yield' and 'let' are for compatiblity with SpiderMonkey and ES.next.
+        // Some others are from future reserved words.
+
+        switch (id.length) {
+        case 2:
+            return (id === 'if') || (id === 'in') || (id === 'do');
+        case 3:
+            return (id === 'var') || (id === 'for') || (id === 'new') ||
+                (id === 'try') || (id === 'let');
+        case 4:
+            return (id === 'this') || (id === 'else') || (id === 'case') ||
+                (id === 'void') || (id === 'with') || (id === 'enum');
+        case 5:
+            return (id === 'while') || (id === 'break') || (id === 'catch') ||
+                (id === 'throw') || (id === 'const') || (id === 'yield') ||
+                (id === 'class') || (id === 'super');
+        case 6:
+            return (id === 'return') || (id === 'typeof') || (id === 'delete') ||
+                (id === 'switch') || (id === 'export') || (id === 'import');
+        case 7:
+            return (id === 'default') || (id === 'finally') || (id === 'extends');
+        case 8:
+            return (id === 'function') || (id === 'continue') || (id === 'debugger');
+        case 10:
+            return (id === 'instanceof');
+        default:
+            return false;
+        }
+    }
+
+    // 7.4 Comments
+
+    function addComment(type, value, start, end, loc) {
+        var comment, attacher;
+
+        assert(typeof start === 'number', 'Comment must have valid position');
+
+        // Because the way the actual token is scanned, often the comments
+        // (if any) are skipped twice during the lexical analysis.
+        // Thus, we need to skip adding a comment if the comment array already
+        // handled it.
+        if (state.lastCommentStart >= start) {
+            return;
+        }
+        state.lastCommentStart = start;
+
+        comment = {
+            type: type,
+            value: value
+        };
+        if (extra.range) {
+            comment.range = [start, end];
+        }
+        if (extra.loc) {
+            comment.loc = loc;
+        }
+        extra.comments.push(comment);
+        if (extra.attachComment) {
+            extra.leadingComments.push(comment);
+            extra.trailingComments.push(comment);
+        }
+    }
+
+    function skipSingleLineComment(offset) {
+        var start, loc, ch, comment;
+
+        start = index - offset;
+        loc = {
+            start: {
+                line: lineNumber,
+                column: index - lineStart - offset
+            }
+        };
+
+        while (index < length) {
+            ch = source.charCodeAt(index);
+            ++index;
+            if (isLineTerminator(ch)) {
+                if (extra.comments) {
+                    comment = source.slice(start + offset, index - 1);
+                    loc.end = {
+                        line: lineNumber,
+                        column: index - lineStart - 1
+                    };
+                    addComment('Line', comment, start, index - 1, loc);
+                }
+                if (ch === 13 && source.charCodeAt(index) === 10) {
+                    ++index;
+                }
+                ++lineNumber;
+                lineStart = index;
+                return;
+            }
+        }
+
+        if (extra.comments) {
+            comment = source.slice(start + offset, index);
+            loc.end = {
+                line: lineNumber,
+                column: index - lineStart
+            };
+            addComment('Line', comment, start, index, loc);
+        }
+    }
+
+    function skipMultiLineComment() {
+        var start, loc, ch, comment;
+
+        if (extra.comments) {
+            start = index - 2;
+            loc = {
+                start: {
+                    line: lineNumber,
+                    column: index - lineStart - 2
+                }
+            };
+        }
+
+        while (index < length) {
+            ch = source.charCodeAt(index);
+            if (isLineTerminator(ch)) {
+                if (ch === 0x0D && source.charCodeAt(index + 1) === 0x0A) {
+                    ++index;
+                }
+                ++lineNumber;
+                ++index;
+                lineStart = index;
+                if (index >= length) {
+                    throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+                }
+            } else if (ch === 0x2A) {
+                // Block comment ends with '*/'.
+                if (source.charCodeAt(index + 1) === 0x2F) {
+                    ++index;
+                    ++index;
+                    if (extra.comments) {
+                        comment = source.slice(start + 2, index - 2);
+                        loc.end = {
+                            line: lineNumber,
+                            column: index - lineStart
+                        };
+                        addComment('Block', comment, start, index, loc);
+                    }
+                    return;
+                }
+                ++index;
+            } else {
+                ++index;
+            }
+        }
+
+        throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+    }
+
+    function skipComment() {
+        var ch, start;
+
+        start = (index === 0);
+        while (index < length) {
+            ch = source.charCodeAt(index);
+
+            if (isWhiteSpace(ch)) {
+                ++index;
+            } else if (isLineTerminator(ch)) {
+                ++index;
+                if (ch === 0x0D && source.charCodeAt(index) === 0x0A) {
+                    ++index;
+                }
+                ++lineNumber;
+                lineStart = index;
+                start = true;
+            } else if (ch === 0x2F) { // U+002F is '/'
+                ch = source.charCodeAt(index + 1);
+                if (ch === 0x2F) {
+                    ++index;
+                    ++index;
+                    skipSingleLineComment(2);
+                    start = true;
+                } else if (ch === 0x2A) {  // U+002A is '*'
+                    ++index;
+                    ++index;
+                    skipMultiLineComment();
+                } else {
+                    break;
+                }
+            } else if (start && ch === 0x2D) { // U+002D is '-'
+                // U+003E is '>'
+                if ((source.charCodeAt(index + 1) === 0x2D) && (source.charCodeAt(index + 2) === 0x3E)) {
+                    // '-->' is a single-line comment
+                    index += 3;
+                    skipSingleLineComment(3);
+                } else {
+                    break;
+                }
+            } else if (ch === 0x3C) { // U+003C is '<'
+                if (source.slice(index + 1, index + 4) === '!--') {
+                    ++index; // `<`
+                    ++index; // `!`
+                    ++index; // `-`
+                    ++index; // `-`
+                    skipSingleLineComment(4);
+                } else {
+                    break;
+                }
+            } else {
+                break;
+            }
+        }
+    }
+
+    function scanHexEscape(prefix) {
+        var i, len, ch, code = 0;
+
+        len = (prefix === 'u') ? 4 : 2;
+        for (i = 0; i < len; ++i) {
+            if (index < length && isHexDigit(source[index])) {
+                ch = source[index++];
+                code = code * 16 + '0123456789abcdef'.indexOf(ch.toLowerCase());
+            } else {
+                return '';
+            }
+        }
+        return String.fromCharCode(code);
+    }
+
+    function getEscapedIdentifier() {
+        var ch, id;
+
+        ch = source.charCodeAt(index++);
+        id = String.fromCharCode(ch);
+
+        // '\u' (U+005C, U+0075) denotes an escaped character.
+        if (ch === 0x5C) {
+            if (source.charCodeAt(index) !== 0x75) {
+                throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+            }
+            ++index;
+            ch = scanHexEscape('u');
+            if (!ch || ch === '\\' || !isIdentifierStart(ch.charCodeAt(0))) {
+                throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+            }
+            id = ch;
+        }
+
+        while (index < length) {
+            ch = source.charCodeAt(index);
+            if (!isIdentifierPart(ch)) {
+                break;
+            }
+            ++index;
+            id += String.fromCharCode(ch);
+
+            // '\u' (U+005C, U+0075) denotes an escaped character.
+            if (ch === 0x5C) {
+                id = id.substr(0, id.length - 1);
+                if (source.charCodeAt(index) !== 0x75) {
+                    throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+                }
+                ++index;
+                ch = scanHexEscape('u');
+                if (!ch || ch === '\\' || !isIdentifierPart(ch.charCodeAt(0))) {
+                    throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+                }
+                id += ch;
+            }
+        }
+
+        return id;
+    }
+
+    function getIdentifier() {
+        var start, ch;
+
+        start = index++;
+        while (index < length) {
+            ch = source.charCodeAt(index);
+            if (ch === 0x5C) {
+                // Blackslash (U+005C) marks Unicode escape sequence.
+                index = start;
+                return getEscapedIdentifier();
+            }
+            if (isIdentifierPart(ch)) {
+                ++index;
+            } else {
+                break;
+            }
+        }
+
+        return source.slice(start, index);
+    }
+
+    function scanIdentifier() {
+        var start, id, type;
+
+        start = index;
+
+        // Backslash (U+005C) starts an escaped character.
+        id = (source.charCodeAt(index) === 0x5C) ? getEscapedIdentifier() : getIdentifier();
+
+        // There is no keyword or literal with only one character.
+        // Thus, it must be an identifier.
+        if (id.length === 1) {
+            type = Token.Identifier;
+        } else if (isKeyword(id)) {
+            type = Token.Keyword;
+        } else if (id === 'null') {
+            type = Token.NullLiteral;
+        } else if (id === 'true' || id === 'false') {
+            type = Token.BooleanLiteral;
+        } else {
+            type = Token.Identifier;
+        }
+
+        return {
+            type: type,
+            value: id,
+            lineNumber: lineNumber,
+            lineStart: lineStart,
+            start: start,
+            end: index
+        };
+    }
+
+
+    // 7.7 Punctuators
+
+    function scanPunctuator() {
+        var start = index,
+            code = source.charCodeAt(index),
+            code2,
+            ch1 = source[index],
+            ch2,
+            ch3,
+            ch4;
+
+        switch (code) {
+
+        // Check for most common single-character punctuators.
+        case 0x2E:  // . dot
+        case 0x28:  // ( open bracket
+        case 0x29:  // ) close bracket
+        case 0x3B:  // ; semicolon
+        case 0x2C:  // , comma
+        case 0x7B:  // { open curly brace
+        case 0x7D:  // } close curly brace
+        case 0x5B:  // [
+        case 0x5D:  // ]
+        case 0x3A:  // :
+        case 0x3F:  // ?
+        case 0x7E:  // ~
+            ++index;
+            if (extra.tokenize) {
+                if (code === 0x28) {
+                    extra.openParenToken = extra.tokens.length;
+                } else if (code === 0x7B) {
+                    extra.openCurlyToken = extra.tokens.length;
+                }
+            }
+            return {
+                type: Token.Punctuator,
+                value: String.fromCharCode(code),
+                lineNumber: lineNumber,
+                lineStart: lineStart,
+                start: start,
+                end: index
+            };
+
+        default:
+            code2 = source.charCodeAt(index + 1);
+
+            // '=' (U+003D) marks an assignment or comparison operator.
+            if (code2 === 0x3D) {
+                switch (code) {
+                case 0x2B:  // +
+                case 0x2D:  // -
+                case 0x2F:  // /
+                case 0x3C:  // <
+                case 0x3E:  // >
+                case 0x5E:  // ^
+                case 0x7C:  // |
+                case 0x25:  // %
+                case 0x26:  // &
+                case 0x2A:  // *
+                    index += 2;
+                    return {
+                        type: Token.Punctuator,
+                        value: String.fromCharCode(code) + String.fromCharCode(code2),
+                        lineNumber: lineNumber,
+                        lineStart: lineStart,
+                        start: start,
+                        end: index
+                    };
+
+                case 0x21: // !
+                case 0x3D: // =
+                    index += 2;
+
+                    // !== and ===
+                    if (source.charCodeAt(index) === 0x3D) {
+                        ++index;
+                    }
+                    return {
+                        type: Token.Punctuator,
+                        value: source.slice(start, index),
+                        lineNumber: lineNumber,
+                        lineStart: lineStart,
+                        start: start,
+                        end: index
+                    };
+                }
+            }
+        }
+
+        // 4-character punctuator: >>>=
+
+        ch4 = source.substr(index, 4);
+
+        if (ch4 === '>>>=') {
+            index += 4;
+            return {
+                type: Token.Punctuator,
+                value: ch4,
+                lineNumber: lineNumber,
+                lineStart: lineStart,
+                start: start,
+                end: index
+            };
+        }
+
+        // 3-character punctuators: === !== >>> <<= >>=
+
+        ch3 = ch4.substr(0, 3);
+
+        if (ch3 === '>>>' || ch3 === '<<=' || ch3 === '>>=') {
+            index += 3;
+            return {
+                type: Token.Punctuator,
+                value: ch3,
+                lineNumber: lineNumber,
+                lineStart: lineStart,
+                start: start,
+                end: index
+            };
+        }
+
+        // Other 2-character punctuators: ++ -- << >> && ||
+        ch2 = ch3.substr(0, 2);
+
+        if ((ch1 === ch2[1] && ('+-<>&|'.indexOf(ch1) >= 0)) || ch2 === '=>') {
+            index += 2;
+            return {
+                type: Token.Punctuator,
+                value: ch2,
+                lineNumber: lineNumber,
+                lineStart: lineStart,
+                start: start,
+                end: index
+            };
+        }
+
+        // 1-character punctuators: < > = ! + - * % & | ^ /
+        if ('<>=!+-*%&|^/'.indexOf(ch1) >= 0) {
+            ++index;
+            return {
+                type: Token.Punctuator,
+                value: ch1,
+                lineNumber: lineNumber,
+                lineStart: lineStart,
+                start: start,
+                end: index
+            };
+        }
+
+        throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+    }
+
+    // 7.8.3 Numeric Literals
+
+    function scanHexLiteral(start) {
+        var number = '';
+
+        while (index < length) {
+            if (!isHexDigit(source[index])) {
+                break;
+            }
+            number += source[index++];
+        }
+
+        if (number.length === 0) {
+            throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+        }
+
+        if (isIdentifierStart(source.charCodeAt(index))) {
+            throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+        }
+
+        return {
+            type: Token.NumericLiteral,
+            value: parseInt('0x' + number, 16),
+            lineNumber: lineNumber,
+            lineStart: lineStart,
+            start: start,
+            end: index
+        };
+    }
+
+    function scanOctalLiteral(start) {
+        var number = '0' + source[index++];
+        while (index < length) {
+            if (!isOctalDigit(source[index])) {
+                break;
+            }
+            number += source[index++];
+        }
+
+        if (isIdentifierStart(source.charCodeAt(index)) || isDecimalDigit(source.charCodeAt(index))) {
+            throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+        }
+
+        return {
+            type: Token.NumericLiteral,
+            value: parseInt(number, 8),
+            octal: true,
+            lineNumber: lineNumber,
+            lineStart: lineStart,
+            start: start,
+            end: index
+        };
+    }
+
+    function scanNumericLiteral() {
+        var number, start, ch;
+
+        ch = source[index];
+        assert(isDecimalDigit(ch.charCodeAt(0)) || (ch === '.'),
+            'Numeric literal must start with a decimal digit or a decimal point');
+
+        start = index;
+        number = '';
+        if (ch !== '.') {
+            number = source[index++];
+            ch = source[index];
+
+            // Hex number starts with '0x'.
+            // Octal number starts with '0'.
+            if (number === '0') {
+                if (ch === 'x' || ch === 'X') {
+                    ++index;
+                    return scanHexLiteral(start);
+                }
+                if (isOctalDigit(ch)) {
+                    return scanOctalLiteral(start);
+                }
+
+                // decimal number starts with '0' such as '09' is illegal.
+                if (ch && isDecimalDigit(ch.charCodeAt(0))) {
+                    throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+                }
+            }
+
+            while (isDecimalDigit(source.charCodeAt(index))) {
+                number += source[index++];
+            }
+            ch = source[index];
+        }
+
+        if (ch === '.') {
+            number += source[index++];
+            while (isDecimalDigit(source.charCodeAt(index))) {
+                number += source[index++];
+            }
+            ch = source[index];
+        }
+
+        if (ch === 'e' || ch === 'E') {
+            number += source[index++];
+
+            ch = source[index];
+            if (ch === '+' || ch === '-') {
+                number += source[index++];
+            }
+            if (isDecimalDigit(source.charCodeAt(index))) {
+                while (isDecimalDigit(source.charCodeAt(index))) {
+                    number += source[index++];
+                }
+            } else {
+                throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+            }
+        }
+
+        if (isIdentifierStart(source.charCodeAt(index))) {
+            throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+        }
+
+        return {
+            type: Token.NumericLiteral,
+            value: parseFloat(number),
+            lineNumber: lineNumber,
+            lineStart: lineStart,
+            start: start,
+            end: index
+        };
+    }
+
+    // 7.8.4 String Literals
+
+    function scanStringLiteral() {
+        var str = '', quote, start, ch, code, unescaped, restore, octal = false, startLineNumber, startLineStart;
+        startLineNumber = lineNumber;
+        startLineStart = lineStart;
+
+        quote = source[index];
+        assert((quote === '\'' || quote === '"'),
+            'String literal must starts with a quote');
+
+        start = index;
+        ++index;
+
+        while (index < length) {
+            ch = source[index++];
+
+            if (ch === quote) {
+                quote = '';
+                break;
+            } else if (ch === '\\') {
+                ch = source[index++];
+                if (!ch || !isLineTerminator(ch.charCodeAt(0))) {
+                    switch (ch) {
+                    case 'u':
+                    case 'x':
+                        restore = index;
+                        unescaped = scanHexEscape(ch);
+                        if (unescaped) {
+                            str += unescaped;
+                        } else {
+                            index = restore;
+                            str += ch;
+                        }
+                        break;
+                    case 'n':
+                        str += '\n';
+                        break;
+                    case 'r':
+                        str += '\r';
+                        break;
+                    case 't':
+                        str += '\t';
+                        break;
+                    case 'b':
+                        str += '\b';
+                        break;
+                    case 'f':
+                        str += '\f';
+                        break;
+                    case 'v':
+                        str += '\x0B';
+                        break;
+
+                    default:
+                        if (isOctalDigit(ch)) {
+                            code = '01234567'.indexOf(ch);
+
+                            // \0 is not octal escape sequence
+                            if (code !== 0) {
+                                octal = true;
+                            }
+
+                            if (index < length && isOctalDigit(source[index])) {
+                                octal = true;
+                                code = code * 8 + '01234567'.indexOf(source[index++]);
+
+                                // 3 digits are only allowed when string starts
+                                // with 0, 1, 2, 3
+                                if ('0123'.indexOf(ch) >= 0 &&
+                                        index < length &&
+                                        isOctalDigit(source[index])) {
+                                    code = code * 8 + '01234567'.indexOf(source[index++]);
+                                }
+                            }
+                            str += String.fromCharCode(code);
+                        } else {
+                            str += ch;
+                        }
+                        break;
+                    }
+                } else {
+                    ++lineNumber;
+                    if (ch ===  '\r' && source[index] === '\n') {
+                        ++index;
+                    }
+                    lineStart = index;
+                }
+            } else if (isLineTerminator(ch.charCodeAt(0))) {
+                break;
+            } else {
+                str += ch;
+            }
+        }
+
+        if (quote !== '') {
+            throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+        }
+
+        return {
+            type: Token.StringLiteral,
+            value: str,
+            octal: octal,
+            startLineNumber: startLineNumber,
+            startLineStart: startLineStart,
+            lineNumber: lineNumber,
+            lineStart: lineStart,
+            start: start,
+            end: index
+        };
+    }
+
+    function testRegExp(pattern, flags) {
+        var value;
+        try {
+            value = new RegExp(pattern, flags);
+        } catch (e) {
+            throwError({}, Messages.InvalidRegExp);
+        }
+        return value;
+    }
+
+    function scanRegExpBody() {
+        var ch, str, classMarker, terminated, body;
+
+        ch = source[index];
+        assert(ch === '/', 'Regular expression literal must start with a slash');
+        str = source[index++];
+
+        classMarker = false;
+        terminated = false;
+        while (index < length) {
+            ch = source[index++];
+            str += ch;
+            if (ch === '\\') {
+                ch = source[index++];
+                // ECMA-262 7.8.5
+                if (isLineTerminator(ch.charCodeAt(0))) {
+                    throwError({}, Messages.UnterminatedRegExp);
+                }
+                str += ch;
+            } else if (isLineTerminator(ch.charCodeAt(0))) {
+                throwError({}, Messages.UnterminatedRegExp);
+            } else if (classMarker) {
+                if (ch === ']') {
+                    classMarker = false;
+                }
+            } else {
+                if (ch === '/') {
+                    terminated = true;
+                    break;
+                } else if (ch === '[') {
+                    classMarker = true;
+                }
+            }
+        }
+
+        if (!terminated) {
+            throwError({}, Messages.UnterminatedRegExp);
+        }
+
+        // Exclude leading and trailing slash.
+        body = str.substr(1, str.length - 2);
+        return {
+            value: body,
+            literal: str
+        };
+    }
+
+    function scanRegExpFlags() {
+        var ch, str, flags, restore;
+
+        str = '';
+        flags = '';
+        while (index < length) {
+            ch = source[index];
+            if (!isIdentifierPart(ch.charCodeAt(0))) {
+                break;
+            }
+
+            ++index;
+            if (ch === '\\' && index < length) {
+                ch = source[index];
+                if (ch === 'u') {
+                    ++index;
+                    restore = index;
+                    ch = scanHexEscape('u');
+                    if (ch) {
+                        flags += ch;
+                        for (str += '\\u'; restore < index; ++restore) {
+                            str += source[restore];
+                        }
+                    } else {
+                        index = restore;
+                        flags += 'u';
+                        str += '\\u';
+                    }
+                    throwErrorTolerant({}, Messages.UnexpectedToken, 'ILLEGAL');
+                } else {
+                    str += '\\';
+                    throwErrorTolerant({}, Messages.UnexpectedToken, 'ILLEGAL');
+                }
+            } else {
+                flags += ch;
+                str += ch;
+            }
+        }
+
+        return {
+            value: flags,
+            literal: str
+        };
+    }
+
+    function scanRegExp() {
+        var start, body, flags, pattern, value;
+
+        lookahead = null;
+        skipComment();
+        start = index;
+
+        body = scanRegExpBody();
+        flags = scanRegExpFlags();
+        value = testRegExp(body.value, flags.value);
+
+        if (extra.tokenize) {
+            return {
+                type: Token.RegularExpression,
+                value: value,
+                lineNumber: lineNumber,
+                lineStart: lineStart,
+                start: start,
+                end: index
+            };
+        }
+
+        return {
+            literal: body.literal + flags.literal,
+            value: value,
+            start: start,
+            end: index
+        };
+    }
+
+    function collectRegex() {
+        var pos, loc, regex, token;
+
+        skipComment();
+
+        pos = index;
+        loc = {
+            start: {
+                line: lineNumber,
+                column: index - lineStart
+            }
+        };
+
+        regex = scanRegExp();
+        loc.end = {
+            line: lineNumber,
+            column: index - lineStart
+        };
+
+        /* istanbul ignore next */
+        if (!extra.tokenize) {
+            // Pop the previous token, which is likely '/' or '/='
+            if (extra.tokens.length > 0) {
+                token = extra.tokens[extra.tokens.length - 1];
+                if (token.range[0] === pos && token.type === 'Punctuator') {
+                    if (token.value === '/' || token.value === '/=') {
+                        extra.tokens.pop();
+                    }
+                }
+            }
+
+            extra.tokens.push({
+                type: 'RegularExpression',
+                value: regex.literal,
+                range: [pos, index],
+                loc: loc
+            });
+        }
+
+        return regex;
+    }
+
+    function isIdentifierName(token) {
+        return token.type === Token.Identifier ||
+            token.type === Token.Keyword ||
+            token.type === Token.BooleanLiteral ||
+            token.type === Token.NullLiteral;
+    }
+
+    function advanceSlash() {
+        var prevToken,
+            checkToken;
+        // Using the following algorithm:
+        // https://github.com/mozilla/sweet.js/wiki/design
+        prevToken = extra.tokens[extra.tokens.length - 1];
+        if (!prevToken) {
+            // Nothing before that: it cannot be a division.
+            return collectRegex();
+        }
+        if (prevToken.type === 'Punctuator') {
+            if (prevToken.value === ']') {
+                return scanPunctuator();
+            }
+            if (prevToken.value === ')') {
+                checkToken = extra.tokens[extra.openParenToken - 1];
+                if (checkToken &&
+                        checkToken.type === 'Keyword' &&
+                        (checkToken.value === 'if' ||
+                         checkToken.value === 'while' ||
+                         checkToken.value === 'for' ||
+                         checkToken.value === 'with')) {
+                    return collectRegex();
+                }
+                return scanPunctuator();
+            }
+            if (prevToken.value === '}') {
+                // Dividing a function by anything makes little sense,
+                // but we have to check for that.
+                if (extra.tokens[extra.openCurlyToken - 3] &&
+                        extra.tokens[extra.openCurlyToken - 3].type === 'Keyword') {
+                    // Anonymous function.
+                    checkToken = extra.tokens[extra.openCurlyToken - 4];
+                    if (!checkToken) {
+                        return scanPunctuator();
+                    }
+                } else if (extra.tokens[extra.openCurlyToken - 4] &&
+                        extra.tokens[extra.openCurlyToken - 4].type === 'Keyword') {
+                    // Named function.
+                    checkToken = extra.tokens[extra.openCurlyToken - 5];
+                    if (!checkToken) {
+                        return collectRegex();
+                    }
+                } else {
+                    return scanPunctuator();
+                }
+                // checkToken determines whether the function is
+                // a declaration or an expression.
+                if (FnExprTokens.indexOf(checkToken.value) >= 0) {
+                    // It is an expression.
+                    return scanPunctuator();
+                }
+                // It is a declaration.
+                return collectRegex();
+            }
+            return collectRegex();
+        }
+        if (prevToken.type === 'Keyword' && prevToken.value !== 'this') {
+            return collectRegex();
+        }
+        return scanPunctuator();
+    }
+
+    function advance() {
+        var ch;
+
+        skipComment();
+
+        if (index >= length) {
+            return {
+                type: Token.EOF,
+                lineNumber: lineNumber,
+                lineStart: lineStart,
+                start: index,
+                end: index
+            };
+        }
+
+        ch = source.charCodeAt(index);
+
+        if (isIdentifierStart(ch)) {
+            return scanIdentifier();
+        }
+
+        // Very common: ( and ) and ;
+        if (ch === 0x28 || ch === 0x29 || ch === 0x3B) {
+            return scanPunctuator();
+        }
+
+        // String literal starts with single quote (U+0027) or double quote (U+0022).
+        if (ch === 0x27 || ch === 0x22) {
+            return scanStringLiteral();
+        }
+
+
+        // Dot (.) U+002E can also start a floating-point number, hence the need
+        // to check the next character.
+        if (ch === 0x2E) {
+            if (isDecimalDigit(source.charCodeAt(index + 1))) {
+                return scanNumericLiteral();
+            }
+            return scanPunctuator();
+        }
+
+        if (isDecimalDigit(ch)) {
+            return scanNumericLiteral();
+        }
+
+        // Slash (/) U+002F can also start a regex.
+        if (extra.tokenize && ch === 0x2F) {
+            return advanceSlash();
+        }
+
+        return scanPunctuator();
+    }
+
+    function collectToken() {
+        var loc, token, range, value;
+
+        skipComment();
+        loc = {
+            start: {
+                line: lineNumber,
+                column: index - lineStart
+            }
+        };
+
+        token = advance();
+        loc.end = {
+            line: lineNumber,
+            column: index - lineStart
+        };
+
+        if (token.type !== Token.EOF) {
+            value = source.slice(token.start, token.end);
+            extra.tokens.push({
+                type: TokenName[token.type],
+                value: value,
+                range: [token.start, token.end],
+                loc: loc
+            });
+        }
+
+        return token;
+    }
+
+    function lex() {
+        var token;
+
+        token = lookahead;
+        index = token.end;
+        lineNumber = token.lineNumber;
+        lineStart = token.lineStart;
+
+        lookahead = (typeof extra.tokens !== 'undefined') ? collectToken() : advance();
+
+        index = token.end;
+        lineNumber = token.lineNumber;
+        lineStart = token.lineStart;
+
+        return token;
+    }
+
+    function peek() {
+        var pos, line, start;
+
+        pos = index;
+        line = lineNumber;
+        start = lineStart;
+        lookahead = (typeof extra.tokens !== 'undefined') ? collectToken() : advance();
+        index = pos;
+        lineNumber = line;
+        lineStart = start;
+    }
+
+    function Position(line, column) {
+        this.line = line;
+        this.column = column;
+    }
+
+    function SourceLocation(startLine, startColumn, line, column) {
+        this.start = new Position(startLine, startColumn);
+        this.end = new Position(line, column);
+    }
+
+    SyntaxTreeDelegate = {
+
+        name: 'SyntaxTree',
+
+        processComment: function (node) {
+            var lastChild, trailingComments;
+
+            if (node.type === Syntax.Program) {
+                if (node.body.length > 0) {
+                    return;
+                }
+            }
+
+            if (extra.trailingComments.length > 0) {
+                if (extra.trailingComments[0].range[0] >= node.range[1]) {
+                    trailingComments = extra.trailingComments;
+                    extra.trailingComments = [];
+                } else {
+                    extra.trailingComments.length = 0;
+                }
+            } else {
+                if (extra.bottomRightStack.length > 0 &&
+                        extra.bottomRightStack[extra.bottomRightStack.length - 1].trailingComments &&
+                        extra.bottomRightStack[extra.bottomRightStack.length - 1].trailingComments[0].range[0] >= node.range[1]) {
+                    trailingComments = extra.bottomRightStack[extra.bottomRightStack.length - 1].trailingComments;
+                    delete extra.bottomRightStack[extra.bottomRightStack.length - 1].trailingComments;
+                }
+            }
+
+            // Eating the stack.
+            while (extra.bottomRightStack.length > 0 && extra.bottomRightStack[extra.bottomRightStack.length - 1].range[0] >= node.range[0]) {
+                lastChild = extra.bottomRightStack.pop();
+            }
+
+            if (lastChild) {
+                if (lastChild.leadingComments && lastChild.leadingComments[lastChild.leadingComments.length - 1].range[1] <= node.range[0]) {
+                    node.leadingComments = lastChild.leadingComments;
+                    delete lastChild.leadingComments;
+                }
+            } else if (extra.leadingComments.length > 0 && extra.leadingComments[extra.leadingComments.length - 1].range[1] <= node.range[0]) {
+                node.leadingComments = extra.leadingComments;
+                extra.leadingComments = [];
+            }
+
+
+            if (trailingComments) {
+                node.trailingComments = trailingComments;
+            }
+
+            extra.bottomRightStack.push(node);
+        },
+
+        markEnd: function (node, startToken) {
+            if (extra.range) {
+                node.range = [startToken.start, index];
+            }
+            if (extra.loc) {
+                node.loc = new SourceLocation(
+                    startToken.startLineNumber === undefined ?  startToken.lineNumber : startToken.startLineNumber,
+                    startToken.start - (startToken.startLineStart === undefined ?  startToken.lineStart : startToken.startLineStart),
+                    lineNumber,
+                    index - lineStart
+                );
+                this.postProcess(node);
+            }
+
+            if (extra.attachComment) {
+                this.processComment(node);
+            }
+            return node;
+        },
+
+        postProcess: function (node) {
+            if (extra.source) {
+                node.loc.source = extra.source;
+            }
+            return node;
+        },
+
+        createArrayExpression: function (elements) {
+            return {
+                type: Syntax.ArrayExpression,
+                elements: elements
+            };
+        },
+
+        createAssignmentExpression: function (operator, left, right) {
+            return {
+                type: Syntax.AssignmentExpression,
+                operator: operator,
+                left: left,
+                right: right
+            };
+        },
+
+        createBinaryExpression: function (operator, left, right) {
+            var type = (operator === '||' || operator === '&&') ? Syntax.LogicalExpression :
+                        Syntax.BinaryExpression;
+            return {
+                type: type,
+                operator: operator,
+                left: left,
+                right: right
+            };
+        },
+
+        createBlockStatement: function (body) {
+            return {
+                type: Syntax.BlockStatement,
+                body: body
+            };
+        },
+
+        createBreakStatement: function (label) {
+            return {
+                type: Syntax.BreakStatement,
+                label: label
+            };
+        },
+
+        createCallExpression: function (callee, args) {
+            return {
+                type: Syntax.CallExpression,
+                callee: callee,
+                'arguments': args
+            };
+        },
+
+        createCatchClause: function (param, body) {
+            return {
+                type: Syntax.CatchClause,
+                param: param,
+                body: body
+            };
+        },
+
+        createConditionalExpression: function (test, consequent, alternate) {
+            return {
+                type: Syntax.ConditionalExpression,
+                test: test,
+                consequent: consequent,
+                alternate: alternate
+            };
+        },
+
+        createContinueStatement: function (label) {
+            return {
+                type: Syntax.ContinueStatement,
+                label: label
+            };
+        },
+
+        createDebuggerStatement: function () {
+            return {
+                type: Syntax.DebuggerStatement
+            };
+        },
+
+        createDoWhileStatement: function (body, test) {
+            return {
+                type: Syntax.DoWhileStatement,
+                body: body,
+                test: test
+            };
+        },
+
+        createEmptyStatement: function () {
+            return {
+                type: Syntax.EmptyStatement
+            };
+        },
+
+        createExpressionStatement: function (expression) {
+            return {
+                type: Syntax.ExpressionStatement,
+                expression: expression
+            };
+        },
+
+        createForStatement: function (init, test, update, body) {
+            return {
+                type: Syntax.ForStatement,
+                init: init,
+                test: test,
+                update: update,
+                body: body
+            };
+        },
+
+        createForInStatement: function (left, right, body) {
+            return {
+                type: Syntax.ForInStatement,
+                left: left,
+                right: right,
+                body: body,
+                each: false
+            };
+        },
+
+        createFunctionDeclaration: function (id, params, defaults, body) {
+            return {
+                type: Syntax.FunctionDeclaration,
+                id: id,
+                params: params,
+                defaults: defaults,
+                body: body,
+                rest: null,
+                generator: false,
+                expression: false
+            };
+        },
+
+        createFunctionExpression: function (id, params, defaults, body) {
+            return {
+                type: Syntax.FunctionExpression,
+                id: id,
+                params: params,
+                defaults: defaults,
+                body: body,
+                rest: null,
+                generator: false,
+                expression: false
+            };
+        },
+
+        createIdentifier: function (name) {
+            return {
+                type: Syntax.Identifier,
+                name: name
+            };
+        },
+
+        createIfStatement: function (test, consequent, alternate) {
+            return {
+                type: Syntax.IfStatement,
+                test: test,
+                consequent: consequent,
+                alternate: alternate
+            };
+        },
+
+        createLabeledStatement: function (label, body) {
+            return {
+                type: Syntax.LabeledStatement,
+                label: label,
+                body: body
+            };
+        },
+
+        createLiteral: function (token) {
+            return {
+                type: Syntax.Literal,
+                value: token.value,
+                raw: source.slice(token.start, token.end)
+            };
+        },
+
+        createMemberExpression: function (accessor, object, property) {
+            return {
+                type: Syntax.MemberExpression,
+                computed: accessor === '[',
+                object: object,
+                property: property
+            };
+        },
+
+        createNewExpression: function (callee, args) {
+            return {
+                type: Syntax.NewExpression,
+                callee: callee,
+                'arguments': args
+            };
+        },
+
+        createObjectExpression: function (properties) {
+            return {
+                type: Syntax.ObjectExpression,
+                properties: properties
+            };
+        },
+
+        createPostfixExpression: function (operator, argument) {
+            return {
+                type: Syntax.UpdateExpression,
+                operator: operator,
+                argument: argument,
+                prefix: false
+            };
+        },
+
+        createProgram: function (body) {
+            return {
+                type: Syntax.Program,
+                body: body
+            };
+        },
+
+        createProperty: function (kind, key, value) {
+            return {
+                type: Syntax.Property,
+                key: key,
+                value: value,
+                kind: kind
+            };
+        },
+
+        createReturnStatement: function (argument) {
+            return {
+                type: Syntax.ReturnStatement,
+                argument: argument
+            };
+        },
+
+        createSequenceExpression: function (expressions) {
+            return {
+                type: Syntax.SequenceExpression,
+                expressions: expressions
+            };
+        },
+
+        createSwitchCase: function (test, consequent) {
+            return {
+                type: Syntax.SwitchCase,
+                test: test,
+                consequent: consequent
+            };
+        },
+
+        createSwitchStatement: function (discriminant, cases) {
+            return {
+                type: Syntax.SwitchStatement,
+                discriminant: discriminant,
+                cases: cases
+            };
+        },
+
+        createThisExpression: function () {
+            return {
+                type: Syntax.ThisExpression
+            };
+        },
+
+        createThrowStatement: function (argument) {
+            return {
+                type: Syntax.ThrowStatement,
+                argument: argument
+            };
+        },
+
+        createTryStatement: function (block, guardedHandlers, handlers, finalizer) {
+            return {
+                type: Syntax.TryStatement,
+                block: block,
+                guardedHandlers: guardedHandlers,
+                handlers: handlers,
+                finalizer: finalizer
+            };
+        },
+
+        createUnaryExpression: function (operator, argument) {
+            if (operator === '++' || operator === '--') {
+                return {
+                    type: Syntax.UpdateExpression,
+                    operator: operator,
+                    argument: argument,
+                    prefix: true
+                };
+            }
+            return {
+                type: Syntax.UnaryExpression,
+                operator: operator,
+                argument: argument,
+                prefix: true
+            };
+        },
+
+        createVariableDeclaration: function (declarations, kind) {
+            return {
+                type: Syntax.VariableDeclaration,
+                declarations: declarations,
+                kind: kind
+            };
+        },
+
+        createVariableDeclarator: function (id, init) {
+            return {
+                type: Syntax.VariableDeclarator,
+                id: id,
+                init: init
+            };
+        },
+
+        createWhileStatement: function (test, body) {
+            return {
+                type: Syntax.WhileStatement,
+                test: test,
+                body: body
+            };
+        },
+
+        createWithStatement: function (object, body) {
+            return {
+                type: Syntax.WithStatement,
+                object: object,
+                body: body
+            };
+        }
+    };
+
+    // Return true if there is a line terminator before the next token.
+
+    function peekLineTerminator() {
+        var pos, line, start, found;
+
+        pos = index;
+        line = lineNumber;
+        start = lineStart;
+        skipComment();
+        found = lineNumber !== line;
+        index = pos;
+        lineNumber = line;
+        lineStart = start;
+
+        return found;
+    }
+
+    // Throw an exception
+
+    function throwError(token, messageFormat) {
+        var error,
+            args = Array.prototype.slice.call(arguments, 2),
+            msg = messageFormat.replace(
+                /%(\d)/g,
+                function (whole, index) {
+                    assert(index < args.length, 'Message reference must be in range');
+                    return args[index];
+                }
+            );
+
+        if (typeof token.lineNumber === 'number') {
+            error = new Error('Line ' + token.lineNumber + ': ' + msg);
+            error.index = token.start;
+            error.lineNumber = token.lineNumber;
+            error.column = token.start - lineStart + 1;
+        } else {
+            error = new Error('Line ' + lineNumber + ': ' + msg);
+            error.index = index;
+            error.lineNumber = lineNumber;
+            error.column = index - lineStart + 1;
+        }
+
+        error.description = msg;
+        throw error;
+    }
+
+    function throwErrorTolerant() {
+        try {
+            throwError.apply(null, arguments);
+        } catch (e) {
+            if (extra.errors) {
+                extra.errors.push(e);
+            } else {
+                throw e;
+            }
+        }
+    }
+
+
+    // Throw an exception because of the token.
+
+    function throwUnexpected(token) {
+        if (token.type === Token.EOF) {
+            throwError(token, Messages.UnexpectedEOS);
+        }
+
+        if (token.type === Token.NumericLiteral) {
+            throwError(token, Messages.UnexpectedNumber);
+        }
+
+        if (token.type === Token.StringLiteral) {
+            throwError(token, Messages.UnexpectedString);
+        }
+
+        if (token.type === Token.Identifier) {
+            throwError(token, Messages.UnexpectedIdentifier);
+        }
+
+        if (token.type === Token.Keyword) {
+            if (isFutureReservedWord(token.value)) {
+                throwError(token, Messages.UnexpectedReserved);
+            } else if (strict && isStrictModeReservedWord(token.value)) {
+                throwErrorTolerant(token, Messages.StrictReservedWord);
+                return;
+            }
+            throwError(token, Messages.UnexpectedToken, token.value);
+        }
+
+        // BooleanLiteral, NullLiteral, or Punctuator.
+        throwError(token, Messages.UnexpectedToken, token.value);
+    }
+
+    // Expect the next token to match the specified punctuator.
+    // If not, an exception will be thrown.
+
+    function expect(value) {
+        var token = lex();
+        if (token.type !== Token.Punctuator || token.value !== value) {
+            throwUnexpected(token);
+        }
+    }
+
+    // Expect the next token to match the specified keyword.
+    // If not, an exception will be thrown.
+
+    function expectKeyword(keyword) {
+        var token = lex();
+        if (token.type !== Token.Keyword || token.value !== keyword) {
+            throwUnexpected(token);
+        }
+    }
+
+    // Return true if the next token matches the specified punctuator.
+
+    function match(value) {
+        return lookahead.type === Token.Punctuator && lookahead.value === value;
+    }
+
+    // Return true if the next token matches the specified keyword
+
+    function matchKeyword(keyword) {
+        return lookahead.type === Token.Keyword && lookahead.value === keyword;
+    }
+
+    // Return true if the next token is an assignment operator
+
+    function matchAssign() {
+        var op;
+
+        if (lookahead.type !== Token.Punctuator) {
+            return false;
+        }
+        op = lookahead.value;
+        return op === '=' ||
+            op === '*=' ||
+            op === '/=' ||
+            op === '%=' ||
+            op === '+=' ||
+            op === '-=' ||
+            op === '<<=' ||
+            op === '>>=' ||
+            op === '>>>=' ||
+            op === '&=' ||
+            op === '^=' ||
+            op === '|=';
+    }
+
+    function consumeSemicolon() {
+        var line, oldIndex = index, oldLineNumber = lineNumber,
+            oldLineStart = lineStart, oldLookahead = lookahead;
+
+        // Catch the very common case first: immediately a semicolon (U+003B).
+        if (source.charCodeAt(index) === 0x3B || match(';')) {
+            lex();
+            return;
+        }
+
+        line = lineNumber;
+        skipComment();
+        if (lineNumber !== line) {
+            index = oldIndex;
+            lineNumber = oldLineNumber;
+            lineStart = oldLineStart;
+            lookahead = oldLookahead;
+            return;
+        }
+
+        if (lookahead.type !== Token.EOF && !match('}')) {
+            throwUnexpected(lookahead);
+        }
+    }
+
+    // Return true if provided expression is LeftHandSideExpression
+
+    function isLeftHandSide(expr) {
+        return expr.type === Syntax.Identifier || expr.type === Syntax.MemberExpression;
+    }
+
+    // 11.1.4 Array Initialiser
+
+    function parseArrayInitialiser() {
+        var elements = [], startToken;
+
+        startToken = lookahead;
+        expect('[');
+
+        while (!match(']')) {
+            if (match(',')) {
+                lex();
+                elements.push(null);
+            } else {
+                elements.push(parseAssignmentExpression());
+
+                if (!match(']')) {
+                    expect(',');
+                }
+            }
+        }
+
+        lex();
+
+        return delegate.markEnd(delegate.createArrayExpression(elements), startToken);
+    }
+
+    // 11.1.5 Object Initialiser
+
+    function parsePropertyFunction(param, first) {
+        var previousStrict, body, startToken;
+
+        previousStrict = strict;
+        startToken = lookahead;
+        body = parseFunctionSourceElements();
+        if (first && strict && isRestrictedWord(param[0].name)) {
+            throwErrorTolerant(first, Messages.StrictParamName);
+        }
+        strict = previousStrict;
+        return delegate.markEnd(delegate.createFunctionExpression(null, param, [], body), startToken);
+    }
+
+    function parseObjectPropertyKey() {
+        var token, startToken;
+
+        startToken = lookahead;
+        token = lex();
+
+        // Note: This function is called only from parseObjectProperty(), where
+        // EOF and Punctuator tokens are already filtered out.
+
+        if (token.type === Token.StringLiteral || token.type === Token.NumericLiteral) {
+            if (strict && token.octal) {
+                throwErrorTolerant(token, Messages.StrictOctalLiteral);
+            }
+            return delegate.markEnd(delegate.createLiteral(token), startToken);
+        }
+
+        return delegate.markEnd(delegate.createIdentifier(token.value), startToken);
+    }
+
+    function parseObjectProperty() {
+        var token, key, id, value, param, startToken;
+
+        token = lookahead;
+        startToken = lookahead;
+
+        if (token.type === Token.Identifier) {
+
+            id = parseObjectPropertyKey();
+
+            // Property Assignment: Getter and Setter.
+
+            if (token.value === 'get' && !match(':')) {
+                key = parseObjectPropertyKey();
+                expect('(');
+                expect(')');
+                value = parsePropertyFunction([]);
+                return delegate.markEnd(delegate.createProperty('get', key, value), startToken);
+            }
+            if (token.value === 'set' && !match(':')) {
+                key = parseObjectPropertyKey();
+                expect('(');
+                token = lookahead;
+                if (token.type !== Token.Identifier) {
+                    expect(')');
+                    throwErrorTolerant(token, Messages.UnexpectedToken, token.value);
+                    value = parsePropertyFunction([]);
+                } else {
+                    param = [ parseVariableIdentifier() ];
+                    expect(')');
+                    value = parsePropertyFunction(param, token);
+                }
+                return delegate.markEnd(delegate.createProperty('set', key, value), startToken);
+            }
+            expect(':');
+            value = parseAssignmentExpression();
+            return delegate.markEnd(delegate.createProperty('init', id, value), startToken);
+        }
+        if (token.type === Token.EOF || token.type === Token.Punctuator) {
+            throwUnexpected(token);
+        } else {
+            key = parseObjectPropertyKey();
+            expect(':');
+            value = parseAssignmentExpression();
+            return delegate.markEnd(delegate.createProperty('init', key, value), startToken);
+        }
+    }
+
+    function parseObjectInitialiser() {
+        var properties = [], property, name, key, kind, map = {}, toString = String, startToken;
+
+        startToken = lookahead;
+
+        expect('{');
+
+        while (!match('}')) {
+            property = parseObjectProperty();
+
+            if (property.key.type === Syntax.Identifier) {
+                name = property.key.name;
+            } else {
+                name = toString(property.key.value);
+            }
+            kind = (property.kind === 'init') ? PropertyKind.Data : (property.kind === 'get') ? PropertyKind.Get : PropertyKind.Set;
+
+            key = '$' + name;
+            if (Object.prototype.hasOwnProperty.call(map, key)) {
+                if (map[key] === PropertyKind.Data) {
+                    if (strict && kind === PropertyKind.Data) {
+                        throwErrorTolerant({}, Messages.StrictDuplicateProperty);
+                    } else if (kind !== PropertyKind.Data) {
+                        throwErrorTolerant({}, Messages.AccessorDataProperty);
+                    }
+                } else {
+                    if (kind === PropertyKind.Data) {
+                        throwErrorTolerant({}, Messages.AccessorDataProperty);
+                    } else if (map[key] & kind) {
+                        throwErrorTolerant({}, Messages.AccessorGetSet);
+                    }
+                }
+                map[key] |= kind;
+            } else {
+                map[key] = kind;
+            }
+
+            properties.push(property);
+
+            if (!match('}')) {
+                expect(',');
+            }
+        }
+
+        expect('}');
+
+        return delegate.markEnd(delegate.createObjectExpression(properties), startToken);
+    }
+
+    // 11.1.6 The Grouping Operator
+
+    function parseGroupExpression() {
+        var expr;
+
+        expect('(');
+
+        expr = parseExpression();
+
+        expect(')');
+
+        return expr;
+    }
+
+
+    // 11.1 Primary Expressions
+
+    function parsePrimaryExpression() {
+        var type, token, expr, startToken;
+
+        if (match('(')) {
+            return parseGroupExpression();
+        }
+
+        if (match('[')) {
+            return parseArrayInitialiser();
+        }
+
+        if (match('{')) {
+            return parseObjectInitialiser();
+        }
+
+        type = lookahead.type;
+        startToken = lookahead;
+
+        if (type === Token.Identifier) {
+            expr =  delegate.createIdentifier(lex().value);
+        } else if (type === Token.StringLiteral || type === Token.NumericLiteral) {
+            if (strict && lookahead.octal) {
+                throwErrorTolerant(lookahead, Messages.StrictOctalLiteral);
+            }
+            expr = delegate.createLiteral(lex());
+        } else if (type === Token.Keyword) {
+            if (matchKeyword('function')) {
+                return parseFunctionExpression();
+            }
+            if (matchKeyword('this')) {
+                lex();
+                expr = delegate.createThisExpression();
+            } else {
+                throwUnexpected(lex());
+            }
+        } else if (type === Token.BooleanLiteral) {
+            token = lex();
+            token.value = (token.value === 'true');
+            expr = delegate.createLiteral(token);
+        } else if (type === Token.NullLiteral) {
+            token = lex();
+            token.value = null;
+            expr = delegate.createLiteral(token);
+        } else if (match('/') || match('/=')) {
+            if (typeof extra.tokens !== 'undefined') {
+                expr = delegate.createLiteral(collectRegex());
+            } else {
+                expr = delegate.createLiteral(scanRegExp());
+            }
+            peek();
+        } else {
+            throwUnexpected(lex());
+        }
+
+        return delegate.markEnd(expr, startToken);
+    }
+
+    // 11.2 Left-Hand-Side Expressions
+
+    function parseArguments() {
+        var args = [];
+
+        expect('(');
+
+        if (!match(')')) {
+            while (index < length) {
+                args.push(parseAssignmentExpression());
+                if (match(')')) {
+                    break;
+                }
+                expect(',');
+            }
+        }
+
+        expect(')');
+
+        return args;
+    }
+
+    function parseNonComputedProperty() {
+        var token, startToken;
+
+        startToken = lookahead;
+        token = lex();
+
+        if (!isIdentifierName(token)) {
+            throwUnexpected(token);
+        }
+
+        return delegate.markEnd(delegate.createIdentifier(token.value), startToken);
+    }
+
+    function parseNonComputedMember() {
+        expect('.');
+
+        return parseNonComputedProperty();
+    }
+
+    function parseComputedMember() {
+        var expr;
+
+        expect('[');
+
+        expr = parseExpression();
+
+        expect(']');
+
+        return expr;
+    }
+
+    function parseNewExpression() {
+        var callee, args, startToken;
+
+        startToken = lookahead;
+        expectKeyword('new');
+        callee = parseLeftHandSideExpression();
+        args = match('(') ? parseArguments() : [];
+
+        return delegate.markEnd(delegate.createNewExpression(callee, args), startToken);
+    }
+
+    function parseLeftHandSideExpressionAllowCall() {
+        var expr, args, property, startToken, previousAllowIn = state.allowIn;
+
+        startToken = lookahead;
+        state.allowIn = true;
+        expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();
+
+        for (;;) {
+            if (match('.')) {
+                property = parseNonComputedMember();
+                expr = delegate.createMemberExpression('.', expr, property);
+            } else if (match('(')) {
+                args = parseArguments();
+                expr = delegate.createCallExpression(expr, args);
+            } else if (match('[')) {
+                property = parseComputedMember();
+                expr = delegate.createMemberExpression('[', expr, property);
+            } else {
+                break;
+            }
+            delegate.markEnd(expr, startToken);
+        }
+        state.allowIn = previousAllowIn;
+
+        return expr;
+    }
+
+    function parseLeftHandSideExpression() {
+        var expr, property, startToken;
+        assert(state.allowIn, 'callee of new expression always allow in keyword.');
+
+        startToken = lookahead;
+
+        expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();
+
+        while (match('.') || match('[')) {
+            if (match('[')) {
+                property = parseComputedMember();
+                expr = delegate.createMemberExpression('[', expr, property);
+            } else {
+                property = parseNonComputedMember();
+                expr = delegate.createMemberExpression('.', expr, property);
+            }
+            delegate.markEnd(expr, startToken);
+        }
+        return expr;
+    }
+
+    // 11.3 Postfix Expressions
+
+    function parsePostfixExpression() {
+        var expr, token, startToken = lookahead;
+
+        expr = parseLeftHandSideExpressionAllowCall();
+
+        if (lookahead.type === Token.Punctuator) {
+            if ((match('++') || match('--')) && !peekLineTerminator()) {
+                // 11.3.1, 11.3.2
+                if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {
+                    throwErrorTolerant({}, Messages.StrictLHSPostfix);
+                }
+
+                if (!isLeftHandSide(expr)) {
+                    throwErrorTolerant({}, Messages.InvalidLHSInAssignment);
+                }
+
+                token = lex();
+                expr = delegate.markEnd(delegate.createPostfixExpression(token.value, expr), startToken);
+            }
+        }
+
+        return expr;
+    }
+
+    // 11.4 Unary Operators
+
+    function parseUnaryExpression() {
+        var token, expr, startToken;
+
+        if (lookahead.type !== Token.Punctuator && lookahead.type !== Token.Keyword) {
+            expr = parsePostfixExpression();
+        } else if (match('++') || match('--')) {
+            startToken = lookahead;
+            token = lex();
+            expr = parseUnaryExpression();
+            // 11.4.4, 11.4.5
+            if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {
+                throwErrorTolerant({}, Messages.StrictLHSPrefix);
+            }
+
+            if (!isLeftHandSide(expr)) {
+                throwErrorTolerant({}, Messages.InvalidLHSInAssignment);
+            }
+
+            expr = delegate.createUnaryExpression(token.value, expr);
+            expr = delegate.markEnd(expr, startToken);
+        } else if (match('+') || match('-') || match('~') || match('!')) {
+            startToken = lookahead;
+            token = lex();
+            expr = parseUnaryExpression();
+            expr = delegate.createUnaryExpression(token.value, expr);
+            expr = delegate.markEnd(expr, startToken);
+        } else if (matchKeyword('delete') || matchKeyword('void') || matchKeyword('typeof')) {
+            startToken = lookahead;
+            token = lex();
+            expr = parseUnaryExpression();
+            expr = delegate.createUnaryExpression(token.value, expr);
+            expr = delegate.markEnd(expr, startToken);
+            if (strict && expr.operator === 'delete' && expr.argument.type === Syntax.Identifier) {
+                throwErrorTolerant({}, Messages.StrictDelete);
+            }
+        } else {
+            expr = parsePostfixExpression();
+        }
+
+        return expr;
+    }
+
+    function binaryPrecedence(token, allowIn) {
+        var prec = 0;
+
+        if (token.type !== Token.Punctuator && token.type !== Token.Keyword) {
+            return 0;
+        }
+
+        switch (token.value) {
+        case '||':
+            prec = 1;
+            break;
+
+        case '&&':
+            prec = 2;
+            break;
+
+        case '|':
+            prec = 3;
+            break;
+
+        case '^':
+            prec = 4;
+            break;
+
+        case '&':
+            prec = 5;
+            break;
+
+        case '==':
+        case '!=':
+        case '===':
+        case '!==':
+            prec = 6;
+            break;
+
+        case '<':
+        case '>':
+        case '<=':
+        case '>=':
+        case 'instanceof':
+            prec = 7;
+            break;
+
+        case 'in':
+            prec = allowIn ? 7 : 0;
+            break;
+
+        case '<<':
+        case '>>':
+        case '>>>':
+            prec = 8;
+            break;
+
+        case '+':
+        case '-':
+            prec = 9;
+            break;
+
+        case '*':
+        case '/':
+        case '%':
+            prec = 11;
+            break;
+
+        default:
+            break;
+        }
+
+        return prec;
+    }
+
+    // 11.5 Multiplicative Operators
+    // 11.6 Additive Operators
+    // 11.7 Bitwise Shift Operators
+    // 11.8 Relational Operators
+    // 11.9 Equality Operators
+    // 11.10 Binary Bitwise Operators
+    // 11.11 Binary Logical Operators
+
+    function parseBinaryExpression() {
+        var marker, markers, expr, token, prec, stack, right, operator, left, i;
+
+        marker = lookahead;
+        left = parseUnaryExpression();
+
+        token = lookahead;
+        prec = binaryPrecedence(token, state.allowIn);
+        if (prec === 0) {
+            return left;
+        }
+        token.prec = prec;
+        lex();
+
+        markers = [marker, lookahead];
+        right = parseUnaryExpression();
+
+        stack = [left, token, right];
+
+        while ((prec = binaryPrecedence(lookahead, state.allowIn)) > 0) {
+
+            // Reduce: make a binary expression from the three topmost entries.
+            while ((stack.length > 2) && (prec <= stack[stack.length - 2].prec)) {
+                right = stack.pop();
+                operator = stack.pop().value;
+                left = stack.pop();
+                expr = delegate.createBinaryExpression(operator, left, right);
+                markers.pop();
+                marker = markers[markers.length - 1];
+                delegate.markEnd(expr, marker);
+                stack.push(expr);
+            }
+
+            // Shift.
+            token = lex();
+            token.prec = prec;
+            stack.push(token);
+            markers.push(lookahead);
+            expr = parseUnaryExpression();
+            stack.push(expr);
+        }
+
+        // Final reduce to clean-up the stack.
+        i = stack.length - 1;
+        expr = stack[i];
+        markers.pop();
+        while (i > 1) {
+            expr = delegate.createBinaryExpression(stack[i - 1].value, stack[i - 2], expr);
+            i -= 2;
+            marker = markers.pop();
+            delegate.markEnd(expr, marker);
+        }
+
+        return expr;
+    }
+
+
+    // 11.12 Conditional Operator
+
+    function parseConditionalExpression() {
+        var expr, previousAllowIn, consequent, alternate, startToken;
+
+        startToken = lookahead;
+
+        expr = parseBinaryExpression();
+
+        if (match('?')) {
+            lex();
+            previousAllowIn = state.allowIn;
+            state.allowIn = true;
+            consequent = parseAssignmentExpression();
+            state.allowIn = previousAllowIn;
+            expect(':');
+            alternate = parseAssignmentExpression();
+
+            expr = delegate.createConditionalExpression(expr, consequent, alternate);
+            delegate.markEnd(expr, startToken);
+        }
+
+        return expr;
+    }
+
+    // 11.13 Assignment Operators
+
+    function parseAssignmentExpression() {
+        var token, left, right, node, startToken;
+
+        token = lookahead;
+        startToken = lookahead;
+
+        node = left = parseConditionalExpression();
+
+        if (matchAssign()) {
+            // LeftHandSideExpression
+            if (!isLeftHandSide(left)) {
+                throwErrorTolerant({}, Messages.InvalidLHSInAssignment);
+            }
+
+            // 11.13.1
+            if (strict && left.type === Syntax.Identifier && isRestrictedWord(left.name)) {
+                throwErrorTolerant(token, Messages.StrictLHSAssignment);
+            }
+
+            token = lex();
+            right = parseAssignmentExpression();
+            node = delegate.markEnd(delegate.createAssignmentExpression(token.value, left, right), startToken);
+        }
+
+        return node;
+    }
+
+    // 11.14 Comma Operator
+
+    function parseExpression() {
+        var expr, startToken = lookahead;
+
+        expr = parseAssignmentExpression();
+
+        if (match(',')) {
+            expr = delegate.createSequenceExpression([ expr ]);
+
+            while (index < length) {
+                if (!match(',')) {
+                    break;
+                }
+                lex();
+                expr.expressions.push(parseAssignmentExpression());
+            }
+
+            delegate.markEnd(expr, startToken);
+        }
+
+        return expr;
+    }
+
+    // 12.1 Block
+
+    function parseStatementList() {
+        var list = [],
+            statement;
+
+        while (index < length) {
+            if (match('}')) {
+                break;
+            }
+            statement = parseSourceElement();
+            if (typeof statement === 'undefined') {
+                break;
+            }
+            list.push(statement);
+        }
+
+        return list;
+    }
+
+    function parseBlock() {
+        var block, startToken;
+
+        startToken = lookahead;
+        expect('{');
+
+        block = parseStatementList();
+
+        expect('}');
+
+        return delegate.markEnd(delegate.createBlockStatement(block), startToken);
+    }
+
+    // 12.2 Variable Statement
+
+    function parseVariableIdentifier() {
+        var token, startToken;
+
+        startToken = lookahead;
+        token = lex();
+
+        if (token.type !== Token.Identifier) {
+            throwUnexpected(token);
+        }
+
+        return delegate.markEnd(delegate.createIdentifier(token.value), startToken);
+    }
+
+    function parseVariableDeclaration(kind) {
+        var init = null, id, startToken;
+
+        startToken = lookahead;
+        id = parseVariableIdentifier();
+
+        // 12.2.1
+        if (strict && isRestrictedWord(id.name)) {
+            throwErrorTolerant({}, Messages.StrictVarName);
+        }
+
+        if (kind === 'const') {
+            expect('=');
+            init = parseAssignmentExpression();
+        } else if (match('=')) {
+            lex();
+            init = parseAssignmentExpression();
+        }
+
+        return delegate.markEnd(delegate.createVariableDeclarator(id, init), startToken);
+    }
+
+    function parseVariableDeclarationList(kind) {
+        var list = [];
+
+        do {
+            list.push(parseVariableDeclaration(kind));
+            if (!match(',')) {
+                break;
+            }
+            lex();
+        } while (index < length);
+
+        return list;
+    }
+
+    function parseVariableStatement() {
+        var declarations;
+
+        expectKeyword('var');
+
+        declarations = parseVariableDeclarationList();
+
+        consumeSemicolon();
+
+        return delegate.createVariableDeclaration(declarations, 'var');
+    }
+
+    // kind may be `const` or `let`
+    // Both are experimental and not in the specification yet.
+    // see http://wiki.ecmascript.org/doku.php?id=harmony:const
+    // and http://wiki.ecmascript.org/doku.php?id=harmony:let
+    function parseConstLetDeclaration(kind) {
+        var declarations, startToken;
+
+        startToken = lookahead;
+
+        expectKeyword(kind);
+
+        declarations = parseVariableDeclarationList(kind);
+
+        consumeSemicolon();
+
+        return delegate.markEnd(delegate.createVariableDeclaration(declarations, kind), startToken);
+    }
+
+    // 12.3 Empty Statement
+
+    function parseEmptyStatement() {
+        expect(';');
+        return delegate.createEmptyStatement();
+    }
+
+    // 12.4 Expression Statement
+
+    function parseExpressionStatement() {
+        var expr = parseExpression();
+        consumeSemicolon();
+        return delegate.createExpressionStatement(expr);
+    }
+
+    // 12.5 If statement
+
+    function parseIfStatement() {
+        var test, consequent, alternate;
+
+        expectKeyword('if');
+
+        expect('(');
+
+        test = parseExpression();
+
+        expect(')');
+
+        consequent = parseStatement();
+
+        if (matchKeyword('else')) {
+            lex();
+            alternate = parseStatement();
+        } else {
+            alternate = null;
+        }
+
+        return delegate.createIfStatement(test, consequent, alternate);
+    }
+
+    // 12.6 Iteration Statements
+
+    function parseDoWhileStatement() {
+        var body, test, oldInIteration;
+
+        expectKeyword('do');
+
+        oldInIteration = state.inIteration;
+        state.inIteration = true;
+
+        body = parseStatement();
+
+        state.inIteration = oldInIteration;
+
+        expectKeyword('while');
+
+        expect('(');
+
+        test = parseExpression();
+
+        expect(')');
+
+        if (match(';')) {
+            lex();
+        }
+
+        return delegate.createDoWhileStatement(body, test);
+    }
+
+    function parseWhileStatement() {
+        var test, body, oldInIteration;
+
+        expectKeyword('while');
+
+        expect('(');
+
+        test = parseExpression();
+
+        expect(')');
+
+        oldInIteration = state.inIteration;
+        state.inIteration = true;
+
+        body = parseStatement();
+
+        state.inIteration = oldInIteration;
+
+        return delegate.createWhileStatement(test, body);
+    }
+
+    function parseForVariableDeclaration() {
+        var token, declarations, startToken;
+
+        startToken = lookahead;
+        token = lex();
+        declarations = parseVariableDeclarationList();
+
+        return delegate.markEnd(delegate.createVariableDeclaration(declarations, token.value), startToken);
+    }
+
+    function parseForStatement() {
+        var init, test, update, left, right, body, oldInIteration, previousAllowIn = state.allowIn;
+
+        init = test = update = null;
+
+        expectKeyword('for');
+
+        expect('(');
+
+        if (match(';')) {
+            lex();
+        } else {
+            if (matchKeyword('var') || matchKeyword('let')) {
+                state.allowIn = false;
+                init = parseForVariableDeclaration();
+                state.allowIn = previousAllowIn;
+
+                if (init.declarations.length === 1 && matchKeyword('in')) {
+                    lex();
+                    left = init;
+                    right = parseExpression();
+                    init = null;
+                }
+            } else {
+                state.allowIn = false;
+                init = parseExpression();
+                state.allowIn = previousAllowIn;
+
+                if (matchKeyword('in')) {
+                    // LeftHandSideExpression
+                    if (!isLeftHandSide(init)) {
+                        throwErrorTolerant({}, Messages.InvalidLHSInForIn);
+                    }
+
+                    lex();
+                    left = init;
+                    right = parseExpression();
+                    init = null;
+                }
+            }
+
+            if (typeof left === 'undefined') {
+                expect(';');
+            }
+        }
+
+        if (typeof left === 'undefined') {
+
+            if (!match(';')) {
+                test = parseExpression();
+            }
+            expect(';');
+
+            if (!match(')')) {
+                update = parseExpression();
+            }
+        }
+
+        expect(')');
+
+        oldInIteration = state.inIteration;
+        state.inIteration = true;
+
+        body = parseStatement();
+
+        state.inIteration = oldInIteration;
+
+        return (typeof left === 'undefined') ?
+                delegate.createForStatement(init, test, update, body) :
+                delegate.createForInStatement(left, right, body);
+    }
+
+    // 12.7 The continue statement
+
+    function parseContinueStatement() {
+        var label = null, key;
+
+        expectKeyword('continue');
+
+        // Optimize the most common form: 'continue;'.
+        if (source.charCodeAt(index) === 0x3B) {
+            lex();
+
+            if (!state.inIteration) {
+                throwError({}, Messages.IllegalContinue);
+            }
+
+            return delegate.createContinueStatement(null);
+        }
+
+        if (peekLineTerminator()) {
+            if (!state.inIteration) {
+                throwError({}, Messages.IllegalContinue);
+            }
+
+            return delegate.createContinueStatement(null);
+        }
+
+        if (lookahead.type === Token.Identifier) {
+            label = parseVariableIdentifier();
+
+            key = '$' + label.name;
+            if (!Object.prototype.hasOwnProperty.call(state.labelSet, key)) {
+                throwError({}, Messages.UnknownLabel, label.name);
+            }
+        }
+
+        consumeSemicolon();
+
+        if (label === null && !state.inIteration) {
+            throwError({}, Messages.IllegalContinue);
+        }
+
+        return delegate.createContinueStatement(label);
+    }
+
+    // 12.8 The break statement
+
+    function parseBreakStatement() {
+        var label = null, key;
+
+        expectKeyword('break');
+
+        // Catch the very common case first: immediately a semicolon (U+003B).
+        if (source.charCodeAt(index) === 0x3B) {
+            lex();
+
+            if (!(state.inIteration || state.inSwitch)) {
+                throwError({}, Messages.IllegalBreak);
+            }
+
+            return delegate.createBreakStatement(null);
+        }
+
+        if (peekLineTerminator()) {
+            if (!(state.inIteration || state.inSwitch)) {
+                throwError({}, Messages.IllegalBreak);
+            }
+
+            return delegate.createBreakStatement(null);
+        }
+
+        if (lookahead.type === Token.Identifier) {
+            label = parseVariableIdentifier();
+
+            key = '$' + label.name;
+            if (!Object.prototype.hasOwnProperty.call(state.labelSet, key)) {
+                throwError({}, Messages.UnknownLabel, label.name);
+            }
+        }
+
+        consumeSemicolon();
+
+        if (label === null && !(state.inIteration || state.inSwitch)) {
+            throwError({}, Messages.IllegalBreak);
+        }
+
+        return delegate.createBreakStatement(label);
+    }
+
+    // 12.9 The return statement
+
+    function parseReturnStatement() {
+        var argument = null;
+
+        expectKeyword('return');
+
+        if (!state.inFunctionBody) {
+            throwErrorTolerant({}, Messages.IllegalReturn);
+        }
+
+        // 'return' followed by a space and an identifier is very common.
+        if (source.charCodeAt(index) === 0x20) {
+            if (isIdentifierStart(source.charCodeAt(index + 1))) {
+                argument = parseExpression();
+                consumeSemicolon();
+                return delegate.createReturnStatement(argument);
+            }
+        }
+
+        if (peekLineTerminator()) {
+            return delegate.createReturnStatement(null);
+        }
+
+        if (!match(';')) {
+            if (!match('}') && lookahead.type !== Token.EOF) {
+                argument = parseExpression();
+            }
+        }
+
+        consumeSemicolon();
+
+        return delegate.createReturnStatement(argument);
+    }
+
+    // 12.10 The with statement
+
+    function parseWithStatement() {
+        var object, body;
+
+        if (strict) {
+            // TODO(ikarienator): Should we update the test cases instead?
+            skipComment();
+            throwErrorTolerant({}, Messages.StrictModeWith);
+        }
+
+        expectKeyword('with');
+
+        expect('(');
+
+        object = parseExpression();
+
+        expect(')');
+
+        body = parseStatement();
+
+        return delegate.createWithStatement(object, body);
+    }
+
+    // 12.10 The swith statement
+
+    function parseSwitchCase() {
+        var test, consequent = [], statement, startToken;
+
+        startToken = lookahead;
+        if (matchKeyword('default')) {
+            lex();
+            test = null;
+        } else {
+            expectKeyword('case');
+            test = parseExpression();
+        }
+        expect(':');
+
+        while (index < length) {
+            if (match('}') || matchKeyword('default') || matchKeyword('case')) {
+                break;
+            }
+            statement = parseStatement();
+            consequent.push(statement);
+        }
+
+        return delegate.markEnd(delegate.createSwitchCase(test, consequent), startToken);
+    }
+
+    function parseSwitchStatement() {
+        var discriminant, cases, clause, oldInSwitch, defaultFound;
+
+        expectKeyword('switch');
+
+        expect('(');
+
+        discriminant = parseExpression();
+
+        expect(')');
+
+        expect('{');
+
+        cases = [];
+
+        if (match('}')) {
+            lex();
+            return delegate.createSwitchStatement(discriminant, cases);
+        }
+
+        oldInSwitch = state.inSwitch;
+        state.inSwitch = true;
+        defaultFound = false;
+
+        while (index < length) {
+            if (match('}')) {
+                break;
+            }
+            clause = parseSwitchCase();
+            if (clause.test === null) {
+                if (defaultFound) {
+                    throwError({}, Messages.MultipleDefaultsInSwitch);
+                }
+                defaultFound = true;
+            }
+            cases.push(clause);
+        }
+
+        state.inSwitch = oldInSwitch;
+
+        expect('}');
+
+        return delegate.createSwitchStatement(discriminant, cases);
+    }
+
+    // 12.13 The throw statement
+
+    function parseThrowStatement() {
+        var argument;
+
+        expectKeyword('throw');
+
+        if (peekLineTerminator()) {
+            throwError({}, Messages.NewlineAfterThrow);
+        }
+
+        argument = parseExpression();
+
+        consumeSemicolon();
+
+        return delegate.createThrowStatement(argument);
+    }
+
+    // 12.14 The try statement
+
+    function parseCatchClause() {
+        var param, body, startToken;
+
+        startToken = lookahead;
+        expectKeyword('catch');
+
+        expect('(');
+        if (match(')')) {
+            throwUnexpected(lookahead);
+        }
+
+        param = parseVariableIdentifier();
+        // 12.14.1
+        if (strict && isRestrictedWord(param.name)) {
+            throwErrorTolerant({}, Messages.StrictCatchVariable);
+        }
+
+        expect(')');
+        body = parseBlock();
+        return delegate.markEnd(delegate.createCatchClause(param, body), startToken);
+    }
+
+    function parseTryStatement() {
+        var block, handlers = [], finalizer = null;
+
+        expectKeyword('try');
+
+        block = parseBlock();
+
+        if (matchKeyword('catch')) {
+            handlers.push(parseCatchClause());
+        }
+
+        if (matchKeyword('finally')) {
+            lex();
+            finalizer = parseBlock();
+        }
+
+        if (handlers.length === 0 && !finalizer) {
+            throwError({}, Messages.NoCatchOrFinally);
+        }
+
+        return delegate.createTryStatement(block, [], handlers, finalizer);
+    }
+
+    // 12.15 The debugger statement
+
+    function parseDebuggerStatement() {
+        expectKeyword('debugger');
+
+        consumeSemicolon();
+
+        return delegate.createDebuggerStatement();
+    }
+
+    // 12 Statements
+
+    function parseStatement() {
+        var type = lookahead.type,
+            expr,
+            labeledBody,
+            key,
+            startToken;
+
+        if (type === Token.EOF) {
+            throwUnexpected(lookahead);
+        }
+
+        if (type === Token.Punctuator && lookahead.value === '{') {
+            return parseBlock();
+        }
+
+        startToken = lookahead;
+
+        if (type === Token.Punctuator) {
+            switch (lookahead.value) {
+            case ';':
+                return delegate.markEnd(parseEmptyStatement(), startToken);
+            case '(':
+                return delegate.markEnd(parseExpressionStatement(), startToken);
+            default:
+                break;
+            }
+        }
+
+        if (type === Token.Keyword) {
+            switch (lookahead.value) {
+            case 'break':
+                return delegate.markEnd(parseBreakStatement(), startToken);
+            case 'continue':
+                return delegate.markEnd(parseContinueStatement(), startToken);
+            case 'debugger':
+                return delegate.markEnd(parseDebuggerStatement(), startToken);
+            case 'do':
+                return delegate.markEnd(parseDoWhileStatement(), startToken);
+            case 'for':
+                return delegate.markEnd(parseForStatement(), startToken);
+            case 'function':
+                return delegate.markEnd(parseFunctionDeclaration(), startToken);
+            case 'if':
+                return delegate.markEnd(parseIfStatement(), startToken);
+            case 'return':
+                return delegate.markEnd(parseReturnStatement(), startToken);
+            case 'switch':
+                return delegate.markEnd(parseSwitchStatement(), startToken);
+            case 'throw':
+                return delegate.markEnd(parseThrowStatement(), startToken);
+            case 'try':
+                return delegate.markEnd(parseTryStatement(), startToken);
+            case 'var':
+                return delegate.markEnd(parseVariableStatement(), startToken);
+            case 'while':
+                return delegate.markEnd(parseWhileStatement(), startToken);
+            case 'with':
+                return delegate.markEnd(parseWithStatement(), startToken);
+            default:
+                break;
+            }
+        }
+
+        expr = parseExpression();
+
+        // 12.12 Labelled Statements
+        if ((expr.type === Syntax.Identifier) && match(':')) {
+            lex();
+
+            key = '$' + expr.name;
+            if (Object.prototype.hasOwnProperty.call(state.labelSet, key)) {
+                throwError({}, Messages.Redeclaration, 'Label', expr.name);
+            }
+
+            state.labelSet[key] = true;
+            labeledBody = parseStatement();
+            delete state.labelSet[key];
+            return delegate.markEnd(delegate.createLabeledStatement(expr, labeledBody), startToken);
+        }
+
+        consumeSemicolon();
+
+        return delegate.markEnd(delegate.createExpressionStatement(expr), startToken);
+    }
+
+    // 13 Function Definition
+
+    function parseFunctionSourceElements() {
+        var sourceElement, sourceElements = [], token, directive, firstRestricted,
+            oldLabelSet, oldInIteration, oldInSwitch, oldInFunctionBody, startToken;
+
+        startToken = lookahead;
+        expect('{');
+
+        while (index < length) {
+            if (lookahead.type !== Token.StringLiteral) {
+                break;
+            }
+            token = lookahead;
+
+            sourceElement = parseSourceElement();
+            sourceElements.push(sourceElement);
+            if (sourceElement.expression.type !== Syntax.Literal) {
+                // this is not directive
+                break;
+            }
+            directive = source.slice(token.start + 1, token.end - 1);
+            if (directive === 'use strict') {
+                strict = true;
+                if (firstRestricted) {
+                    throwErrorTolerant(firstRestricted, Messages.StrictOctalLiteral);
+                }
+            } else {
+                if (!firstRestricted && token.octal) {
+                    firstRestricted = token;
+                }
+            }
+        }
+
+        oldLabelSet = state.labelSet;
+        oldInIteration = state.inIteration;
+        oldInSwitch = state.inSwitch;
+        oldInFunctionBody = state.inFunctionBody;
+
+        state.labelSet = {};
+        state.inIteration = false;
+        state.inSwitch = false;
+        state.inFunctionBody = true;
+
+        while (index < length) {
+            if (match('}')) {
+                break;
+            }
+            sourceElement = parseSourceElement();
+            if (typeof sourceElement === 'undefined') {
+                break;
+            }
+            sourceElements.push(sourceElement);
+        }
+
+        expect('}');
+
+        state.labelSet = oldLabelSet;
+        state.inIteration = oldInIteration;
+        state.inSwitch = oldInSwitch;
+        state.inFunctionBody = oldInFunctionBody;
+
+        return delegate.markEnd(delegate.createBlockStatement(sourceElements), startToken);
+    }
+
+    function parseParams(firstRestricted) {
+        var param, params = [], token, stricted, paramSet, key, message;
+        expect('(');
+
+        if (!match(')')) {
+            paramSet = {};
+            while (index < length) {
+                token = lookahead;
+                param = parseVariableIdentifier();
+                key = '$' + token.value;
+                if (strict) {
+                    if (isRestrictedWord(token.value)) {
+                        stricted = token;
+                        message = Messages.StrictParamName;
+                    }
+                    if (Object.prototype.hasOwnProperty.call(paramSet, key)) {
+                        stricted = token;
+                        message = Messages.StrictParamDupe;
+                    }
+                } else if (!firstRestricted) {
+                    if (isRestrictedWord(token.value)) {
+                        firstRestricted = token;
+                        message = Messages.StrictParamName;
+                    } else if (isStrictModeReservedWord(token.value)) {
+                        firstRestricted = token;
+                        message = Messages.StrictReservedWord;
+                    } else if (Object.prototype.hasOwnProperty.call(paramSet, key)) {
+                        firstRestricted = token;
+                        message = Messages.StrictParamDupe;
+                    }
+                }
+                params.push(param);
+                paramSet[key] = true;
+                if (match(')')) {
+                    break;
+                }
+                expect(',');
+            }
+        }
+
+        expect(')');
+
+        return {
+            params: params,
+            stricted: stricted,
+            firstRestricted: firstRestricted,
+            message: message
+        };
+    }
+
+    function parseFunctionDeclaration() {
+        var id, params = [], body, token, stricted, tmp, firstRestricted, message, previousStrict, startToken;
+
+        startToken = lookahead;
+
+        expectKeyword('function');
+        token = lookahead;
+        id = parseVariableIdentifier();
+        if (strict) {
+            if (isRestrictedWord(token.value)) {
+                throwErrorTolerant(token, Messages.StrictFunctionName);
+            }
+        } else {
+            if (isRestrictedWord(token.value)) {
+                firstRestricted = token;
+                message = Messages.StrictFunctionName;
+            } else if (isStrictModeReservedWord(token.value)) {
+                firstRestricted = token;
+                message = Messages.StrictReservedWord;
+            }
+        }
+
+        tmp = parseParams(firstRestricted);
+        params = tmp.params;
+        stricted = tmp.stricted;
+        firstRestricted = tmp.firstRestricted;
+        if (tmp.message) {
+            message = tmp.message;
+        }
+
+        previousStrict = strict;
+        body = parseFunctionSourceElements();
+        if (strict && firstRestricted) {
+            throwError(firstRestricted, message);
+        }
+        if (strict && stricted) {
+            throwErrorTolerant(stricted, message);
+        }
+        strict = previousStrict;
+
+        return delegate.markEnd(delegate.createFunctionDeclaration(id, params, [], body), startToken);
+    }
+
+    function parseFunctionExpression() {
+        var token, id = null, stricted, firstRestricted, message, tmp, params = [], body, previousStrict, startToken;
+
+        startToken = lookahead;
+        expectKeyword('function');
+
+        if (!match('(')) {
+            token = lookahead;
+            id = parseVariableIdentifier();
+            if (strict) {
+                if (isRestrictedWord(token.value)) {
+                    throwErrorTolerant(token, Messages.StrictFunctionName);
+                }
+            } else {
+                if (isRestrictedWord(token.value)) {
+                    firstRestricted = token;
+                    message = Messages.StrictFunctionName;
+                } else if (isStrictModeReservedWord(token.value)) {
+                    firstRestricted = token;
+                    message = Messages.StrictReservedWord;
+                }
+            }
+        }
+
+        tmp = parseParams(firstRestricted);
+        params = tmp.params;
+        stricted = tmp.stricted;
+        firstRestricted = tmp.firstRestricted;
+        if (tmp.message) {
+            message = tmp.message;
+        }
+
+        previousStrict = strict;
+        body = parseFunctionSourceElements();
+        if (strict && firstRestricted) {
+            throwError(firstRestricted, message);
+        }
+        if (strict && stricted) {
+            throwErrorTolerant(stricted, message);
+        }
+        strict = previousStrict;
+
+        return delegate.markEnd(delegate.createFunctionExpression(id, params, [], body), startToken);
+    }
+
+    // 14 Program
+
+    function parseSourceElement() {
+        if (lookahead.type === Token.Keyword) {
+            switch (lookahead.value) {
+            case 'const':
+            case 'let':
+                return parseConstLetDeclaration(lookahead.value);
+            case 'function':
+                return parseFunctionDeclaration();
+            default:
+                return parseStatement();
+            }
+        }
+
+        if (lookahead.type !== Token.EOF) {
+            return parseStatement();
+        }
+    }
+
+    function parseSourceElements() {
+        var sourceElement, sourceElements = [], token, directive, firstRestricted;
+
+        while (index < length) {
+            token = lookahead;
+            if (token.type !== Token.StringLiteral) {
+                break;
+            }
+
+            sourceElement = parseSourceElement();
+            sourceElements.push(sourceElement);
+            if (sourceElement.expression.type !== Syntax.Literal) {
+                // this is not directive
+                break;
+            }
+            directive = source.slice(token.start + 1, token.end - 1);
+            if (directive === 'use strict') {
+                strict = true;
+                if (firstRestricted) {
+                    throwErrorTolerant(firstRestricted, Messages.StrictOctalLiteral);
+                }
+            } else {
+                if (!firstRestricted && token.octal) {
+                    firstRestricted = token;
+                }
+            }
+        }
+
+        while (index < length) {
+            sourceElement = parseSourceElement();
+            /* istanbul ignore if */
+            if (typeof sourceElement === 'undefined') {
+                break;
+            }
+            sourceElements.push(sourceElement);
+        }
+        return sourceElements;
+    }
+
+    function parseProgram() {
+        var body, startToken;
+
+        skipComment();
+        peek();
+        startToken = lookahead;
+        strict = false;
+
+        body = parseSourceElements();
+        return delegate.markEnd(delegate.createProgram(body), startToken);
+    }
+
+    function filterTokenLocation() {
+        var i, entry, token, tokens = [];
+
+        for (i = 0; i < extra.tokens.length; ++i) {
+            entry = extra.tokens[i];
+            token = {
+                type: entry.type,
+                value: entry.value
+            };
+            if (extra.range) {
+                token.range = entry.range;
+            }
+            if (extra.loc) {
+                token.loc = entry.loc;
+            }
+            tokens.push(token);
+        }
+
+        extra.tokens = tokens;
+    }
+
+    function tokenize(code, options) {
+        var toString,
+            token,
+            tokens;
+
+        toString = String;
+        if (typeof code !== 'string' && !(code instanceof String)) {
+            code = toString(code);
+        }
+
+        delegate = SyntaxTreeDelegate;
+        source = code;
+        index = 0;
+        lineNumber = (source.length > 0) ? 1 : 0;
+        lineStart = 0;
+        length = source.length;
+        lookahead = null;
+        state = {
+            allowIn: true,
+            labelSet: {},
+            inFunctionBody: false,
+            inIteration: false,
+            inSwitch: false,
+            lastCommentStart: -1
+        };
+
+        extra = {};
+
+        // Options matching.
+        options = options || {};
+
+        // Of course we collect tokens here.
+        options.tokens = true;
+        extra.tokens = [];
+        extra.tokenize = true;
+        // The following two fields are necessary to compute the Regex tokens.
+        extra.openParenToken = -1;
+        extra.openCurlyToken = -1;
+
+        extra.range = (typeof options.range === 'boolean') && options.range;
+        extra.loc = (typeof options.loc === 'boolean') && options.loc;
+
+        if (typeof options.comment === 'boolean' && options.comment) {
+            extra.comments = [];
+        }
+        if (typeof options.tolerant === 'boolean' && options.tolerant) {
+            extra.errors = [];
+        }
+
+        try {
+            peek();
+            if (lookahead.type === Token.EOF) {
+                return extra.tokens;
+            }
+
+            token = lex();
+            while (lookahead.type !== Token.EOF) {
+                try {
+                    token = lex();
+                } catch (lexError) {
+                    token = lookahead;
+                    if (extra.errors) {
+                        extra.errors.push(lexError);
+                        // We have to break on the first error
+                        // to avoid infinite loops.
+                        break;
+                    } else {
+                        throw lexError;
+                    }
+                }
+            }
+
+            filterTokenLocation();
+            tokens = extra.tokens;
+            if (typeof extra.comments !== 'undefined') {
+                tokens.comments = extra.comments;
+            }
+            if (typeof extra.errors !== 'undefined') {
+                tokens.errors = extra.errors;
+            }
+        } catch (e) {
+            throw e;
+        } finally {
+            extra = {};
+        }
+        return tokens;
+    }
+
+    function parse(code, options) {
+        var program, toString;
+
+        toString = String;
+        if (typeof code !== 'string' && !(code instanceof String)) {
+            code = toString(code);
+        }
+
+        delegate = SyntaxTreeDelegate;
+        source = code;
+        index = 0;
+        lineNumber = (source.length > 0) ? 1 : 0;
+        lineStart = 0;
+        length = source.length;
+        lookahead = null;
+        state = {
+            allowIn: true,
+            labelSet: {},
+            inFunctionBody: false,
+            inIteration: false,
+            inSwitch: false,
+            lastCommentStart: -1
+        };
+
+        extra = {};
+        if (typeof options !== 'undefined') {
+            extra.range = (typeof options.range === 'boolean') && options.range;
+            extra.loc = (typeof options.loc === 'boolean') && options.loc;
+            extra.attachComment = (typeof options.attachComment === 'boolean') && options.attachComment;
+
+            if (extra.loc && options.source !== null && options.source !== undefined) {
+                extra.source = toString(options.source);
+            }
+
+            if (typeof options.tokens === 'boolean' && options.tokens) {
+                extra.tokens = [];
+            }
+            if (typeof options.comment === 'boolean' && options.comment) {
+                extra.comments = [];
+            }
+            if (typeof options.tolerant === 'boolean' && options.tolerant) {
+                extra.errors = [];
+            }
+            if (extra.attachComment) {
+                extra.range = true;
+                extra.comments = [];
+                extra.bottomRightStack = [];
+                extra.trailingComments = [];
+                extra.leadingComments = [];
+            }
+        }
+
+        try {
+            program = parseProgram();
+            if (typeof extra.comments !== 'undefined') {
+                program.comments = extra.comments;
+            }
+            if (typeof extra.tokens !== 'undefined') {
+                filterTokenLocation();
+                program.tokens = extra.tokens;
+            }
+            if (typeof extra.errors !== 'undefined') {
+                program.errors = extra.errors;
+            }
+        } catch (e) {
+            throw e;
+        } finally {
+            extra = {};
+        }
+
+        return program;
+    }
+
+    // Sync with *.json manifests.
+    exports.version = '1.2.4';
+
+    exports.tokenize = tokenize;
+
+    exports.parse = parse;
+
+    // Deep copy.
+   /* istanbul ignore next */
+    exports.Syntax = (function () {
+        var name, types = {};
+
+        if (typeof Object.create === 'function') {
+            types = Object.create(null);
+        }
+
+        for (name in Syntax) {
+            if (Syntax.hasOwnProperty(name)) {
+                types[name] = Syntax[name];
+            }
+        }
+
+        if (typeof Object.freeze === 'function') {
+            Object.freeze(types);
+        }
+
+        return types;
+    }());
+
+}));
+/* vim: set sw=4 ts=4 et tw=80 : */
+
+},{}],22:[function(_dereq_,module,exports){
+/**
+ * power-assert-formatter.js - Power Assert output formatter
+ *
+ * https://github.com/twada/power-assert-formatter
+ *
+ * Copyright (c) 2013-2015 Takuto Wada
+ * Licensed under the MIT license.
+ *   https://github.com/twada/power-assert-formatter/blob/master/MIT-LICENSE.txt
+ */
+'use strict';
+
+module.exports = _dereq_('./lib/create');
+
+},{"./lib/create":27}],23:[function(_dereq_,module,exports){
+'use strict';
+
+function AssertionRenderer (traversal, config) {
+    var assertionLine;
+    traversal.on('start', function (context) {
+        assertionLine = context.source.content;
+    });
+    traversal.on('render', function (writer) {
+        writer.write('');
+        writer.write(assertionLine);
+    });
+}
+module.exports = AssertionRenderer;
+
+},{}],24:[function(_dereq_,module,exports){
+'use strict';
+
+var typeName = _dereq_('type-name'),
+    keys = Object.keys || _dereq_('object-keys'),
+    syntax = _dereq_('estraverse').Syntax;
+
+
+function BinaryExpressionRenderer(traversal, config) {
+    this.config = config;
+    this.stringify = config.stringify;
+    this.diff = config.diff;
+    this.espathToPair = {};
+    var _this = this;
+    traversal.on('esnode', function (esNode) {
+        var pair;
+        if (!esNode.isCaptured()) {
+            if (isTargetBinaryExpression(esNode.getParent()) && esNode.currentNode.type === syntax.Literal) {
+                _this.espathToPair[esNode.parentEspath][esNode.currentProp] = {code: esNode.code(), value: esNode.value()};
+            }
+            return;
+        }
+        if (isTargetBinaryExpression(esNode.getParent())) {
+            _this.espathToPair[esNode.parentEspath][esNode.currentProp] = {code: esNode.code(), value: esNode.value()};
+        }
+        if (isTargetBinaryExpression(esNode)) {
+            pair = {
+                operator: esNode.currentNode.operator,
+                value: esNode.value()
+            };
+            _this.espathToPair[esNode.espath] = pair;
+        }
+    });
+    traversal.on('render', function (writer) {
+        var pairs = [];
+        keys(_this.espathToPair).forEach(function (espath) {
+            var pair = _this.espathToPair[espath];
+            if (pair.left && pair.right) {
+                pairs.push(pair);
+            }
+        });
+        pairs.forEach(function (pair) {
+            _this.compare(pair, writer);
+        });
+    });
+}
+
+BinaryExpressionRenderer.prototype.compare = function (pair, writer) {
+    if (isStringDiffTarget(pair)) {
+        this.showStringDiff(pair, writer);
+    } else {
+        this.showExpectedAndActual(pair, writer);
+    }
+};
+
+BinaryExpressionRenderer.prototype.showExpectedAndActual = function (pair, writer) {
+    writer.write('');
+    writer.write('[' + typeName(pair.right.value) + '] ' + pair.right.code);
+    writer.write('=> ' + this.stringify(pair.right.value));
+    writer.write('[' + typeName(pair.left.value)  + '] ' + pair.left.code);
+    writer.write('=> ' + this.stringify(pair.left.value));
+};
+
+BinaryExpressionRenderer.prototype.showStringDiff = function (pair, writer) {
+    writer.write('');
+    writer.write('--- [string] ' + pair.right.code);
+    writer.write('+++ [string] ' + pair.left.code);
+    writer.write(this.diff(pair.right.value, pair.left.value, this.config));
+};
+
+function isTargetBinaryExpression (esNode) {
+    return esNode &&
+        esNode.currentNode.type === syntax.BinaryExpression &&
+        (esNode.currentNode.operator === '===' || esNode.currentNode.operator === '==') &&
+        esNode.isCaptured() &&
+        !(esNode.value());
+}
+
+function isStringDiffTarget(pair) {
+    return typeof pair.left.value === 'string' && typeof pair.right.value === 'string';
+}
+
+module.exports = BinaryExpressionRenderer;
+
+},{"estraverse":36,"object-keys":39,"type-name":43}],25:[function(_dereq_,module,exports){
+'use strict';
+
+function DiagramRenderer (traversal, config) {
+    this.config = config;
+    this.events = [];
+    this.stringify = config.stringify;
+    this.widthOf = config.widthOf;
+    this.initialVertivalBarLength = 1;
+    var _this = this;
+    traversal.on('start', function (context) {
+        _this.context = context;
+        _this.assertionLine = context.source.content;
+        _this.initializeRows();
+    });
+    traversal.on('esnode', function (esNode) {
+        if (!esNode.isCaptured()) {
+            return;
+        }
+        _this.events.push({value: esNode.value(), loc: esNode.location()});
+    });
+    traversal.on('render', function (writer) {
+        _this.events.sort(rightToLeft);
+        _this.constructRows(_this.events);
+        _this.rows.forEach(function (columns) {
+            writer.write(columns.join(''));
+        });
+    });
+}
+
+DiagramRenderer.prototype.initializeRows = function () {
+    this.rows = [];
+    for (var i = 0; i <= this.initialVertivalBarLength; i += 1) {
+        this.addOneMoreRow();
+    }
+};
+
+DiagramRenderer.prototype.newRowFor = function (assertionLine) {
+    return createRow(this.widthOf(assertionLine), ' ');
+};
+
+DiagramRenderer.prototype.addOneMoreRow = function () {
+    this.rows.push(this.newRowFor(this.assertionLine));
+};
+
+DiagramRenderer.prototype.lastRow = function () {
+    return this.rows[this.rows.length - 1];
+};
+
+DiagramRenderer.prototype.renderVerticalBarAt = function (columnIndex) {
+    var i, lastRowIndex = this.rows.length - 1;
+    for (i = 0; i < lastRowIndex; i += 1) {
+        this.rows[i].splice(columnIndex, 1, '|');
+    }
+};
+
+DiagramRenderer.prototype.renderValueAt = function (columnIndex, dumpedValue) {
+    var i, width = this.widthOf(dumpedValue);
+    for (i = 0; i < width; i += 1) {
+        this.lastRow().splice(columnIndex + i, 1, dumpedValue.charAt(i));
+    }
+};
+
+DiagramRenderer.prototype.isOverlapped = function (prevCapturing, nextCaputuring, dumpedValue) {
+    return (typeof prevCapturing !== 'undefined') && this.startColumnFor(prevCapturing) <= (this.startColumnFor(nextCaputuring) + this.widthOf(dumpedValue));
+};
+
+DiagramRenderer.prototype.constructRows = function (capturedEvents) {
+    var that = this,
+        prevCaptured;
+    capturedEvents.forEach(function (captured) {
+        var dumpedValue = that.stringify(captured.value);
+        if (that.isOverlapped(prevCaptured, captured, dumpedValue)) {
+            that.addOneMoreRow();
+        }
+        that.renderVerticalBarAt(that.startColumnFor(captured));
+        that.renderValueAt(that.startColumnFor(captured), dumpedValue);
+        prevCaptured = captured;
+    });
+};
+
+DiagramRenderer.prototype.startColumnFor = function (captured) {
+    return this.widthOf(this.assertionLine.slice(0, captured.loc.start.column));
+};
+
+function createRow (numCols, initial) {
+    var row = [], i;
+    for(i = 0; i < numCols; i += 1) {
+        row[i] = initial;
+    }
+    return row;
+}
+
+function rightToLeft (a, b) {
+    return b.loc.start.column - a.loc.start.column;
+}
+
+module.exports = DiagramRenderer;
+
+},{}],26:[function(_dereq_,module,exports){
+'use strict';
+
+function FileRenderer (traversal, config) {
+    var filepath, lineNumber;
+    traversal.on('start', function (context) {
+        filepath = context.source.filepath;
+        lineNumber = context.source.line;
+    });
+    traversal.on('render', function (writer) {
+        if (filepath) {
+            writer.write('# ' + [filepath, lineNumber].join(':'));
+        } else {
+            writer.write('# at line: ' + lineNumber);
+        }
+    });
+}
+module.exports = FileRenderer;
+
+},{}],27:[function(_dereq_,module,exports){
+'use strict';
+
+var stringifier = _dereq_('stringifier'),
+    stringWidth = _dereq_('./string-width'),
+    StringWriter = _dereq_('./string-writer'),
+    ContextTraversal = _dereq_('./traverse'),
+    udiff = _dereq_('./udiff'),
+    defaultOptions = _dereq_('./default-options'),
+    typeName = _dereq_('type-name'),
+    extend = _dereq_('xtend');
+
+(function() {
+    // "Browserify can only analyze static requires. It is not in the scope of browserify to handle dynamic requires."
+    // https://github.com/substack/node-browserify/issues/377
+    _dereq_('./built-in/assertion');
+    _dereq_('./built-in/binary-expression');
+    _dereq_('./built-in/diagram');
+    _dereq_('./built-in/file');
+})();
+
+function create (options) {
+    var config = extend(defaultOptions(), options);
+    if (typeof config.widthOf !== 'function') {
+        config.widthOf = stringWidth(extend(config));
+    }
+    if (typeof config.stringify !== 'function') {
+        config.stringify = stringifier(extend(config));
+    }
+    if (typeof config.diff !== 'function') {
+        config.diff = udiff(extend(config));
+    }
+    if (!config.writerClass) {
+        config.writerClass = StringWriter;
+    }
+    return function (context) {
+        var traversal = new ContextTraversal(context);
+        var writer = new config.writerClass(extend(config));
+        var renderers = config.renderers.map(function (rendererName) {
+            var RendererClass;
+            if (typeName(rendererName) === 'function') {
+                RendererClass = rendererName;
+            } else if (typeName(rendererName) === 'string') {
+                RendererClass = _dereq_(rendererName);
+            }
+            return new RendererClass(traversal, extend(config));
+        });
+        traversal.emit('start', context);
+        traversal.traverse();
+        traversal.emit('render', writer);
+        writer.write('');
+        renderers.length = 0;
+        return writer.flush();
+    };
+}
+
+create.defaultOptions = defaultOptions;
+create.stringWidth = stringWidth;
+module.exports = create;
+
+},{"./built-in/assertion":23,"./built-in/binary-expression":24,"./built-in/diagram":25,"./built-in/file":26,"./default-options":28,"./string-width":31,"./string-writer":32,"./traverse":33,"./udiff":34,"stringifier":41,"type-name":43,"xtend":45}],28:[function(_dereq_,module,exports){
+module.exports = function defaultOptions () {
+    'use strict';
+    return {
+        lineDiffThreshold: 5,
+        maxDepth: 1,
+        outputOffset: 2,
+        anonymous: 'Object',
+        circular: '#@Circular#',
+        lineSeparator: '\n',
+        ambiguousEastAsianCharWidth: 2,
+        renderers: [
+            './built-in/file',
+            './built-in/assertion',
+            './built-in/diagram',
+            './built-in/binary-expression'
+        ]
+    };
+};
+
+},{}],29:[function(_dereq_,module,exports){
+'use strict';
+
+var syntax = _dereq_('estraverse').Syntax,
+    locationOf = _dereq_('./location');
+
+function EsNode (path, currentNode, parentNode, espathToValue, jsCode, jsAST) {
+    if (path) {
+        this.espath = path.join('/');
+        this.parentEspath = path.slice(0, path.length - 1).join('/');
+        this.currentProp = path[path.length - 1];
+    } else {
+        this.espath = '';
+        this.parentEspath = '';
+        this.currentProp = null;
+    }
+    this.currentNode = currentNode;
+    this.parentNode = parentNode;
+    this.parentEsNode = null;
+    this.espathToValue = espathToValue;
+    this.jsCode = jsCode;
+    this.jsAST = jsAST;
+}
+
+EsNode.prototype.setParent = function (parentEsNode) {
+    this.parentEsNode = parentEsNode;
+};
+
+EsNode.prototype.getParent = function () {
+    return this.parentEsNode;
+};
+
+EsNode.prototype.code = function () {
+    return this.jsCode.slice(this.currentNode.loc.start.column, this.currentNode.loc.end.column);
+};
+
+EsNode.prototype.value = function () {
+    if (this.currentNode.type === syntax.Literal) {
+        return this.currentNode.value;
+    }
+    return this.espathToValue[this.espath];
+};
+
+EsNode.prototype.isCaptured = function () {
+    return this.espathToValue.hasOwnProperty(this.espath);
+};
+
+EsNode.prototype.location = function () {
+    return locationOf(this.currentNode, this.jsAST.tokens);
+};
+
+module.exports = EsNode;
+
+},{"./location":30,"estraverse":36}],30:[function(_dereq_,module,exports){
+'use strict';
+
+var syntax = _dereq_('estraverse').Syntax;
+
+function locationOf(currentNode, tokens) {
+    switch(currentNode.type) {
+    case syntax.MemberExpression:
+        return propertyLocationOf(currentNode, tokens);
+    case syntax.CallExpression:
+        if (currentNode.callee.type === syntax.MemberExpression) {
+            return propertyLocationOf(currentNode.callee, tokens);
+        }
+        break;
+    case syntax.BinaryExpression:
+    case syntax.LogicalExpression:
+    case syntax.AssignmentExpression:
+        return infixOperatorLocationOf(currentNode, tokens);
+    default:
+        break;
+    }
+    return currentNode.loc;
+}
+
+function propertyLocationOf(memberExpression, tokens) {
+    var prop = memberExpression.property,
+        token;
+    if (!memberExpression.computed) {
+        return prop.loc;
+    }
+    token = findLeftBracketTokenOf(memberExpression, tokens);
+    return token ? token.loc : prop.loc;
+}
+
+// calculate location of infix operator for BinaryExpression, AssignmentExpression and LogicalExpression.
+function infixOperatorLocationOf (expression, tokens) {
+    var token = findOperatorTokenOf(expression, tokens);
+    return token ? token.loc : expression.left.loc;
+}
+
+function findLeftBracketTokenOf(expression, tokens) {
+    var fromLine = expression.loc.start.line,
+        toLine = expression.property.loc.start.line,
+        fromColumn = expression.property.loc.start.column;
+    return searchToken(tokens, fromLine, toLine, function (token, index) {
+        var prevToken;
+        if (token.loc.start.column === fromColumn) {
+            prevToken = tokens[index - 1];
+            if (prevToken.type === 'Punctuator' && prevToken.value === '[') {
+                return prevToken;
+            }
+        }
+        return undefined;
+    });
+}
+
+function findOperatorTokenOf(expression, tokens) {
+    var fromLine = expression.left.loc.end.line,
+        toLine = expression.right.loc.start.line,
+        fromColumn = expression.left.loc.end.column,
+        toColumn = expression.right.loc.start.column;
+    return searchToken(tokens, fromLine, toLine, function (token, index) {
+        if (fromColumn < token.loc.start.column &&
+            token.loc.end.column < toColumn &&
+            token.type === 'Punctuator' &&
+            token.value === expression.operator) {
+            return token;
+        }
+        return undefined;
+    });
+}
+
+function searchToken(tokens, fromLine, toLine, predicate) {
+    var i, token, found;
+    for(i = 0; i < tokens.length; i += 1) {
+        token = tokens[i];
+        if (token.loc.start.line < fromLine) {
+            continue;
+        }
+        if (toLine < token.loc.end.line) {
+            break;
+        }
+        found = predicate(token, i);
+        if (found) {
+            return found;
+        }
+    }
+    return undefined;
+}
+
+module.exports = locationOf;
+
+},{"estraverse":36}],31:[function(_dereq_,module,exports){
+'use strict';
+
+var eaw = _dereq_('eastasianwidth');
+
+function stringWidth (config) {
+    var ambiguousCharWidth = (config && config.ambiguousEastAsianCharWidth) || 1;
+    return function widthOf (str) {
+        var i, code, width = 0;
+        for(i = 0; i < str.length; i+=1) {
+            code = eaw.eastAsianWidth(str.charAt(i));
+            switch(code) {
+            case 'F':
+            case 'W':
+                width += 2;
+                break;
+            case 'H':
+            case 'Na':
+            case 'N':
+                width += 1;
+                break;
+            case 'A':
+                width += ambiguousCharWidth;
+                break;
+            }
+        }
+        return width;
+    };
+}
+
+module.exports = stringWidth;
+
+},{"eastasianwidth":35}],32:[function(_dereq_,module,exports){
+'use strict';
+
+function spacerStr (len) {
+    var str = '';
+    for(var i = 0; i < len; i += 1) {
+        str += ' ';
+    }
+    return str;
+}
+
+function StringWriter (config) {
+    this.lines = [];
+    this.lineSeparator = config.lineSeparator;
+    this.regex = new RegExp(this.lineSeparator, 'g');
+    this.spacer = spacerStr(config.outputOffset);
+}
+
+StringWriter.prototype.write = function (str) {
+    this.lines.push(this.spacer + str.replace(this.regex, this.lineSeparator + this.spacer));
+};
+
+StringWriter.prototype.flush = function () {
+    var str = this.lines.join(this.lineSeparator);
+    this.lines.length = 0;
+    return str;
+};
+
+module.exports = StringWriter;
+
+},{}],33:[function(_dereq_,module,exports){
+'use strict';
+
+var estraverse = _dereq_('estraverse'),
+    esprima = _dereq_('esprima'),
+    EventEmitter = _dereq_('events').EventEmitter,
+    inherits = _dereq_('util').inherits,
+    EsNode = _dereq_('./esnode');
+
+function ContextTraversal (context) {
+    this.context = context;
+    EventEmitter.call(this);
+}
+inherits(ContextTraversal, EventEmitter);
+
+ContextTraversal.prototype.traverse = function () {
+    var _this = this;
+    this.context.args.forEach(function (arg) {
+        onEachEsNode(arg, _this.context.source.content, function (esNode) {
+            _this.emit('esnode', esNode);
+        });
+    });
+};
+
+function onEachEsNode(arg, jsCode, callback) {
+    var jsAST = esprima.parse(jsCode, {tolerant: true, loc: true, tokens: true, raw: true}),
+        espathToValue = arg.events.reduce(function (accum, ev) {
+            accum[ev.espath] = ev.value;
+            return accum;
+        }, {}),
+        nodeStack = [];
+    estraverse.traverse(extractExpressionFrom(jsAST), {
+        enter: function (currentNode, parentNode) {
+            var esNode = new EsNode(this.path(), currentNode, parentNode, espathToValue, jsCode, jsAST);
+            if (1 < nodeStack.length) {
+                esNode.setParent(nodeStack[nodeStack.length - 1]);
+            }
+            nodeStack.push(esNode);
+            callback(esNode);
+        },
+        leave: function (currentNode, parentNode) {
+            nodeStack.pop();
+        }
+    });
+}
+
+function extractExpressionFrom (tree) {
+    var expressionStatement = tree.body[0],
+        expression = expressionStatement.expression;
+    return expression;
+}
+
+module.exports = ContextTraversal;
+
+},{"./esnode":29,"esprima":21,"estraverse":36,"events":2,"util":6}],34:[function(_dereq_,module,exports){
+'use strict';
+
+var DiffMatchPatch = _dereq_('googlediff'),
+    dmp = new DiffMatchPatch();
+
+function udiff (config) {
+    return function diff (text1, text2) {
+        var patch;
+        if (config && shouldUseLineLevelDiff(text1, config)) {
+            patch = udiffLines(text1, text2);
+        } else {
+            patch = udiffChars(text1, text2);
+        }
+        return decodeURIComponent(patch);
+    };
+}
+
+function shouldUseLineLevelDiff (text, config) {
+    return config.lineDiffThreshold < text.split(/\r\n|\r|\n/).length;
+}
+
+function udiffLines(text1, text2) {
+    /*jshint camelcase: false */
+    var a = dmp.diff_linesToChars_(text1, text2),
+        diffs = dmp.diff_main(a.chars1, a.chars2, false);
+    dmp.diff_charsToLines_(diffs, a.lineArray);
+    dmp.diff_cleanupSemantic(diffs);
+    return dmp.patch_toText(dmp.patch_make(text1, diffs));
+}
+
+function udiffChars (text1, text2) {
+    /*jshint camelcase: false */
+    var diffs = dmp.diff_main(text1, text2, false);
+    dmp.diff_cleanupSemantic(diffs);
+    return dmp.patch_toText(dmp.patch_make(text1, diffs));
+}
+
+module.exports = udiff;
+
+},{"googlediff":37}],35:[function(_dereq_,module,exports){
+var eaw = exports;
+
+eaw.eastAsianWidth = function(character) {
+  var x = character.charCodeAt(0);
+  var y = (character.length == 2) ? character.charCodeAt(1) : 0;
+  var codePoint = x;
+  if ((0xD800 <= x && x <= 0xDBFF) && (0xDC00 <= y && y <= 0xDFFF)) {
+    x &= 0x3FF;
+    y &= 0x3FF;
+    codePoint = (x << 10) | y;
+    codePoint += 0x10000;
+  }
+
+  if ((0x3000 == codePoint) ||
+      (0xFF01 <= codePoint && codePoint <= 0xFF60) ||
+      (0xFFE0 <= codePoint && codePoint <= 0xFFE6)) {
+    return 'F';
+  }
+  if ((0x20A9 == codePoint) ||
+      (0xFF61 <= codePoint && codePoint <= 0xFFBE) ||
+      (0xFFC2 <= codePoint && codePoint <= 0xFFC7) ||
+      (0xFFCA <= codePoint && codePoint <= 0xFFCF) ||
+      (0xFFD2 <= codePoint && codePoint <= 0xFFD7) ||
+      (0xFFDA <= codePoint && codePoint <= 0xFFDC) ||
+      (0xFFE8 <= codePoint && codePoint <= 0xFFEE)) {
+    return 'H';
+  }
+  if ((0x1100 <= codePoint && codePoint <= 0x115F) ||
+      (0x11A3 <= codePoint && codePoint <= 0x11A7) ||
+      (0x11FA <= codePoint && codePoint <= 0x11FF) ||
+      (0x2329 <= codePoint && codePoint <= 0x232A) ||
+      (0x2E80 <= codePoint && codePoint <= 0x2E99) ||
+      (0x2E9B <= codePoint && codePoint <= 0x2EF3) ||
+      (0x2F00 <= codePoint && codePoint <= 0x2FD5) ||
+      (0x2FF0 <= codePoint && codePoint <= 0x2FFB) ||
+      (0x3001 <= codePoint && codePoint <= 0x303E) ||
+      (0x3041 <= codePoint && codePoint <= 0x3096) ||
+      (0x3099 <= codePoint && codePoint <= 0x30FF) ||
+      (0x3105 <= codePoint && codePoint <= 0x312D) ||
+      (0x3131 <= codePoint && codePoint <= 0x318E) ||
+      (0x3190 <= codePoint && codePoint <= 0x31BA) ||
+      (0x31C0 <= codePoint && codePoint <= 0x31E3) ||
+      (0x31F0 <= codePoint && codePoint <= 0x321E) ||
+      (0x3220 <= codePoint && codePoint <= 0x3247) ||
+      (0x3250 <= codePoint && codePoint <= 0x32FE) ||
+      (0x3300 <= codePoint && codePoint <= 0x4DBF) ||
+      (0x4E00 <= codePoint && codePoint <= 0xA48C) ||
+      (0xA490 <= codePoint && codePoint <= 0xA4C6) ||
+      (0xA960 <= codePoint && codePoint <= 0xA97C) ||
+      (0xAC00 <= codePoint && codePoint <= 0xD7A3) ||
+      (0xD7B0 <= codePoint && codePoint <= 0xD7C6) ||
+      (0xD7CB <= codePoint && codePoint <= 0xD7FB) ||
+      (0xF900 <= codePoint && codePoint <= 0xFAFF) ||
+      (0xFE10 <= codePoint && codePoint <= 0xFE19) ||
+      (0xFE30 <= codePoint && codePoint <= 0xFE52) ||
+      (0xFE54 <= codePoint && codePoint <= 0xFE66) ||
+      (0xFE68 <= codePoint && codePoint <= 0xFE6B) ||
+      (0x1B000 <= codePoint && codePoint <= 0x1B001) ||
+      (0x1F200 <= codePoint && codePoint <= 0x1F202) ||
+      (0x1F210 <= codePoint && codePoint <= 0x1F23A) ||
+      (0x1F240 <= codePoint && codePoint <= 0x1F248) ||
+      (0x1F250 <= codePoint && codePoint <= 0x1F251) ||
+      (0x20000 <= codePoint && codePoint <= 0x2F73F) ||
+      (0x2B740 <= codePoint && codePoint <= 0x2FFFD) ||
+      (0x30000 <= codePoint && codePoint <= 0x3FFFD)) {
+    return 'W';
+  }
+  if ((0x0020 <= codePoint && codePoint <= 0x007E) ||
+      (0x00A2 <= codePoint && codePoint <= 0x00A3) ||
+      (0x00A5 <= codePoint && codePoint <= 0x00A6) ||
+      (0x00AC == codePoint) ||
+      (0x00AF == codePoint) ||
+      (0x27E6 <= codePoint && codePoint <= 0x27ED) ||
+      (0x2985 <= codePoint && codePoint <= 0x2986)) {
+    return 'Na';
+  }
+  if ((0x00A1 == codePoint) ||
+      (0x00A4 == codePoint) ||
+      (0x00A7 <= codePoint && codePoint <= 0x00A8) ||
+      (0x00AA == codePoint) ||
+      (0x00AD <= codePoint && codePoint <= 0x00AE) ||
+      (0x00B0 <= codePoint && codePoint <= 0x00B4) ||
+      (0x00B6 <= codePoint && codePoint <= 0x00BA) ||
+      (0x00BC <= codePoint && codePoint <= 0x00BF) ||
+      (0x00C6 == codePoint) ||
+      (0x00D0 == codePoint) ||
+      (0x00D7 <= codePoint && codePoint <= 0x00D8) ||
+      (0x00DE <= codePoint && codePoint <= 0x00E1) ||
+      (0x00E6 == codePoint) ||
+      (0x00E8 <= codePoint && codePoint <= 0x00EA) ||
+      (0x00EC <= codePoint && codePoint <= 0x00ED) ||
+      (0x00F0 == codePoint) ||
+      (0x00F2 <= codePoint && codePoint <= 0x00F3) ||
+      (0x00F7 <= codePoint && codePoint <= 0x00FA) ||
+      (0x00FC == codePoint) ||
+      (0x00FE == codePoint) ||
+      (0x0101 == codePoint) ||
+      (0x0111 == codePoint) ||
+      (0x0113 == codePoint) ||
+      (0x011B == codePoint) ||
+      (0x0126 <= codePoint && codePoint <= 0x0127) ||
+      (0x012B == codePoint) ||
+      (0x0131 <= codePoint && codePoint <= 0x0133) ||
+      (0x0138 == codePoint) ||
+      (0x013F <= codePoint && codePoint <= 0x0142) ||
+      (0x0144 == codePoint) ||
+      (0x0148 <= codePoint && codePoint <= 0x014B) ||
+      (0x014D == codePoint) ||
+      (0x0152 <= codePoint && codePoint <= 0x0153) ||
+      (0x0166 <= codePoint && codePoint <= 0x0167) ||
+      (0x016B == codePoint) ||
+      (0x01CE == codePoint) ||
+      (0x01D0 == codePoint) ||
+      (0x01D2 == codePoint) ||
+      (0x01D4 == codePoint) ||
+      (0x01D6 == codePoint) ||
+      (0x01D8 == codePoint) ||
+      (0x01DA == codePoint) ||
+      (0x01DC == codePoint) ||
+      (0x0251 == codePoint) ||
+      (0x0261 == codePoint) ||
+      (0x02C4 == codePoint) ||
+      (0x02C7 == codePoint) ||
+      (0x02C9 <= codePoint && codePoint <= 0x02CB) ||
+      (0x02CD == codePoint) ||
+      (0x02D0 == codePoint) ||
+      (0x02D8 <= codePoint && codePoint <= 0x02DB) ||
+      (0x02DD == codePoint) ||
+      (0x02DF == codePoint) ||
+      (0x0300 <= codePoint && codePoint <= 0x036F) ||
+      (0x0391 <= codePoint && codePoint <= 0x03A1) ||
+      (0x03A3 <= codePoint && codePoint <= 0x03A9) ||
+      (0x03B1 <= codePoint && codePoint <= 0x03C1) ||
+      (0x03C3 <= codePoint && codePoint <= 0x03C9) ||
+      (0x0401 == codePoint) ||
+      (0x0410 <= codePoint && codePoint <= 0x044F) ||
+      (0x0451 == codePoint) ||
+      (0x2010 == codePoint) ||
+      (0x2013 <= codePoint && codePoint <= 0x2016) ||
+      (0x2018 <= codePoint && codePoint <= 0x2019) ||
+      (0x201C <= codePoint && codePoint <= 0x201D) ||
+      (0x2020 <= codePoint && codePoint <= 0x2022) ||
+      (0x2024 <= codePoint && codePoint <= 0x2027) ||
+      (0x2030 == codePoint) ||
+      (0x2032 <= codePoint && codePoint <= 0x2033) ||
+      (0x2035 == codePoint) ||
+      (0x203B == codePoint) ||
+      (0x203E == codePoint) ||
+      (0x2074 == codePoint) ||
+      (0x207F == codePoint) ||
+      (0x2081 <= codePoint && codePoint <= 0x2084) ||
+      (0x20AC == codePoint) ||
+      (0x2103 == codePoint) ||
+      (0x2105 == codePoint) ||
+      (0x2109 == codePoint) ||
+      (0x2113 == codePoint) ||
+      (0x2116 == codePoint) ||
+      (0x2121 <= codePoint && codePoint <= 0x2122) ||
+      (0x2126 == codePoint) ||
+      (0x212B == codePoint) ||
+      (0x2153 <= codePoint && codePoint <= 0x2154) ||
+      (0x215B <= codePoint && codePoint <= 0x215E) ||
+      (0x2160 <= codePoint && codePoint <= 0x216B) ||
+      (0x2170 <= codePoint && codePoint <= 0x2179) ||
+      (0x2189 == codePoint) ||
+      (0x2190 <= codePoint && codePoint <= 0x2199) ||
+      (0x21B8 <= codePoint && codePoint <= 0x21B9) ||
+      (0x21D2 == codePoint) ||
+      (0x21D4 == codePoint) ||
+      (0x21E7 == codePoint) ||
+      (0x2200 == codePoint) ||
+      (0x2202 <= codePoint && codePoint <= 0x2203) ||
+      (0x2207 <= codePoint && codePoint <= 0x2208) ||
+      (0x220B == codePoint) ||
+      (0x220F == codePoint) ||
+      (0x2211 == codePoint) ||
+      (0x2215 == codePoint) ||
+      (0x221A == codePoint) ||
+      (0x221D <= codePoint && codePoint <= 0x2220) ||
+      (0x2223 == codePoint) ||
+      (0x2225 == codePoint) ||
+      (0x2227 <= codePoint && codePoint <= 0x222C) ||
+      (0x222E == codePoint) ||
+      (0x2234 <= codePoint && codePoint <= 0x2237) ||
+      (0x223C <= codePoint && codePoint <= 0x223D) ||
+      (0x2248 == codePoint) ||
+      (0x224C == codePoint) ||
+      (0x2252 == codePoint) ||
+      (0x2260 <= codePoint && codePoint <= 0x2261) ||
+      (0x2264 <= codePoint && codePoint <= 0x2267) ||
+      (0x226A <= codePoint && codePoint <= 0x226B) ||
+      (0x226E <= codePoint && codePoint <= 0x226F) ||
+      (0x2282 <= codePoint && codePoint <= 0x2283) ||
+      (0x2286 <= codePoint && codePoint <= 0x2287) ||
+      (0x2295 == codePoint) ||
+      (0x2299 == codePoint) ||
+      (0x22A5 == codePoint) ||
+      (0x22BF == codePoint) ||
+      (0x2312 == codePoint) ||
+      (0x2460 <= codePoint && codePoint <= 0x24E9) ||
+      (0x24EB <= codePoint && codePoint <= 0x254B) ||
+      (0x2550 <= codePoint && codePoint <= 0x2573) ||
+      (0x2580 <= codePoint && codePoint <= 0x258F) ||
+      (0x2592 <= codePoint && codePoint <= 0x2595) ||
+      (0x25A0 <= codePoint && codePoint <= 0x25A1) ||
+      (0x25A3 <= codePoint && codePoint <= 0x25A9) ||
+      (0x25B2 <= codePoint && codePoint <= 0x25B3) ||
+      (0x25B6 <= codePoint && codePoint <= 0x25B7) ||
+      (0x25BC <= codePoint && codePoint <= 0x25BD) ||
+      (0x25C0 <= codePoint && codePoint <= 0x25C1) ||
+      (0x25C6 <= codePoint && codePoint <= 0x25C8) ||
+      (0x25CB == codePoint) ||
+      (0x25CE <= codePoint && codePoint <= 0x25D1) ||
+      (0x25E2 <= codePoint && codePoint <= 0x25E5) ||
+      (0x25EF == codePoint) ||
+      (0x2605 <= codePoint && codePoint <= 0x2606) ||
+      (0x2609 == codePoint) ||
+      (0x260E <= codePoint && codePoint <= 0x260F) ||
+      (0x2614 <= codePoint && codePoint <= 0x2615) ||
+      (0x261C == codePoint) ||
+      (0x261E == codePoint) ||
+      (0x2640 == codePoint) ||
+      (0x2642 == codePoint) ||
+      (0x2660 <= codePoint && codePoint <= 0x2661) ||
+      (0x2663 <= codePoint && codePoint <= 0x2665) ||
+      (0x2667 <= codePoint && codePoint <= 0x266A) ||
+      (0x266C <= codePoint && codePoint <= 0x266D) ||
+      (0x266F == codePoint) ||
+      (0x269E <= codePoint && codePoint <= 0x269F) ||
+      (0x26BE <= codePoint && codePoint <= 0x26BF) ||
+      (0x26C4 <= codePoint && codePoint <= 0x26CD) ||
+      (0x26CF <= codePoint && codePoint <= 0x26E1) ||
+      (0x26E3 == codePoint) ||
+      (0x26E8 <= codePoint && codePoint <= 0x26FF) ||
+      (0x273D == codePoint) ||
+      (0x2757 == codePoint) ||
+      (0x2776 <= codePoint && codePoint <= 0x277F) ||
+      (0x2B55 <= codePoint && codePoint <= 0x2B59) ||
+      (0x3248 <= codePoint && codePoint <= 0x324F) ||
+      (0xE000 <= codePoint && codePoint <= 0xF8FF) ||
+      (0xFE00 <= codePoint && codePoint <= 0xFE0F) ||
+      (0xFFFD == codePoint) ||
+      (0x1F100 <= codePoint && codePoint <= 0x1F10A) ||
+      (0x1F110 <= codePoint && codePoint <= 0x1F12D) ||
+      (0x1F130 <= codePoint && codePoint <= 0x1F169) ||
+      (0x1F170 <= codePoint && codePoint <= 0x1F19A) ||
+      (0xE0100 <= codePoint && codePoint <= 0xE01EF) ||
+      (0xF0000 <= codePoint && codePoint <= 0xFFFFD) ||
+      (0x100000 <= codePoint && codePoint <= 0x10FFFD)) {
+    return 'A';
+  }
+
+  return 'N';
+};
+
+eaw.characterLength = function(character) {
+  var code = this.eastAsianWidth(character);
+  if (code == 'F' || code == 'W' || code == 'A') {
+    return 2;
+  } else {
+    return 1;
+  }
+};
+
+eaw.length = function(string) {
+  var len = 0;
+  for (var i = 0; i < string.length; i++) {
+    len = len + this.characterLength(string.charAt(i));
+  }
+  return len;
+};
+
+},{}],36:[function(_dereq_,module,exports){
+/*
+  Copyright (C) 2012-2013 Yusuke Suzuki <utatane.tea@gmail.com>
+  Copyright (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com>
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+/*jslint vars:false, bitwise:true*/
+/*jshint indent:4*/
+/*global exports:true, define:true*/
+(function (root, factory) {
+    'use strict';
+
+    // Universal Module Definition (UMD) to support AMD, CommonJS/Node.js,
+    // and plain browser loading,
+    if (typeof define === 'function' && define.amd) {
+        define(['exports'], factory);
+    } else if (typeof exports !== 'undefined') {
+        factory(exports);
+    } else {
+        factory((root.estraverse = {}));
+    }
+}(this, function (exports) {
+    'use strict';
+
+    var Syntax,
+        isArray,
+        VisitorOption,
+        VisitorKeys,
+        objectCreate,
+        objectKeys,
+        BREAK,
+        SKIP,
+        REMOVE;
+
+    function ignoreJSHintError() { }
+
+    isArray = Array.isArray;
+    if (!isArray) {
+        isArray = function isArray(array) {
+            return Object.prototype.toString.call(array) === '[object Array]';
+        };
+    }
+
+    function deepCopy(obj) {
+        var ret = {}, key, val;
+        for (key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                val = obj[key];
+                if (typeof val === 'object' && val !== null) {
+                    ret[key] = deepCopy(val);
+                } else {
+                    ret[key] = val;
+                }
+            }
+        }
+        return ret;
+    }
+
+    function shallowCopy(obj) {
+        var ret = {}, key;
+        for (key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                ret[key] = obj[key];
+            }
+        }
+        return ret;
+    }
+    ignoreJSHintError(shallowCopy);
+
+    // based on LLVM libc++ upper_bound / lower_bound
+    // MIT License
+
+    function upperBound(array, func) {
+        var diff, len, i, current;
+
+        len = array.length;
+        i = 0;
+
+        while (len) {
+            diff = len >>> 1;
+            current = i + diff;
+            if (func(array[current])) {
+                len = diff;
+            } else {
+                i = current + 1;
+                len -= diff + 1;
+            }
+        }
+        return i;
+    }
+
+    function lowerBound(array, func) {
+        var diff, len, i, current;
+
+        len = array.length;
+        i = 0;
+
+        while (len) {
+            diff = len >>> 1;
+            current = i + diff;
+            if (func(array[current])) {
+                i = current + 1;
+                len -= diff + 1;
+            } else {
+                len = diff;
+            }
+        }
+        return i;
+    }
+    ignoreJSHintError(lowerBound);
+
+    objectCreate = Object.create || (function () {
+        function F() { }
+
+        return function (o) {
+            F.prototype = o;
+            return new F();
+        };
+    })();
+
+    objectKeys = Object.keys || function (o) {
+        var keys = [], key;
+        for (key in o) {
+            keys.push(key);
+        }
+        return keys;
+    };
+
+    function extend(to, from) {
+        objectKeys(from).forEach(function (key) {
+            to[key] = from[key];
+        });
+        return to;
+    }
+
+    Syntax = {
+        AssignmentExpression: 'AssignmentExpression',
+        ArrayExpression: 'ArrayExpression',
+        ArrayPattern: 'ArrayPattern',
+        ArrowFunctionExpression: 'ArrowFunctionExpression',
+        BlockStatement: 'BlockStatement',
+        BinaryExpression: 'BinaryExpression',
+        BreakStatement: 'BreakStatement',
+        CallExpression: 'CallExpression',
+        CatchClause: 'CatchClause',
+        ClassBody: 'ClassBody',
+        ClassDeclaration: 'ClassDeclaration',
+        ClassExpression: 'ClassExpression',
+        ComprehensionBlock: 'ComprehensionBlock',  // CAUTION: It's deferred to ES7.
+        ComprehensionExpression: 'ComprehensionExpression',  // CAUTION: It's deferred to ES7.
+        ConditionalExpression: 'ConditionalExpression',
+        ContinueStatement: 'ContinueStatement',
+        DebuggerStatement: 'DebuggerStatement',
+        DirectiveStatement: 'DirectiveStatement',
+        DoWhileStatement: 'DoWhileStatement',
+        EmptyStatement: 'EmptyStatement',
+        ExportBatchSpecifier: 'ExportBatchSpecifier',
+        ExportDeclaration: 'ExportDeclaration',
+        ExportSpecifier: 'ExportSpecifier',
+        ExpressionStatement: 'ExpressionStatement',
+        ForStatement: 'ForStatement',
+        ForInStatement: 'ForInStatement',
+        ForOfStatement: 'ForOfStatement',
+        FunctionDeclaration: 'FunctionDeclaration',
+        FunctionExpression: 'FunctionExpression',
+        GeneratorExpression: 'GeneratorExpression',  // CAUTION: It's deferred to ES7.
+        Identifier: 'Identifier',
+        IfStatement: 'IfStatement',
+        ImportDeclaration: 'ImportDeclaration',
+        ImportDefaultSpecifier: 'ImportDefaultSpecifier',
+        ImportNamespaceSpecifier: 'ImportNamespaceSpecifier',
+        ImportSpecifier: 'ImportSpecifier',
+        Literal: 'Literal',
+        LabeledStatement: 'LabeledStatement',
+        LogicalExpression: 'LogicalExpression',
+        MemberExpression: 'MemberExpression',
+        MethodDefinition: 'MethodDefinition',
+        ModuleSpecifier: 'ModuleSpecifier',
+        NewExpression: 'NewExpression',
+        ObjectExpression: 'ObjectExpression',
+        ObjectPattern: 'ObjectPattern',
+        Program: 'Program',
+        Property: 'Property',
+        ReturnStatement: 'ReturnStatement',
+        SequenceExpression: 'SequenceExpression',
+        SpreadElement: 'SpreadElement',
+        SwitchStatement: 'SwitchStatement',
+        SwitchCase: 'SwitchCase',
+        TaggedTemplateExpression: 'TaggedTemplateExpression',
+        TemplateElement: 'TemplateElement',
+        TemplateLiteral: 'TemplateLiteral',
+        ThisExpression: 'ThisExpression',
+        ThrowStatement: 'ThrowStatement',
+        TryStatement: 'TryStatement',
+        UnaryExpression: 'UnaryExpression',
+        UpdateExpression: 'UpdateExpression',
+        VariableDeclaration: 'VariableDeclaration',
+        VariableDeclarator: 'VariableDeclarator',
+        WhileStatement: 'WhileStatement',
+        WithStatement: 'WithStatement',
+        YieldExpression: 'YieldExpression'
+    };
+
+    VisitorKeys = {
+        AssignmentExpression: ['left', 'right'],
+        ArrayExpression: ['elements'],
+        ArrayPattern: ['elements'],
+        ArrowFunctionExpression: ['params', 'defaults', 'rest', 'body'],
+        BlockStatement: ['body'],
+        BinaryExpression: ['left', 'right'],
+        BreakStatement: ['label'],
+        CallExpression: ['callee', 'arguments'],
+        CatchClause: ['param', 'body'],
+        ClassBody: ['body'],
+        ClassDeclaration: ['id', 'body', 'superClass'],
+        ClassExpression: ['id', 'body', 'superClass'],
+        ComprehensionBlock: ['left', 'right'],  // CAUTION: It's deferred to ES7.
+        ComprehensionExpression: ['blocks', 'filter', 'body'],  // CAUTION: It's deferred to ES7.
+        ConditionalExpression: ['test', 'consequent', 'alternate'],
+        ContinueStatement: ['label'],
+        DebuggerStatement: [],
+        DirectiveStatement: [],
+        DoWhileStatement: ['body', 'test'],
+        EmptyStatement: [],
+        ExportBatchSpecifier: [],
+        ExportDeclaration: ['declaration', 'specifiers', 'source'],
+        ExportSpecifier: ['id', 'name'],
+        ExpressionStatement: ['expression'],
+        ForStatement: ['init', 'test', 'update', 'body'],
+        ForInStatement: ['left', 'right', 'body'],
+        ForOfStatement: ['left', 'right', 'body'],
+        FunctionDeclaration: ['id', 'params', 'defaults', 'rest', 'body'],
+        FunctionExpression: ['id', 'params', 'defaults', 'rest', 'body'],
+        GeneratorExpression: ['blocks', 'filter', 'body'],  // CAUTION: It's deferred to ES7.
+        Identifier: [],
+        IfStatement: ['test', 'consequent', 'alternate'],
+        ImportDeclaration: ['specifiers', 'source'],
+        ImportDefaultSpecifier: ['id'],
+        ImportNamespaceSpecifier: ['id'],
+        ImportSpecifier: ['id', 'name'],
+        Literal: [],
+        LabeledStatement: ['label', 'body'],
+        LogicalExpression: ['left', 'right'],
+        MemberExpression: ['object', 'property'],
+        MethodDefinition: ['key', 'value'],
+        ModuleSpecifier: [],
+        NewExpression: ['callee', 'arguments'],
+        ObjectExpression: ['properties'],
+        ObjectPattern: ['properties'],
+        Program: ['body'],
+        Property: ['key', 'value'],
+        ReturnStatement: ['argument'],
+        SequenceExpression: ['expressions'],
+        SpreadElement: ['argument'],
+        SwitchStatement: ['discriminant', 'cases'],
+        SwitchCase: ['test', 'consequent'],
+        TaggedTemplateExpression: ['tag', 'quasi'],
+        TemplateElement: [],
+        TemplateLiteral: ['quasis', 'expressions'],
+        ThisExpression: [],
+        ThrowStatement: ['argument'],
+        TryStatement: ['block', 'handlers', 'handler', 'guardedHandlers', 'finalizer'],
+        UnaryExpression: ['argument'],
+        UpdateExpression: ['argument'],
+        VariableDeclaration: ['declarations'],
+        VariableDeclarator: ['id', 'init'],
+        WhileStatement: ['test', 'body'],
+        WithStatement: ['object', 'body'],
+        YieldExpression: ['argument']
+    };
+
+    // unique id
+    BREAK = {};
+    SKIP = {};
+    REMOVE = {};
+
+    VisitorOption = {
+        Break: BREAK,
+        Skip: SKIP,
+        Remove: REMOVE
+    };
+
+    function Reference(parent, key) {
+        this.parent = parent;
+        this.key = key;
+    }
+
+    Reference.prototype.replace = function replace(node) {
+        this.parent[this.key] = node;
+    };
+
+    Reference.prototype.remove = function remove() {
+        if (isArray(this.parent)) {
+            this.parent.splice(this.key, 1);
+            return true;
+        } else {
+            this.replace(null);
+            return false;
+        }
+    };
+
+    function Element(node, path, wrap, ref) {
+        this.node = node;
+        this.path = path;
+        this.wrap = wrap;
+        this.ref = ref;
+    }
+
+    function Controller() { }
+
+    // API:
+    // return property path array from root to current node
+    Controller.prototype.path = function path() {
+        var i, iz, j, jz, result, element;
+
+        function addToPath(result, path) {
+            if (isArray(path)) {
+                for (j = 0, jz = path.length; j < jz; ++j) {
+                    result.push(path[j]);
+                }
+            } else {
+                result.push(path);
+            }
+        }
+
+        // root node
+        if (!this.__current.path) {
+            return null;
+        }
+
+        // first node is sentinel, second node is root element
+        result = [];
+        for (i = 2, iz = this.__leavelist.length; i < iz; ++i) {
+            element = this.__leavelist[i];
+            addToPath(result, element.path);
+        }
+        addToPath(result, this.__current.path);
+        return result;
+    };
+
+    // API:
+    // return array of parent elements
+    Controller.prototype.parents = function parents() {
+        var i, iz, result;
+
+        // first node is sentinel
+        result = [];
+        for (i = 1, iz = this.__leavelist.length; i < iz; ++i) {
+            result.push(this.__leavelist[i].node);
+        }
+
+        return result;
+    };
+
+    // API:
+    // return current node
+    Controller.prototype.current = function current() {
+        return this.__current.node;
+    };
+
+    Controller.prototype.__execute = function __execute(callback, element) {
+        var previous, result;
+
+        result = undefined;
+
+        previous  = this.__current;
+        this.__current = element;
+        this.__state = null;
+        if (callback) {
+            result = callback.call(this, element.node, this.__leavelist[this.__leavelist.length - 1].node);
+        }
+        this.__current = previous;
+
+        return result;
+    };
+
+    // API:
+    // notify control skip / break
+    Controller.prototype.notify = function notify(flag) {
+        this.__state = flag;
+    };
+
+    // API:
+    // skip child nodes of current node
+    Controller.prototype.skip = function () {
+        this.notify(SKIP);
+    };
+
+    // API:
+    // break traversals
+    Controller.prototype['break'] = function () {
+        this.notify(BREAK);
+    };
+
+    // API:
+    // remove node
+    Controller.prototype.remove = function () {
+        this.notify(REMOVE);
+    };
+
+    Controller.prototype.__initialize = function(root, visitor) {
+        this.visitor = visitor;
+        this.root = root;
+        this.__worklist = [];
+        this.__leavelist = [];
+        this.__current = null;
+        this.__state = null;
+        this.__fallback = visitor.fallback === 'iteration';
+        this.__keys = VisitorKeys;
+        if (visitor.keys) {
+            this.__keys = extend(objectCreate(this.__keys), visitor.keys);
+        }
+    };
+
+    function isNode(node) {
+        if (node == null) {
+            return false;
+        }
+        return typeof node === 'object' && typeof node.type === 'string';
+    }
+
+    function isProperty(nodeType, key) {
+        return (nodeType === Syntax.ObjectExpression || nodeType === Syntax.ObjectPattern) && 'properties' === key;
+    }
+
+    Controller.prototype.traverse = function traverse(root, visitor) {
+        var worklist,
+            leavelist,
+            element,
+            node,
+            nodeType,
+            ret,
+            key,
+            current,
+            current2,
+            candidates,
+            candidate,
+            sentinel;
+
+        this.__initialize(root, visitor);
+
+        sentinel = {};
+
+        // reference
+        worklist = this.__worklist;
+        leavelist = this.__leavelist;
+
+        // initialize
+        worklist.push(new Element(root, null, null, null));
+        leavelist.push(new Element(null, null, null, null));
+
+        while (worklist.length) {
+            element = worklist.pop();
+
+            if (element === sentinel) {
+                element = leavelist.pop();
+
+                ret = this.__execute(visitor.leave, element);
+
+                if (this.__state === BREAK || ret === BREAK) {
+                    return;
+                }
+                continue;
+            }
+
+            if (element.node) {
+
+                ret = this.__execute(visitor.enter, element);
+
+                if (this.__state === BREAK || ret === BREAK) {
+                    return;
+                }
+
+                worklist.push(sentinel);
+                leavelist.push(element);
+
+                if (this.__state === SKIP || ret === SKIP) {
+                    continue;
+                }
+
+                node = element.node;
+                nodeType = element.wrap || node.type;
+                candidates = this.__keys[nodeType];
+                if (!candidates) {
+                    if (this.__fallback) {
+                        candidates = objectKeys(node);
+                    } else {
+                        throw new Error('Unknown node type ' + nodeType + '.');
+                    }
+                }
+
+                current = candidates.length;
+                while ((current -= 1) >= 0) {
+                    key = candidates[current];
+                    candidate = node[key];
+                    if (!candidate) {
+                        continue;
+                    }
+
+                    if (isArray(candidate)) {
+                        current2 = candidate.length;
+                        while ((current2 -= 1) >= 0) {
+                            if (!candidate[current2]) {
+                                continue;
+                            }
+                            if (isProperty(nodeType, candidates[current])) {
+                                element = new Element(candidate[current2], [key, current2], 'Property', null);
+                            } else if (isNode(candidate[current2])) {
+                                element = new Element(candidate[current2], [key, current2], null, null);
+                            } else {
+                                continue;
+                            }
+                            worklist.push(element);
+                        }
+                    } else if (isNode(candidate)) {
+                        worklist.push(new Element(candidate, key, null, null));
+                    }
+                }
+            }
+        }
+    };
+
+    Controller.prototype.replace = function replace(root, visitor) {
+        function removeElem(element) {
+            var i,
+                key,
+                nextElem,
+                parent;
+
+            if (element.ref.remove()) {
+                // When the reference is an element of an array.
+                key = element.ref.key;
+                parent = element.ref.parent;
+
+                // If removed from array, then decrease following items' keys.
+                i = worklist.length;
+                while (i--) {
+                    nextElem = worklist[i];
+                    if (nextElem.ref && nextElem.ref.parent === parent) {
+                        if  (nextElem.ref.key < key) {
+                            break;
+                        }
+                        --nextElem.ref.key;
+                    }
+                }
+            }
+        }
+
+        var worklist,
+            leavelist,
+            node,
+            nodeType,
+            target,
+            element,
+            current,
+            current2,
+            candidates,
+            candidate,
+            sentinel,
+            outer,
+            key;
+
+        this.__initialize(root, visitor);
+
+        sentinel = {};
+
+        // reference
+        worklist = this.__worklist;
+        leavelist = this.__leavelist;
+
+        // initialize
+        outer = {
+            root: root
+        };
+        element = new Element(root, null, null, new Reference(outer, 'root'));
+        worklist.push(element);
+        leavelist.push(element);
+
+        while (worklist.length) {
+            element = worklist.pop();
+
+            if (element === sentinel) {
+                element = leavelist.pop();
+
+                target = this.__execute(visitor.leave, element);
+
+                // node may be replaced with null,
+                // so distinguish between undefined and null in this place
+                if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
+                    // replace
+                    element.ref.replace(target);
+                }
+
+                if (this.__state === REMOVE || target === REMOVE) {
+                    removeElem(element);
+                }
+
+                if (this.__state === BREAK || target === BREAK) {
+                    return outer.root;
+                }
+                continue;
+            }
+
+            target = this.__execute(visitor.enter, element);
+
+            // node may be replaced with null,
+            // so distinguish between undefined and null in this place
+            if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
+                // replace
+                element.ref.replace(target);
+                element.node = target;
+            }
+
+            if (this.__state === REMOVE || target === REMOVE) {
+                removeElem(element);
+                element.node = null;
+            }
+
+            if (this.__state === BREAK || target === BREAK) {
+                return outer.root;
+            }
+
+            // node may be null
+            node = element.node;
+            if (!node) {
+                continue;
+            }
+
+            worklist.push(sentinel);
+            leavelist.push(element);
+
+            if (this.__state === SKIP || target === SKIP) {
+                continue;
+            }
+
+            nodeType = element.wrap || node.type;
+            candidates = this.__keys[nodeType];
+            if (!candidates) {
+                if (this.__fallback) {
+                    candidates = objectKeys(node);
+                } else {
+                    throw new Error('Unknown node type ' + nodeType + '.');
+                }
+            }
+
+            current = candidates.length;
+            while ((current -= 1) >= 0) {
+                key = candidates[current];
+                candidate = node[key];
+                if (!candidate) {
+                    continue;
+                }
+
+                if (isArray(candidate)) {
+                    current2 = candidate.length;
+                    while ((current2 -= 1) >= 0) {
+                        if (!candidate[current2]) {
+                            continue;
+                        }
+                        if (isProperty(nodeType, candidates[current])) {
+                            element = new Element(candidate[current2], [key, current2], 'Property', new Reference(candidate, current2));
+                        } else if (isNode(candidate[current2])) {
+                            element = new Element(candidate[current2], [key, current2], null, new Reference(candidate, current2));
+                        } else {
+                            continue;
+                        }
+                        worklist.push(element);
+                    }
+                } else if (isNode(candidate)) {
+                    worklist.push(new Element(candidate, key, null, new Reference(node, key)));
+                }
+            }
+        }
+
+        return outer.root;
+    };
+
+    function traverse(root, visitor) {
+        var controller = new Controller();
+        return controller.traverse(root, visitor);
+    }
+
+    function replace(root, visitor) {
+        var controller = new Controller();
+        return controller.replace(root, visitor);
+    }
+
+    function extendCommentRange(comment, tokens) {
+        var target;
+
+        target = upperBound(tokens, function search(token) {
+            return token.range[0] > comment.range[0];
+        });
+
+        comment.extendedRange = [comment.range[0], comment.range[1]];
+
+        if (target !== tokens.length) {
+            comment.extendedRange[1] = tokens[target].range[0];
+        }
+
+        target -= 1;
+        if (target >= 0) {
+            comment.extendedRange[0] = tokens[target].range[1];
+        }
+
+        return comment;
+    }
+
+    function attachComments(tree, providedComments, tokens) {
+        // At first, we should calculate extended comment ranges.
+        var comments = [], comment, len, i, cursor;
+
+        if (!tree.range) {
+            throw new Error('attachComments needs range information');
+        }
+
+        // tokens array is empty, we attach comments to tree as 'leadingComments'
+        if (!tokens.length) {
+            if (providedComments.length) {
+                for (i = 0, len = providedComments.length; i < len; i += 1) {
+                    comment = deepCopy(providedComments[i]);
+                    comment.extendedRange = [0, tree.range[0]];
+                    comments.push(comment);
+                }
+                tree.leadingComments = comments;
+            }
+            return tree;
+        }
+
+        for (i = 0, len = providedComments.length; i < len; i += 1) {
+            comments.push(extendCommentRange(deepCopy(providedComments[i]), tokens));
+        }
+
+        // This is based on John Freeman's implementation.
+        cursor = 0;
+        traverse(tree, {
+            enter: function (node) {
+                var comment;
+
+                while (cursor < comments.length) {
+                    comment = comments[cursor];
+                    if (comment.extendedRange[1] > node.range[0]) {
+                        break;
+                    }
+
+                    if (comment.extendedRange[1] === node.range[0]) {
+                        if (!node.leadingComments) {
+                            node.leadingComments = [];
+                        }
+                        node.leadingComments.push(comment);
+                        comments.splice(cursor, 1);
+                    } else {
+                        cursor += 1;
+                    }
+                }
+
+                // already out of owned node
+                if (cursor === comments.length) {
+                    return VisitorOption.Break;
+                }
+
+                if (comments[cursor].extendedRange[0] > node.range[1]) {
+                    return VisitorOption.Skip;
+                }
+            }
+        });
+
+        cursor = 0;
+        traverse(tree, {
+            leave: function (node) {
+                var comment;
+
+                while (cursor < comments.length) {
+                    comment = comments[cursor];
+                    if (node.range[1] < comment.extendedRange[0]) {
+                        break;
+                    }
+
+                    if (node.range[1] === comment.extendedRange[0]) {
+                        if (!node.trailingComments) {
+                            node.trailingComments = [];
+                        }
+                        node.trailingComments.push(comment);
+                        comments.splice(cursor, 1);
+                    } else {
+                        cursor += 1;
+                    }
+                }
+
+                // already out of owned node
+                if (cursor === comments.length) {
+                    return VisitorOption.Break;
+                }
+
+                if (comments[cursor].extendedRange[0] > node.range[1]) {
+                    return VisitorOption.Skip;
+                }
+            }
+        });
+
+        return tree;
+    }
+
+    exports.version = '1.7.1';
+    exports.Syntax = Syntax;
+    exports.traverse = traverse;
+    exports.replace = replace;
+    exports.attachComments = attachComments;
+    exports.VisitorKeys = VisitorKeys;
+    exports.VisitorOption = VisitorOption;
+    exports.Controller = Controller;
+}));
+/* vim: set sw=4 ts=4 et tw=80 : */
+
+},{}],37:[function(_dereq_,module,exports){
+module.exports = _dereq_('./javascript/diff_match_patch_uncompressed.js').diff_match_patch;
+
+},{"./javascript/diff_match_patch_uncompressed.js":38}],38:[function(_dereq_,module,exports){
+/**
+ * Diff Match and Patch
+ *
+ * Copyright 2006 Google Inc.
+ * http://code.google.com/p/google-diff-match-patch/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Computes the difference between two texts to create a patch.
+ * Applies the patch onto another text, allowing for errors.
+ * @author fraser@google.com (Neil Fraser)
+ */
+
+/**
+ * Class containing the diff, match and patch methods.
+ * @constructor
+ */
+function diff_match_patch() {
+
+  // Defaults.
+  // Redefine these in your program to override the defaults.
+
+  // Number of seconds to map a diff before giving up (0 for infinity).
+  this.Diff_Timeout = 1.0;
+  // Cost of an empty edit operation in terms of edit characters.
+  this.Diff_EditCost = 4;
+  // At what point is no match declared (0.0 = perfection, 1.0 = very loose).
+  this.Match_Threshold = 0.5;
+  // How far to search for a match (0 = exact location, 1000+ = broad match).
+  // A match this many characters away from the expected location will add
+  // 1.0 to the score (0.0 is a perfect match).
+  this.Match_Distance = 1000;
+  // When deleting a large block of text (over ~64 characters), how close do
+  // the contents have to be to match the expected contents. (0.0 = perfection,
+  // 1.0 = very loose).  Note that Match_Threshold controls how closely the
+  // end points of a delete need to match.
+  this.Patch_DeleteThreshold = 0.5;
+  // Chunk size for context length.
+  this.Patch_Margin = 4;
+
+  // The number of bits in an int.
+  this.Match_MaxBits = 32;
+}
+
+
+//  DIFF FUNCTIONS
+
+
+/**
+ * The data structure representing a diff is an array of tuples:
+ * [[DIFF_DELETE, 'Hello'], [DIFF_INSERT, 'Goodbye'], [DIFF_EQUAL, ' world.']]
+ * which means: delete 'Hello', add 'Goodbye' and keep ' world.'
+ */
+var DIFF_DELETE = -1;
+var DIFF_INSERT = 1;
+var DIFF_EQUAL = 0;
+
+/** @typedef {{0: number, 1: string}} */
+diff_match_patch.Diff;
+
+
+/**
+ * Find the differences between two texts.  Simplifies the problem by stripping
+ * any common prefix or suffix off the texts before diffing.
+ * @param {string} text1 Old string to be diffed.
+ * @param {string} text2 New string to be diffed.
+ * @param {boolean=} opt_checklines Optional speedup flag. If present and false,
+ *     then don't run a line-level diff first to identify the changed areas.
+ *     Defaults to true, which does a faster, slightly less optimal diff.
+ * @param {number} opt_deadline Optional time when the diff should be complete
+ *     by.  Used internally for recursive calls.  Users should set DiffTimeout
+ *     instead.
+ * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.
+ */
+diff_match_patch.prototype.diff_main = function(text1, text2, opt_checklines,
+    opt_deadline) {
+  // Set a deadline by which time the diff must be complete.
+  if (typeof opt_deadline == 'undefined') {
+    if (this.Diff_Timeout <= 0) {
+      opt_deadline = Number.MAX_VALUE;
+    } else {
+      opt_deadline = (new Date).getTime() + this.Diff_Timeout * 1000;
+    }
+  }
+  var deadline = opt_deadline;
+
+  // Check for null inputs.
+  if (text1 == null || text2 == null) {
+    throw new Error('Null input. (diff_main)');
+  }
+
+  // Check for equality (speedup).
+  if (text1 == text2) {
+    if (text1) {
+      return [[DIFF_EQUAL, text1]];
+    }
+    return [];
+  }
+
+  if (typeof opt_checklines == 'undefined') {
+    opt_checklines = true;
+  }
+  var checklines = opt_checklines;
+
+  // Trim off common prefix (speedup).
+  var commonlength = this.diff_commonPrefix(text1, text2);
+  var commonprefix = text1.substring(0, commonlength);
+  text1 = text1.substring(commonlength);
+  text2 = text2.substring(commonlength);
+
+  // Trim off common suffix (speedup).
+  commonlength = this.diff_commonSuffix(text1, text2);
+  var commonsuffix = text1.substring(text1.length - commonlength);
+  text1 = text1.substring(0, text1.length - commonlength);
+  text2 = text2.substring(0, text2.length - commonlength);
+
+  // Compute the diff on the middle block.
+  var diffs = this.diff_compute_(text1, text2, checklines, deadline);
+
+  // Restore the prefix and suffix.
+  if (commonprefix) {
+    diffs.unshift([DIFF_EQUAL, commonprefix]);
+  }
+  if (commonsuffix) {
+    diffs.push([DIFF_EQUAL, commonsuffix]);
+  }
+  this.diff_cleanupMerge(diffs);
+  return diffs;
+};
+
+
+/**
+ * Find the differences between two texts.  Assumes that the texts do not
+ * have any common prefix or suffix.
+ * @param {string} text1 Old string to be diffed.
+ * @param {string} text2 New string to be diffed.
+ * @param {boolean} checklines Speedup flag.  If false, then don't run a
+ *     line-level diff first to identify the changed areas.
+ *     If true, then run a faster, slightly less optimal diff.
+ * @param {number} deadline Time when the diff should be complete by.
+ * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.
+ * @private
+ */
+diff_match_patch.prototype.diff_compute_ = function(text1, text2, checklines,
+    deadline) {
+  var diffs;
+
+  if (!text1) {
+    // Just add some text (speedup).
+    return [[DIFF_INSERT, text2]];
+  }
+
+  if (!text2) {
+    // Just delete some text (speedup).
+    return [[DIFF_DELETE, text1]];
+  }
+
+  var longtext = text1.length > text2.length ? text1 : text2;
+  var shorttext = text1.length > text2.length ? text2 : text1;
+  var i = longtext.indexOf(shorttext);
+  if (i != -1) {
+    // Shorter text is inside the longer text (speedup).
+    diffs = [[DIFF_INSERT, longtext.substring(0, i)],
+             [DIFF_EQUAL, shorttext],
+             [DIFF_INSERT, longtext.substring(i + shorttext.length)]];
+    // Swap insertions for deletions if diff is reversed.
+    if (text1.length > text2.length) {
+      diffs[0][0] = diffs[2][0] = DIFF_DELETE;
+    }
+    return diffs;
+  }
+
+  if (shorttext.length == 1) {
+    // Single character string.
+    // After the previous speedup, the character can't be an equality.
+    return [[DIFF_DELETE, text1], [DIFF_INSERT, text2]];
+  }
+
+  // Check to see if the problem can be split in two.
+  var hm = this.diff_halfMatch_(text1, text2);
+  if (hm) {
+    // A half-match was found, sort out the return data.
+    var text1_a = hm[0];
+    var text1_b = hm[1];
+    var text2_a = hm[2];
+    var text2_b = hm[3];
+    var mid_common = hm[4];
+    // Send both pairs off for separate processing.
+    var diffs_a = this.diff_main(text1_a, text2_a, checklines, deadline);
+    var diffs_b = this.diff_main(text1_b, text2_b, checklines, deadline);
+    // Merge the results.
+    return diffs_a.concat([[DIFF_EQUAL, mid_common]], diffs_b);
+  }
+
+  if (checklines && text1.length > 100 && text2.length > 100) {
+    return this.diff_lineMode_(text1, text2, deadline);
+  }
+
+  return this.diff_bisect_(text1, text2, deadline);
+};
+
+
+/**
+ * Do a quick line-level diff on both strings, then rediff the parts for
+ * greater accuracy.
+ * This speedup can produce non-minimal diffs.
+ * @param {string} text1 Old string to be diffed.
+ * @param {string} text2 New string to be diffed.
+ * @param {number} deadline Time when the diff should be complete by.
+ * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.
+ * @private
+ */
+diff_match_patch.prototype.diff_lineMode_ = function(text1, text2, deadline) {
+  // Scan the text on a line-by-line basis first.
+  var a = this.diff_linesToChars_(text1, text2);
+  text1 = a.chars1;
+  text2 = a.chars2;
+  var linearray = a.lineArray;
+
+  var diffs = this.diff_main(text1, text2, false, deadline);
+
+  // Convert the diff back to original text.
+  this.diff_charsToLines_(diffs, linearray);
+  // Eliminate freak matches (e.g. blank lines)
+  this.diff_cleanupSemantic(diffs);
+
+  // Rediff any replacement blocks, this time character-by-character.
+  // Add a dummy entry at the end.
+  diffs.push([DIFF_EQUAL, '']);
+  var pointer = 0;
+  var count_delete = 0;
+  var count_insert = 0;
+  var text_delete = '';
+  var text_insert = '';
+  while (pointer < diffs.length) {
+    switch (diffs[pointer][0]) {
+      case DIFF_INSERT:
+        count_insert++;
+        text_insert += diffs[pointer][1];
+        break;
+      case DIFF_DELETE:
+        count_delete++;
+        text_delete += diffs[pointer][1];
+        break;
+      case DIFF_EQUAL:
+        // Upon reaching an equality, check for prior redundancies.
+        if (count_delete >= 1 && count_insert >= 1) {
+          // Delete the offending records and add the merged ones.
+          diffs.splice(pointer - count_delete - count_insert,
+                       count_delete + count_insert);
+          pointer = pointer - count_delete - count_insert;
+          var a = this.diff_main(text_delete, text_insert, false, deadline);
+          for (var j = a.length - 1; j >= 0; j--) {
+            diffs.splice(pointer, 0, a[j]);
+          }
+          pointer = pointer + a.length;
+        }
+        count_insert = 0;
+        count_delete = 0;
+        text_delete = '';
+        text_insert = '';
+        break;
+    }
+    pointer++;
+  }
+  diffs.pop();  // Remove the dummy entry at the end.
+
+  return diffs;
+};
+
+
+/**
+ * Find the 'middle snake' of a diff, split the problem in two
+ * and return the recursively constructed diff.
+ * See Myers 1986 paper: An O(ND) Difference Algorithm and Its Variations.
+ * @param {string} text1 Old string to be diffed.
+ * @param {string} text2 New string to be diffed.
+ * @param {number} deadline Time at which to bail if not yet complete.
+ * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.
+ * @private
+ */
+diff_match_patch.prototype.diff_bisect_ = function(text1, text2, deadline) {
+  // Cache the text lengths to prevent multiple calls.
+  var text1_length = text1.length;
+  var text2_length = text2.length;
+  var max_d = Math.ceil((text1_length + text2_length) / 2);
+  var v_offset = max_d;
+  var v_length = 2 * max_d;
+  var v1 = new Array(v_length);
+  var v2 = new Array(v_length);
+  // Setting all elements to -1 is faster in Chrome & Firefox than mixing
+  // integers and undefined.
+  for (var x = 0; x < v_length; x++) {
+    v1[x] = -1;
+    v2[x] = -1;
+  }
+  v1[v_offset + 1] = 0;
+  v2[v_offset + 1] = 0;
+  var delta = text1_length - text2_length;
+  // If the total number of characters is odd, then the front path will collide
+  // with the reverse path.
+  var front = (delta % 2 != 0);
+  // Offsets for start and end of k loop.
+  // Prevents mapping of space beyond the grid.
+  var k1start = 0;
+  var k1end = 0;
+  var k2start = 0;
+  var k2end = 0;
+  for (var d = 0; d < max_d; d++) {
+    // Bail out if deadline is reached.
+    if ((new Date()).getTime() > deadline) {
+      break;
+    }
+
+    // Walk the front path one step.
+    for (var k1 = -d + k1start; k1 <= d - k1end; k1 += 2) {
+      var k1_offset = v_offset + k1;
+      var x1;
+      if (k1 == -d || (k1 != d && v1[k1_offset - 1] < v1[k1_offset + 1])) {
+        x1 = v1[k1_offset + 1];
+      } else {
+        x1 = v1[k1_offset - 1] + 1;
+      }
+      var y1 = x1 - k1;
+      while (x1 < text1_length && y1 < text2_length &&
+             text1.charAt(x1) == text2.charAt(y1)) {
+        x1++;
+        y1++;
+      }
+      v1[k1_offset] = x1;
+      if (x1 > text1_length) {
+        // Ran off the right of the graph.
+        k1end += 2;
+      } else if (y1 > text2_length) {
+        // Ran off the bottom of the graph.
+        k1start += 2;
+      } else if (front) {
+        var k2_offset = v_offset + delta - k1;
+        if (k2_offset >= 0 && k2_offset < v_length && v2[k2_offset] != -1) {
+          // Mirror x2 onto top-left coordinate system.
+          var x2 = text1_length - v2[k2_offset];
+          if (x1 >= x2) {
+            // Overlap detected.
+            return this.diff_bisectSplit_(text1, text2, x1, y1, deadline);
+          }
+        }
+      }
+    }
+
+    // Walk the reverse path one step.
+    for (var k2 = -d + k2start; k2 <= d - k2end; k2 += 2) {
+      var k2_offset = v_offset + k2;
+      var x2;
+      if (k2 == -d || (k2 != d && v2[k2_offset - 1] < v2[k2_offset + 1])) {
+        x2 = v2[k2_offset + 1];
+      } else {
+        x2 = v2[k2_offset - 1] + 1;
+      }
+      var y2 = x2 - k2;
+      while (x2 < text1_length && y2 < text2_length &&
+             text1.charAt(text1_length - x2 - 1) ==
+             text2.charAt(text2_length - y2 - 1)) {
+        x2++;
+        y2++;
+      }
+      v2[k2_offset] = x2;
+      if (x2 > text1_length) {
+        // Ran off the left of the graph.
+        k2end += 2;
+      } else if (y2 > text2_length) {
+        // Ran off the top of the graph.
+        k2start += 2;
+      } else if (!front) {
+        var k1_offset = v_offset + delta - k2;
+        if (k1_offset >= 0 && k1_offset < v_length && v1[k1_offset] != -1) {
+          var x1 = v1[k1_offset];
+          var y1 = v_offset + x1 - k1_offset;
+          // Mirror x2 onto top-left coordinate system.
+          x2 = text1_length - x2;
+          if (x1 >= x2) {
+            // Overlap detected.
+            return this.diff_bisectSplit_(text1, text2, x1, y1, deadline);
+          }
+        }
+      }
+    }
+  }
+  // Diff took too long and hit the deadline or
+  // number of diffs equals number of characters, no commonality at all.
+  return [[DIFF_DELETE, text1], [DIFF_INSERT, text2]];
+};
+
+
+/**
+ * Given the location of the 'middle snake', split the diff in two parts
+ * and recurse.
+ * @param {string} text1 Old string to be diffed.
+ * @param {string} text2 New string to be diffed.
+ * @param {number} x Index of split point in text1.
+ * @param {number} y Index of split point in text2.
+ * @param {number} deadline Time at which to bail if not yet complete.
+ * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.
+ * @private
+ */
+diff_match_patch.prototype.diff_bisectSplit_ = function(text1, text2, x, y,
+    deadline) {
+  var text1a = text1.substring(0, x);
+  var text2a = text2.substring(0, y);
+  var text1b = text1.substring(x);
+  var text2b = text2.substring(y);
+
+  // Compute both diffs serially.
+  var diffs = this.diff_main(text1a, text2a, false, deadline);
+  var diffsb = this.diff_main(text1b, text2b, false, deadline);
+
+  return diffs.concat(diffsb);
+};
+
+
+/**
+ * Split two texts into an array of strings.  Reduce the texts to a string of
+ * hashes where each Unicode character represents one line.
+ * @param {string} text1 First string.
+ * @param {string} text2 Second string.
+ * @return {{chars1: string, chars2: string, lineArray: !Array.<string>}}
+ *     An object containing the encoded text1, the encoded text2 and
+ *     the array of unique strings.
+ *     The zeroth element of the array of unique strings is intentionally blank.
+ * @private
+ */
+diff_match_patch.prototype.diff_linesToChars_ = function(text1, text2) {
+  var lineArray = [];  // e.g. lineArray[4] == 'Hello\n'
+  var lineHash = {};   // e.g. lineHash['Hello\n'] == 4
+
+  // '\x00' is a valid character, but various debuggers don't like it.
+  // So we'll insert a junk entry to avoid generating a null character.
+  lineArray[0] = '';
+
+  /**
+   * Split a text into an array of strings.  Reduce the texts to a string of
+   * hashes where each Unicode character represents one line.
+   * Modifies linearray and linehash through being a closure.
+   * @param {string} text String to encode.
+   * @return {string} Encoded string.
+   * @private
+   */
+  function diff_linesToCharsMunge_(text) {
+    var chars = '';
+    // Walk the text, pulling out a substring for each line.
+    // text.split('\n') would would temporarily double our memory footprint.
+    // Modifying text would create many large strings to garbage collect.
+    var lineStart = 0;
+    var lineEnd = -1;
+    // Keeping our own length variable is faster than looking it up.
+    var lineArrayLength = lineArray.length;
+    while (lineEnd < text.length - 1) {
+      lineEnd = text.indexOf('\n', lineStart);
+      if (lineEnd == -1) {
+        lineEnd = text.length - 1;
+      }
+      var line = text.substring(lineStart, lineEnd + 1);
+      lineStart = lineEnd + 1;
+
+      if (lineHash.hasOwnProperty ? lineHash.hasOwnProperty(line) :
+          (lineHash[line] !== undefined)) {
+        chars += String.fromCharCode(lineHash[line]);
+      } else {
+        chars += String.fromCharCode(lineArrayLength);
+        lineHash[line] = lineArrayLength;
+        lineArray[lineArrayLength++] = line;
+      }
+    }
+    return chars;
+  }
+
+  var chars1 = diff_linesToCharsMunge_(text1);
+  var chars2 = diff_linesToCharsMunge_(text2);
+  return {chars1: chars1, chars2: chars2, lineArray: lineArray};
+};
+
+
+/**
+ * Rehydrate the text in a diff from a string of line hashes to real lines of
+ * text.
+ * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
+ * @param {!Array.<string>} lineArray Array of unique strings.
+ * @private
+ */
+diff_match_patch.prototype.diff_charsToLines_ = function(diffs, lineArray) {
+  for (var x = 0; x < diffs.length; x++) {
+    var chars = diffs[x][1];
+    var text = [];
+    for (var y = 0; y < chars.length; y++) {
+      text[y] = lineArray[chars.charCodeAt(y)];
+    }
+    diffs[x][1] = text.join('');
+  }
+};
+
+
+/**
+ * Determine the common prefix of two strings.
+ * @param {string} text1 First string.
+ * @param {string} text2 Second string.
+ * @return {number} The number of characters common to the start of each
+ *     string.
+ */
+diff_match_patch.prototype.diff_commonPrefix = function(text1, text2) {
+  // Quick check for common null cases.
+  if (!text1 || !text2 || text1.charAt(0) != text2.charAt(0)) {
+    return 0;
+  }
+  // Binary search.
+  // Performance analysis: http://neil.fraser.name/news/2007/10/09/
+  var pointermin = 0;
+  var pointermax = Math.min(text1.length, text2.length);
+  var pointermid = pointermax;
+  var pointerstart = 0;
+  while (pointermin < pointermid) {
+    if (text1.substring(pointerstart, pointermid) ==
+        text2.substring(pointerstart, pointermid)) {
+      pointermin = pointermid;
+      pointerstart = pointermin;
+    } else {
+      pointermax = pointermid;
+    }
+    pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);
+  }
+  return pointermid;
+};
+
+
+/**
+ * Determine the common suffix of two strings.
+ * @param {string} text1 First string.
+ * @param {string} text2 Second string.
+ * @return {number} The number of characters common to the end of each string.
+ */
+diff_match_patch.prototype.diff_commonSuffix = function(text1, text2) {
+  // Quick check for common null cases.
+  if (!text1 || !text2 ||
+      text1.charAt(text1.length - 1) != text2.charAt(text2.length - 1)) {
+    return 0;
+  }
+  // Binary search.
+  // Performance analysis: http://neil.fraser.name/news/2007/10/09/
+  var pointermin = 0;
+  var pointermax = Math.min(text1.length, text2.length);
+  var pointermid = pointermax;
+  var pointerend = 0;
+  while (pointermin < pointermid) {
+    if (text1.substring(text1.length - pointermid, text1.length - pointerend) ==
+        text2.substring(text2.length - pointermid, text2.length - pointerend)) {
+      pointermin = pointermid;
+      pointerend = pointermin;
+    } else {
+      pointermax = pointermid;
+    }
+    pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);
+  }
+  return pointermid;
+};
+
+
+/**
+ * Determine if the suffix of one string is the prefix of another.
+ * @param {string} text1 First string.
+ * @param {string} text2 Second string.
+ * @return {number} The number of characters common to the end of the first
+ *     string and the start of the second string.
+ * @private
+ */
+diff_match_patch.prototype.diff_commonOverlap_ = function(text1, text2) {
+  // Cache the text lengths to prevent multiple calls.
+  var text1_length = text1.length;
+  var text2_length = text2.length;
+  // Eliminate the null case.
+  if (text1_length == 0 || text2_length == 0) {
+    return 0;
+  }
+  // Truncate the longer string.
+  if (text1_length > text2_length) {
+    text1 = text1.substring(text1_length - text2_length);
+  } else if (text1_length < text2_length) {
+    text2 = text2.substring(0, text1_length);
+  }
+  var text_length = Math.min(text1_length, text2_length);
+  // Quick check for the worst case.
+  if (text1 == text2) {
+    return text_length;
+  }
+
+  // Start by looking for a single character match
+  // and increase length until no match is found.
+  // Performance analysis: http://neil.fraser.name/news/2010/11/04/
+  var best = 0;
+  var length = 1;
+  while (true) {
+    var pattern = text1.substring(text_length - length);
+    var found = text2.indexOf(pattern);
+    if (found == -1) {
+      return best;
+    }
+    length += found;
+    if (found == 0 || text1.substring(text_length - length) ==
+        text2.substring(0, length)) {
+      best = length;
+      length++;
+    }
+  }
+};
+
+
+/**
+ * Do the two texts share a substring which is at least half the length of the
+ * longer text?
+ * This speedup can produce non-minimal diffs.
+ * @param {string} text1 First string.
+ * @param {string} text2 Second string.
+ * @return {Array.<string>} Five element Array, containing the prefix of
+ *     text1, the suffix of text1, the prefix of text2, the suffix of
+ *     text2 and the common middle.  Or null if there was no match.
+ * @private
+ */
+diff_match_patch.prototype.diff_halfMatch_ = function(text1, text2) {
+  if (this.Diff_Timeout <= 0) {
+    // Don't risk returning a non-optimal diff if we have unlimited time.
+    return null;
+  }
+  var longtext = text1.length > text2.length ? text1 : text2;
+  var shorttext = text1.length > text2.length ? text2 : text1;
+  if (longtext.length < 4 || shorttext.length * 2 < longtext.length) {
+    return null;  // Pointless.
+  }
+  var dmp = this;  // 'this' becomes 'window' in a closure.
+
+  /**
+   * Does a substring of shorttext exist within longtext such that the substring
+   * is at least half the length of longtext?
+   * Closure, but does not reference any external variables.
+   * @param {string} longtext Longer string.
+   * @param {string} shorttext Shorter string.
+   * @param {number} i Start index of quarter length substring within longtext.
+   * @return {Array.<string>} Five element Array, containing the prefix of
+   *     longtext, the suffix of longtext, the prefix of shorttext, the suffix
+   *     of shorttext and the common middle.  Or null if there was no match.
+   * @private
+   */
+  function diff_halfMatchI_(longtext, shorttext, i) {
+    // Start with a 1/4 length substring at position i as a seed.
+    var seed = longtext.substring(i, i + Math.floor(longtext.length / 4));
+    var j = -1;
+    var best_common = '';
+    var best_longtext_a, best_longtext_b, best_shorttext_a, best_shorttext_b;
+    while ((j = shorttext.indexOf(seed, j + 1)) != -1) {
+      var prefixLength = dmp.diff_commonPrefix(longtext.substring(i),
+                                               shorttext.substring(j));
+      var suffixLength = dmp.diff_commonSuffix(longtext.substring(0, i),
+                                               shorttext.substring(0, j));
+      if (best_common.length < suffixLength + prefixLength) {
+        best_common = shorttext.substring(j - suffixLength, j) +
+            shorttext.substring(j, j + prefixLength);
+        best_longtext_a = longtext.substring(0, i - suffixLength);
+        best_longtext_b = longtext.substring(i + prefixLength);
+        best_shorttext_a = shorttext.substring(0, j - suffixLength);
+        best_shorttext_b = shorttext.substring(j + prefixLength);
+      }
+    }
+    if (best_common.length * 2 >= longtext.length) {
+      return [best_longtext_a, best_longtext_b,
+              best_shorttext_a, best_shorttext_b, best_common];
+    } else {
+      return null;
+    }
+  }
+
+  // First check if the second quarter is the seed for a half-match.
+  var hm1 = diff_halfMatchI_(longtext, shorttext,
+                             Math.ceil(longtext.length / 4));
+  // Check again based on the third quarter.
+  var hm2 = diff_halfMatchI_(longtext, shorttext,
+                             Math.ceil(longtext.length / 2));
+  var hm;
+  if (!hm1 && !hm2) {
+    return null;
+  } else if (!hm2) {
+    hm = hm1;
+  } else if (!hm1) {
+    hm = hm2;
+  } else {
+    // Both matched.  Select the longest.
+    hm = hm1[4].length > hm2[4].length ? hm1 : hm2;
+  }
+
+  // A half-match was found, sort out the return data.
+  var text1_a, text1_b, text2_a, text2_b;
+  if (text1.length > text2.length) {
+    text1_a = hm[0];
+    text1_b = hm[1];
+    text2_a = hm[2];
+    text2_b = hm[3];
+  } else {
+    text2_a = hm[0];
+    text2_b = hm[1];
+    text1_a = hm[2];
+    text1_b = hm[3];
+  }
+  var mid_common = hm[4];
+  return [text1_a, text1_b, text2_a, text2_b, mid_common];
+};
+
+
+/**
+ * Reduce the number of edits by eliminating semantically trivial equalities.
+ * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
+ */
+diff_match_patch.prototype.diff_cleanupSemantic = function(diffs) {
+  var changes = false;
+  var equalities = [];  // Stack of indices where equalities are found.
+  var equalitiesLength = 0;  // Keeping our own length var is faster in JS.
+  /** @type {?string} */
+  var lastequality = null;
+  // Always equal to diffs[equalities[equalitiesLength - 1]][1]
+  var pointer = 0;  // Index of current position.
+  // Number of characters that changed prior to the equality.
+  var length_insertions1 = 0;
+  var length_deletions1 = 0;
+  // Number of characters that changed after the equality.
+  var length_insertions2 = 0;
+  var length_deletions2 = 0;
+  while (pointer < diffs.length) {
+    if (diffs[pointer][0] == DIFF_EQUAL) {  // Equality found.
+      equalities[equalitiesLength++] = pointer;
+      length_insertions1 = length_insertions2;
+      length_deletions1 = length_deletions2;
+      length_insertions2 = 0;
+      length_deletions2 = 0;
+      lastequality = diffs[pointer][1];
+    } else {  // An insertion or deletion.
+      if (diffs[pointer][0] == DIFF_INSERT) {
+        length_insertions2 += diffs[pointer][1].length;
+      } else {
+        length_deletions2 += diffs[pointer][1].length;
+      }
+      // Eliminate an equality that is smaller or equal to the edits on both
+      // sides of it.
+      if (lastequality && (lastequality.length <=
+          Math.max(length_insertions1, length_deletions1)) &&
+          (lastequality.length <= Math.max(length_insertions2,
+                                           length_deletions2))) {
+        // Duplicate record.
+        diffs.splice(equalities[equalitiesLength - 1], 0,
+                     [DIFF_DELETE, lastequality]);
+        // Change second copy to insert.
+        diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT;
+        // Throw away the equality we just deleted.
+        equalitiesLength--;
+        // Throw away the previous equality (it needs to be reevaluated).
+        equalitiesLength--;
+        pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1;
+        length_insertions1 = 0;  // Reset the counters.
+        length_deletions1 = 0;
+        length_insertions2 = 0;
+        length_deletions2 = 0;
+        lastequality = null;
+        changes = true;
+      }
+    }
+    pointer++;
+  }
+
+  // Normalize the diff.
+  if (changes) {
+    this.diff_cleanupMerge(diffs);
+  }
+  this.diff_cleanupSemanticLossless(diffs);
+
+  // Find any overlaps between deletions and insertions.
+  // e.g: <del>abcxxx</del><ins>xxxdef</ins>
+  //   -> <del>abc</del>xxx<ins>def</ins>
+  // e.g: <del>xxxabc</del><ins>defxxx</ins>
+  //   -> <ins>def</ins>xxx<del>abc</del>
+  // Only extract an overlap if it is as big as the edit ahead or behind it.
+  pointer = 1;
+  while (pointer < diffs.length) {
+    if (diffs[pointer - 1][0] == DIFF_DELETE &&
+        diffs[pointer][0] == DIFF_INSERT) {
+      var deletion = diffs[pointer - 1][1];
+      var insertion = diffs[pointer][1];
+      var overlap_length1 = this.diff_commonOverlap_(deletion, insertion);
+      var overlap_length2 = this.diff_commonOverlap_(insertion, deletion);
+      if (overlap_length1 >= overlap_length2) {
+        if (overlap_length1 >= deletion.length / 2 ||
+            overlap_length1 >= insertion.length / 2) {
+          // Overlap found.  Insert an equality and trim the surrounding edits.
+          diffs.splice(pointer, 0,
+              [DIFF_EQUAL, insertion.substring(0, overlap_length1)]);
+          diffs[pointer - 1][1] =
+              deletion.substring(0, deletion.length - overlap_length1);
+          diffs[pointer + 1][1] = insertion.substring(overlap_length1);
+          pointer++;
+        }
+      } else {
+        if (overlap_length2 >= deletion.length / 2 ||
+            overlap_length2 >= insertion.length / 2) {
+          // Reverse overlap found.
+          // Insert an equality and swap and trim the surrounding edits.
+          diffs.splice(pointer, 0,
+              [DIFF_EQUAL, deletion.substring(0, overlap_length2)]);
+          diffs[pointer - 1][0] = DIFF_INSERT;
+          diffs[pointer - 1][1] =
+              insertion.substring(0, insertion.length - overlap_length2);
+          diffs[pointer + 1][0] = DIFF_DELETE;
+          diffs[pointer + 1][1] =
+              deletion.substring(overlap_length2);
+          pointer++;
+        }
+      }
+      pointer++;
+    }
+    pointer++;
+  }
+};
+
+
+/**
+ * Look for single edits surrounded on both sides by equalities
+ * which can be shifted sideways to align the edit to a word boundary.
+ * e.g: The c<ins>at c</ins>ame. -> The <ins>cat </ins>came.
+ * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
+ */
+diff_match_patch.prototype.diff_cleanupSemanticLossless = function(diffs) {
+  /**
+   * Given two strings, compute a score representing whether the internal
+   * boundary falls on logical boundaries.
+   * Scores range from 6 (best) to 0 (worst).
+   * Closure, but does not reference any external variables.
+   * @param {string} one First string.
+   * @param {string} two Second string.
+   * @return {number} The score.
+   * @private
+   */
+  function diff_cleanupSemanticScore_(one, two) {
+    if (!one || !two) {
+      // Edges are the best.
+      return 6;
+    }
+
+    // Each port of this function behaves slightly differently due to
+    // subtle differences in each language's definition of things like
+    // 'whitespace'.  Since this function's purpose is largely cosmetic,
+    // the choice has been made to use each language's native features
+    // rather than force total conformity.
+    var char1 = one.charAt(one.length - 1);
+    var char2 = two.charAt(0);
+    var nonAlphaNumeric1 = char1.match(diff_match_patch.nonAlphaNumericRegex_);
+    var nonAlphaNumeric2 = char2.match(diff_match_patch.nonAlphaNumericRegex_);
+    var whitespace1 = nonAlphaNumeric1 &&
+        char1.match(diff_match_patch.whitespaceRegex_);
+    var whitespace2 = nonAlphaNumeric2 &&
+        char2.match(diff_match_patch.whitespaceRegex_);
+    var lineBreak1 = whitespace1 &&
+        char1.match(diff_match_patch.linebreakRegex_);
+    var lineBreak2 = whitespace2 &&
+        char2.match(diff_match_patch.linebreakRegex_);
+    var blankLine1 = lineBreak1 &&
+        one.match(diff_match_patch.blanklineEndRegex_);
+    var blankLine2 = lineBreak2 &&
+        two.match(diff_match_patch.blanklineStartRegex_);
+
+    if (blankLine1 || blankLine2) {
+      // Five points for blank lines.
+      return 5;
+    } else if (lineBreak1 || lineBreak2) {
+      // Four points for line breaks.
+      return 4;
+    } else if (nonAlphaNumeric1 && !whitespace1 && whitespace2) {
+      // Three points for end of sentences.
+      return 3;
+    } else if (whitespace1 || whitespace2) {
+      // Two points for whitespace.
+      return 2;
+    } else if (nonAlphaNumeric1 || nonAlphaNumeric2) {
+      // One point for non-alphanumeric.
+      return 1;
+    }
+    return 0;
+  }
+
+  var pointer = 1;
+  // Intentionally ignore the first and last element (don't need checking).
+  while (pointer < diffs.length - 1) {
+    if (diffs[pointer - 1][0] == DIFF_EQUAL &&
+        diffs[pointer + 1][0] == DIFF_EQUAL) {
+      // This is a single edit surrounded by equalities.
+      var equality1 = diffs[pointer - 1][1];
+      var edit = diffs[pointer][1];
+      var equality2 = diffs[pointer + 1][1];
+
+      // First, shift the edit as far left as possible.
+      var commonOffset = this.diff_commonSuffix(equality1, edit);
+      if (commonOffset) {
+        var commonString = edit.substring(edit.length - commonOffset);
+        equality1 = equality1.substring(0, equality1.length - commonOffset);
+        edit = commonString + edit.substring(0, edit.length - commonOffset);
+        equality2 = commonString + equality2;
+      }
+
+      // Second, step character by character right, looking for the best fit.
+      var bestEquality1 = equality1;
+      var bestEdit = edit;
+      var bestEquality2 = equality2;
+      var bestScore = diff_cleanupSemanticScore_(equality1, edit) +
+          diff_cleanupSemanticScore_(edit, equality2);
+      while (edit.charAt(0) === equality2.charAt(0)) {
+        equality1 += edit.charAt(0);
+        edit = edit.substring(1) + equality2.charAt(0);
+        equality2 = equality2.substring(1);
+        var score = diff_cleanupSemanticScore_(equality1, edit) +
+            diff_cleanupSemanticScore_(edit, equality2);
+        // The >= encourages trailing rather than leading whitespace on edits.
+        if (score >= bestScore) {
+          bestScore = score;
+          bestEquality1 = equality1;
+          bestEdit = edit;
+          bestEquality2 = equality2;
+        }
+      }
+
+      if (diffs[pointer - 1][1] != bestEquality1) {
+        // We have an improvement, save it back to the diff.
+        if (bestEquality1) {
+          diffs[pointer - 1][1] = bestEquality1;
+        } else {
+          diffs.splice(pointer - 1, 1);
+          pointer--;
+        }
+        diffs[pointer][1] = bestEdit;
+        if (bestEquality2) {
+          diffs[pointer + 1][1] = bestEquality2;
+        } else {
+          diffs.splice(pointer + 1, 1);
+          pointer--;
+        }
+      }
+    }
+    pointer++;
+  }
+};
+
+// Define some regex patterns for matching boundaries.
+diff_match_patch.nonAlphaNumericRegex_ = /[^a-zA-Z0-9]/;
+diff_match_patch.whitespaceRegex_ = /\s/;
+diff_match_patch.linebreakRegex_ = /[\r\n]/;
+diff_match_patch.blanklineEndRegex_ = /\n\r?\n$/;
+diff_match_patch.blanklineStartRegex_ = /^\r?\n\r?\n/;
+
+/**
+ * Reduce the number of edits by eliminating operationally trivial equalities.
+ * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
+ */
+diff_match_patch.prototype.diff_cleanupEfficiency = function(diffs) {
+  var changes = false;
+  var equalities = [];  // Stack of indices where equalities are found.
+  var equalitiesLength = 0;  // Keeping our own length var is faster in JS.
+  /** @type {?string} */
+  var lastequality = null;
+  // Always equal to diffs[equalities[equalitiesLength - 1]][1]
+  var pointer = 0;  // Index of current position.
+  // Is there an insertion operation before the last equality.
+  var pre_ins = false;
+  // Is there a deletion operation before the last equality.
+  var pre_del = false;
+  // Is there an insertion operation after the last equality.
+  var post_ins = false;
+  // Is there a deletion operation after the last equality.
+  var post_del = false;
+  while (pointer < diffs.length) {
+    if (diffs[pointer][0] == DIFF_EQUAL) {  // Equality found.
+      if (diffs[pointer][1].length < this.Diff_EditCost &&
+          (post_ins || post_del)) {
+        // Candidate found.
+        equalities[equalitiesLength++] = pointer;
+        pre_ins = post_ins;
+        pre_del = post_del;
+        lastequality = diffs[pointer][1];
+      } else {
+        // Not a candidate, and can never become one.
+        equalitiesLength = 0;
+        lastequality = null;
+      }
+      post_ins = post_del = false;
+    } else {  // An insertion or deletion.
+      if (diffs[pointer][0] == DIFF_DELETE) {
+        post_del = true;
+      } else {
+        post_ins = true;
+      }
+      /*
+       * Five types to be split:
+       * <ins>A</ins><del>B</del>XY<ins>C</ins><del>D</del>
+       * <ins>A</ins>X<ins>C</ins><del>D</del>
+       * <ins>A</ins><del>B</del>X<ins>C</ins>
+       * <ins>A</del>X<ins>C</ins><del>D</del>
+       * <ins>A</ins><del>B</del>X<del>C</del>
+       */
+      if (lastequality && ((pre_ins && pre_del && post_ins && post_del) ||
+                           ((lastequality.length < this.Diff_EditCost / 2) &&
+                            (pre_ins + pre_del + post_ins + post_del) == 3))) {
+        // Duplicate record.
+        diffs.splice(equalities[equalitiesLength - 1], 0,
+                     [DIFF_DELETE, lastequality]);
+        // Change second copy to insert.
+        diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT;
+        equalitiesLength--;  // Throw away the equality we just deleted;
+        lastequality = null;
+        if (pre_ins && pre_del) {
+          // No changes made which could affect previous entry, keep going.
+          post_ins = post_del = true;
+          equalitiesLength = 0;
+        } else {
+          equalitiesLength--;  // Throw away the previous equality.
+          pointer = equalitiesLength > 0 ?
+              equalities[equalitiesLength - 1] : -1;
+          post_ins = post_del = false;
+        }
+        changes = true;
+      }
+    }
+    pointer++;
+  }
+
+  if (changes) {
+    this.diff_cleanupMerge(diffs);
+  }
+};
+
+
+/**
+ * Reorder and merge like edit sections.  Merge equalities.
+ * Any edit section can move as long as it doesn't cross an equality.
+ * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
+ */
+diff_match_patch.prototype.diff_cleanupMerge = function(diffs) {
+  diffs.push([DIFF_EQUAL, '']);  // Add a dummy entry at the end.
+  var pointer = 0;
+  var count_delete = 0;
+  var count_insert = 0;
+  var text_delete = '';
+  var text_insert = '';
+  var commonlength;
+  while (pointer < diffs.length) {
+    switch (diffs[pointer][0]) {
+      case DIFF_INSERT:
+        count_insert++;
+        text_insert += diffs[pointer][1];
+        pointer++;
+        break;
+      case DIFF_DELETE:
+        count_delete++;
+        text_delete += diffs[pointer][1];
+        pointer++;
+        break;
+      case DIFF_EQUAL:
+        // Upon reaching an equality, check for prior redundancies.
+        if (count_delete + count_insert > 1) {
+          if (count_delete !== 0 && count_insert !== 0) {
+            // Factor out any common prefixies.
+            commonlength = this.diff_commonPrefix(text_insert, text_delete);
+            if (commonlength !== 0) {
+              if ((pointer - count_delete - count_insert) > 0 &&
+                  diffs[pointer - count_delete - count_insert - 1][0] ==
+                  DIFF_EQUAL) {
+                diffs[pointer - count_delete - count_insert - 1][1] +=
+                    text_insert.substring(0, commonlength);
+              } else {
+                diffs.splice(0, 0, [DIFF_EQUAL,
+                                    text_insert.substring(0, commonlength)]);
+                pointer++;
+              }
+              text_insert = text_insert.substring(commonlength);
+              text_delete = text_delete.substring(commonlength);
+            }
+            // Factor out any common suffixies.
+            commonlength = this.diff_commonSuffix(text_insert, text_delete);
+            if (commonlength !== 0) {
+              diffs[pointer][1] = text_insert.substring(text_insert.length -
+                  commonlength) + diffs[pointer][1];
+              text_insert = text_insert.substring(0, text_insert.length -
+                  commonlength);
+              text_delete = text_delete.substring(0, text_delete.length -
+                  commonlength);
+            }
+          }
+          // Delete the offending records and add the merged ones.
+          if (count_delete === 0) {
+            diffs.splice(pointer - count_insert,
+                count_delete + count_insert, [DIFF_INSERT, text_insert]);
+          } else if (count_insert === 0) {
+            diffs.splice(pointer - count_delete,
+                count_delete + count_insert, [DIFF_DELETE, text_delete]);
+          } else {
+            diffs.splice(pointer - count_delete - count_insert,
+                count_delete + count_insert, [DIFF_DELETE, text_delete],
+                [DIFF_INSERT, text_insert]);
+          }
+          pointer = pointer - count_delete - count_insert +
+                    (count_delete ? 1 : 0) + (count_insert ? 1 : 0) + 1;
+        } else if (pointer !== 0 && diffs[pointer - 1][0] == DIFF_EQUAL) {
+          // Merge this equality with the previous one.
+          diffs[pointer - 1][1] += diffs[pointer][1];
+          diffs.splice(pointer, 1);
+        } else {
+          pointer++;
+        }
+        count_insert = 0;
+        count_delete = 0;
+        text_delete = '';
+        text_insert = '';
+        break;
+    }
+  }
+  if (diffs[diffs.length - 1][1] === '') {
+    diffs.pop();  // Remove the dummy entry at the end.
+  }
+
+  // Second pass: look for single edits surrounded on both sides by equalities
+  // which can be shifted sideways to eliminate an equality.
+  // e.g: A<ins>BA</ins>C -> <ins>AB</ins>AC
+  var changes = false;
+  pointer = 1;
+  // Intentionally ignore the first and last element (don't need checking).
+  while (pointer < diffs.length - 1) {
+    if (diffs[pointer - 1][0] == DIFF_EQUAL &&
+        diffs[pointer + 1][0] == DIFF_EQUAL) {
+      // This is a single edit surrounded by equalities.
+      if (diffs[pointer][1].substring(diffs[pointer][1].length -
+          diffs[pointer - 1][1].length) == diffs[pointer - 1][1]) {
+        // Shift the edit over the previous equality.
+        diffs[pointer][1] = diffs[pointer - 1][1] +
+            diffs[pointer][1].substring(0, diffs[pointer][1].length -
+                                        diffs[pointer - 1][1].length);
+        diffs[pointer + 1][1] = diffs[pointer - 1][1] + diffs[pointer + 1][1];
+        diffs.splice(pointer - 1, 1);
+        changes = true;
+      } else if (diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) ==
+          diffs[pointer + 1][1]) {
+        // Shift the edit over the next equality.
+        diffs[pointer - 1][1] += diffs[pointer + 1][1];
+        diffs[pointer][1] =
+            diffs[pointer][1].substring(diffs[pointer + 1][1].length) +
+            diffs[pointer + 1][1];
+        diffs.splice(pointer + 1, 1);
+        changes = true;
+      }
+    }
+    pointer++;
+  }
+  // If shifts were made, the diff needs reordering and another shift sweep.
+  if (changes) {
+    this.diff_cleanupMerge(diffs);
+  }
+};
+
+
+/**
+ * loc is a location in text1, compute and return the equivalent location in
+ * text2.
+ * e.g. 'The cat' vs 'The big cat', 1->1, 5->8
+ * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
+ * @param {number} loc Location within text1.
+ * @return {number} Location within text2.
+ */
+diff_match_patch.prototype.diff_xIndex = function(diffs, loc) {
+  var chars1 = 0;
+  var chars2 = 0;
+  var last_chars1 = 0;
+  var last_chars2 = 0;
+  var x;
+  for (x = 0; x < diffs.length; x++) {
+    if (diffs[x][0] !== DIFF_INSERT) {  // Equality or deletion.
+      chars1 += diffs[x][1].length;
+    }
+    if (diffs[x][0] !== DIFF_DELETE) {  // Equality or insertion.
+      chars2 += diffs[x][1].length;
+    }
+    if (chars1 > loc) {  // Overshot the location.
+      break;
+    }
+    last_chars1 = chars1;
+    last_chars2 = chars2;
+  }
+  // Was the location was deleted?
+  if (diffs.length != x && diffs[x][0] === DIFF_DELETE) {
+    return last_chars2;
+  }
+  // Add the remaining character length.
+  return last_chars2 + (loc - last_chars1);
+};
+
+
+/**
+ * Convert a diff array into a pretty HTML report.
+ * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
+ * @return {string} HTML representation.
+ */
+diff_match_patch.prototype.diff_prettyHtml = function(diffs) {
+  var html = [];
+  var pattern_amp = /&/g;
+  var pattern_lt = /</g;
+  var pattern_gt = />/g;
+  var pattern_para = /\n/g;
+  for (var x = 0; x < diffs.length; x++) {
+    var op = diffs[x][0];    // Operation (insert, delete, equal)
+    var data = diffs[x][1];  // Text of change.
+    var text = data.replace(pattern_amp, '&amp;').replace(pattern_lt, '&lt;')
+        .replace(pattern_gt, '&gt;').replace(pattern_para, '&para;<br>');
+    switch (op) {
+      case DIFF_INSERT:
+        html[x] = '<ins style="background:#e6ffe6;">' + text + '</ins>';
+        break;
+      case DIFF_DELETE:
+        html[x] = '<del style="background:#ffe6e6;">' + text + '</del>';
+        break;
+      case DIFF_EQUAL:
+        html[x] = '<span>' + text + '</span>';
+        break;
+    }
+  }
+  return html.join('');
+};
+
+
+/**
+ * Compute and return the source text (all equalities and deletions).
+ * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
+ * @return {string} Source text.
+ */
+diff_match_patch.prototype.diff_text1 = function(diffs) {
+  var text = [];
+  for (var x = 0; x < diffs.length; x++) {
+    if (diffs[x][0] !== DIFF_INSERT) {
+      text[x] = diffs[x][1];
+    }
+  }
+  return text.join('');
+};
+
+
+/**
+ * Compute and return the destination text (all equalities and insertions).
+ * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
+ * @return {string} Destination text.
+ */
+diff_match_patch.prototype.diff_text2 = function(diffs) {
+  var text = [];
+  for (var x = 0; x < diffs.length; x++) {
+    if (diffs[x][0] !== DIFF_DELETE) {
+      text[x] = diffs[x][1];
+    }
+  }
+  return text.join('');
+};
+
+
+/**
+ * Compute the Levenshtein distance; the number of inserted, deleted or
+ * substituted characters.
+ * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
+ * @return {number} Number of changes.
+ */
+diff_match_patch.prototype.diff_levenshtein = function(diffs) {
+  var levenshtein = 0;
+  var insertions = 0;
+  var deletions = 0;
+  for (var x = 0; x < diffs.length; x++) {
+    var op = diffs[x][0];
+    var data = diffs[x][1];
+    switch (op) {
+      case DIFF_INSERT:
+        insertions += data.length;
+        break;
+      case DIFF_DELETE:
+        deletions += data.length;
+        break;
+      case DIFF_EQUAL:
+        // A deletion and an insertion is one substitution.
+        levenshtein += Math.max(insertions, deletions);
+        insertions = 0;
+        deletions = 0;
+        break;
+    }
+  }
+  levenshtein += Math.max(insertions, deletions);
+  return levenshtein;
+};
+
+
+/**
+ * Crush the diff into an encoded string which describes the operations
+ * required to transform text1 into text2.
+ * E.g. =3\t-2\t+ing  -> Keep 3 chars, delete 2 chars, insert 'ing'.
+ * Operations are tab-separated.  Inserted text is escaped using %xx notation.
+ * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
+ * @return {string} Delta text.
+ */
+diff_match_patch.prototype.diff_toDelta = function(diffs) {
+  var text = [];
+  for (var x = 0; x < diffs.length; x++) {
+    switch (diffs[x][0]) {
+      case DIFF_INSERT:
+        text[x] = '+' + encodeURI(diffs[x][1]);
+        break;
+      case DIFF_DELETE:
+        text[x] = '-' + diffs[x][1].length;
+        break;
+      case DIFF_EQUAL:
+        text[x] = '=' + diffs[x][1].length;
+        break;
+    }
+  }
+  return text.join('\t').replace(/%20/g, ' ');
+};
+
+
+/**
+ * Given the original text1, and an encoded string which describes the
+ * operations required to transform text1 into text2, compute the full diff.
+ * @param {string} text1 Source string for the diff.
+ * @param {string} delta Delta text.
+ * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.
+ * @throws {!Error} If invalid input.
+ */
+diff_match_patch.prototype.diff_fromDelta = function(text1, delta) {
+  var diffs = [];
+  var diffsLength = 0;  // Keeping our own length var is faster in JS.
+  var pointer = 0;  // Cursor in text1
+  var tokens = delta.split(/\t/g);
+  for (var x = 0; x < tokens.length; x++) {
+    // Each token begins with a one character parameter which specifies the
+    // operation of this token (delete, insert, equality).
+    var param = tokens[x].substring(1);
+    switch (tokens[x].charAt(0)) {
+      case '+':
+        try {
+          diffs[diffsLength++] = [DIFF_INSERT, decodeURI(param)];
+        } catch (ex) {
+          // Malformed URI sequence.
+          throw new Error('Illegal escape in diff_fromDelta: ' + param);
+        }
+        break;
+      case '-':
+        // Fall through.
+      case '=':
+        var n = parseInt(param, 10);
+        if (isNaN(n) || n < 0) {
+          throw new Error('Invalid number in diff_fromDelta: ' + param);
+        }
+        var text = text1.substring(pointer, pointer += n);
+        if (tokens[x].charAt(0) == '=') {
+          diffs[diffsLength++] = [DIFF_EQUAL, text];
+        } else {
+          diffs[diffsLength++] = [DIFF_DELETE, text];
+        }
+        break;
+      default:
+        // Blank tokens are ok (from a trailing \t).
+        // Anything else is an error.
+        if (tokens[x]) {
+          throw new Error('Invalid diff operation in diff_fromDelta: ' +
+                          tokens[x]);
+        }
+    }
+  }
+  if (pointer != text1.length) {
+    throw new Error('Delta length (' + pointer +
+        ') does not equal source text length (' + text1.length + ').');
+  }
+  return diffs;
+};
+
+
+//  MATCH FUNCTIONS
+
+
+/**
+ * Locate the best instance of 'pattern' in 'text' near 'loc'.
+ * @param {string} text The text to search.
+ * @param {string} pattern The pattern to search for.
+ * @param {number} loc The location to search around.
+ * @return {number} Best match index or -1.
+ */
+diff_match_patch.prototype.match_main = function(text, pattern, loc) {
+  // Check for null inputs.
+  if (text == null || pattern == null || loc == null) {
+    throw new Error('Null input. (match_main)');
+  }
+
+  loc = Math.max(0, Math.min(loc, text.length));
+  if (text == pattern) {
+    // Shortcut (potentially not guaranteed by the algorithm)
+    return 0;
+  } else if (!text.length) {
+    // Nothing to match.
+    return -1;
+  } else if (text.substring(loc, loc + pattern.length) == pattern) {
+    // Perfect match at the perfect spot!  (Includes case of null pattern)
+    return loc;
+  } else {
+    // Do a fuzzy compare.
+    return this.match_bitap_(text, pattern, loc);
+  }
+};
+
+
+/**
+ * Locate the best instance of 'pattern' in 'text' near 'loc' using the
+ * Bitap algorithm.
+ * @param {string} text The text to search.
+ * @param {string} pattern The pattern to search for.
+ * @param {number} loc The location to search around.
+ * @return {number} Best match index or -1.
+ * @private
+ */
+diff_match_patch.prototype.match_bitap_ = function(text, pattern, loc) {
+  if (pattern.length > this.Match_MaxBits) {
+    throw new Error('Pattern too long for this browser.');
+  }
+
+  // Initialise the alphabet.
+  var s = this.match_alphabet_(pattern);
+
+  var dmp = this;  // 'this' becomes 'window' in a closure.
+
+  /**
+   * Compute and return the score for a match with e errors and x location.
+   * Accesses loc and pattern through being a closure.
+   * @param {number} e Number of errors in match.
+   * @param {number} x Location of match.
+   * @return {number} Overall score for match (0.0 = good, 1.0 = bad).
+   * @private
+   */
+  function match_bitapScore_(e, x) {
+    var accuracy = e / pattern.length;
+    var proximity = Math.abs(loc - x);
+    if (!dmp.Match_Distance) {
+      // Dodge divide by zero error.
+      return proximity ? 1.0 : accuracy;
+    }
+    return accuracy + (proximity / dmp.Match_Distance);
+  }
+
+  // Highest score beyond which we give up.
+  var score_threshold = this.Match_Threshold;
+  // Is there a nearby exact match? (speedup)
+  var best_loc = text.indexOf(pattern, loc);
+  if (best_loc != -1) {
+    score_threshold = Math.min(match_bitapScore_(0, best_loc), score_threshold);
+    // What about in the other direction? (speedup)
+    best_loc = text.lastIndexOf(pattern, loc + pattern.length);
+    if (best_loc != -1) {
+      score_threshold =
+          Math.min(match_bitapScore_(0, best_loc), score_threshold);
+    }
+  }
+
+  // Initialise the bit arrays.
+  var matchmask = 1 << (pattern.length - 1);
+  best_loc = -1;
+
+  var bin_min, bin_mid;
+  var bin_max = pattern.length + text.length;
+  var last_rd;
+  for (var d = 0; d < pattern.length; d++) {
+    // Scan for the best match; each iteration allows for one more error.
+    // Run a binary search to determine how far from 'loc' we can stray at this
+    // error level.
+    bin_min = 0;
+    bin_mid = bin_max;
+    while (bin_min < bin_mid) {
+      if (match_bitapScore_(d, loc + bin_mid) <= score_threshold) {
+        bin_min = bin_mid;
+      } else {
+        bin_max = bin_mid;
+      }
+      bin_mid = Math.floor((bin_max - bin_min) / 2 + bin_min);
+    }
+    // Use the result from this iteration as the maximum for the next.
+    bin_max = bin_mid;
+    var start = Math.max(1, loc - bin_mid + 1);
+    var finish = Math.min(loc + bin_mid, text.length) + pattern.length;
+
+    var rd = Array(finish + 2);
+    rd[finish + 1] = (1 << d) - 1;
+    for (var j = finish; j >= start; j--) {
+      // The alphabet (s) is a sparse hash, so the following line generates
+      // warnings.
+      var charMatch = s[text.charAt(j - 1)];
+      if (d === 0) {  // First pass: exact match.
+        rd[j] = ((rd[j + 1] << 1) | 1) & charMatch;
+      } else {  // Subsequent passes: fuzzy match.
+        rd[j] = (((rd[j + 1] << 1) | 1) & charMatch) |
+                (((last_rd[j + 1] | last_rd[j]) << 1) | 1) |
+                last_rd[j + 1];
+      }
+      if (rd[j] & matchmask) {
+        var score = match_bitapScore_(d, j - 1);
+        // This match will almost certainly be better than any existing match.
+        // But check anyway.
+        if (score <= score_threshold) {
+          // Told you so.
+          score_threshold = score;
+          best_loc = j - 1;
+          if (best_loc > loc) {
+            // When passing loc, don't exceed our current distance from loc.
+            start = Math.max(1, 2 * loc - best_loc);
+          } else {
+            // Already passed loc, downhill from here on in.
+            break;
+          }
+        }
+      }
+    }
+    // No hope for a (better) match at greater error levels.
+    if (match_bitapScore_(d + 1, loc) > score_threshold) {
+      break;
+    }
+    last_rd = rd;
+  }
+  return best_loc;
+};
+
+
+/**
+ * Initialise the alphabet for the Bitap algorithm.
+ * @param {string} pattern The text to encode.
+ * @return {!Object} Hash of character locations.
+ * @private
+ */
+diff_match_patch.prototype.match_alphabet_ = function(pattern) {
+  var s = {};
+  for (var i = 0; i < pattern.length; i++) {
+    s[pattern.charAt(i)] = 0;
+  }
+  for (var i = 0; i < pattern.length; i++) {
+    s[pattern.charAt(i)] |= 1 << (pattern.length - i - 1);
+  }
+  return s;
+};
+
+
+//  PATCH FUNCTIONS
+
+
+/**
+ * Increase the context until it is unique,
+ * but don't let the pattern expand beyond Match_MaxBits.
+ * @param {!diff_match_patch.patch_obj} patch The patch to grow.
+ * @param {string} text Source text.
+ * @private
+ */
+diff_match_patch.prototype.patch_addContext_ = function(patch, text) {
+  if (text.length == 0) {
+    return;
+  }
+  var pattern = text.substring(patch.start2, patch.start2 + patch.length1);
+  var padding = 0;
+
+  // Look for the first and last matches of pattern in text.  If two different
+  // matches are found, increase the pattern length.
+  while (text.indexOf(pattern) != text.lastIndexOf(pattern) &&
+         pattern.length < this.Match_MaxBits - this.Patch_Margin -
+         this.Patch_Margin) {
+    padding += this.Patch_Margin;
+    pattern = text.substring(patch.start2 - padding,
+                             patch.start2 + patch.length1 + padding);
+  }
+  // Add one chunk for good luck.
+  padding += this.Patch_Margin;
+
+  // Add the prefix.
+  var prefix = text.substring(patch.start2 - padding, patch.start2);
+  if (prefix) {
+    patch.diffs.unshift([DIFF_EQUAL, prefix]);
+  }
+  // Add the suffix.
+  var suffix = text.substring(patch.start2 + patch.length1,
+                              patch.start2 + patch.length1 + padding);
+  if (suffix) {
+    patch.diffs.push([DIFF_EQUAL, suffix]);
+  }
+
+  // Roll back the start points.
+  patch.start1 -= prefix.length;
+  patch.start2 -= prefix.length;
+  // Extend the lengths.
+  patch.length1 += prefix.length + suffix.length;
+  patch.length2 += prefix.length + suffix.length;
+};
+
+
+/**
+ * Compute a list of patches to turn text1 into text2.
+ * Use diffs if provided, otherwise compute it ourselves.
+ * There are four ways to call this function, depending on what data is
+ * available to the caller:
+ * Method 1:
+ * a = text1, b = text2
+ * Method 2:
+ * a = diffs
+ * Method 3 (optimal):
+ * a = text1, b = diffs
+ * Method 4 (deprecated, use method 3):
+ * a = text1, b = text2, c = diffs
+ *
+ * @param {string|!Array.<!diff_match_patch.Diff>} a text1 (methods 1,3,4) or
+ * Array of diff tuples for text1 to text2 (method 2).
+ * @param {string|!Array.<!diff_match_patch.Diff>} opt_b text2 (methods 1,4) or
+ * Array of diff tuples for text1 to text2 (method 3) or undefined (method 2).
+ * @param {string|!Array.<!diff_match_patch.Diff>} opt_c Array of diff tuples
+ * for text1 to text2 (method 4) or undefined (methods 1,2,3).
+ * @return {!Array.<!diff_match_patch.patch_obj>} Array of Patch objects.
+ */
+diff_match_patch.prototype.patch_make = function(a, opt_b, opt_c) {
+  var text1, diffs;
+  if (typeof a == 'string' && typeof opt_b == 'string' &&
+      typeof opt_c == 'undefined') {
+    // Method 1: text1, text2
+    // Compute diffs from text1 and text2.
+    text1 = /** @type {string} */(a);
+    diffs = this.diff_main(text1, /** @type {string} */(opt_b), true);
+    if (diffs.length > 2) {
+      this.diff_cleanupSemantic(diffs);
+      this.diff_cleanupEfficiency(diffs);
+    }
+  } else if (a && typeof a == 'object' && typeof opt_b == 'undefined' &&
+      typeof opt_c == 'undefined') {
+    // Method 2: diffs
+    // Compute text1 from diffs.
+    diffs = /** @type {!Array.<!diff_match_patch.Diff>} */(a);
+    text1 = this.diff_text1(diffs);
+  } else if (typeof a == 'string' && opt_b && typeof opt_b == 'object' &&
+      typeof opt_c == 'undefined') {
+    // Method 3: text1, diffs
+    text1 = /** @type {string} */(a);
+    diffs = /** @type {!Array.<!diff_match_patch.Diff>} */(opt_b);
+  } else if (typeof a == 'string' && typeof opt_b == 'string' &&
+      opt_c && typeof opt_c == 'object') {
+    // Method 4: text1, text2, diffs
+    // text2 is not used.
+    text1 = /** @type {string} */(a);
+    diffs = /** @type {!Array.<!diff_match_patch.Diff>} */(opt_c);
+  } else {
+    throw new Error('Unknown call format to patch_make.');
+  }
+
+  if (diffs.length === 0) {
+    return [];  // Get rid of the null case.
+  }
+  var patches = [];
+  var patch = new diff_match_patch.patch_obj();
+  var patchDiffLength = 0;  // Keeping our own length var is faster in JS.
+  var char_count1 = 0;  // Number of characters into the text1 string.
+  var char_count2 = 0;  // Number of characters into the text2 string.
+  // Start with text1 (prepatch_text) and apply the diffs until we arrive at
+  // text2 (postpatch_text).  We recreate the patches one by one to determine
+  // context info.
+  var prepatch_text = text1;
+  var postpatch_text = text1;
+  for (var x = 0; x < diffs.length; x++) {
+    var diff_type = diffs[x][0];
+    var diff_text = diffs[x][1];
+
+    if (!patchDiffLength && diff_type !== DIFF_EQUAL) {
+      // A new patch starts here.
+      patch.start1 = char_count1;
+      patch.start2 = char_count2;
+    }
+
+    switch (diff_type) {
+      case DIFF_INSERT:
+        patch.diffs[patchDiffLength++] = diffs[x];
+        patch.length2 += diff_text.length;
+        postpatch_text = postpatch_text.substring(0, char_count2) + diff_text +
+                         postpatch_text.substring(char_count2);
+        break;
+      case DIFF_DELETE:
+        patch.length1 += diff_text.length;
+        patch.diffs[patchDiffLength++] = diffs[x];
+        postpatch_text = postpatch_text.substring(0, char_count2) +
+                         postpatch_text.substring(char_count2 +
+                             diff_text.length);
+        break;
+      case DIFF_EQUAL:
+        if (diff_text.length <= 2 * this.Patch_Margin &&
+            patchDiffLength && diffs.length != x + 1) {
+          // Small equality inside a patch.
+          patch.diffs[patchDiffLength++] = diffs[x];
+          patch.length1 += diff_text.length;
+          patch.length2 += diff_text.length;
+        } else if (diff_text.length >= 2 * this.Patch_Margin) {
+          // Time for a new patch.
+          if (patchDiffLength) {
+            this.patch_addContext_(patch, prepatch_text);
+            patches.push(patch);
+            patch = new diff_match_patch.patch_obj();
+            patchDiffLength = 0;
+            // Unlike Unidiff, our patch lists have a rolling context.
+            // http://code.google.com/p/google-diff-match-patch/wiki/Unidiff
+            // Update prepatch text & pos to reflect the application of the
+            // just completed patch.
+            prepatch_text = postpatch_text;
+            char_count1 = char_count2;
+          }
+        }
+        break;
+    }
+
+    // Update the current character count.
+    if (diff_type !== DIFF_INSERT) {
+      char_count1 += diff_text.length;
+    }
+    if (diff_type !== DIFF_DELETE) {
+      char_count2 += diff_text.length;
+    }
+  }
+  // Pick up the leftover patch if not empty.
+  if (patchDiffLength) {
+    this.patch_addContext_(patch, prepatch_text);
+    patches.push(patch);
+  }
+
+  return patches;
+};
+
+
+/**
+ * Given an array of patches, return another array that is identical.
+ * @param {!Array.<!diff_match_patch.patch_obj>} patches Array of Patch objects.
+ * @return {!Array.<!diff_match_patch.patch_obj>} Array of Patch objects.
+ */
+diff_match_patch.prototype.patch_deepCopy = function(patches) {
+  // Making deep copies is hard in JavaScript.
+  var patchesCopy = [];
+  for (var x = 0; x < patches.length; x++) {
+    var patch = patches[x];
+    var patchCopy = new diff_match_patch.patch_obj();
+    patchCopy.diffs = [];
+    for (var y = 0; y < patch.diffs.length; y++) {
+      patchCopy.diffs[y] = patch.diffs[y].slice();
+    }
+    patchCopy.start1 = patch.start1;
+    patchCopy.start2 = patch.start2;
+    patchCopy.length1 = patch.length1;
+    patchCopy.length2 = patch.length2;
+    patchesCopy[x] = patchCopy;
+  }
+  return patchesCopy;
+};
+
+
+/**
+ * Merge a set of patches onto the text.  Return a patched text, as well
+ * as a list of true/false values indicating which patches were applied.
+ * @param {!Array.<!diff_match_patch.patch_obj>} patches Array of Patch objects.
+ * @param {string} text Old text.
+ * @return {!Array.<string|!Array.<boolean>>} Two element Array, containing the
+ *      new text and an array of boolean values.
+ */
+diff_match_patch.prototype.patch_apply = function(patches, text) {
+  if (patches.length == 0) {
+    return [text, []];
+  }
+
+  // Deep copy the patches so that no changes are made to originals.
+  patches = this.patch_deepCopy(patches);
+
+  var nullPadding = this.patch_addPadding(patches);
+  text = nullPadding + text + nullPadding;
+
+  this.patch_splitMax(patches);
+  // delta keeps track of the offset between the expected and actual location
+  // of the previous patch.  If there are patches expected at positions 10 and
+  // 20, but the first patch was found at 12, delta is 2 and the second patch
+  // has an effective expected position of 22.
+  var delta = 0;
+  var results = [];
+  for (var x = 0; x < patches.length; x++) {
+    var expected_loc = patches[x].start2 + delta;
+    var text1 = this.diff_text1(patches[x].diffs);
+    var start_loc;
+    var end_loc = -1;
+    if (text1.length > this.Match_MaxBits) {
+      // patch_splitMax will only provide an oversized pattern in the case of
+      // a monster delete.
+      start_loc = this.match_main(text, text1.substring(0, this.Match_MaxBits),
+                                  expected_loc);
+      if (start_loc != -1) {
+        end_loc = this.match_main(text,
+            text1.substring(text1.length - this.Match_MaxBits),
+            expected_loc + text1.length - this.Match_MaxBits);
+        if (end_loc == -1 || start_loc >= end_loc) {
+          // Can't find valid trailing context.  Drop this patch.
+          start_loc = -1;
+        }
+      }
+    } else {
+      start_loc = this.match_main(text, text1, expected_loc);
+    }
+    if (start_loc == -1) {
+      // No match found.  :(
+      results[x] = false;
+      // Subtract the delta for this failed patch from subsequent patches.
+      delta -= patches[x].length2 - patches[x].length1;
+    } else {
+      // Found a match.  :)
+      results[x] = true;
+      delta = start_loc - expected_loc;
+      var text2;
+      if (end_loc == -1) {
+        text2 = text.substring(start_loc, start_loc + text1.length);
+      } else {
+        text2 = text.substring(start_loc, end_loc + this.Match_MaxBits);
+      }
+      if (text1 == text2) {
+        // Perfect match, just shove the replacement text in.
+        text = text.substring(0, start_loc) +
+               this.diff_text2(patches[x].diffs) +
+               text.substring(start_loc + text1.length);
+      } else {
+        // Imperfect match.  Run a diff to get a framework of equivalent
+        // indices.
+        var diffs = this.diff_main(text1, text2, false);
+        if (text1.length > this.Match_MaxBits &&
+            this.diff_levenshtein(diffs) / text1.length >
+            this.Patch_DeleteThreshold) {
+          // The end points match, but the content is unacceptably bad.
+          results[x] = false;
+        } else {
+          this.diff_cleanupSemanticLossless(diffs);
+          var index1 = 0;
+          var index2;
+          for (var y = 0; y < patches[x].diffs.length; y++) {
+            var mod = patches[x].diffs[y];
+            if (mod[0] !== DIFF_EQUAL) {
+              index2 = this.diff_xIndex(diffs, index1);
+            }
+            if (mod[0] === DIFF_INSERT) {  // Insertion
+              text = text.substring(0, start_loc + index2) + mod[1] +
+                     text.substring(start_loc + index2);
+            } else if (mod[0] === DIFF_DELETE) {  // Deletion
+              text = text.substring(0, start_loc + index2) +
+                     text.substring(start_loc + this.diff_xIndex(diffs,
+                         index1 + mod[1].length));
+            }
+            if (mod[0] !== DIFF_DELETE) {
+              index1 += mod[1].length;
+            }
+          }
+        }
+      }
+    }
+  }
+  // Strip the padding off.
+  text = text.substring(nullPadding.length, text.length - nullPadding.length);
+  return [text, results];
+};
+
+
+/**
+ * Add some padding on text start and end so that edges can match something.
+ * Intended to be called only from within patch_apply.
+ * @param {!Array.<!diff_match_patch.patch_obj>} patches Array of Patch objects.
+ * @return {string} The padding string added to each side.
+ */
+diff_match_patch.prototype.patch_addPadding = function(patches) {
+  var paddingLength = this.Patch_Margin;
+  var nullPadding = '';
+  for (var x = 1; x <= paddingLength; x++) {
+    nullPadding += String.fromCharCode(x);
+  }
+
+  // Bump all the patches forward.
+  for (var x = 0; x < patches.length; x++) {
+    patches[x].start1 += paddingLength;
+    patches[x].start2 += paddingLength;
+  }
+
+  // Add some padding on start of first diff.
+  var patch = patches[0];
+  var diffs = patch.diffs;
+  if (diffs.length == 0 || diffs[0][0] != DIFF_EQUAL) {
+    // Add nullPadding equality.
+    diffs.unshift([DIFF_EQUAL, nullPadding]);
+    patch.start1 -= paddingLength;  // Should be 0.
+    patch.start2 -= paddingLength;  // Should be 0.
+    patch.length1 += paddingLength;
+    patch.length2 += paddingLength;
+  } else if (paddingLength > diffs[0][1].length) {
+    // Grow first equality.
+    var extraLength = paddingLength - diffs[0][1].length;
+    diffs[0][1] = nullPadding.substring(diffs[0][1].length) + diffs[0][1];
+    patch.start1 -= extraLength;
+    patch.start2 -= extraLength;
+    patch.length1 += extraLength;
+    patch.length2 += extraLength;
+  }
+
+  // Add some padding on end of last diff.
+  patch = patches[patches.length - 1];
+  diffs = patch.diffs;
+  if (diffs.length == 0 || diffs[diffs.length - 1][0] != DIFF_EQUAL) {
+    // Add nullPadding equality.
+    diffs.push([DIFF_EQUAL, nullPadding]);
+    patch.length1 += paddingLength;
+    patch.length2 += paddingLength;
+  } else if (paddingLength > diffs[diffs.length - 1][1].length) {
+    // Grow last equality.
+    var extraLength = paddingLength - diffs[diffs.length - 1][1].length;
+    diffs[diffs.length - 1][1] += nullPadding.substring(0, extraLength);
+    patch.length1 += extraLength;
+    patch.length2 += extraLength;
+  }
+
+  return nullPadding;
+};
+
+
+/**
+ * Look through the patches and break up any which are longer than the maximum
+ * limit of the match algorithm.
+ * Intended to be called only from within patch_apply.
+ * @param {!Array.<!diff_match_patch.patch_obj>} patches Array of Patch objects.
+ */
+diff_match_patch.prototype.patch_splitMax = function(patches) {
+  var patch_size = this.Match_MaxBits;
+  for (var x = 0; x < patches.length; x++) {
+    if (patches[x].length1 <= patch_size) {
+      continue;
+    }
+    var bigpatch = patches[x];
+    // Remove the big old patch.
+    patches.splice(x--, 1);
+    var start1 = bigpatch.start1;
+    var start2 = bigpatch.start2;
+    var precontext = '';
+    while (bigpatch.diffs.length !== 0) {
+      // Create one of several smaller patches.
+      var patch = new diff_match_patch.patch_obj();
+      var empty = true;
+      patch.start1 = start1 - precontext.length;
+      patch.start2 = start2 - precontext.length;
+      if (precontext !== '') {
+        patch.length1 = patch.length2 = precontext.length;
+        patch.diffs.push([DIFF_EQUAL, precontext]);
+      }
+      while (bigpatch.diffs.length !== 0 &&
+             patch.length1 < patch_size - this.Patch_Margin) {
+        var diff_type = bigpatch.diffs[0][0];
+        var diff_text = bigpatch.diffs[0][1];
+        if (diff_type === DIFF_INSERT) {
+          // Insertions are harmless.
+          patch.length2 += diff_text.length;
+          start2 += diff_text.length;
+          patch.diffs.push(bigpatch.diffs.shift());
+          empty = false;
+        } else if (diff_type === DIFF_DELETE && patch.diffs.length == 1 &&
+                   patch.diffs[0][0] == DIFF_EQUAL &&
+                   diff_text.length > 2 * patch_size) {
+          // This is a large deletion.  Let it pass in one chunk.
+          patch.length1 += diff_text.length;
+          start1 += diff_text.length;
+          empty = false;
+          patch.diffs.push([diff_type, diff_text]);
+          bigpatch.diffs.shift();
+        } else {
+          // Deletion or equality.  Only take as much as we can stomach.
+          diff_text = diff_text.substring(0,
+              patch_size - patch.length1 - this.Patch_Margin);
+          patch.length1 += diff_text.length;
+          start1 += diff_text.length;
+          if (diff_type === DIFF_EQUAL) {
+            patch.length2 += diff_text.length;
+            start2 += diff_text.length;
+          } else {
+            empty = false;
+          }
+          patch.diffs.push([diff_type, diff_text]);
+          if (diff_text == bigpatch.diffs[0][1]) {
+            bigpatch.diffs.shift();
+          } else {
+            bigpatch.diffs[0][1] =
+                bigpatch.diffs[0][1].substring(diff_text.length);
+          }
+        }
+      }
+      // Compute the head context for the next patch.
+      precontext = this.diff_text2(patch.diffs);
+      precontext =
+          precontext.substring(precontext.length - this.Patch_Margin);
+      // Append the end context for this patch.
+      var postcontext = this.diff_text1(bigpatch.diffs)
+                            .substring(0, this.Patch_Margin);
+      if (postcontext !== '') {
+        patch.length1 += postcontext.length;
+        patch.length2 += postcontext.length;
+        if (patch.diffs.length !== 0 &&
+            patch.diffs[patch.diffs.length - 1][0] === DIFF_EQUAL) {
+          patch.diffs[patch.diffs.length - 1][1] += postcontext;
+        } else {
+          patch.diffs.push([DIFF_EQUAL, postcontext]);
+        }
+      }
+      if (!empty) {
+        patches.splice(++x, 0, patch);
+      }
+    }
+  }
+};
+
+
+/**
+ * Take a list of patches and return a textual representation.
+ * @param {!Array.<!diff_match_patch.patch_obj>} patches Array of Patch objects.
+ * @return {string} Text representation of patches.
+ */
+diff_match_patch.prototype.patch_toText = function(patches) {
+  var text = [];
+  for (var x = 0; x < patches.length; x++) {
+    text[x] = patches[x];
+  }
+  return text.join('');
+};
+
+
+/**
+ * Parse a textual representation of patches and return a list of Patch objects.
+ * @param {string} textline Text representation of patches.
+ * @return {!Array.<!diff_match_patch.patch_obj>} Array of Patch objects.
+ * @throws {!Error} If invalid input.
+ */
+diff_match_patch.prototype.patch_fromText = function(textline) {
+  var patches = [];
+  if (!textline) {
+    return patches;
+  }
+  var text = textline.split('\n');
+  var textPointer = 0;
+  var patchHeader = /^@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@$/;
+  while (textPointer < text.length) {
+    var m = text[textPointer].match(patchHeader);
+    if (!m) {
+      throw new Error('Invalid patch string: ' + text[textPointer]);
+    }
+    var patch = new diff_match_patch.patch_obj();
+    patches.push(patch);
+    patch.start1 = parseInt(m[1], 10);
+    if (m[2] === '') {
+      patch.start1--;
+      patch.length1 = 1;
+    } else if (m[2] == '0') {
+      patch.length1 = 0;
+    } else {
+      patch.start1--;
+      patch.length1 = parseInt(m[2], 10);
+    }
+
+    patch.start2 = parseInt(m[3], 10);
+    if (m[4] === '') {
+      patch.start2--;
+      patch.length2 = 1;
+    } else if (m[4] == '0') {
+      patch.length2 = 0;
+    } else {
+      patch.start2--;
+      patch.length2 = parseInt(m[4], 10);
+    }
+    textPointer++;
+
+    while (textPointer < text.length) {
+      var sign = text[textPointer].charAt(0);
+      try {
+        var line = decodeURI(text[textPointer].substring(1));
+      } catch (ex) {
+        // Malformed URI sequence.
+        throw new Error('Illegal escape in patch_fromText: ' + line);
+      }
+      if (sign == '-') {
+        // Deletion.
+        patch.diffs.push([DIFF_DELETE, line]);
+      } else if (sign == '+') {
+        // Insertion.
+        patch.diffs.push([DIFF_INSERT, line]);
+      } else if (sign == ' ') {
+        // Minor equality.
+        patch.diffs.push([DIFF_EQUAL, line]);
+      } else if (sign == '@') {
+        // Start of next patch.
+        break;
+      } else if (sign === '') {
+        // Blank line?  Whatever.
+      } else {
+        // WTF?
+        throw new Error('Invalid patch mode "' + sign + '" in: ' + line);
+      }
+      textPointer++;
+    }
+  }
+  return patches;
+};
+
+
+/**
+ * Class representing one patch operation.
+ * @constructor
+ */
+diff_match_patch.patch_obj = function() {
+  /** @type {!Array.<!diff_match_patch.Diff>} */
+  this.diffs = [];
+  /** @type {?number} */
+  this.start1 = null;
+  /** @type {?number} */
+  this.start2 = null;
+  /** @type {number} */
+  this.length1 = 0;
+  /** @type {number} */
+  this.length2 = 0;
+};
+
+
+/**
+ * Emmulate GNU diff's format.
+ * Header: @@ -382,8 +481,9 @@
+ * Indicies are printed as 1-based, not 0-based.
+ * @return {string} The GNU diff string.
+ */
+diff_match_patch.patch_obj.prototype.toString = function() {
+  var coords1, coords2;
+  if (this.length1 === 0) {
+    coords1 = this.start1 + ',0';
+  } else if (this.length1 == 1) {
+    coords1 = this.start1 + 1;
+  } else {
+    coords1 = (this.start1 + 1) + ',' + this.length1;
+  }
+  if (this.length2 === 0) {
+    coords2 = this.start2 + ',0';
+  } else if (this.length2 == 1) {
+    coords2 = this.start2 + 1;
+  } else {
+    coords2 = (this.start2 + 1) + ',' + this.length2;
+  }
+  var text = ['@@ -' + coords1 + ' +' + coords2 + ' @@\n'];
+  var op;
+  // Escape the body of the patch with %xx notation.
+  for (var x = 0; x < this.diffs.length; x++) {
+    switch (this.diffs[x][0]) {
+      case DIFF_INSERT:
+        op = '+';
+        break;
+      case DIFF_DELETE:
+        op = '-';
+        break;
+      case DIFF_EQUAL:
+        op = ' ';
+        break;
+    }
+    text[x + 1] = op + encodeURI(this.diffs[x][1]) + '\n';
+  }
+  return text.join('').replace(/%20/g, ' ');
+};
+
+
+// Export these global variables so that they survive Google's JS compiler.
+// In a browser, 'this' will be 'window'.
+// Users of node.js should 'require' the uncompressed version since Google's
+// JS compiler may break the following exports for non-browser environments.
+this['diff_match_patch'] = diff_match_patch;
+this['DIFF_DELETE'] = DIFF_DELETE;
+this['DIFF_INSERT'] = DIFF_INSERT;
+this['DIFF_EQUAL'] = DIFF_EQUAL;
+
+},{}],39:[function(_dereq_,module,exports){
+'use strict';
+
+// modified from https://github.com/es-shims/es5-shim
+var has = Object.prototype.hasOwnProperty;
+var toStr = Object.prototype.toString;
+var isArgs = _dereq_('./isArguments');
+var hasDontEnumBug = !({ 'toString': null }).propertyIsEnumerable('toString');
+var hasProtoEnumBug = function () {}.propertyIsEnumerable('prototype');
+var dontEnums = [
+	'toString',
+	'toLocaleString',
+	'valueOf',
+	'hasOwnProperty',
+	'isPrototypeOf',
+	'propertyIsEnumerable',
+	'constructor'
+];
+
+var keysShim = function keys(object) {
+	var isObject = object !== null && typeof object === 'object';
+	var isFunction = toStr.call(object) === '[object Function]';
+	var isArguments = isArgs(object);
+	var isString = isObject && toStr.call(object) === '[object String]';
+	var theKeys = [];
+
+	if (!isObject && !isFunction && !isArguments) {
+		throw new TypeError('Object.keys called on a non-object');
+	}
+
+	var skipProto = hasProtoEnumBug && isFunction;
+	if (isString && object.length > 0 && !has.call(object, 0)) {
+		for (var i = 0; i < object.length; ++i) {
+			theKeys.push(String(i));
+		}
+	}
+
+	if (isArguments && object.length > 0) {
+		for (var j = 0; j < object.length; ++j) {
+			theKeys.push(String(j));
+		}
+	} else {
+		for (var name in object) {
+			if (!(skipProto && name === 'prototype') && has.call(object, name)) {
+				theKeys.push(String(name));
+			}
+		}
+	}
+
+	if (hasDontEnumBug) {
+		var ctor = object.constructor;
+		var skipConstructor = ctor && ctor.prototype === object;
+
+		for (var k = 0; k < dontEnums.length; ++k) {
+			if (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) {
+				theKeys.push(dontEnums[k]);
+			}
+		}
+	}
+	return theKeys;
+};
+
+keysShim.shim = function shimObjectKeys() {
+	if (!Object.keys) {
+		Object.keys = keysShim;
+	}
+	return Object.keys || keysShim;
+};
+
+module.exports = keysShim;
+
+},{"./isArguments":40}],40:[function(_dereq_,module,exports){
+'use strict';
+
+var toStr = Object.prototype.toString;
+
+module.exports = function isArguments(value) {
+	var str = toStr.call(value);
+	var isArgs = str === '[object Arguments]';
+	if (!isArgs) {
+		isArgs = str !== '[object Array]'
+			&& value !== null
+			&& typeof value === 'object'
+			&& typeof value.length === 'number'
+			&& value.length >= 0
+			&& toStr.call(value.callee) === '[object Function]';
+	}
+	return isArgs;
+};
+
+},{}],41:[function(_dereq_,module,exports){
+/**
+ * stringifier
+ * 
+ * https://github.com/twada/stringifier
+ *
+ * Copyright (c) 2014-2015 Takuto Wada
+ * Licensed under the MIT license.
+ *   http://twada.mit-license.org/2014-2015
+ */
+'use strict';
+
+var traverse = _dereq_('traverse'),
+    typeName = _dereq_('type-name'),
+    extend = _dereq_('xtend'),
+    s = _dereq_('./strategies');
+
+function defaultHandlers () {
+    return {
+        'null': s.always('null'),
+        'undefined': s.always('undefined'),
+        'function': s.prune(),
+        'string': s.json(),
+        'boolean': s.json(),
+        'number': s.number(),
+        'RegExp': s.toStr(),
+        'String': s.newLike(),
+        'Boolean': s.newLike(),
+        'Number': s.newLike(),
+        'Date': s.newLike(),
+        'Array': s.array(),
+        'Object': s.object(),
+        '@default': s.object()
+    };
+}
+
+function defaultOptions () {
+    return {
+        maxDepth: null,
+        indent: null,
+        anonymous: '@Anonymous',
+        circular: '#@Circular#',
+        snip: '..(snip)',
+        lineSeparator: '\n',
+        typeFun: typeName
+    };
+}
+
+function createStringifier (customOptions) {
+    var options = extend(defaultOptions(), customOptions),
+        handlers = extend(defaultHandlers(), options.handlers);
+    return function stringifyAny (push, x) {
+        var context = this,
+            handler = handlerFor(context.node, options, handlers),
+            currentPath = '/' + context.path.join('/'),
+            customization = handlers[currentPath],
+            acc = {
+                context: context,
+                options: options,
+                handlers: handlers,
+                push: push
+            };
+        if (typeName(customization) === 'function') {
+            handler = customization;
+        } else if (typeName(customization) === 'number') {
+            handler = s.flow.compose(s.filters.truncate(customization),handler);
+        }
+        handler(acc, x);
+        return push;
+    };
+}
+
+function handlerFor (val, options, handlers) {
+    var tname = options.typeFun(val);
+    if (typeName(handlers[tname]) === 'function') {
+        return handlers[tname];
+    }
+    return handlers['@default'];
+}
+
+function walk (val, reducer) {
+    var buffer = [],
+        push = function (str) {
+            buffer.push(str);
+        };
+    traverse(val).reduce(reducer, push);
+    return buffer.join('');
+}
+
+function stringify (val, options) {
+    return walk(val, createStringifier(options));
+}
+
+function stringifier (options) {
+    return function (val) {
+        return walk(val, createStringifier(options));
+    };
+}
+
+stringifier.stringify = stringify;
+stringifier.strategies = s;
+stringifier.defaultOptions = defaultOptions;
+stringifier.defaultHandlers = defaultHandlers;
+module.exports = stringifier;
+
+},{"./strategies":42,"traverse":44,"type-name":43,"xtend":45}],42:[function(_dereq_,module,exports){
+'use strict';
+
+var typeName = _dereq_('type-name'),
+    slice = Array.prototype.slice,
+    END = {},
+    ITERATE = {};
+
+// arguments should end with end or iterate
+function compose () {
+    var filters = slice.apply(arguments);
+    return filters.reduceRight(function(right, left) {
+        return left(right);
+    });
+}
+
+// skip children
+function end () {
+    return function (acc, x) {
+        acc.context.keys = [];
+        return END;
+    };
+}
+
+// iterate children
+function iterate () {
+    return function (acc, x) {
+        return ITERATE;
+    };
+}
+
+function filter (predicate) {
+    return function (next) {
+        return function (acc, x) {
+            var toBeIterated,
+                isIteratingArray = (typeName(x) === 'Array');
+            if (typeName(predicate) === 'function') {
+                toBeIterated = [];
+                acc.context.keys.forEach(function (key) {
+                    var indexOrKey = isIteratingArray ? parseInt(key, 10) : key,
+                        kvp = {
+                            key: indexOrKey,
+                            value: x[key]
+                        },
+                        decision = predicate(kvp);
+                    if (decision) {
+                        toBeIterated.push(key);
+                    }
+                    if (typeName(decision) === 'number') {
+                        truncateByKey(decision, key, acc);
+                    }
+                    if (typeName(decision) === 'function') {
+                        customizeStrategyForKey(decision, key, acc);
+                    }
+                });
+                acc.context.keys = toBeIterated;
+            }
+            return next(acc, x);
+        };
+    };
+}
+
+function customizeStrategyForKey (strategy, key, acc) {
+    acc.handlers[currentPath(key, acc)] = strategy;
+}
+
+function truncateByKey (size, key, acc) {
+    acc.handlers[currentPath(key, acc)] = size;
+}
+
+function currentPath (key, acc) {
+    var pathToCurrentNode = [''].concat(acc.context.path);
+    if (typeName(key) !== 'undefined') {
+        pathToCurrentNode.push(key);
+    }
+    return pathToCurrentNode.join('/');
+}
+
+function allowedKeys (orderedWhiteList) {
+    return function (next) {
+        return function (acc, x) {
+            var isIteratingArray = (typeName(x) === 'Array');
+            if (!isIteratingArray && typeName(orderedWhiteList) === 'Array') {
+                acc.context.keys = orderedWhiteList.filter(function (propKey) {
+                    return acc.context.keys.indexOf(propKey) !== -1;
+                });
+            }
+            return next(acc, x);
+        };
+    };
+}
+
+function safeKeys () {
+    return function (next) {
+        return function (acc, x) {
+            if (typeName(x) !== 'Array') {
+                acc.context.keys = acc.context.keys.filter(function (propKey) {
+                    // Error handling for unsafe property access.
+                    // For example, on PhantomJS,
+                    // accessing HTMLInputElement.selectionEnd causes TypeError
+                    try {
+                        var val = x[propKey];
+                        return true;
+                    } catch (e) {
+                        // skip unsafe key
+                        return false;
+                    }
+                });
+            }
+            return next(acc, x);
+        };
+    };
+}
+
+function when (guard, then) {
+    return function (next) {
+        return function (acc, x) {
+            var kvp = {
+                key: acc.context.key,
+                value: x
+            };
+            if (guard(kvp, acc)) {
+                return then(acc, x);
+            }
+            return next(acc, x);
+        };
+    };
+}
+
+function truncate (size) {
+    return function (next) {
+        return function (acc, x) {
+            var orig = acc.push, ret;
+            acc.push = function (str) {
+                var savings = str.length - size,
+                    truncated;
+                if (savings <= size) {
+                    orig.call(acc, str);
+                } else {
+                    truncated = str.substring(0, size);
+                    orig.call(acc, truncated + acc.options.snip);
+                }
+            };
+            ret = next(acc, x);
+            acc.push = orig;
+            return ret;
+        };
+    };
+}
+
+function constructorName () {
+    return function (next) {
+        return function (acc, x) {
+            var name = acc.options.typeFun(x);
+            if (name === '') {
+                name = acc.options.anonymous;
+            }
+            acc.push(name);
+            return next(acc, x);
+        };
+    };
+}
+
+function always (str) {
+    return function (next) {
+        return function (acc, x) {
+            acc.push(str);
+            return next(acc, x);
+        };
+    };
+}
+
+function optionValue (key) {
+    return function (next) {
+        return function (acc, x) {
+            acc.push(acc.options[key]);
+            return next(acc, x);
+        };
+    };
+}
+
+function json (replacer) {
+    return function (next) {
+        return function (acc, x) {
+            acc.push(JSON.stringify(x, replacer));
+            return next(acc, x);
+        };
+    };
+}
+
+function toStr () {
+    return function (next) {
+        return function (acc, x) {
+            acc.push(x.toString());
+            return next(acc, x);
+        };
+    };
+}
+
+function decorateArray () {
+    return function (next) {
+        return function (acc, x) {
+            acc.context.before(function (node) {
+                acc.push('[');
+            });
+            acc.context.after(function (node) {
+                afterAllChildren(this, acc.push, acc.options);
+                acc.push(']');
+            });
+            acc.context.pre(function (val, key) {
+                beforeEachChild(this, acc.push, acc.options);
+            });
+            acc.context.post(function (childContext) {
+                afterEachChild(childContext, acc.push);
+            });
+            return next(acc, x);
+        };
+    };
+}
+
+function decorateObject () {
+    return function (next) {
+        return function (acc, x) {
+            acc.context.before(function (node) {
+                acc.push('{');
+            });
+            acc.context.after(function (node) {
+                afterAllChildren(this, acc.push, acc.options);
+                acc.push('}');
+            });
+            acc.context.pre(function (val, key) {
+                beforeEachChild(this, acc.push, acc.options);
+                acc.push(sanitizeKey(key) + (acc.options.indent ? ': ' : ':'));
+            });
+            acc.context.post(function (childContext) {
+                afterEachChild(childContext, acc.push);
+            });
+            return next(acc, x);
+        };
+    };
+}
+
+function sanitizeKey (key) {
+    return /^[A-Za-z_]+$/.test(key) ? key : JSON.stringify(key);
+}
+
+function afterAllChildren (context, push, options) {
+    if (options.indent && 0 < context.keys.length) {
+        push(options.lineSeparator);
+        for(var i = 0; i < context.level; i += 1) { // indent level - 1
+            push(options.indent);
+        }
+    }
+}
+
+function beforeEachChild (context, push, options) {
+    if (options.indent) {
+        push(options.lineSeparator);
+        for(var i = 0; i <= context.level; i += 1) {
+            push(options.indent);
+        }
+    }
+}
+
+function afterEachChild (childContext, push) {
+    if (!childContext.isLast) {
+        push(',');
+    }
+}
+
+function nan (kvp, acc) {
+    return kvp.value !== kvp.value;
+}
+
+function positiveInfinity (kvp, acc) {
+    return !isFinite(kvp.value) && kvp.value === Infinity;
+}
+
+function negativeInfinity (kvp, acc) {
+    return !isFinite(kvp.value) && kvp.value !== Infinity;
+}
+
+function circular (kvp, acc) {
+    return acc.context.circular;
+}
+
+function maxDepth (kvp, acc) {
+    return (acc.options.maxDepth && acc.options.maxDepth <= acc.context.level);
+}
+
+var prune = compose(
+    always('#'),
+    constructorName(),
+    always('#'),
+    end()
+);
+var omitNaN = when(nan, compose(
+    always('NaN'),
+    end()
+));
+var omitPositiveInfinity = when(positiveInfinity, compose(
+    always('Infinity'),
+    end()
+));
+var omitNegativeInfinity = when(negativeInfinity, compose(
+    always('-Infinity'),
+    end()
+));
+var omitCircular = when(circular, compose(
+    optionValue('circular'),
+    end()
+));
+var omitMaxDepth = when(maxDepth, prune);
+
+module.exports = {
+    filters: {
+        always: always,
+        constructorName: constructorName,
+        json: json,
+        toStr: toStr,
+        prune: prune,
+        truncate: truncate,
+        decorateArray: decorateArray,
+        decorateObject: decorateObject
+    },
+    flow: {
+        compose: compose,
+        when: when,
+        allowedKeys: allowedKeys,
+        safeKeys: safeKeys,
+        filter: filter,
+        iterate: iterate,
+        end: end
+    },
+    symbols: {
+        END: END,
+        ITERATE: ITERATE
+    },
+    always: function (str) {
+        return compose(always(str), end());
+    },
+    json: function () {
+        return compose(json(), end());
+    },
+    toStr: function () {
+        return compose(toStr(), end());
+    },
+    prune: function () {
+        return prune;
+    },
+    number: function () {
+        return compose(
+            omitNaN,
+            omitPositiveInfinity,
+            omitNegativeInfinity,
+            json(),
+            end()
+        );
+    },
+    newLike: function () {
+        return compose(
+            always('new '),
+            constructorName(),
+            always('('),
+            json(),
+            always(')'),
+            end()
+        );
+    },
+    array: function (predicate) {
+        return compose(
+            omitCircular,
+            omitMaxDepth,
+            decorateArray(),
+            filter(predicate),
+            iterate()
+        );
+    },
+    object: function (predicate, orderedWhiteList) {
+        return compose(
+            omitCircular,
+            omitMaxDepth,
+            constructorName(),
+            decorateObject(),
+            allowedKeys(orderedWhiteList),
+            safeKeys(),
+            filter(predicate),
+            iterate()
+        );
+    }
+};
+
+},{"type-name":43}],43:[function(_dereq_,module,exports){
+/**
+ * type-name - Just a reasonable typeof
+ * 
+ * https://github.com/twada/type-name
+ *
+ * Copyright (c) 2014 Takuto Wada
+ * Licensed under the MIT license.
+ *   http://twada.mit-license.org/
+ */
+'use strict';
+
+var toStr = Object.prototype.toString;
+
+function funcName (f) {
+    return f.name ? f.name : /^\s*function\s*([^\(]*)/im.exec(f.toString())[1];
+}
+
+function ctorName (obj) {
+    var strName = toStr.call(obj).slice(8, -1);
+    if (strName === 'Object' && obj.constructor) {
+        return funcName(obj.constructor);
+    }
+    return strName;
+}
+
+function typeName (val) {
+    var type;
+    if (val === null) {
+        return 'null';
+    }
+    type = typeof(val);
+    if (type === 'object') {
+        return ctorName(val);
+    }
+    return type;
+}
+
+module.exports = typeName;
+
+},{}],44:[function(_dereq_,module,exports){
+var traverse = module.exports = function (obj) {
+    return new Traverse(obj);
+};
+
+function Traverse (obj) {
+    this.value = obj;
+}
+
+Traverse.prototype.get = function (ps) {
+    var node = this.value;
+    for (var i = 0; i < ps.length; i ++) {
+        var key = ps[i];
+        if (!node || !hasOwnProperty.call(node, key)) {
+            node = undefined;
+            break;
+        }
+        node = node[key];
+    }
+    return node;
+};
+
+Traverse.prototype.has = function (ps) {
+    var node = this.value;
+    for (var i = 0; i < ps.length; i ++) {
+        var key = ps[i];
+        if (!node || !hasOwnProperty.call(node, key)) {
+            return false;
+        }
+        node = node[key];
+    }
+    return true;
+};
+
+Traverse.prototype.set = function (ps, value) {
+    var node = this.value;
+    for (var i = 0; i < ps.length - 1; i ++) {
+        var key = ps[i];
+        if (!hasOwnProperty.call(node, key)) node[key] = {};
+        node = node[key];
+    }
+    node[ps[i]] = value;
+    return value;
+};
+
+Traverse.prototype.map = function (cb) {
+    return walk(this.value, cb, true);
+};
+
+Traverse.prototype.forEach = function (cb) {
+    this.value = walk(this.value, cb, false);
+    return this.value;
+};
+
+Traverse.prototype.reduce = function (cb, init) {
+    var skip = arguments.length === 1;
+    var acc = skip ? this.value : init;
+    this.forEach(function (x) {
+        if (!this.isRoot || !skip) {
+            acc = cb.call(this, acc, x);
+        }
+    });
+    return acc;
+};
+
+Traverse.prototype.paths = function () {
+    var acc = [];
+    this.forEach(function (x) {
+        acc.push(this.path); 
+    });
+    return acc;
+};
+
+Traverse.prototype.nodes = function () {
+    var acc = [];
+    this.forEach(function (x) {
+        acc.push(this.node);
+    });
+    return acc;
+};
+
+Traverse.prototype.clone = function () {
+    var parents = [], nodes = [];
+    
+    return (function clone (src) {
+        for (var i = 0; i < parents.length; i++) {
+            if (parents[i] === src) {
+                return nodes[i];
+            }
+        }
+        
+        if (typeof src === 'object' && src !== null) {
+            var dst = copy(src);
+            
+            parents.push(src);
+            nodes.push(dst);
+            
+            forEach(objectKeys(src), function (key) {
+                dst[key] = clone(src[key]);
+            });
+            
+            parents.pop();
+            nodes.pop();
+            return dst;
+        }
+        else {
+            return src;
+        }
+    })(this.value);
+};
+
+function walk (root, cb, immutable) {
+    var path = [];
+    var parents = [];
+    var alive = true;
+    
+    return (function walker (node_) {
+        var node = immutable ? copy(node_) : node_;
+        var modifiers = {};
+        
+        var keepGoing = true;
+        
+        var state = {
+            node : node,
+            node_ : node_,
+            path : [].concat(path),
+            parent : parents[parents.length - 1],
+            parents : parents,
+            key : path.slice(-1)[0],
+            isRoot : path.length === 0,
+            level : path.length,
+            circular : null,
+            update : function (x, stopHere) {
+                if (!state.isRoot) {
+                    state.parent.node[state.key] = x;
+                }
+                state.node = x;
+                if (stopHere) keepGoing = false;
+            },
+            'delete' : function (stopHere) {
+                delete state.parent.node[state.key];
+                if (stopHere) keepGoing = false;
+            },
+            remove : function (stopHere) {
+                if (isArray(state.parent.node)) {
+                    state.parent.node.splice(state.key, 1);
+                }
+                else {
+                    delete state.parent.node[state.key];
+                }
+                if (stopHere) keepGoing = false;
+            },
+            keys : null,
+            before : function (f) { modifiers.before = f },
+            after : function (f) { modifiers.after = f },
+            pre : function (f) { modifiers.pre = f },
+            post : function (f) { modifiers.post = f },
+            stop : function () { alive = false },
+            block : function () { keepGoing = false }
+        };
+        
+        if (!alive) return state;
+        
+        function updateState() {
+            if (typeof state.node === 'object' && state.node !== null) {
+                if (!state.keys || state.node_ !== state.node) {
+                    state.keys = objectKeys(state.node)
+                }
+                
+                state.isLeaf = state.keys.length == 0;
+                
+                for (var i = 0; i < parents.length; i++) {
+                    if (parents[i].node_ === node_) {
+                        state.circular = parents[i];
+                        break;
+                    }
+                }
+            }
+            else {
+                state.isLeaf = true;
+                state.keys = null;
+            }
+            
+            state.notLeaf = !state.isLeaf;
+            state.notRoot = !state.isRoot;
+        }
+        
+        updateState();
+        
+        // use return values to update if defined
+        var ret = cb.call(state, state.node);
+        if (ret !== undefined && state.update) state.update(ret);
+        
+        if (modifiers.before) modifiers.before.call(state, state.node);
+        
+        if (!keepGoing) return state;
+        
+        if (typeof state.node == 'object'
+        && state.node !== null && !state.circular) {
+            parents.push(state);
+            
+            updateState();
+            
+            forEach(state.keys, function (key, i) {
+                path.push(key);
+                
+                if (modifiers.pre) modifiers.pre.call(state, state.node[key], key);
+                
+                var child = walker(state.node[key]);
+                if (immutable && hasOwnProperty.call(state.node, key)) {
+                    state.node[key] = child.node;
+                }
+                
+                child.isLast = i == state.keys.length - 1;
+                child.isFirst = i == 0;
+                
+                if (modifiers.post) modifiers.post.call(state, child);
+                
+                path.pop();
+            });
+            parents.pop();
+        }
+        
+        if (modifiers.after) modifiers.after.call(state, state.node);
+        
+        return state;
+    })(root).node;
+}
+
+function copy (src) {
+    if (typeof src === 'object' && src !== null) {
+        var dst;
+        
+        if (isArray(src)) {
+            dst = [];
+        }
+        else if (isDate(src)) {
+            dst = new Date(src.getTime ? src.getTime() : src);
+        }
+        else if (isRegExp(src)) {
+            dst = new RegExp(src);
+        }
+        else if (isError(src)) {
+            dst = { message: src.message };
+        }
+        else if (isBoolean(src)) {
+            dst = new Boolean(src);
+        }
+        else if (isNumber(src)) {
+            dst = new Number(src);
+        }
+        else if (isString(src)) {
+            dst = new String(src);
+        }
+        else if (Object.create && Object.getPrototypeOf) {
+            dst = Object.create(Object.getPrototypeOf(src));
+        }
+        else if (src.constructor === Object) {
+            dst = {};
+        }
+        else {
+            var proto =
+                (src.constructor && src.constructor.prototype)
+                || src.__proto__
+                || {}
+            ;
+            var T = function () {};
+            T.prototype = proto;
+            dst = new T;
+        }
+        
+        forEach(objectKeys(src), function (key) {
+            dst[key] = src[key];
+        });
+        return dst;
+    }
+    else return src;
+}
+
+var objectKeys = Object.keys || function keys (obj) {
+    var res = [];
+    for (var key in obj) res.push(key)
+    return res;
+};
+
+function toS (obj) { return Object.prototype.toString.call(obj) }
+function isDate (obj) { return toS(obj) === '[object Date]' }
+function isRegExp (obj) { return toS(obj) === '[object RegExp]' }
+function isError (obj) { return toS(obj) === '[object Error]' }
+function isBoolean (obj) { return toS(obj) === '[object Boolean]' }
+function isNumber (obj) { return toS(obj) === '[object Number]' }
+function isString (obj) { return toS(obj) === '[object String]' }
+
+var isArray = Array.isArray || function isArray (xs) {
+    return Object.prototype.toString.call(xs) === '[object Array]';
+};
+
+var forEach = function (xs, fn) {
+    if (xs.forEach) return xs.forEach(fn)
+    else for (var i = 0; i < xs.length; i++) {
+        fn(xs[i], i, xs);
+    }
+};
+
+forEach(objectKeys(Traverse.prototype), function (key) {
+    traverse[key] = function (obj) {
+        var args = [].slice.call(arguments, 1);
+        var t = new Traverse(obj);
+        return t[key].apply(t, args);
+    };
+});
+
+var hasOwnProperty = Object.hasOwnProperty || function (obj, key) {
+    return key in obj;
+};
+
+},{}],45:[function(_dereq_,module,exports){
+module.exports = extend
+
+function extend() {
+    var target = {}
+
+    for (var i = 0; i < arguments.length; i++) {
+        var source = arguments[i]
+
+        for (var key in source) {
+            if (source.hasOwnProperty(key)) {
+                target[key] = source[key]
+            }
+        }
+    }
+
+    return target
+}
+
+},{}],46:[function(_dereq_,module,exports){
+module.exports = extend
+
+function extend(target) {
+    for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i]
+
+        for (var key in source) {
+            if (source.hasOwnProperty(key)) {
+                target[key] = source[key]
+            }
+        }
+    }
+
+    return target
+}
+
+},{}]},{},[7])(7)
+});
+
diff --git a/packages/planner/node_modules/deepcopy/deepcopy.js b/packages/planner/node_modules/deepcopy/deepcopy.js
new file mode 100644
index 00000000..cb66bc6a
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/deepcopy.js
@@ -0,0 +1,229 @@
+/*!
+ * @license deepcopy.js Copyright(c) 2013 sasa+1
+ * https://github.com/sasaplus1/deepcopy.js
+ * Released under the MIT license.
+ */
+
+
+/**
+ * export to AMD/CommonJS/global.
+ *
+ * @param {Object} global global object.
+ * @param {Function} factory factory method.
+ */
+(function(global, factory) {
+  'use strict';
+
+  if (typeof define === 'function' && !!define.amd) {
+    define(factory);
+  } else if (typeof exports === 'object') {
+    module.exports = factory();
+  } else {
+    global.deepcopy = factory();
+  }
+}(this, function() {
+  'use strict';
+
+  var isNode, util, isBuffer, getKeys, getSymbols, indexOfArray;
+
+  // is node.js/io.js?
+  isNode = (typeof process !== 'undefined' && typeof require !== 'undefined');
+
+  // fallback util module for browser.
+  util = (isNode) ? require('util') : (function() {
+    function isArray(value) {
+      return (typeof value === 'object' &&
+          Object.prototype.toString.call(value) === '[object Array]');
+    }
+
+    function isDate(value) {
+      return (typeof value === 'object' &&
+          Object.prototype.toString.call(value) === '[object Date]');
+    }
+
+    function isRegExp(value) {
+      return (typeof value === 'object' &&
+          Object.prototype.toString.call(value) === '[object RegExp]');
+    }
+
+    function isSymbol(value) {
+      return (typeof value === 'symbol');
+    }
+
+    return {
+      isArray: (typeof Array.isArray === 'function') ?
+          function(obj) {
+            return Array.isArray(obj);
+          } : isArray,
+      isDate: isDate,
+      isRegExp: isRegExp,
+      isSymbol: (typeof Symbol === 'function') ?
+          isSymbol :
+          function() {
+            // always return false when Symbol is not supported.
+            return false;
+          }
+    };
+  }());
+
+  // fallback Buffer.isBuffer
+  isBuffer = (isNode) ?
+      function(obj) {
+        return Buffer.isBuffer(obj);
+      } :
+      function() {
+        // if browser, always return false
+        return false;
+      };
+
+  // fallback Object.keys for old browsers.
+  getKeys = (typeof Object.keys === 'function') ?
+      function(obj) {
+        return Object.keys(obj);
+      } :
+      function(obj) {
+        var keys = [],
+            key;
+
+        if (obj === null || typeof obj !== 'object') {
+          throw new TypeError('obj is not an Object');
+        }
+
+        for (key in obj) {
+          obj.hasOwnProperty(key) && keys.push(key);
+        }
+
+        return keys;
+      };
+
+  // get symbols in object.
+  getSymbols = (typeof Symbol === 'function') ?
+      function(obj) {
+        return Object.getOwnPropertySymbols(obj);
+      } :
+      function() {
+        // always return empty array when Symbol is not supported.
+        return [];
+      };
+
+  // fallback Array#indexOf for old browsers.
+  indexOfArray = (typeof Array.prototype.indexOf === 'function') ?
+      function(array, searchElement) {
+        return array.indexOf(searchElement);
+      } :
+      function(array, searchElement) {
+        var i, len;
+
+        if (!util.isArray(array)) {
+          throw new TypeError('array is not an Array');
+        }
+
+        for (i = 0, len = array.length; i < len; ++i) {
+          if (array[i] === searchElement) {
+            return i;
+          }
+        }
+
+        return -1;
+      };
+
+  /**
+   * recursive deep copy for value.
+   *
+   * @private
+   * @param {*} value copy target.
+   * @param {*} clone
+   * @param {Array} visited
+   * @param {Array} reference
+   * @return {*} copied value.
+   */
+  function copyValue_(value, clone, visited, reference) {
+    var str, pos, buf, keys, i, len, key, val, idx, obj, ref;
+
+    // number, string, boolean, null, undefined, function and symbol.
+    if (value === null || typeof value !== 'object') {
+      return value;
+    }
+
+    // Date.
+    if (util.isDate(value)) {
+      // Firefox need to convert to Number
+      //
+      // Firefox:
+      //   var date = new Date;
+      //   +date;            // 1420909365967
+      //   +new Date(date);  // 1420909365000
+      //   +new Date(+date); // 1420909365967
+      // Chrome:
+      //   var date = new Date;
+      //   +date;            // 1420909757913
+      //   +new Date(date);  // 1420909757913
+      //   +new Date(+date); // 1420909757913
+      return new Date(+value);
+    }
+
+    // RegExp.
+    if (util.isRegExp(value)) {
+      // Chrome, Safari:
+      //   (new RegExp).source => "(?:)"
+      // Firefox:
+      //   (new RegExp).source => ""
+      // Chrome, Safari, Firefox
+      //   String(new RegExp) => "/(?:)/"
+      str = String(value);
+      pos = str.lastIndexOf('/');
+
+      return new RegExp(str.slice(1, pos), str.slice(pos + 1));
+    }
+
+    // Buffer, node.js only.
+    if (isBuffer(value)) {
+      buf = new Buffer(value.length);
+      value.copy(buf);
+
+      return buf;
+    }
+
+    // Object or Array.
+    keys = getKeys(value).concat(getSymbols(value));
+
+    for (i = 0, len = keys.length; i < len; ++i) {
+      key = keys[i];
+      val = value[key];
+
+      if (val !== null && typeof val === 'object') {
+        idx = indexOfArray(visited, val);
+
+        if (idx === -1) {
+          // not circular reference
+          obj = (util.isArray(val)) ? [] : {};
+
+          visited.push(val);
+          reference.push(obj);
+        } else {
+          // circular reference
+          ref = reference[idx];
+        }
+      }
+
+      clone[key] = ref || copyValue_(val, obj, visited, reference);
+    }
+
+    return clone;
+  }
+
+  /**
+   * deep copy for value.
+   *
+   * @param {*} value copy target.
+   */
+  function deepcopy(value) {
+    var clone = (util.isArray(value)) ? [] : {},
+        visited = [value],
+        reference = [clone];
+
+    return copyValue_(value, clone, visited, reference);
+  }
+
+  return deepcopy;
+}));
diff --git a/packages/planner/node_modules/deepcopy/package.json b/packages/planner/node_modules/deepcopy/package.json
new file mode 100644
index 00000000..17cbb745
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/package.json
@@ -0,0 +1,69 @@
+{
+  "name": "deepcopy",
+  "version": "0.5.0",
+  "author": {
+    "name": "sasa+1",
+    "email": "sasaplus1@gmail.com"
+  },
+  "contributors": [
+    {
+      "name": "kjirou",
+      "email": "kjirou.web@gmail.com"
+    }
+  ],
+  "description": "deep copy for any data",
+  "main": "./deepcopy.js",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/sasaplus1/deepcopy.js.git"
+  },
+  "directories": {
+    "test": "test/"
+  },
+  "scripts": {
+    "bower": "bower install",
+    "fix": "fixjsstyle --flagfile .closurelinter -r .",
+    "lint": "gjslint --flagfile .closurelinter -r .",
+    "minify": "uglifyjs ./deepcopy.js --comments '@license' -cm -r deepcopy -o ./deepcopy.min.js",
+    "power": "espower ./test/test.js > ./test/test.pwr.js",
+    "test": "mocha ./test/test.js",
+    "testem": "testem",
+    "travis": "testem ci --launch Firefox,PhantomJS"
+  },
+  "devDependencies": {
+    "bower": "~1.4",
+    "espower-cli": "~0.2",
+    "intelli-espower-loader": "~0.6",
+    "mocha": "~2.2",
+    "power-assert": "~0.10",
+    "testem": "~0.7",
+    "uglify-js": "~2.4"
+  },
+  "gitHead": "6fffac0b35e82d5ae67b756f6955f28d10f0fac1",
+  "bugs": {
+    "url": "https://github.com/sasaplus1/deepcopy.js/issues"
+  },
+  "homepage": "https://github.com/sasaplus1/deepcopy.js",
+  "_id": "deepcopy@0.5.0",
+  "_shasum": "d2ca34335c2d31f54c1b4f13745e001977d491a2",
+  "_from": "deepcopy@*",
+  "_npmVersion": "2.7.5",
+  "_nodeVersion": "1.6.4",
+  "_npmUser": {
+    "name": "sasaplus1",
+    "email": "sasaplus1@gmail.com"
+  },
+  "maintainers": [
+    {
+      "name": "sasaplus1",
+      "email": "sasaplus1@gmail.com"
+    }
+  ],
+  "dist": {
+    "shasum": "d2ca34335c2d31f54c1b4f13745e001977d491a2",
+    "tarball": "http://registry.npmjs.org/deepcopy/-/deepcopy-0.5.0.tgz"
+  },
+  "_resolved": "https://registry.npmjs.org/deepcopy/-/deepcopy-0.5.0.tgz",
+  "readme": "ERROR: No README data found!"
+}
diff --git a/packages/planner/node_modules/deepcopy/testem.json b/packages/planner/node_modules/deepcopy/testem.json
new file mode 100644
index 00000000..d49cd811
--- /dev/null
+++ b/packages/planner/node_modules/deepcopy/testem.json
@@ -0,0 +1,5 @@
+{
+  "before_tests": "npm run power",
+  "on_exit": "rm ./test/test.pwr.js",
+  "test_page": "./test/index.html"
+}

From 8c26c2e917f95403fc291a3f1e303ddd9e16b2a9 Mon Sep 17 00:00:00 2001
From: tomsmeding <hallo@tomsmeding.nl>
Date: Wed, 26 Aug 2015 20:53:48 +0200
Subject: [PATCH 08/18] Finally something works

---
 packages/planner/planner.js  | 205 ++++++++++++++++++++++++++++-------
 packages/planner/testtest.js |  18 +++
 2 files changed, 186 insertions(+), 37 deletions(-)
 create mode 100755 packages/planner/testtest.js

diff --git a/packages/planner/planner.js b/packages/planner/planner.js
index 275b272d..0da3e518 100644
--- a/packages/planner/planner.js
+++ b/packages/planner/planner.js
@@ -4,16 +4,22 @@
  * @module planner
  */
 
+var deepcopy=require("deepcopy");
+
 var assert = function (val) {
 	if (!val) throw new Error("AssertionError: false == true");
 };
 
+function subjectGrade(subjid){
+	return Math.random()*9+1; //TODO:: Get average grade of student for this subject
+}
+
 HomeworkDescription=function(){
-	if(!(this instanceof HomeworkDescription))return new HomeworkDescription;
+	if(!(this instanceof HomeworkDescription))return new HomeworkDescription(arguments[0],arguments[1],arguments[2]);
 
 	//A unique identifier for a subject. Can be pretty much anything, lest it's a primitive type
-	// and unique and fixed, i.e. there is only one identifier per subject and only one subject per identifier.
-	this.subject=null;
+	//  and unique and fixed, i.e. there is only one identifier per subject and only one subject per identifier.
+	this.subject=arguments.length>0?arguments[0]:null;
 
 	//Items in `location` can be multiple things, e.g.
 	//- [chapter,paragraph,exercise]
@@ -21,14 +27,22 @@ HomeworkDescription=function(){
 	//- [chapter,exercise]
 	//- [bookid,page]
 	//In general, anything that can be expressed in a sequence of integers that specifies the location.
+	//  (Actually, they should be index paths — think NSIndexPath)
 	//The `location` property contains an array of those, because homework can be multiple exercises, for example.
 	//Please make the array contiguous, though; don't mix indexing conventions! (!) (!!)
-	this.location=[];
-}
+	this.location=arguments.length>1?arguments[1]:[];
+
+	//A Date indicating when this homework is due
+	this.duedate=arguments.length>2?arguments[2]:null;
+};
 
 Planner=function(){
-	if(!(this instanceof Planner))return new Planner;
+	if(!(this instanceof Planner))return new Planner(arguments[0]);
 
+	this.isPlannerObject=true;
+
+	//PREV: Object[subject id][location index path item][value of the loc. idxp. item][samples of time taken]
+	//Object[subject id][loc item 0][loc item 1]...[loc item n] = time taken for that index path
 	var subjects={}; //The Cache
 
 	//`timetaken` in any unit you find convenient; but please be consistent. Suggestion: seconds.
@@ -39,40 +53,144 @@ Planner=function(){
 		loc=hwdesc.location;
 		assert(loc.length!=0);
 		if(!subjects[subj]){
-			subjects[subj]=new Array(loc[0].length);
-			for(i=0;i<loc[0].length;i++){
-				if(!subjects[subj][i])subjects[subj][i]={};
-				for(j=0;j<loc.length;j++){
-					if(subjects[subj][i][loc[j][i]]){
-						subjects[subj][i][loc[j][i]].push(timetaken/loc.length);
-					} else {
-						subjects[subj][i][loc[j][i]]=[timetaken/loc.length];
-					}
+			subjects[subj]={};
+		}
+		var itemref;
+		for(i=0;i<loc.length;i++){
+			itemref=subjects[subj];
+			for(j=0;j<loc[i].length;j++){
+				if(j==loc[i].length-1){
+					itemref[loc[i][j]]=timetaken/hwdesc.location.length;
+				} else if(!itemref[loc[i][j]]){
+					itemref[loc[i][j]]={};
 				}
+				itemref=itemref[loc[i][j]];
 			}
 		}
 	};
 
+	this.generalSubjectEstimate=function(subjid){
+		var grade=subjectGrade(subjid);
+		return 3600*3/2-3600*grade;
+	};
+
+	function estimateSingle(hwdesc){
+		assert(hwdesc instanceof HomeworkDescription);
+		assert(hwdesc.location.length==1);
+		if(!subjects[hwdesc.subject]){
+			return this.generalSubjectEstimate(hwdesc.subject);
+		}
+		var i,itemref=subjects[hwdesc.subject];
+		for(i=0;i<hwdesc.location[0].length;i++){
+			if(itemref[hwdesc.location[0][i]]==null)break;
+			itemref=itemref[hwdesc.location[0][i]];
+		}
+		if(i==hwdesc.location[0].length)return itemref;
+		var key,timearr=[];
+		for(key in itemref){
+			timearr.push(itemref[key]);
+		}
+		return rms(timearr);
+	}
+
 	this.estimate=function(hwdesc){
 		var subj,loc;
-		assert(hwdesc instanceof HomeworkDescription);
-		subj=hwdesc.subject;
-		loc=hwdesc.location;
-		var total=0;
-		loc.forEach(function(locitem){
-			total+=rms(subjects[subj].map(function(sitem,i){
-				console.log(sitem,locitem[i],sitem[locitem[i]]);
-				return rms(sitem[locitem[i]]);
-			}));
-		});
-		return total;
+		//assert(hwdesc instanceof HomeworkDescription);
+		return sum(hwdesc.location.map(function(loc){
+			return estimateSingle(HomeworkDescription(hwdesc.subject,[loc]));
+		}));
 	};
 
 	this.persistable=function(){
-		return subjects;
-	}
-}
+		return deepcopy(subjects);
+	};
+	this.frompersistable=function(subj){
+		if(subj.isPlannerObject===true) //they persisted the whole object ._.
+			subjects=subj.persistable();
+		else subjects=deepcopy(subj);
+	};
 
+	this.availableTimeConvert=function(code){
+		// return [0,30*60,90*60,180*60][code];
+		return (15*code*code+15*code)*60;
+	};
+
+	//`items` is an Array of HomeworkDescriptions
+	//`available` is an Array of ints, specifying how much time (in the time unit) there is available
+	//  on that day of the plan region.
+	//`today` is a Date which the planner uses as "today"
+	this.plan=function(items,available,today){
+		items=deepcopy(items); //we'll modify them for our own needs
+		var ndays=available.length;
+		var needed=new Array(ndays);
+		var i;
+		for(i=0;i<ndays;i++){
+			available[i]=this.availableTimeConvert(available[i]);
+			needed[i]=this.estimate(items[i]);
+		}
+		console.log("available =",available," needed =",needed);
+		today=startOfDay(today);
+		var maxdiff=0;
+		for(i=0;i<items.length;i++){
+			items[i].duedate=startOfDay(items[i].duedate);
+			items[i].duediff=diffDays(today,items[i].duedate);
+			if(items[i].duediff<0)items[i].duediff=0; //you're a bit late son
+			maxdiff=Math.max(maxdiff,items[i].duediff);
+		}
+		var dueInDays=new Array(maxdiff+1);
+		for(i=0;i<=maxdiff;i++)dueInDays[i]=[];
+		for(i=0;i<items.length;i++){
+			dueInDays[items[i].duediff].push({item:items[i],needed:needed[i]});
+		}
+		for(i=0;i<dueInDays.length;i++){
+			dueInDays[i].sort(function(a,b){return a.needed<b.needed;}); //descending sort on needed time
+		}
+		var schedule=new Array(maxdiff);
+		var daylength=new Array(maxdiff);
+		for(i=0;i<maxdiff;i++){
+			schedule[i]=[];
+			daylength[i]=0;
+		}
+		var workingForDay;
+		var day,it;
+		workingForDay=0;
+		while(true){
+			while(workingForDay<dueInDays.length&&dueInDays[workingForDay].length==0)workingForDay++;
+			if(workingForDay>=dueInDays.length)break; //done!
+			console.log("day:",dueInDays[workingForDay]);
+			it=dueInDays[workingForDay].shift();
+			console.log("it =",it);
+			console.log("daylength[0]="+daylength[0]+" it.needed="+it.needed+" available[0]="+available[0]);
+			for(day=0;day<it.item.duediff;day++){
+				if(daylength[day]+it.needed<=available[day])break;
+			}
+			if(day==it.item.duediff)assert(false); //TODO FIX STUFF THAT DOESN'T FIT
+			schedule[day].push(it.item);
+			daylength[day]+=it.needed;
+		}
+		var ret={};
+		for(i=0;i<schedule.length;i++){
+			if(schedule[i].length==0)continue;
+			ret[addDays(today,i)]=schedule[i];
+		}
+		return ret;
+	};
+
+
+
+	if(arguments.length==1)subjects=deepcopy(arguments[0]); //from a persist source
+};
+
+
+function startOfDay(date){
+	return new Date(date.getFullYear(),date.getMonth(),date.getDate());
+}
+function addDays(date,ndays){
+	return new Date(date.getTime()+ndays*24*3600*1000);
+}
+function diffDays(d1,d2){
+	return ~~((d2.getTime()-d1.getTime())/(24*3600*1000));
+}
 
 function rms(arr){
 	var sum,i,len;
@@ -81,6 +199,13 @@ function rms(arr){
 	for(i=0;i<len;i++)sum+=arr[i]*arr[i];
 	return Math.sqrt(sum/len);
 }
+function sum(arr){
+	var sum,i,len;
+	sum=0;
+	len=arr.length;
+	for(i=0;i<len;i++)sum+=arr[i];
+	return sum;
+}
 
 if(typeof Meteor=="undefined"){
 	module.exports={
@@ -90,12 +215,18 @@ if(typeof Meteor=="undefined"){
 }
 
 /*
-var REQ=require("./planner");
-var h=REQ.HomeworkDescription();
-h.subject="ne";
-h.location=[[1,2],[1,3]];
-var P=REQ.Planner();
-P.learn(h,10);
-console.log(util.inspect(P.persistable(),{depth:10}));
-P.estimate(h);
+REQ=require("./planner")
+H=REQ.HomeworkDescription
+P=REQ.Planner
+function hh(s,l){var h=new H;h.subject=s;h.location=l;return h;}
+function inspect(o){console.log(util.inspect(o,{depth:8}));}
+function startOfDay(date){return new Date(date.getFullYear(),date.getMonth(),date.getDate());}
+function addDays(date,ndays){return new Date(date.getTime()+ndays*24*3600*1000);}
+p=new P
+p.learn(hh("ne",[[1,1],[1,2]]),100)
+p.learn(hh("ne",[[1,5]]),40)
+inspect(p.persistable())
+p.estimate(hh("ne",[[1,5]]))
+p.estimate(hh("ne",[[1,4]]))
+p.plan([H("ne",[[1,2]],addDays(startOfDay(new Date),2)),H("ne",[[1,1],[1,5]],addDays(startOfDay(new Date),1))],[1,1],new Date)
 */
diff --git a/packages/planner/testtest.js b/packages/planner/testtest.js
new file mode 100755
index 00000000..7bc3e88f
--- /dev/null
+++ b/packages/planner/testtest.js
@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+var util=require("util");
+
+REQ=require("./planner")
+H=REQ.HomeworkDescription
+P=REQ.Planner
+function hh(s,l){var h=new H;h.subject=s;h.location=l;return h;}
+function inspect(o){console.log(util.inspect(o,{depth:8}));}
+function startOfDay(date){return new Date(date.getFullYear(),date.getMonth(),date.getDate());}
+function addDays(date,ndays){return new Date(date.getTime()+ndays*24*3600*1000);}
+p=new P
+p.learn(hh("ne",[[1,1],[1,2]]),100)
+p.learn(hh("ne",[[1,5]]),40)
+inspect(p.persistable())
+p.estimate(hh("ne",[[1,5]]))
+p.estimate(hh("ne",[[1,4]]))
+var schedule=p.plan([H("ne",[[1,2]],addDays(startOfDay(new Date),2)),H("ne",[[1,1],[1,5]],addDays(startOfDay(new Date),1))],[1,1],new Date)
+console.log(schedule)

From f9806d8bd6287b347226f297bb501f7afde5e58d Mon Sep 17 00:00:00 2001
From: Lieuwe Rooijakkers <lieuwerooijakkers@gmail.com>
Date: Thu, 27 Aug 2015 21:47:41 +0200
Subject: [PATCH 09/18] deepcopy -> lodash

We already have lodash included in the app, so that means less code needed to
be included.
---
 packages/planner/.gitignore                   |     1 +
 .../planner/node_modules/deepcopy/.npmignore  |     4 -
 .../planner/node_modules/deepcopy/HISTORY.md  |    46 -
 .../planner/node_modules/deepcopy/LICENSE     |    21 -
 .../planner/node_modules/deepcopy/README.md   |   156 -
 .../planner/node_modules/deepcopy/bower.json  |    14 -
 .../bower_components/es5-shim/.bower.json     |    43 -
 .../bower_components/es5-shim/CHANGES         |   176 -
 .../bower_components/es5-shim/CONTRIBUTORS.md |    27 -
 .../bower_components/es5-shim/LICENSE         |    22 -
 .../bower_components/es5-shim/Makefile        |    23 -
 .../bower_components/es5-shim/README.md       |   167 -
 .../bower_components/es5-shim/bower.json      |    34 -
 .../bower_components/es5-shim/component.json  |    19 -
 .../bower_components/es5-shim/es5-sham.js     |   496 -
 .../bower_components/es5-shim/es5-sham.map    |     1 -
 .../bower_components/es5-shim/es5-sham.min.js |     7 -
 .../bower_components/es5-shim/es5-shim.js     |  1435 --
 .../bower_components/es5-shim/es5-shim.map    |     1 -
 .../bower_components/es5-shim/es5-shim.min.js |     7 -
 .../bower_components/es5-shim/package.json    |    74 -
 .../bower_components/es5-shim/shims.json      |     7 -
 .../bower_components/mocha/.bower.json        |    56 -
 .../bower_components/mocha/.editorconfig      |    18 -
 .../deepcopy/bower_components/mocha/.mailmap  |     1 -
 .../bower_components/mocha/CONTRIBUTING.md    |    49 -
 .../bower_components/mocha/HISTORY.md         |   801 --
 .../deepcopy/bower_components/mocha/LICENSE   |    22 -
 .../deepcopy/bower_components/mocha/README.md |   226 -
 .../bower_components/mocha/bower.json         |    47 -
 .../bower_components/mocha/media/logo.svg     |     7 -
 .../deepcopy/bower_components/mocha/mocha.css |   270 -
 .../deepcopy/bower_components/mocha/mocha.js  |  6298 ---------
 .../bower_components/power-assert/.bower.json |    56 -
 .../power-assert/CHANGELOG.md                 |   217 -
 .../power-assert/MIT-LICENSE.txt              |    20 -
 .../bower_components/power-assert/README.md   |   982 --
 .../bower_components/power-assert/bower.json  |    46 -
 .../power-assert/build/power-assert.js        | 11647 ----------------
 .../planner/node_modules/deepcopy/deepcopy.js |   229 -
 .../node_modules/deepcopy/package.json        |    69 -
 .../planner/node_modules/deepcopy/testem.json |     5 -
 packages/planner/package.js                   |     8 +-
 packages/planner/package.json                 |    14 +
 packages/planner/planner.js                   |    10 +-
 45 files changed, 25 insertions(+), 23854 deletions(-)
 create mode 100644 packages/planner/.gitignore
 delete mode 100644 packages/planner/node_modules/deepcopy/.npmignore
 delete mode 100644 packages/planner/node_modules/deepcopy/HISTORY.md
 delete mode 100644 packages/planner/node_modules/deepcopy/LICENSE
 delete mode 100644 packages/planner/node_modules/deepcopy/README.md
 delete mode 100644 packages/planner/node_modules/deepcopy/bower.json
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/es5-shim/.bower.json
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/es5-shim/CHANGES
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/es5-shim/CONTRIBUTORS.md
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/es5-shim/LICENSE
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/es5-shim/Makefile
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/es5-shim/README.md
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/es5-shim/bower.json
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/es5-shim/component.json
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-sham.js
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-sham.map
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-sham.min.js
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-shim.js
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-shim.map
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-shim.min.js
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/es5-shim/package.json
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/es5-shim/shims.json
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/mocha/.bower.json
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/mocha/.editorconfig
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/mocha/.mailmap
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/mocha/CONTRIBUTING.md
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/mocha/HISTORY.md
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/mocha/LICENSE
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/mocha/README.md
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/mocha/bower.json
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/mocha/media/logo.svg
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/mocha/mocha.css
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/mocha/mocha.js
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/power-assert/.bower.json
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/power-assert/CHANGELOG.md
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/power-assert/MIT-LICENSE.txt
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/power-assert/README.md
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/power-assert/bower.json
 delete mode 100644 packages/planner/node_modules/deepcopy/bower_components/power-assert/build/power-assert.js
 delete mode 100644 packages/planner/node_modules/deepcopy/deepcopy.js
 delete mode 100644 packages/planner/node_modules/deepcopy/package.json
 delete mode 100644 packages/planner/node_modules/deepcopy/testem.json
 create mode 100644 packages/planner/package.json

diff --git a/packages/planner/.gitignore b/packages/planner/.gitignore
new file mode 100644
index 00000000..3c3629e6
--- /dev/null
+++ b/packages/planner/.gitignore
@@ -0,0 +1 @@
+node_modules
diff --git a/packages/planner/node_modules/deepcopy/.npmignore b/packages/planner/node_modules/deepcopy/.npmignore
deleted file mode 100644
index 7cd09eab..00000000
--- a/packages/planner/node_modules/deepcopy/.npmignore
+++ /dev/null
@@ -1,4 +0,0 @@
-deepcopy.min.js
-.closurelinter
-.travis.yml
-test/
diff --git a/packages/planner/node_modules/deepcopy/HISTORY.md b/packages/planner/node_modules/deepcopy/HISTORY.md
deleted file mode 100644
index ab2105d3..00000000
--- a/packages/planner/node_modules/deepcopy/HISTORY.md
+++ /dev/null
@@ -1,46 +0,0 @@
-# 0.5.0 / 2015-04-11
-
-  - supported for Symbol
-
-# 0.4.0 / 2015-01-10
-
-  - refactored
-  - bugfix for Firefox
-  - supported for Buffer (node.js only)
-  - changed to use power-assert from expect.js
-
-# 0.3.3 / 2013-12-03
-
-  - bugfix
-    - thanks to @kjirou
-
-# 0.3.2 / 2013-09-08
-
-  - more compressed deepcopy.min.js
-  - changed from chai to expect.js
-
-# 0.3.1 / 2013-06-12
-
-  - changed from Array#indexOf to indexOfArray
-
-# 0.3.0 / 2013-06-01
-
-  - added support for browser
-  - changed repository name to deepcopy.js from deepcopy
-
-# 0.2.0 / 2013-05-26
-
-  - added support for circular reference
-  - rewrote README.md
-
-# 0.1.2 / 2013-03-29
-
-  - added support for node.js 0.10
-
-# 0.1.1 / 2013-01-28
-
-  - rewrote README.md
-
-# 0.1.0 / 2013-01-26
-
-  - initial release
diff --git a/packages/planner/node_modules/deepcopy/LICENSE b/packages/planner/node_modules/deepcopy/LICENSE
deleted file mode 100644
index 95dccda6..00000000
--- a/packages/planner/node_modules/deepcopy/LICENSE
+++ /dev/null
@@ -1,21 +0,0 @@
-(The MIT LICENSE)
-
-Copyright (c) 2013 sasa+1 <sasaplus1@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to
-deal in the Software without restriction, including without limitation the
-rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-IN THE SOFTWARE.
diff --git a/packages/planner/node_modules/deepcopy/README.md b/packages/planner/node_modules/deepcopy/README.md
deleted file mode 100644
index f2ea14aa..00000000
--- a/packages/planner/node_modules/deepcopy/README.md
+++ /dev/null
@@ -1,156 +0,0 @@
-# deepcopy.js
-
-[![Build Status](https://travis-ci.org/sasaplus1/deepcopy.js.svg)](https://travis-ci.org/sasaplus1/deepcopy.js)
-[![Dependency Status](https://gemnasium.com/sasaplus1/deepcopy.js.svg)](https://gemnasium.com/sasaplus1/deepcopy.js)
-[![NPM version](https://badge.fury.io/js/deepcopy.svg)](http://badge.fury.io/js/deepcopy)
-[![Bower version](https://badge.fury.io/bo/deepcopy.svg)](http://badge.fury.io/bo/deepcopy)
-
-deep copy for any data
-
-## Installation
-
-### npm
-
-```sh
-$ npm install deepcopy
-```
-
-### bower
-
-```sh
-$ bower install deepcopy
-```
-
-## Usage
-
-### node.js
-
-```js
-var deepcopy = require('deepcopy');
-```
-
-### browser
-
-```html
-<script src="deepcopy.min.js"></script>
-```
-
-define `deepcopy` by `define()` if using AMD loader.
-
-otherwise `deepcopy` export to global.
-
-### Example
-
-```js
-var data, shallow, deep;
-
-data = {
-  objects: {
-    array: [
-      null, undefined, new Date, /deepcopy/ig
-    ],
-    object: {
-      number: NaN,
-      string: 'A',
-      boolean: true
-    },
-    to: null
-  }
-};
-
-// circular reference
-data.objects.to = data;
-
-// shallow copy and deep copy
-shallow = data;
-deep = deepcopy(data);
-
-// remove entry
-delete data.objects;
-
-// results
-console.log(data);
-// {}
-console.log(shallow);
-// {}
-console.log(require('util').inspect(deep, { depth: null }));
-// { objects:
-//    { array:
-//       [ null,
-//         undefined,
-//         Sat Jan 10 2015 03:18:32 GMT+0900 (JST),
-//         /deepcopy/gi ],
-//      object: { number: NaN, string: 'A', boolean: true },
-//      to: [Circular] } }
-```
-
-```js
-var data, deep;
-
-data = { object: {} };
-data.object[Symbol.for('sym')] = 123;
-
-deep = deepcopy(data);
-
-delete data.object;
-
-console.log(data.object);
-// undefined
-console.log(deep.object[Symbol.for('sym')]);
-// 123
-```
-
-## Functions
-
-### deepcopy(value)
-
-* `value`
-  * `*` - copy target value
-* `return`
-  * `*` - deep copied value
-
-return deep copied value.
-
-supported types are below:
-
-* Number
-* String
-* Boolean
-* Null
-* Undefined
-* Function (shallow copy)
-* Date
-* RegExp
-* Array
-  * recursive copy
-  * also can copy if it has circular reference
-* Object
-  * recursive copy
-  * also can copy if it has circular reference
-* Buffer (node.js only)
-* Symbol
-
-## Test
-
-### node.js
-
-```sh
-$ npm install
-$ npm test
-```
-
-### browser
-
-```sh
-$ npm install
-$ npm run bower
-$ npm run testem
-```
-
-## Contributors
-
-* [kjirou](https://github.com/kjirou)
-
-## License
-
-The MIT license. Please see LICENSE file.
diff --git a/packages/planner/node_modules/deepcopy/bower.json b/packages/planner/node_modules/deepcopy/bower.json
deleted file mode 100644
index 8cc555c6..00000000
--- a/packages/planner/node_modules/deepcopy/bower.json
+++ /dev/null
@@ -1,14 +0,0 @@
-{
-  "name": "deepcopy",
-  "main": "./deepcopy.min.js",
-  "ignore": [
-    "**/.*",
-    "node_modules",
-    "bower_components"
-  ],
-  "devDependencies": {
-    "es5-shim": "~4.0",
-    "mocha": "~2.1",
-    "power-assert": "~0.10"
-  }
-}
diff --git a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/.bower.json b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/.bower.json
deleted file mode 100644
index a856b1f8..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/.bower.json
+++ /dev/null
@@ -1,43 +0,0 @@
-{
-  "name": "es5-shim",
-  "version": "4.0.6",
-  "main": "es5-shim.js",
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/es-shims/es5-shim"
-  },
-  "homepage": "https://github.com/es-shims/es5-shim",
-  "authors": [
-    "Kris Kowal <kris@cixar.com> (http://github.com/kriskowal/)",
-    "Sami Samhuri <sami.samhuri@gmail.com> (http://samhuri.net/)",
-    "Florian Schäfer <florian.schaefer@gmail.com> (http://github.com/fschaefer)",
-    "Irakli Gozalishvili <rfobic@gmail.com> (http://jeditoolkit.com)",
-    "Kit Cambridge <kitcambridge@gmail.com> (http://kitcambridge.github.com)",
-    "Jordan Harband <ljharb@gmail.com> (https://github.com/ljharb/)"
-  ],
-  "description": "ECMAScript 5 compatibility shims for legacy JavaScript engines",
-  "keywords": [
-    "shim",
-    "es5",
-    "es5 shim",
-    "javascript",
-    "ecmascript",
-    "polyfill"
-  ],
-  "license": "MIT",
-  "ignore": [
-    "**/.*",
-    "node_modules",
-    "bower_components",
-    "tests"
-  ],
-  "_release": "4.0.6",
-  "_resolution": {
-    "type": "version",
-    "tag": "v4.0.6",
-    "commit": "aeb6b1cc477d1f452f0badff4631aba9ba501562"
-  },
-  "_source": "git://github.com/es-shims/es5-shim.git",
-  "_target": "~4.0",
-  "_originalSource": "es5-shim"
-}
\ No newline at end of file
diff --git a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/CHANGES b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/CHANGES
deleted file mode 100644
index d5480c48..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/CHANGES
+++ /dev/null
@@ -1,176 +0,0 @@
-4.0.6
-  - Update `jscs`, `uglify-js`, add `eslint`
-  - es5-sham: fix Object.defineProperty to not check for own properties (#211)
-  - Fix Array#splice bug in Safari 5 (#284)
-  - Fix `Object.keys` issue with boxed primitives with extra properties in older browsers. (#242, #285)
-
-4.0.5
-  - Update `jscs` so tests pass
-
-4.0.4
-  - Style/indentation/whitespace cleanups.
-  - README tweaks
-
-4.0.3
-  - Fix keywords (#268)
-  - add some Date tests
-  - Note in README that the es5-sham requires the es5-shim (https://github.com/es-shims/es5-shim/issues/256#issuecomment-52875710)
-
-4.0.2
-  - Start including version numbers in minified files (#267)
-
-4.0.1
-  - Fix legacy arguments object detection in Object.keys (#260)
-
-4.0.0
-  - No longer shim the ES5-spec behavior of splice when `deleteCount` is omitted - since no engines implement it, and ES6 changes it. (#255)
-  - Use Object.defineProperty where available, so that polyfills are non-enumerable when possible (#250)
-  - lots of internal refactoring
-  - Fixed a bug referencing String#indexOf and String#lastIndexOf before polyfilling it (#253, #254)
-
-3.4.0
-  - Removed nonstandard SpiderMonkey extension to Array#splice - when `deleteCount` is omitted, it's now treated as 0. (#192, #239)
-  - Fix Object.keys with Arguments objects in Safari 5.0
-  - Now shimming String#split in Opera 10.6
-  - Avoid using "toString" as a variable name, since that breaks Opera
-  - Internal implementation and test cleanups
-
-3.3.2
- - Remove an internal "bind" call, which should make the shim a bit faster
- - Fix a bug with object boxing in Array#reduceRight that was failing a test in IE 6
-
-3.3.1
- - Fixing an Array#splice bug in IE 6/7
- - cleaning up Array#splice tests
-
-3.3.0
- - Fix Array#reduceRight in node 0.6 and older browsers (#238)
-
-3.2.0
- - Fix es5-sham UMD definition to work properly with AMD (#237)
- - Ensure that Array methods do not autobox context in strict mode (#233)
-
-3.1.1
- - Update minified files (#231)
-
-3.1.0
- - Fix String#replace in Firefox up through 29 (#228)
-
-3.0.2
- - Fix `Function#bind` in IE 7 and 8 (#224, #225, #226)
-
-3.0.1
- - Version bump to ensure npm has newest minified assets
-
-3.0.0
- - es5-sham: fix `Object.getPrototypeOf` and `Object.getOwnPropertyDescriptor` for Opera Mini
- - Better override noncompliant native ES5 methods: `Array#forEach`, `Array#map`, `Array#filter`, `Array#every`, `Array#some`, `Array#reduce`, `Date.parse`, `String#trim`
- - Added spec-compliant shim for `parseInt`
- - Ensure `Object.keys` handles more edge cases with `arguments` objects and boxed primitives
- - Improve minification of builds
-
-2.3.0
- - parseInt is now properly shimmed in ES3 browsers to default the radix
- - update URLs to point to the new organization
-
-2.2.0
- - Function.prototype.bind shim now reports correct length on a bound function
- - fix node 0.6.x v8 bug in Array#forEach
- - test improvements
-
-2.1.0
- - Object.create fixes
- - tweaks to the Object.defineProperties shim
-
-2.0.0
- - Separate reliable shims from dubious shims (shams).
-
-1.2.10
- - Group-effort Style Cleanup
- - Took a stab at fixing Object.defineProperty on IE8 without
-   bad side-effects. (@hax)
- - Object.isExtensible no longer fakes it. (@xavierm)
- - Date.prototype.toISOString no longer deals with partial
-   ISO dates, per spec (@kitcambridge)
- - More (mostly from @bryanforbes)
-
-1.2.9
- - Corrections to toISOString by @kitcambridge
- - Fixed three bugs in array methods revealed by Jasmine tests.
- - Cleaned up Function.prototype.bind with more fixes and tests from
-   @bryanforbes.
-
-1.2.8
- - Actually fixed problems with Function.prototype.bind, and regressions
-   from 1.2.7 (@bryanforbes, @jdalton #36)
-
-1.2.7 - REGRESSED
- - Fixed problems with Function.prototype.bind when called as a constructor.
-   (@jdalton #36)
-
-1.2.6
- - Revised Date.parse to match ES 5.1 (kitcambridge)
-
-1.2.5
- - Fixed a bug for padding it Date..toISOString (tadfisher issue #33)
-
-1.2.4
- - Fixed a descriptor bug in Object.defineProperty (raynos)
-
-1.2.3
- - Cleaned up RequireJS and <script> boilerplate
-
-1.2.2
- - Changed reduce to follow the letter of the spec with regard to having and
-   owning properties.
- - Fixed a bug where RegExps pass as Functions in some engines in reduce.
-
-1.2.1
- - Adding few fixes to make jshint happy.
- - Fix for issue #12, function expressions can cause scoping issues in IE.
- - NPM will minify on install or when `npm run-script install` is executed.
- - Adding .gitignore to avoid publishing dev dependencies.
-
-1.2.0
- - Making script loadable as AMD module.
- - Adding `indexOf` to the list of safe shims.
-
-1.1.0
- - Added support for accessor properties where possible (which is all browsers
-   except IE).
- - Stop exposing bound function's (that are returned by
-   `Function.prototype.bind`) internal properties (`bound, boundTo, boundArgs`)
-   as in some cases (when using facade objects for example) capabilities of the
-   enclosed functions will be leaked.
- - `Object.create` now explicitly sets `__proto__` property to guarantee
-   correct behavior of `Object.getPrototypeOf`'s on all objects created using
-   `Object.create`.
- - Switched to `===` from `==` where possible as it's slightly faster on older
-   browsers that are target of this lib.
- - Added names to all anonymous functions to have a better stack traces.
-
-1.0.0
- - fixed Date.toISODate, using UTC accessors, as in
-   http://code.google.com/p/v8/source/browse/trunk/src/date.js?r=6120#986
-   (arian)
-
-0.0.4
- - Revised Object.getPrototypeOf to work in more cases
-   in response to http://ejohn.org/blog/objectgetprototypeof/
-   [issue #2] (fschaefer)
-
-0.0.3
- - Fixed typos in Object.keys (samsonjs)
-
-0.0.2
-   Per kangax's recommendations:
- - faster Object.create(null)
- - fixed a function-scope function declaration statement in Object.create
-
-0.0.1
- - fixed Object.create(null), in so far as that's possible
- - reworked Rhino Object.freeze(Function) bug detector and patcher
-
-0.0.0
- - forked from narwhal-lib
-
diff --git a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/CONTRIBUTORS.md b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/CONTRIBUTORS.md
deleted file mode 100644
index 43ebf770..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/CONTRIBUTORS.md
+++ /dev/null
@@ -1,27 +0,0 @@
-
--   kriskowal Kris Kowal Copyright (C) 2009-2011 MIT License
--   tlrobinson Tom Robinson Copyright (C) 2009-2010 MIT License (Narwhal
-    Project)
--   dantman Daniel Friesen Copyright (C) 2010 XXX TODO License or CLA
--   fschaefer Florian Schäfer Copyright (C) 2010 MIT License
--   Gozala Irakli Gozalishvili Copyright (C) 2010 MIT License
--   kitcambridge Kit Cambridge Copyright (C) 2011 MIT License
--   kossnocorp Sasha Koss XXX TODO License or CLA
--   bryanforbes Bryan Forbes XXX TODO License or CLA
--   killdream Quildreen Motta Copyright (C) 2011 MIT Licence
--   michaelficarra Michael Ficarra Copyright (C) 2011 3-clause BSD
-    License
--   sharkbrainguy Gerard Paapu Copyright (C) 2011 MIT License
--   bbqsrc Brendan Molloy (C) 2011 Creative Commons Zero (public domain)
--   iwyg XXX TODO License or CLA
--   DomenicDenicola Domenic Denicola Copyright (C) 2011 MIT License
--   xavierm02 Montillet Xavier Copyright (C) 2011 MIT License
--   Raynos Jake Verbaten Copyright (C) 2011 MIT Licence
--   samsonjs Sami Samhuri Copyright (C) 2010 MIT License
--   rwldrn Rick Waldron Copyright (C) 2011 MIT License
--   lexer Alexey Zakharov XXX TODO License or CLA
--   280 North Inc. (Now Motorola LLC, a subsidiary of Google Inc.)
-    Copyright (C) 2009 MIT License
--   Steven Levithan Copyright (C) 2012 MIT License
--   Jordan Harband (C) 2013 MIT License
-
diff --git a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/LICENSE b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/LICENSE
deleted file mode 100644
index 3dbd7de3..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/LICENSE
+++ /dev/null
@@ -1,22 +0,0 @@
-The MIT License (MIT)
-
-Copyright (C) 2009-2014 Kristopher Michael Kowal and contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
diff --git a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/Makefile b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/Makefile
deleted file mode 100644
index c4086599..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/Makefile
+++ /dev/null
@@ -1,23 +0,0 @@
-
-.PHONY: verify-tag verify-changes release
-
-default: release
-
-verify-tag:
-ifndef TAG
-	$(error TAG is undefined)
-endif
-
-CHANGES_ERROR = $(error No CHANGES specified)
-
-verify-changes:
-	@ (git status -sb --porcelain | \grep -E '^( M|M ) CHANGES' > /dev/null) || (echo no CHANGES specified && exit 2)
-
-release: verify-changes verify-tag
-	@ OLD_TAG=`git describe --abbrev=0 --tags` && \
-		npm run minify && \
-		replace "$${OLD_TAG/v/}" "$(TAG)" -- *.min.js *.json README.md && \
-		replace "blob/master" "blob/v$(TAG)" -- *.min.js && \
-		git commit -m "v$(TAG)" *.js *.map *.json README.md CHANGES && \
-		git tag "v$(TAG)"
-
diff --git a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/README.md b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/README.md
deleted file mode 100644
index 5c78c7e1..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/README.md
+++ /dev/null
@@ -1,167 +0,0 @@
-#es5-shim <sup>[![Version Badge][npm-version-svg]][npm-url]</sup>
-
-[![npm badge][npm-badge-png]][npm-url]
-
-[![Build Status][travis-svg]][travis-url]
-[![dependency status][deps-svg]][deps-url]
-[![dev dependency status][dev-deps-svg]][dev-deps-url]
-
-`es5-shim.js` and `es5-shim.min.js` monkey-patch a JavaScript context to
-contain all EcmaScript 5 methods that can be faithfully emulated with a
-legacy JavaScript engine.
-
-`es5-sham.js` and `es5-sham.min.js` monkey-patch other ES5 methods as
-closely as possible.  For these methods, as closely as possible to ES5
-is not very close.  Many of these shams are intended only to allow code
-to be written to ES5 without causing run-time errors in older engines.
-In many cases, this means that these shams cause many ES5 methods to
-silently fail.  Decide carefully whether this is what you want.
-**Note:** `es5-sham.js` requires `es5-shim.js` to be able to work properly.
-
-
-## Tests
-
-The tests are written with the Jasmine BDD test framework.
-To run the tests, navigate to <root-folder>/tests/ , or,
-simply `npm install` and `npm test`.
-
-## Shims
-
-### Complete tests ###
-
-* Array.prototype.every
-* Array.prototype.filter
-* Array.prototype.forEach
-* Array.prototype.indexOf
-* Array.prototype.lastIndexOf
-* Array.prototype.map
-* Array.prototype.some
-* Array.prototype.reduce
-* Array.prototype.reduceRight
-* Array.isArray
-* Date.now
-* Date.prototype.toJSON
-* Function.prototype.bind
-    * :warning: Caveat: the bound function has a prototype property.
-    * :warning: Caveat: bound functions do not try too hard to keep you
-      from manipulating their ``arguments`` and ``caller`` properties.
-    * :warning: Caveat: bound functions don't have checks in ``call`` and
-      ``apply`` to avoid executing as a constructor.
-* Number.prototype.toFixed
-* Object.keys
-* String.prototype.split
-* String.prototype.trim
-* String.prototype.replace
-    * Firefox (through v29) natively handles capturing groups incorrectly.
-* Date.parse (for ISO parsing)
-* Date.prototype.toISOString
-* parseInt
-
-## Shams
-
-* :warning: Object.create
-
-    For the case of simply "begetting" an object that inherits
-    prototypically from another, this should work fine across legacy
-    engines.
-
-    :warning: The second argument is passed to Object.defineProperties
-    which will probably fail either silently or with extreme prejudice.
-
-* :warning: Object.getPrototypeOf
-
-    This will return "undefined" in some cases.  It uses `__proto__` if
-    it's available.  Failing that, it uses constructor.prototype, which
-    depends on the constructor property of the object's prototype having
-    not been replaced.  If your object was created like this, it won't
-    work:
-
-        function Foo() {
-        }
-        Foo.prototype = {};
-
-    Because the prototype reassignment destroys the constructor
-    property.
-
-    This will work for all objects that were created using
-    `Object.create` implemented with this library.
-
-* :warning: Object.getOwnPropertyNames
-
-    This method uses Object.keys, so it will not be accurate on legacy
-    engines.
-
-* Object.isSealed
-
-    Returns "false" in all legacy engines for all objects, which is
-    conveniently guaranteed to be accurate.
-
-* Object.isFrozen
-
-    Returns "false" in all legacy engines for all objects, which is
-    conveniently guaranteed to be accurate.
-
-* Object.isExtensible
-
-    Works like a charm, by trying very hard to extend the object then
-    redacting the extension.
-
-### May fail
-
-* :warning: Object.getOwnPropertyDescriptor
-
-    The behavior of this shim does not conform to ES5.  It should
-    probably not be used at this time, until its behavior has been
-    reviewed and been confirmed to be useful in legacy engines.
-
-* :warning: Object.defineProperty
-
-    In the worst of circumstances, IE 8 provides a version of this
-    method that only works on DOM objects.  This sham will not be
-    installed.  The given version of `defineProperty` will throw an
-    exception if used on non-DOM objects.
-
-    In slightly better circumstances, this method will silently fail to
-    set "writable", "enumerable", and "configurable" properties.
-
-    Providing a getter or setter with "get" or "set" on a descriptor
-    will silently fail on engines that lack "__defineGetter__" and
-    "__defineSetter__", which include all versions of IE.
-
-    https://github.com/es-shims/es5-shim/issues#issue/5
-
-* :warning: Object.defineProperties
-
-    This uses the Object.defineProperty shim.
-
-* Object.seal
-
-    Silently fails on all legacy engines.  This should be
-    fine unless you are depending on the safety and security
-    provisions of this method, which you cannot possibly
-    obtain in legacy engines.
-
-* Object.freeze
-
-    Silently fails on all legacy engines.  This should be
-    fine unless you are depending on the safety and security
-    provisions of this method, which you cannot possibly
-    obtain in legacy engines.
-
-* Object.preventExtensions
-
-    Silently fails on all legacy engines.  This should be
-    fine unless you are depending on the safety and security
-    provisions of this method, which you cannot possibly
-    obtain in legacy engines.
-
-[npm-url]: https://npmjs.org/package/es5-shim
-[npm-version-svg]: http://vb.teelaun.ch/es-shims/es5-shim.svg
-[travis-svg]: https://travis-ci.org/es-shims/es5-shim.svg
-[travis-url]: https://travis-ci.org/es-shims/es5-shim
-[deps-svg]: https://david-dm.org/es-shims/es5-shim.svg
-[deps-url]: https://david-dm.org/es-shims/es5-shim
-[dev-deps-svg]: https://david-dm.org/es-shims/es5-shim/dev-status.svg
-[dev-deps-url]: https://david-dm.org/es-shims/es5-shim#info=devDependencies
-[npm-badge-png]: https://nodei.co/npm/es5-shim.png?downloads=true&stars=true
-
diff --git a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/bower.json b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/bower.json
deleted file mode 100644
index d2ce3c77..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/bower.json
+++ /dev/null
@@ -1,34 +0,0 @@
-{
-    "name": "es5-shim",
-    "version": "4.0.6",
-    "main": "es5-shim.js",
-    "repository": {
-        "type": "git",
-        "url": "git://github.com/es-shims/es5-shim"
-    },
-    "homepage": "https://github.com/es-shims/es5-shim",
-    "authors": [
-        "Kris Kowal <kris@cixar.com> (http://github.com/kriskowal/)",
-        "Sami Samhuri <sami.samhuri@gmail.com> (http://samhuri.net/)",
-        "Florian Schäfer <florian.schaefer@gmail.com> (http://github.com/fschaefer)",
-        "Irakli Gozalishvili <rfobic@gmail.com> (http://jeditoolkit.com)",
-        "Kit Cambridge <kitcambridge@gmail.com> (http://kitcambridge.github.com)",
-        "Jordan Harband <ljharb@gmail.com> (https://github.com/ljharb/)"
-    ],
-    "description": "ECMAScript 5 compatibility shims for legacy JavaScript engines",
-    "keywords": [
-        "shim",
-        "es5",
-        "es5 shim",
-        "javascript",
-        "ecmascript",
-        "polyfill"
-    ],
-    "license": "MIT",
-    "ignore": [
-        "**/.*",
-        "node_modules",
-        "bower_components",
-        "tests"
-    ]
-}
diff --git a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/component.json b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/component.json
deleted file mode 100644
index dda4e636..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/component.json
+++ /dev/null
@@ -1,19 +0,0 @@
-{
-    "name": "es5-shim",
-    "repo": "es-shims/es5-shim",
-    "description": "ECMAScript 5 compatibility shims for legacy JavaScript engines",
-    "version": "v4.0.6",
-    "keywords": [
-        "shim",
-        "es5",
-        "es5 shim",
-        "javascript",
-        "ecmascript",
-        "polyfill"
-    ],
-    "license": "MIT",
-    "main": "es5-shim.js",
-    "scripts": [
-        "es5-shim.js"
-    ]
-}
diff --git a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-sham.js b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-sham.js
deleted file mode 100644
index 73c51228..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-sham.js
+++ /dev/null
@@ -1,496 +0,0 @@
-/*!
- * https://github.com/es-shims/es5-shim
- * @license es5-shim Copyright 2009-2014 by contributors, MIT License
- * see https://github.com/es-shims/es5-shim/blob/master/LICENSE
- */
-
-// vim: ts=4 sts=4 sw=4 expandtab
-
-//Add semicolon to prevent IIFE from being passed as argument to concated code.
-;
-
-// UMD (Universal Module Definition)
-// see https://github.com/umdjs/umd/blob/master/returnExports.js
-(function (root, factory) {
-    'use strict';
-    /*global define, exports, module */
-    if (typeof define === 'function' && define.amd) {
-        // AMD. Register as an anonymous module.
-        define(factory);
-    } else if (typeof exports === 'object') {
-        // Node. Does not work with strict CommonJS, but
-        // only CommonJS-like enviroments that support module.exports,
-        // like Node.
-        module.exports = factory();
-    } else {
-        // Browser globals (root is window)
-        root.returnExports = factory();
-  }
-}(this, function () {
-
-var call = Function.prototype.call;
-var prototypeOfObject = Object.prototype;
-var owns = call.bind(prototypeOfObject.hasOwnProperty);
-
-// If JS engine supports accessors creating shortcuts.
-var defineGetter;
-var defineSetter;
-var lookupGetter;
-var lookupSetter;
-var supportsAccessors = owns(prototypeOfObject, '__defineGetter__');
-if (supportsAccessors) {
-    /*eslint-disable no-underscore-dangle */
-    defineGetter = call.bind(prototypeOfObject.__defineGetter__);
-    defineSetter = call.bind(prototypeOfObject.__defineSetter__);
-    lookupGetter = call.bind(prototypeOfObject.__lookupGetter__);
-    lookupSetter = call.bind(prototypeOfObject.__lookupSetter__);
-    /*eslint-enable no-underscore-dangle */
-}
-
-// ES5 15.2.3.2
-// http://es5.github.com/#x15.2.3.2
-if (!Object.getPrototypeOf) {
-    // https://github.com/es-shims/es5-shim/issues#issue/2
-    // http://ejohn.org/blog/objectgetprototypeof/
-    // recommended by fschaefer on github
-    //
-    // sure, and webreflection says ^_^
-    // ... this will nerever possibly return null
-    // ... Opera Mini breaks here with infinite loops
-    Object.getPrototypeOf = function getPrototypeOf(object) {
-        /*eslint-disable no-proto */
-        var proto = object.__proto__;
-        /*eslint-enable no-proto */
-        if (proto || proto === null) {
-            return proto;
-        } else if (object.constructor) {
-            return object.constructor.prototype;
-        } else {
-            return prototypeOfObject;
-        }
-    };
-}
-
-//ES5 15.2.3.3
-//http://es5.github.com/#x15.2.3.3
-
-function doesGetOwnPropertyDescriptorWork(object) {
-    try {
-        object.sentinel = 0;
-        return Object.getOwnPropertyDescriptor(object, 'sentinel').value === 0;
-    } catch (exception) {
-        // returns falsy
-    }
-}
-
-//check whether getOwnPropertyDescriptor works if it's given. Otherwise,
-//shim partially.
-if (Object.defineProperty) {
-    var getOwnPropertyDescriptorWorksOnObject = doesGetOwnPropertyDescriptorWork({});
-    var getOwnPropertyDescriptorWorksOnDom = typeof document === 'undefined' ||
-    doesGetOwnPropertyDescriptorWork(document.createElement('div'));
-    if (!getOwnPropertyDescriptorWorksOnDom || !getOwnPropertyDescriptorWorksOnObject) {
-        var getOwnPropertyDescriptorFallback = Object.getOwnPropertyDescriptor;
-    }
-}
-
-if (!Object.getOwnPropertyDescriptor || getOwnPropertyDescriptorFallback) {
-    var ERR_NON_OBJECT = 'Object.getOwnPropertyDescriptor called on a non-object: ';
-
-    /*eslint-disable no-proto */
-    Object.getOwnPropertyDescriptor = function getOwnPropertyDescriptor(object, property) {
-        if ((typeof object !== 'object' && typeof object !== 'function') || object === null) {
-            throw new TypeError(ERR_NON_OBJECT + object);
-        }
-
-        // make a valiant attempt to use the real getOwnPropertyDescriptor
-        // for I8's DOM elements.
-        if (getOwnPropertyDescriptorFallback) {
-            try {
-                return getOwnPropertyDescriptorFallback.call(Object, object, property);
-            } catch (exception) {
-                // try the shim if the real one doesn't work
-            }
-        }
-
-        var descriptor;
-
-        // If object does not owns property return undefined immediately.
-        if (!owns(object, property)) {
-            return descriptor;
-        }
-
-        // If object has a property then it's for sure both `enumerable` and
-        // `configurable`.
-        descriptor = { enumerable: true, configurable: true };
-
-        // If JS engine supports accessor properties then property may be a
-        // getter or setter.
-        if (supportsAccessors) {
-            // Unfortunately `__lookupGetter__` will return a getter even
-            // if object has own non getter property along with a same named
-            // inherited getter. To avoid misbehavior we temporary remove
-            // `__proto__` so that `__lookupGetter__` will return getter only
-            // if it's owned by an object.
-            var prototype = object.__proto__;
-            var notPrototypeOfObject = object !== prototypeOfObject;
-            // avoid recursion problem, breaking in Opera Mini when
-            // Object.getOwnPropertyDescriptor(Object.prototype, 'toString')
-            // or any other Object.prototype accessor
-            if (notPrototypeOfObject) {
-                object.__proto__ = prototypeOfObject;
-            }
-
-            var getter = lookupGetter(object, property);
-            var setter = lookupSetter(object, property);
-
-            if (notPrototypeOfObject) {
-                // Once we have getter and setter we can put values back.
-                object.__proto__ = prototype;
-            }
-
-            if (getter || setter) {
-                if (getter) {
-                    descriptor.get = getter;
-                }
-                if (setter) {
-                    descriptor.set = setter;
-                }
-                // If it was accessor property we're done and return here
-                // in order to avoid adding `value` to the descriptor.
-                return descriptor;
-            }
-        }
-
-        // If we got this far we know that object has an own property that is
-        // not an accessor so we set it as a value and return descriptor.
-        descriptor.value = object[property];
-        descriptor.writable = true;
-        return descriptor;
-    };
-    /*eslint-enable no-proto */
-}
-
-// ES5 15.2.3.4
-// http://es5.github.com/#x15.2.3.4
-if (!Object.getOwnPropertyNames) {
-    Object.getOwnPropertyNames = function getOwnPropertyNames(object) {
-        return Object.keys(object);
-    };
-}
-
-// ES5 15.2.3.5
-// http://es5.github.com/#x15.2.3.5
-if (!Object.create) {
-
-    // Contributed by Brandon Benvie, October, 2012
-    var createEmpty;
-    var supportsProto = !({ __proto__: null } instanceof Object);
-                        // the following produces false positives
-                        // in Opera Mini => not a reliable check
-                        // Object.prototype.__proto__ === null
-    /*global document */
-    if (supportsProto || typeof document === 'undefined') {
-        createEmpty = function () {
-            return { __proto__: null };
-        };
-    } else {
-        // In old IE __proto__ can't be used to manually set `null`, nor does
-        // any other method exist to make an object that inherits from nothing,
-        // aside from Object.prototype itself. Instead, create a new global
-        // object and *steal* its Object.prototype and strip it bare. This is
-        // used as the prototype to create nullary objects.
-        createEmpty = function () {
-            var iframe = document.createElement('iframe');
-            var parent = document.body || document.documentElement;
-            iframe.style.display = 'none';
-            parent.appendChild(iframe);
-            /*eslint-disable no-script-url */
-            iframe.src = 'javascript:';
-            /*eslint-enable no-script-url */
-            var empty = iframe.contentWindow.Object.prototype;
-            parent.removeChild(iframe);
-            iframe = null;
-            delete empty.constructor;
-            delete empty.hasOwnProperty;
-            delete empty.propertyIsEnumerable;
-            delete empty.isPrototypeOf;
-            delete empty.toLocaleString;
-            delete empty.toString;
-            delete empty.valueOf;
-            /*eslint-disable no-proto */
-            empty.__proto__ = null;
-            /*eslint-enable no-proto */
-
-            function Empty() {}
-            Empty.prototype = empty;
-            // short-circuit future calls
-            createEmpty = function () {
-                return new Empty();
-            };
-            return new Empty();
-        };
-    }
-
-    Object.create = function create(prototype, properties) {
-
-        var object;
-        function Type() {}  // An empty constructor.
-
-        if (prototype === null) {
-            object = createEmpty();
-        } else {
-            if (typeof prototype !== 'object' && typeof prototype !== 'function') {
-                // In the native implementation `parent` can be `null`
-                // OR *any* `instanceof Object`  (Object|Function|Array|RegExp|etc)
-                // Use `typeof` tho, b/c in old IE, DOM elements are not `instanceof Object`
-                // like they are in modern browsers. Using `Object.create` on DOM elements
-                // is...err...probably inappropriate, but the native version allows for it.
-                throw new TypeError('Object prototype may only be an Object or null'); // same msg as Chrome
-            }
-            Type.prototype = prototype;
-            object = new Type();
-            // IE has no built-in implementation of `Object.getPrototypeOf`
-            // neither `__proto__`, but this manually setting `__proto__` will
-            // guarantee that `Object.getPrototypeOf` will work as expected with
-            // objects created using `Object.create`
-            /*eslint-disable no-proto */
-            object.__proto__ = prototype;
-            /*eslint-enable no-proto */
-        }
-
-        if (properties !== void 0) {
-            Object.defineProperties(object, properties);
-        }
-
-        return object;
-    };
-}
-
-// ES5 15.2.3.6
-// http://es5.github.com/#x15.2.3.6
-
-// Patch for WebKit and IE8 standard mode
-// Designed by hax <hax.github.com>
-// related issue: https://github.com/es-shims/es5-shim/issues#issue/5
-// IE8 Reference:
-//     http://msdn.microsoft.com/en-us/library/dd282900.aspx
-//     http://msdn.microsoft.com/en-us/library/dd229916.aspx
-// WebKit Bugs:
-//     https://bugs.webkit.org/show_bug.cgi?id=36423
-
-function doesDefinePropertyWork(object) {
-    try {
-        Object.defineProperty(object, 'sentinel', {});
-        return 'sentinel' in object;
-    } catch (exception) {
-        // returns falsy
-    }
-}
-
-// check whether defineProperty works if it's given. Otherwise,
-// shim partially.
-if (Object.defineProperty) {
-    var definePropertyWorksOnObject = doesDefinePropertyWork({});
-    var definePropertyWorksOnDom = typeof document === 'undefined' ||
-        doesDefinePropertyWork(document.createElement('div'));
-    if (!definePropertyWorksOnObject || !definePropertyWorksOnDom) {
-        var definePropertyFallback = Object.defineProperty,
-            definePropertiesFallback = Object.defineProperties;
-    }
-}
-
-if (!Object.defineProperty || definePropertyFallback) {
-    var ERR_NON_OBJECT_DESCRIPTOR = 'Property description must be an object: ';
-    var ERR_NON_OBJECT_TARGET = 'Object.defineProperty called on non-object: ';
-    var ERR_ACCESSORS_NOT_SUPPORTED = 'getters & setters can not be defined on this javascript engine';
-
-    Object.defineProperty = function defineProperty(object, property, descriptor) {
-        if ((typeof object !== 'object' && typeof object !== 'function') || object === null) {
-            throw new TypeError(ERR_NON_OBJECT_TARGET + object);
-        }
-        if ((typeof descriptor !== 'object' && typeof descriptor !== 'function') || descriptor === null) {
-            throw new TypeError(ERR_NON_OBJECT_DESCRIPTOR + descriptor);
-        }
-        // make a valiant attempt to use the real defineProperty
-        // for I8's DOM elements.
-        if (definePropertyFallback) {
-            try {
-                return definePropertyFallback.call(Object, object, property, descriptor);
-            } catch (exception) {
-                // try the shim if the real one doesn't work
-            }
-        }
-
-        // If it's a data property.
-        if ('value' in descriptor) {
-            // fail silently if 'writable', 'enumerable', or 'configurable'
-            // are requested but not supported
-            /*
-            // alternate approach:
-            if ( // can't implement these features; allow false but not true
-                ('writable' in descriptor && !descriptor.writable) ||
-                ('enumerable' in descriptor && !descriptor.enumerable) ||
-                ('configurable' in descriptor && !descriptor.configurable)
-            ))
-                throw new RangeError(
-                    'This implementation of Object.defineProperty does not support configurable, enumerable, or writable.'
-                );
-            */
-
-            if (supportsAccessors && (lookupGetter(object, property) || lookupSetter(object, property))) {
-                // As accessors are supported only on engines implementing
-                // `__proto__` we can safely override `__proto__` while defining
-                // a property to make sure that we don't hit an inherited
-                // accessor.
-                /*eslint-disable no-proto */
-                var prototype = object.__proto__;
-                object.__proto__ = prototypeOfObject;
-                // Deleting a property anyway since getter / setter may be
-                // defined on object itself.
-                delete object[property];
-                object[property] = descriptor.value;
-                // Setting original `__proto__` back now.
-                object.__proto__ = prototype;
-                /*eslint-enable no-proto */
-            } else {
-                object[property] = descriptor.value;
-            }
-        } else {
-            if (!supportsAccessors) {
-                throw new TypeError(ERR_ACCESSORS_NOT_SUPPORTED);
-            }
-            // If we got that far then getters and setters can be defined !!
-            if ('get' in descriptor) {
-                defineGetter(object, property, descriptor.get);
-            }
-            if ('set' in descriptor) {
-                defineSetter(object, property, descriptor.set);
-            }
-        }
-        return object;
-    };
-}
-
-// ES5 15.2.3.7
-// http://es5.github.com/#x15.2.3.7
-if (!Object.defineProperties || definePropertiesFallback) {
-    Object.defineProperties = function defineProperties(object, properties) {
-        // make a valiant attempt to use the real defineProperties
-        if (definePropertiesFallback) {
-            try {
-                return definePropertiesFallback.call(Object, object, properties);
-            } catch (exception) {
-                // try the shim if the real one doesn't work
-            }
-        }
-
-        for (var property in properties) {
-            if (owns(properties, property) && property !== '__proto__') {
-                Object.defineProperty(object, property, properties[property]);
-            }
-        }
-        return object;
-    };
-}
-
-// ES5 15.2.3.8
-// http://es5.github.com/#x15.2.3.8
-if (!Object.seal) {
-    Object.seal = function seal(object) {
-        if (Object(object) !== object) {
-            throw new TypeError('Object.seal can only be called on Objects.');
-        }
-        // this is misleading and breaks feature-detection, but
-        // allows "securable" code to "gracefully" degrade to working
-        // but insecure code.
-        return object;
-    };
-}
-
-// ES5 15.2.3.9
-// http://es5.github.com/#x15.2.3.9
-if (!Object.freeze) {
-    Object.freeze = function freeze(object) {
-        if (Object(object) !== object) {
-            throw new TypeError('Object.freeze can only be called on Objects.');
-        }
-        // this is misleading and breaks feature-detection, but
-        // allows "securable" code to "gracefully" degrade to working
-        // but insecure code.
-        return object;
-    };
-}
-
-// detect a Rhino bug and patch it
-try {
-    Object.freeze(function () {});
-} catch (exception) {
-    Object.freeze = (function freeze(freezeObject) {
-        return function freeze(object) {
-            if (typeof object === 'function') {
-                return object;
-            } else {
-                return freezeObject(object);
-            }
-        };
-    }(Object.freeze));
-}
-
-// ES5 15.2.3.10
-// http://es5.github.com/#x15.2.3.10
-if (!Object.preventExtensions) {
-    Object.preventExtensions = function preventExtensions(object) {
-        if (Object(object) !== object) {
-            throw new TypeError('Object.preventExtensions can only be called on Objects.');
-        }
-        // this is misleading and breaks feature-detection, but
-        // allows "securable" code to "gracefully" degrade to working
-        // but insecure code.
-        return object;
-    };
-}
-
-// ES5 15.2.3.11
-// http://es5.github.com/#x15.2.3.11
-if (!Object.isSealed) {
-    Object.isSealed = function isSealed(object) {
-        if (Object(object) !== object) {
-            throw new TypeError('Object.isSealed can only be called on Objects.');
-        }
-        return false;
-    };
-}
-
-// ES5 15.2.3.12
-// http://es5.github.com/#x15.2.3.12
-if (!Object.isFrozen) {
-    Object.isFrozen = function isFrozen(object) {
-        if (Object(object) !== object) {
-            throw new TypeError('Object.isFrozen can only be called on Objects.');
-        }
-        return false;
-    };
-}
-
-// ES5 15.2.3.13
-// http://es5.github.com/#x15.2.3.13
-if (!Object.isExtensible) {
-    Object.isExtensible = function isExtensible(object) {
-        // 1. If Type(O) is not Object throw a TypeError exception.
-        if (Object(object) !== object) {
-            throw new TypeError('Object.isExtensible can only be called on Objects.');
-        }
-        // 2. Return the Boolean value of the [[Extensible]] internal property of O.
-        var name = '';
-        while (owns(object, name)) {
-            name += '?';
-        }
-        object[name] = true;
-        var returnValue = owns(object, name);
-        delete object[name];
-        return returnValue;
-    };
-}
-
-}));
diff --git a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-sham.map b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-sham.map
deleted file mode 100644
index 6f95560b..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-sham.map
+++ /dev/null
@@ -1 +0,0 @@
-{"version":3,"sources":["es5-sham.js"],"names":["root","factory","define","amd","exports","module","returnExports","this","call","Function","prototype","prototypeOfObject","Object","owns","bind","hasOwnProperty","defineGetter","defineSetter","lookupGetter","lookupSetter","supportsAccessors","__defineGetter__","__defineSetter__","__lookupGetter__","__lookupSetter__","getPrototypeOf","object","proto","__proto__","constructor","doesGetOwnPropertyDescriptorWork","sentinel","getOwnPropertyDescriptor","value","exception","defineProperty","getOwnPropertyDescriptorWorksOnObject","getOwnPropertyDescriptorWorksOnDom","document","createElement","getOwnPropertyDescriptorFallback","ERR_NON_OBJECT","property","TypeError","descriptor","enumerable","configurable","notPrototypeOfObject","getter","setter","get","set","writable","getOwnPropertyNames","keys","create","createEmpty","supportsProto","iframe","parent","body","documentElement","style","display","appendChild","src","empty","contentWindow","removeChild","propertyIsEnumerable","isPrototypeOf","toLocaleString","toString","valueOf","Empty","properties","Type","defineProperties","doesDefinePropertyWork","definePropertyWorksOnObject","definePropertyWorksOnDom","definePropertyFallback","definePropertiesFallback","ERR_NON_OBJECT_DESCRIPTOR","ERR_NON_OBJECT_TARGET","ERR_ACCESSORS_NOT_SUPPORTED","seal","freeze","freezeObject","preventExtensions","isSealed","isFrozen","isExtensible","name","returnValue"],"mappings":";;;;;CAaC,SAAUA,EAAMC,GACb,YAEA,UAAWC,UAAW,YAAcA,OAAOC,IAAK,CAE5CD,OAAOD,OACJ,UAAWG,WAAY,SAAU,CAIpCC,OAAOD,QAAUH,QACd,CAEHD,EAAKM,cAAgBL,OAE3BM,KAAM,WAER,GAAIC,GAAOC,SAASC,UAAUF,IAC9B,IAAIG,GAAoBC,OAAOF,SAC/B,IAAIG,GAAOL,EAAKM,KAAKH,EAAkBI,eAGvC,IAAIC,EACJ,IAAIC,EACJ,IAAIC,EACJ,IAAIC,EACJ,IAAIC,GAAoBP,EAAKF,EAAmB,mBAChD,IAAIS,EAAmB,CAEnBJ,EAAeR,EAAKM,KAAKH,EAAkBU,iBAC3CJ,GAAeT,EAAKM,KAAKH,EAAkBW,iBAC3CJ,GAAeV,EAAKM,KAAKH,EAAkBY,iBAC3CJ,GAAeX,EAAKM,KAAKH,EAAkBa,kBAM/C,IAAKZ,OAAOa,eAAgB,CAQxBb,OAAOa,eAAiB,QAASA,GAAeC,GAE5C,GAAIC,GAAQD,EAAOE,SAEnB,IAAID,GAASA,IAAU,KAAM,CACzB,MAAOA,OACJ,IAAID,EAAOG,YAAa,CAC3B,MAAOH,GAAOG,YAAYnB,cACvB,CACH,MAAOC,KAQnB,QAASmB,GAAiCJ,GACtC,IACIA,EAAOK,SAAW,CAClB,OAAOnB,QAAOoB,yBAAyBN,EAAQ,YAAYO,QAAU,EACvE,MAAOC,KAOb,GAAItB,OAAOuB,eAAgB,CACvB,GAAIC,GAAwCN,KAC5C,IAAIO,SAA4CC,YAAa,aAC7DR,EAAiCQ,SAASC,cAAc,OACxD,KAAKF,IAAuCD,EAAuC,CAC/E,GAAII,GAAmC5B,OAAOoB,0BAItD,IAAKpB,OAAOoB,0BAA4BQ,EAAkC,CACtE,GAAIC,GAAiB,0DAGrB7B,QAAOoB,yBAA2B,QAASA,GAAyBN,EAAQgB,GACxE,SAAYhB,KAAW,gBAAmBA,KAAW,YAAeA,IAAW,KAAM,CACjF,KAAM,IAAIiB,WAAUF,EAAiBf,GAKzC,GAAIc,EAAkC,CAClC,IACI,MAAOA,GAAiChC,KAAKI,OAAQc,EAAQgB,GAC/D,MAAOR,KAKb,GAAIU,EAGJ,KAAK/B,EAAKa,EAAQgB,GAAW,CACzB,MAAOE,GAKXA,GAAeC,WAAY,KAAMC,aAAc,KAI/C,IAAI1B,EAAmB,CAMnB,GAAIV,GAAYgB,EAAOE,SACvB,IAAImB,GAAuBrB,IAAWf,CAItC,IAAIoC,EAAsB,CACtBrB,EAAOE,UAAYjB,EAGvB,GAAIqC,GAAS9B,EAAaQ,EAAQgB,EAClC,IAAIO,GAAS9B,EAAaO,EAAQgB,EAElC,IAAIK,EAAsB,CAEtBrB,EAAOE,UAAYlB,EAGvB,GAAIsC,GAAUC,EAAQ,CAClB,GAAID,EAAQ,CACRJ,EAAWM,IAAMF,EAErB,GAAIC,EAAQ,CACRL,EAAWO,IAAMF,EAIrB,MAAOL,IAMfA,EAAWX,MAAQP,EAAOgB,EAC1BE,GAAWQ,SAAW,IACtB,OAAOR,IAOf,IAAKhC,OAAOyC,oBAAqB,CAC7BzC,OAAOyC,oBAAsB,QAASA,GAAoB3B,GACtD,MAAOd,QAAO0C,KAAK5B,IAM3B,IAAKd,OAAO2C,OAAQ,CAGhB,GAAIC,EACJ,IAAIC,MAAoB7B,UAAW,eAAkBhB,QAKrD,IAAI6C,SAAwBnB,YAAa,YAAa,CAClDkB,EAAc,WACV,OAAS5B,UAAW,WAErB,CAMH4B,EAAc,WACV,GAAIE,GAASpB,SAASC,cAAc,SACpC,IAAIoB,GAASrB,SAASsB,MAAQtB,SAASuB,eACvCH,GAAOI,MAAMC,QAAU,MACvBJ,GAAOK,YAAYN,EAEnBA,GAAOO,IAAM,aAEb,IAAIC,GAAQR,EAAOS,cAAcvD,OAAOF,SACxCiD,GAAOS,YAAYV,EACnBA,GAAS,WACFQ,GAAMrC,kBACNqC,GAAMnD,qBACNmD,GAAMG,2BACNH,GAAMI,oBACNJ,GAAMK,qBACNL,GAAMM,eACNN,GAAMO,OAEbP,GAAMtC,UAAY,IAGlB,SAAS8C,MACTA,EAAMhE,UAAYwD,CAElBV,GAAc,WACV,MAAO,IAAIkB,GAEf,OAAO,IAAIA,IAInB9D,OAAO2C,OAAS,QAASA,GAAO7C,EAAWiE,GAEvC,GAAIjD,EACJ,SAASkD,MAET,GAAIlE,IAAc,KAAM,CACpBgB,EAAS8B,QACN,CACH,SAAW9C,KAAc,gBAAmBA,KAAc,WAAY,CAMlE,KAAM,IAAIiC,WAAU,kDAExBiC,EAAKlE,UAAYA,CACjBgB,GAAS,GAAIkD,EAMblD,GAAOE,UAAYlB,EAIvB,GAAIiE,QAAoB,GAAG,CACvB/D,OAAOiE,iBAAiBnD,EAAQiD,GAGpC,MAAOjD,IAgBf,QAASoD,GAAuBpD,GAC5B,IACId,OAAOuB,eAAeT,EAAQ,cAC9B,OAAO,YAAcA,GACvB,MAAOQ,KAOb,GAAItB,OAAOuB,eAAgB,CACvB,GAAI4C,GAA8BD,KAClC,IAAIE,SAAkC1C,YAAa,aAC/CwC,EAAuBxC,SAASC,cAAc,OAClD,KAAKwC,IAAgCC,EAA0B,CAC3D,GAAIC,GAAyBrE,OAAOuB,eAChC+C,EAA2BtE,OAAOiE,kBAI9C,IAAKjE,OAAOuB,gBAAkB8C,EAAwB,CAClD,GAAIE,GAA4B,0CAChC,IAAIC,GAAwB,8CAC5B,IAAIC,GAA8B,gEAElCzE,QAAOuB,eAAiB,QAASA,GAAeT,EAAQgB,EAAUE,GAC9D,SAAYlB,KAAW,gBAAmBA,KAAW,YAAeA,IAAW,KAAM,CACjF,KAAM,IAAIiB,WAAUyC,EAAwB1D,GAEhD,SAAYkB,KAAe,gBAAmBA,KAAe,YAAeA,IAAe,KAAM,CAC7F,KAAM,IAAID,WAAUwC,EAA4BvC,GAIpD,GAAIqC,EAAwB,CACxB,IACI,MAAOA,GAAuBzE,KAAKI,OAAQc,EAAQgB,EAAUE,GAC/D,MAAOV,KAMb,GAAI,SAAWU,GAAY,CAevB,GAAIxB,IAAsBF,EAAaQ,EAAQgB,IAAavB,EAAaO,EAAQgB,IAAY,CAMzF,GAAIhC,GAAYgB,EAAOE,SACvBF,GAAOE,UAAYjB,QAGZe,GAAOgB,EACdhB,GAAOgB,GAAYE,EAAWX,KAE9BP,GAAOE,UAAYlB,MAEhB,CACHgB,EAAOgB,GAAYE,EAAWX,WAE/B,CACH,IAAKb,EAAmB,CACpB,KAAM,IAAIuB,WAAU0C,GAGxB,GAAI,OAASzC,GAAY,CACrB5B,EAAaU,EAAQgB,EAAUE,EAAWM,KAE9C,GAAI,OAASN,GAAY,CACrB3B,EAAaS,EAAQgB,EAAUE,EAAWO,MAGlD,MAAOzB,IAMf,IAAKd,OAAOiE,kBAAoBK,EAA0B,CACtDtE,OAAOiE,iBAAmB,QAASA,GAAiBnD,EAAQiD,GAExD,GAAIO,EAA0B,CAC1B,IACI,MAAOA,GAAyB1E,KAAKI,OAAQc,EAAQiD,GACvD,MAAOzC,KAKb,IAAK,GAAIQ,KAAYiC,GAAY,CAC7B,GAAI9D,EAAK8D,EAAYjC,IAAaA,IAAa,YAAa,CACxD9B,OAAOuB,eAAeT,EAAQgB,EAAUiC,EAAWjC,KAG3D,MAAOhB,IAMf,IAAKd,OAAO0E,KAAM,CACd1E,OAAO0E,KAAO,QAASA,GAAK5D,GACxB,GAAId,OAAOc,KAAYA,EAAQ,CAC3B,KAAM,IAAIiB,WAAU,8CAKxB,MAAOjB,IAMf,IAAKd,OAAO2E,OAAQ,CAChB3E,OAAO2E,OAAS,QAASA,GAAO7D,GAC5B,GAAId,OAAOc,KAAYA,EAAQ,CAC3B,KAAM,IAAIiB,WAAU,gDAKxB,MAAOjB,IAKf,IACId,OAAO2E,OAAO,cAChB,MAAOrD,GACLtB,OAAO2E,OAAU,QAASA,GAAOC,GAC7B,MAAO,SAASD,GAAO7D,GACnB,SAAWA,KAAW,WAAY,CAC9B,MAAOA,OACJ,CACH,MAAO8D,GAAa9D,MAG9Bd,OAAO2E,QAKb,IAAK3E,OAAO6E,kBAAmB,CAC3B7E,OAAO6E,kBAAoB,QAASA,GAAkB/D,GAClD,GAAId,OAAOc,KAAYA,EAAQ,CAC3B,KAAM,IAAIiB,WAAU,2DAKxB,MAAOjB,IAMf,IAAKd,OAAO8E,SAAU,CAClB9E,OAAO8E,SAAW,QAASA,GAAShE,GAChC,GAAId,OAAOc,KAAYA,EAAQ,CAC3B,KAAM,IAAIiB,WAAU,kDAExB,MAAO,QAMf,IAAK/B,OAAO+E,SAAU,CAClB/E,OAAO+E,SAAW,QAASA,GAASjE,GAChC,GAAId,OAAOc,KAAYA,EAAQ,CAC3B,KAAM,IAAIiB,WAAU,kDAExB,MAAO,QAMf,IAAK/B,OAAOgF,aAAc,CACtBhF,OAAOgF,aAAe,QAASA,GAAalE,GAExC,GAAId,OAAOc,KAAYA,EAAQ,CAC3B,KAAM,IAAIiB,WAAU,sDAGxB,GAAIkD,GAAO,EACX,OAAOhF,EAAKa,EAAQmE,GAAO,CACvBA,GAAQ,IAEZnE,EAAOmE,GAAQ,IACf,IAAIC,GAAcjF,EAAKa,EAAQmE,SACxBnE,GAAOmE,EACd,OAAOC"}
\ No newline at end of file
diff --git a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-sham.min.js b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-sham.min.js
deleted file mode 100644
index f5df1caa..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-sham.min.js
+++ /dev/null
@@ -1,7 +0,0 @@
-/*!
- * https://github.com/es-shims/es5-shim
- * @license es5-shim Copyright 2009-2014 by contributors, MIT License
- * see https://github.com/es-shims/es5-shim/blob/v4.0.6/LICENSE
- */
-(function(e,t){"use strict";if(typeof define==="function"&&define.amd){define(t)}else if(typeof exports==="object"){module.exports=t()}else{e.returnExports=t()}})(this,function(){var e=Function.prototype.call;var t=Object.prototype;var r=e.bind(t.hasOwnProperty);var n;var o;var c;var i;var f=r(t,"__defineGetter__");if(f){n=e.bind(t.__defineGetter__);o=e.bind(t.__defineSetter__);c=e.bind(t.__lookupGetter__);i=e.bind(t.__lookupSetter__)}if(!Object.getPrototypeOf){Object.getPrototypeOf=function E(e){var r=e.__proto__;if(r||r===null){return r}else if(e.constructor){return e.constructor.prototype}else{return t}}}function l(e){try{e.sentinel=0;return Object.getOwnPropertyDescriptor(e,"sentinel").value===0}catch(t){}}if(Object.defineProperty){var u=l({});var a=typeof document==="undefined"||l(document.createElement("div"));if(!a||!u){var p=Object.getOwnPropertyDescriptor}}if(!Object.getOwnPropertyDescriptor||p){var b="Object.getOwnPropertyDescriptor called on a non-object: ";Object.getOwnPropertyDescriptor=function g(e,n){if(typeof e!=="object"&&typeof e!=="function"||e===null){throw new TypeError(b+e)}if(p){try{return p.call(Object,e,n)}catch(o){}}var l;if(!r(e,n)){return l}l={enumerable:true,configurable:true};if(f){var u=e.__proto__;var a=e!==t;if(a){e.__proto__=t}var s=c(e,n);var O=i(e,n);if(a){e.__proto__=u}if(s||O){if(s){l.get=s}if(O){l.set=O}return l}}l.value=e[n];l.writable=true;return l}}if(!Object.getOwnPropertyNames){Object.getOwnPropertyNames=function T(e){return Object.keys(e)}}if(!Object.create){var s;var O=!({__proto__:null}instanceof Object);if(O||typeof document==="undefined"){s=function(){return{__proto__:null}}}else{s=function(){var e=document.createElement("iframe");var t=document.body||document.documentElement;e.style.display="none";t.appendChild(e);e.src="javascript:";var r=e.contentWindow.Object.prototype;t.removeChild(e);e=null;delete r.constructor;delete r.hasOwnProperty;delete r.propertyIsEnumerable;delete r.isPrototypeOf;delete r.toLocaleString;delete r.toString;delete r.valueOf;r.__proto__=null;function n(){}n.prototype=r;s=function(){return new n};return new n}}Object.create=function x(e,t){var r;function n(){}if(e===null){r=s()}else{if(typeof e!=="object"&&typeof e!=="function"){throw new TypeError("Object prototype may only be an Object or null")}n.prototype=e;r=new n;r.__proto__=e}if(t!==void 0){Object.defineProperties(r,t)}return r}}function j(e){try{Object.defineProperty(e,"sentinel",{});return"sentinel"in e}catch(t){}}if(Object.defineProperty){var d=j({});var y=typeof document==="undefined"||j(document.createElement("div"));if(!d||!y){var _=Object.defineProperty,v=Object.defineProperties}}if(!Object.defineProperty||_){var w="Property description must be an object: ";var P="Object.defineProperty called on non-object: ";var h="getters & setters can not be defined on this javascript engine";Object.defineProperty=function z(e,r,l){if(typeof e!=="object"&&typeof e!=="function"||e===null){throw new TypeError(P+e)}if(typeof l!=="object"&&typeof l!=="function"||l===null){throw new TypeError(w+l)}if(_){try{return _.call(Object,e,r,l)}catch(u){}}if("value"in l){if(f&&(c(e,r)||i(e,r))){var a=e.__proto__;e.__proto__=t;delete e[r];e[r]=l.value;e.__proto__=a}else{e[r]=l.value}}else{if(!f){throw new TypeError(h)}if("get"in l){n(e,r,l.get)}if("set"in l){o(e,r,l.set)}}return e}}if(!Object.defineProperties||v){Object.defineProperties=function S(e,t){if(v){try{return v.call(Object,e,t)}catch(n){}}for(var o in t){if(r(t,o)&&o!=="__proto__"){Object.defineProperty(e,o,t[o])}}return e}}if(!Object.seal){Object.seal=function D(e){if(Object(e)!==e){throw new TypeError("Object.seal can only be called on Objects.")}return e}}if(!Object.freeze){Object.freeze=function F(e){if(Object(e)!==e){throw new TypeError("Object.freeze can only be called on Objects.")}return e}}try{Object.freeze(function(){})}catch(m){Object.freeze=function k(e){return function t(r){if(typeof r==="function"){return r}else{return e(r)}}}(Object.freeze)}if(!Object.preventExtensions){Object.preventExtensions=function G(e){if(Object(e)!==e){throw new TypeError("Object.preventExtensions can only be called on Objects.")}return e}}if(!Object.isSealed){Object.isSealed=function C(e){if(Object(e)!==e){throw new TypeError("Object.isSealed can only be called on Objects.")}return false}}if(!Object.isFrozen){Object.isFrozen=function N(e){if(Object(e)!==e){throw new TypeError("Object.isFrozen can only be called on Objects.")}return false}}if(!Object.isExtensible){Object.isExtensible=function I(e){if(Object(e)!==e){throw new TypeError("Object.isExtensible can only be called on Objects.")}var t="";while(r(e,t)){t+="?"}e[t]=true;var n=r(e,t);delete e[t];return n}}});
-//# sourceMappingURL=es5-sham.map
\ No newline at end of file
diff --git a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-shim.js b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-shim.js
deleted file mode 100644
index d3e4c9cc..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-shim.js
+++ /dev/null
@@ -1,1435 +0,0 @@
-/*!
- * https://github.com/es-shims/es5-shim
- * @license es5-shim Copyright 2009-2014 by contributors, MIT License
- * see https://github.com/es-shims/es5-shim/blob/master/LICENSE
- */
-
-// vim: ts=4 sts=4 sw=4 expandtab
-
-// Add semicolon to prevent IIFE from being passed as argument to concatenated code.
-;
-
-// UMD (Universal Module Definition)
-// see https://github.com/umdjs/umd/blob/master/returnExports.js
-(function (root, factory) {
-    'use strict';
-    /*global define, exports, module */
-    if (typeof define === 'function' && define.amd) {
-        // AMD. Register as an anonymous module.
-        define(factory);
-    } else if (typeof exports === 'object') {
-        // Node. Does not work with strict CommonJS, but
-        // only CommonJS-like enviroments that support module.exports,
-        // like Node.
-        module.exports = factory();
-    } else {
-        // Browser globals (root is window)
-        root.returnExports = factory();
-    }
-}(this, function () {
-
-/**
- * Brings an environment as close to ECMAScript 5 compliance
- * as is possible with the facilities of erstwhile engines.
- *
- * Annotated ES5: http://es5.github.com/ (specific links below)
- * ES5 Spec: http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf
- * Required reading: http://javascriptweblog.wordpress.com/2011/12/05/extending-javascript-natives/
- */
-
-// Shortcut to an often accessed properties, in order to avoid multiple
-// dereference that costs universally.
-var ArrayPrototype = Array.prototype;
-var ObjectPrototype = Object.prototype;
-var FunctionPrototype = Function.prototype;
-var StringPrototype = String.prototype;
-var NumberPrototype = Number.prototype;
-var array_slice = ArrayPrototype.slice;
-var array_splice = ArrayPrototype.splice;
-var array_push = ArrayPrototype.push;
-var array_unshift = ArrayPrototype.unshift;
-var call = FunctionPrototype.call;
-
-// Having a toString local variable name breaks in Opera so use to_string.
-var to_string = ObjectPrototype.toString;
-
-var isFunction = function (val) {
-    return to_string.call(val) === '[object Function]';
-};
-var isRegex = function (val) {
-    return to_string.call(val) === '[object RegExp]';
-};
-var isArray = function isArray(obj) {
-    return to_string.call(obj) === '[object Array]';
-};
-var isString = function isString(obj) {
-    return to_string.call(obj) === '[object String]';
-};
-var isArguments = function isArguments(value) {
-    var str = to_string.call(value);
-    var isArgs = str === '[object Arguments]';
-    if (!isArgs) {
-        isArgs = !isArray(value) &&
-          value !== null &&
-          typeof value === 'object' &&
-          typeof value.length === 'number' &&
-          value.length >= 0 &&
-          isFunction(value.callee);
-    }
-    return isArgs;
-};
-
-/* inlined from http://npmjs.com/define-properties */
-var defineProperties = (function (has) {
-  var supportsDescriptors = Object.defineProperty && (function () {
-      try {
-          Object.defineProperty({}, 'x', {});
-          return true;
-      } catch (e) { /* this is ES3 */
-          return false;
-      }
-  }());
-
-  // Define configurable, writable and non-enumerable props
-  // if they don't exist.
-  var defineProperty;
-  if (supportsDescriptors) {
-      defineProperty = function (object, name, method, forceAssign) {
-          if (!forceAssign && (name in object)) { return; }
-          Object.defineProperty(object, name, {
-              configurable: true,
-              enumerable: false,
-              writable: true,
-              value: method
-          });
-      };
-  } else {
-      defineProperty = function (object, name, method, forceAssign) {
-          if (!forceAssign && (name in object)) { return; }
-          object[name] = method;
-      };
-  }
-  return function defineProperties(object, map, forceAssign) {
-      for (var name in map) {
-          if (has.call(map, name)) {
-            defineProperty(object, name, map[name], forceAssign);
-          }
-      }
-  };
-}(ObjectPrototype.hasOwnProperty));
-
-//
-// Util
-// ======
-//
-
-// ES5 9.4
-// http://es5.github.com/#x9.4
-// http://jsperf.com/to-integer
-
-function toInteger(num) {
-    var n = +num;
-    if (n !== n) { // isNaN
-        n = 0;
-    } else if (n !== 0 && n !== (1 / 0) && n !== -(1 / 0)) {
-        n = (n > 0 || -1) * Math.floor(Math.abs(n));
-    }
-    return n;
-}
-
-function isPrimitive(input) {
-    var type = typeof input;
-    return input === null ||
-        type === 'undefined' ||
-        type === 'boolean' ||
-        type === 'number' ||
-        type === 'string';
-}
-
-function toPrimitive(input) {
-    var val, valueOf, toStr;
-    if (isPrimitive(input)) {
-        return input;
-    }
-    valueOf = input.valueOf;
-    if (isFunction(valueOf)) {
-        val = valueOf.call(input);
-        if (isPrimitive(val)) {
-            return val;
-        }
-    }
-    toStr = input.toString;
-    if (isFunction(toStr)) {
-        val = toStr.call(input);
-        if (isPrimitive(val)) {
-            return val;
-        }
-    }
-    throw new TypeError();
-}
-
-var ES = {
-    // ES5 9.9
-    // http://es5.github.com/#x9.9
-    ToObject: function (o) {
-        /*jshint eqnull: true */
-        if (o == null) { // this matches both null and undefined
-            throw new TypeError("can't convert " + o + ' to object');
-        }
-        return Object(o);
-    },
-    ToUint32: function ToUint32(x) {
-        return x >>> 0;
-    }
-};
-
-//
-// Function
-// ========
-//
-
-// ES-5 15.3.4.5
-// http://es5.github.com/#x15.3.4.5
-
-var Empty = function Empty() {};
-
-defineProperties(FunctionPrototype, {
-    bind: function bind(that) { // .length is 1
-        // 1. Let Target be the this value.
-        var target = this;
-        // 2. If IsCallable(Target) is false, throw a TypeError exception.
-        if (!isFunction(target)) {
-            throw new TypeError('Function.prototype.bind called on incompatible ' + target);
-        }
-        // 3. Let A be a new (possibly empty) internal list of all of the
-        //   argument values provided after thisArg (arg1, arg2 etc), in order.
-        // XXX slicedArgs will stand in for "A" if used
-        var args = array_slice.call(arguments, 1); // for normal call
-        // 4. Let F be a new native ECMAScript object.
-        // 11. Set the [[Prototype]] internal property of F to the standard
-        //   built-in Function prototype object as specified in 15.3.3.1.
-        // 12. Set the [[Call]] internal property of F as described in
-        //   15.3.4.5.1.
-        // 13. Set the [[Construct]] internal property of F as described in
-        //   15.3.4.5.2.
-        // 14. Set the [[HasInstance]] internal property of F as described in
-        //   15.3.4.5.3.
-        var bound;
-        var binder = function () {
-
-            if (this instanceof bound) {
-                // 15.3.4.5.2 [[Construct]]
-                // When the [[Construct]] internal method of a function object,
-                // F that was created using the bind function is called with a
-                // list of arguments ExtraArgs, the following steps are taken:
-                // 1. Let target be the value of F's [[TargetFunction]]
-                //   internal property.
-                // 2. If target has no [[Construct]] internal method, a
-                //   TypeError exception is thrown.
-                // 3. Let boundArgs be the value of F's [[BoundArgs]] internal
-                //   property.
-                // 4. Let args be a new list containing the same values as the
-                //   list boundArgs in the same order followed by the same
-                //   values as the list ExtraArgs in the same order.
-                // 5. Return the result of calling the [[Construct]] internal
-                //   method of target providing args as the arguments.
-
-                var result = target.apply(
-                    this,
-                    args.concat(array_slice.call(arguments))
-                );
-                if (Object(result) === result) {
-                    return result;
-                }
-                return this;
-
-            } else {
-                // 15.3.4.5.1 [[Call]]
-                // When the [[Call]] internal method of a function object, F,
-                // which was created using the bind function is called with a
-                // this value and a list of arguments ExtraArgs, the following
-                // steps are taken:
-                // 1. Let boundArgs be the value of F's [[BoundArgs]] internal
-                //   property.
-                // 2. Let boundThis be the value of F's [[BoundThis]] internal
-                //   property.
-                // 3. Let target be the value of F's [[TargetFunction]] internal
-                //   property.
-                // 4. Let args be a new list containing the same values as the
-                //   list boundArgs in the same order followed by the same
-                //   values as the list ExtraArgs in the same order.
-                // 5. Return the result of calling the [[Call]] internal method
-                //   of target providing boundThis as the this value and
-                //   providing args as the arguments.
-
-                // equiv: target.call(this, ...boundArgs, ...args)
-                return target.apply(
-                    that,
-                    args.concat(array_slice.call(arguments))
-                );
-
-            }
-
-        };
-
-        // 15. If the [[Class]] internal property of Target is "Function", then
-        //     a. Let L be the length property of Target minus the length of A.
-        //     b. Set the length own property of F to either 0 or L, whichever is
-        //       larger.
-        // 16. Else set the length own property of F to 0.
-
-        var boundLength = Math.max(0, target.length - args.length);
-
-        // 17. Set the attributes of the length own property of F to the values
-        //   specified in 15.3.5.1.
-        var boundArgs = [];
-        for (var i = 0; i < boundLength; i++) {
-            boundArgs.push('$' + i);
-        }
-
-        // XXX Build a dynamic function with desired amount of arguments is the only
-        // way to set the length property of a function.
-        // In environments where Content Security Policies enabled (Chrome extensions,
-        // for ex.) all use of eval or Function costructor throws an exception.
-        // However in all of these environments Function.prototype.bind exists
-        // and so this code will never be executed.
-        bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this, arguments); }')(binder);
-
-        if (target.prototype) {
-            Empty.prototype = target.prototype;
-            bound.prototype = new Empty();
-            // Clean up dangling references.
-            Empty.prototype = null;
-        }
-
-        // TODO
-        // 18. Set the [[Extensible]] internal property of F to true.
-
-        // TODO
-        // 19. Let thrower be the [[ThrowTypeError]] function Object (13.2.3).
-        // 20. Call the [[DefineOwnProperty]] internal method of F with
-        //   arguments "caller", PropertyDescriptor {[[Get]]: thrower, [[Set]]:
-        //   thrower, [[Enumerable]]: false, [[Configurable]]: false}, and
-        //   false.
-        // 21. Call the [[DefineOwnProperty]] internal method of F with
-        //   arguments "arguments", PropertyDescriptor {[[Get]]: thrower,
-        //   [[Set]]: thrower, [[Enumerable]]: false, [[Configurable]]: false},
-        //   and false.
-
-        // TODO
-        // NOTE Function objects created using Function.prototype.bind do not
-        // have a prototype property or the [[Code]], [[FormalParameters]], and
-        // [[Scope]] internal properties.
-        // XXX can't delete prototype in pure-js.
-
-        // 22. Return F.
-        return bound;
-    }
-});
-
-// _Please note: Shortcuts are defined after `Function.prototype.bind` as we
-// us it in defining shortcuts.
-var owns = call.bind(ObjectPrototype.hasOwnProperty);
-
-//
-// Array
-// =====
-//
-
-// ES5 15.4.4.12
-// http://es5.github.com/#x15.4.4.12
-var spliceNoopReturnsEmptyArray = (function () {
-    var a = [1, 2];
-    var result = a.splice();
-    return a.length === 2 && isArray(result) && result.length === 0;
-}());
-defineProperties(ArrayPrototype, {
-    // Safari 5.0 bug where .splice() returns undefined
-    splice: function splice(start, deleteCount) {
-        if (arguments.length === 0) {
-            return [];
-        } else {
-            return array_splice.apply(this, arguments);
-        }
-    }
-}, !spliceNoopReturnsEmptyArray);
-
-var spliceWorksWithEmptyObject = (function () {
-    var obj = {};
-    ArrayPrototype.splice.call(obj, 0, 0, 1);
-    return obj.length === 1;
-}());
-defineProperties(ArrayPrototype, {
-    splice: function splice(start, deleteCount) {
-        if (arguments.length === 0) { return []; }
-        var args = arguments;
-        this.length = Math.max(toInteger(this.length), 0);
-        if (arguments.length > 0 && typeof deleteCount !== 'number') {
-            args = array_slice.call(arguments);
-            if (args.length < 2) {
-                args.push(this.length - start);
-            } else {
-                args[1] = toInteger(deleteCount);
-            }
-        }
-        return array_splice.apply(this, args);
-    }
-}, !spliceWorksWithEmptyObject);
-
-// ES5 15.4.4.12
-// http://es5.github.com/#x15.4.4.13
-// Return len+argCount.
-// [bugfix, ielt8]
-// IE < 8 bug: [].unshift(0) === undefined but should be "1"
-var hasUnshiftReturnValueBug = [].unshift(0) !== 1;
-defineProperties(ArrayPrototype, {
-    unshift: function () {
-        array_unshift.apply(this, arguments);
-        return this.length;
-    }
-}, hasUnshiftReturnValueBug);
-
-// ES5 15.4.3.2
-// http://es5.github.com/#x15.4.3.2
-// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/isArray
-defineProperties(Array, { isArray: isArray });
-
-// The IsCallable() check in the Array functions
-// has been replaced with a strict check on the
-// internal class of the object to trap cases where
-// the provided function was actually a regular
-// expression literal, which in V8 and
-// JavaScriptCore is a typeof "function".  Only in
-// V8 are regular expression literals permitted as
-// reduce parameters, so it is desirable in the
-// general case for the shim to match the more
-// strict and common behavior of rejecting regular
-// expressions.
-
-// ES5 15.4.4.18
-// http://es5.github.com/#x15.4.4.18
-// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/array/forEach
-
-// Check failure of by-index access of string characters (IE < 9)
-// and failure of `0 in boxedString` (Rhino)
-var boxedString = Object('a');
-var splitString = boxedString[0] !== 'a' || !(0 in boxedString);
-
-var properlyBoxesContext = function properlyBoxed(method) {
-    // Check node 0.6.21 bug where third parameter is not boxed
-    var properlyBoxesNonStrict = true;
-    var properlyBoxesStrict = true;
-    if (method) {
-        method.call('foo', function (_, __, context) {
-            if (typeof context !== 'object') { properlyBoxesNonStrict = false; }
-        });
-
-        method.call([1], function () {
-            'use strict';
-            properlyBoxesStrict = typeof this === 'string';
-        }, 'x');
-    }
-    return !!method && properlyBoxesNonStrict && properlyBoxesStrict;
-};
-
-defineProperties(ArrayPrototype, {
-    forEach: function forEach(fun /*, thisp*/) {
-        var object = ES.ToObject(this),
-            self = splitString && isString(this) ? this.split('') : object,
-            thisp = arguments[1],
-            i = -1,
-            length = self.length >>> 0;
-
-        // If no callback function or if callback is not a callable function
-        if (!isFunction(fun)) {
-            throw new TypeError(); // TODO message
-        }
-
-        while (++i < length) {
-            if (i in self) {
-                // Invoke the callback function with call, passing arguments:
-                // context, property value, property key, thisArg object
-                // context
-                fun.call(thisp, self[i], i, object);
-            }
-        }
-    }
-}, !properlyBoxesContext(ArrayPrototype.forEach));
-
-// ES5 15.4.4.19
-// http://es5.github.com/#x15.4.4.19
-// https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map
-defineProperties(ArrayPrototype, {
-    map: function map(fun /*, thisp*/) {
-        var object = ES.ToObject(this),
-            self = splitString && isString(this) ? this.split('') : object,
-            length = self.length >>> 0,
-            result = Array(length),
-            thisp = arguments[1];
-
-        // If no callback function or if callback is not a callable function
-        if (!isFunction(fun)) {
-            throw new TypeError(fun + ' is not a function');
-        }
-
-        for (var i = 0; i < length; i++) {
-            if (i in self) {
-                result[i] = fun.call(thisp, self[i], i, object);
-            }
-        }
-        return result;
-    }
-}, !properlyBoxesContext(ArrayPrototype.map));
-
-// ES5 15.4.4.20
-// http://es5.github.com/#x15.4.4.20
-// https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/filter
-defineProperties(ArrayPrototype, {
-    filter: function filter(fun /*, thisp */) {
-        var object = ES.ToObject(this),
-            self = splitString && isString(this) ? this.split('') : object,
-            length = self.length >>> 0,
-            result = [],
-            value,
-            thisp = arguments[1];
-
-        // If no callback function or if callback is not a callable function
-        if (!isFunction(fun)) {
-            throw new TypeError(fun + ' is not a function');
-        }
-
-        for (var i = 0; i < length; i++) {
-            if (i in self) {
-                value = self[i];
-                if (fun.call(thisp, value, i, object)) {
-                    result.push(value);
-                }
-            }
-        }
-        return result;
-    }
-}, !properlyBoxesContext(ArrayPrototype.filter));
-
-// ES5 15.4.4.16
-// http://es5.github.com/#x15.4.4.16
-// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/every
-defineProperties(ArrayPrototype, {
-    every: function every(fun /*, thisp */) {
-        var object = ES.ToObject(this),
-            self = splitString && isString(this) ? this.split('') : object,
-            length = self.length >>> 0,
-            thisp = arguments[1];
-
-        // If no callback function or if callback is not a callable function
-        if (!isFunction(fun)) {
-            throw new TypeError(fun + ' is not a function');
-        }
-
-        for (var i = 0; i < length; i++) {
-            if (i in self && !fun.call(thisp, self[i], i, object)) {
-                return false;
-            }
-        }
-        return true;
-    }
-}, !properlyBoxesContext(ArrayPrototype.every));
-
-// ES5 15.4.4.17
-// http://es5.github.com/#x15.4.4.17
-// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/some
-defineProperties(ArrayPrototype, {
-    some: function some(fun /*, thisp */) {
-        var object = ES.ToObject(this),
-            self = splitString && isString(this) ? this.split('') : object,
-            length = self.length >>> 0,
-            thisp = arguments[1];
-
-        // If no callback function or if callback is not a callable function
-        if (!isFunction(fun)) {
-            throw new TypeError(fun + ' is not a function');
-        }
-
-        for (var i = 0; i < length; i++) {
-            if (i in self && fun.call(thisp, self[i], i, object)) {
-                return true;
-            }
-        }
-        return false;
-    }
-}, !properlyBoxesContext(ArrayPrototype.some));
-
-// ES5 15.4.4.21
-// http://es5.github.com/#x15.4.4.21
-// https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/reduce
-var reduceCoercesToObject = false;
-if (ArrayPrototype.reduce) {
-    reduceCoercesToObject = typeof ArrayPrototype.reduce.call('es5', function (_, __, ___, list) { return list; }) === 'object';
-}
-defineProperties(ArrayPrototype, {
-    reduce: function reduce(fun /*, initial*/) {
-        var object = ES.ToObject(this),
-            self = splitString && isString(this) ? this.split('') : object,
-            length = self.length >>> 0;
-
-        // If no callback function or if callback is not a callable function
-        if (!isFunction(fun)) {
-            throw new TypeError(fun + ' is not a function');
-        }
-
-        // no value to return if no initial value and an empty array
-        if (!length && arguments.length === 1) {
-            throw new TypeError('reduce of empty array with no initial value');
-        }
-
-        var i = 0;
-        var result;
-        if (arguments.length >= 2) {
-            result = arguments[1];
-        } else {
-            do {
-                if (i in self) {
-                    result = self[i++];
-                    break;
-                }
-
-                // if array contains no values, no initial value to return
-                if (++i >= length) {
-                    throw new TypeError('reduce of empty array with no initial value');
-                }
-            } while (true);
-        }
-
-        for (; i < length; i++) {
-            if (i in self) {
-                result = fun.call(void 0, result, self[i], i, object);
-            }
-        }
-
-        return result;
-    }
-}, !reduceCoercesToObject);
-
-// ES5 15.4.4.22
-// http://es5.github.com/#x15.4.4.22
-// https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/reduceRight
-var reduceRightCoercesToObject = false;
-if (ArrayPrototype.reduceRight) {
-    reduceRightCoercesToObject = typeof ArrayPrototype.reduceRight.call('es5', function (_, __, ___, list) { return list; }) === 'object';
-}
-defineProperties(ArrayPrototype, {
-    reduceRight: function reduceRight(fun /*, initial*/) {
-        var object = ES.ToObject(this),
-            self = splitString && isString(this) ? this.split('') : object,
-            length = self.length >>> 0;
-
-        // If no callback function or if callback is not a callable function
-        if (!isFunction(fun)) {
-            throw new TypeError(fun + ' is not a function');
-        }
-
-        // no value to return if no initial value, empty array
-        if (!length && arguments.length === 1) {
-            throw new TypeError('reduceRight of empty array with no initial value');
-        }
-
-        var result, i = length - 1;
-        if (arguments.length >= 2) {
-            result = arguments[1];
-        } else {
-            do {
-                if (i in self) {
-                    result = self[i--];
-                    break;
-                }
-
-                // if array contains no values, no initial value to return
-                if (--i < 0) {
-                    throw new TypeError('reduceRight of empty array with no initial value');
-                }
-            } while (true);
-        }
-
-        if (i < 0) {
-            return result;
-        }
-
-        do {
-            if (i in self) {
-                result = fun.call(void 0, result, self[i], i, object);
-            }
-        } while (i--);
-
-        return result;
-    }
-}, !reduceRightCoercesToObject);
-
-// ES5 15.4.4.14
-// http://es5.github.com/#x15.4.4.14
-// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/indexOf
-var hasFirefox2IndexOfBug = Array.prototype.indexOf && [0, 1].indexOf(1, 2) !== -1;
-defineProperties(ArrayPrototype, {
-    indexOf: function indexOf(sought /*, fromIndex */) {
-        var self = splitString && isString(this) ? this.split('') : ES.ToObject(this),
-            length = self.length >>> 0;
-
-        if (!length) {
-            return -1;
-        }
-
-        var i = 0;
-        if (arguments.length > 1) {
-            i = toInteger(arguments[1]);
-        }
-
-        // handle negative indices
-        i = i >= 0 ? i : Math.max(0, length + i);
-        for (; i < length; i++) {
-            if (i in self && self[i] === sought) {
-                return i;
-            }
-        }
-        return -1;
-    }
-}, hasFirefox2IndexOfBug);
-
-// ES5 15.4.4.15
-// http://es5.github.com/#x15.4.4.15
-// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/lastIndexOf
-var hasFirefox2LastIndexOfBug = Array.prototype.lastIndexOf && [0, 1].lastIndexOf(0, -3) !== -1;
-defineProperties(ArrayPrototype, {
-    lastIndexOf: function lastIndexOf(sought /*, fromIndex */) {
-        var self = splitString && isString(this) ? this.split('') : ES.ToObject(this),
-            length = self.length >>> 0;
-
-        if (!length) {
-            return -1;
-        }
-        var i = length - 1;
-        if (arguments.length > 1) {
-            i = Math.min(i, toInteger(arguments[1]));
-        }
-        // handle negative indices
-        i = i >= 0 ? i : length - Math.abs(i);
-        for (; i >= 0; i--) {
-            if (i in self && sought === self[i]) {
-                return i;
-            }
-        }
-        return -1;
-    }
-}, hasFirefox2LastIndexOfBug);
-
-//
-// Object
-// ======
-//
-
-// ES5 15.2.3.14
-// http://es5.github.com/#x15.2.3.14
-
-// http://whattheheadsaid.com/2010/10/a-safer-object-keys-compatibility-implementation
-var hasDontEnumBug = !({'toString': null}).propertyIsEnumerable('toString'),
-    hasProtoEnumBug = function () {}.propertyIsEnumerable('prototype'),
-    hasStringEnumBug = !owns('x', '0'),
-    dontEnums = [
-        'toString',
-        'toLocaleString',
-        'valueOf',
-        'hasOwnProperty',
-        'isPrototypeOf',
-        'propertyIsEnumerable',
-        'constructor'
-    ],
-    dontEnumsLength = dontEnums.length;
-
-defineProperties(Object, {
-    keys: function keys(object) {
-        var isFn = isFunction(object),
-            isArgs = isArguments(object),
-            isObject = object !== null && typeof object === 'object',
-            isStr = isObject && isString(object);
-
-        if (!isObject && !isFn && !isArgs) {
-            throw new TypeError('Object.keys called on a non-object');
-        }
-
-        var theKeys = [];
-        var skipProto = hasProtoEnumBug && isFn;
-        if ((isStr && hasStringEnumBug) || isArgs) {
-            for (var i = 0; i < object.length; ++i) {
-                theKeys.push(String(i));
-            }
-        }
-
-        if (!isArgs) {
-            for (var name in object) {
-                if (!(skipProto && name === 'prototype') && owns(object, name)) {
-                    theKeys.push(String(name));
-                }
-            }
-        }
-
-        if (hasDontEnumBug) {
-            var ctor = object.constructor,
-                skipConstructor = ctor && ctor.prototype === object;
-            for (var j = 0; j < dontEnumsLength; j++) {
-                var dontEnum = dontEnums[j];
-                if (!(skipConstructor && dontEnum === 'constructor') && owns(object, dontEnum)) {
-                    theKeys.push(dontEnum);
-                }
-            }
-        }
-        return theKeys;
-    }
-});
-
-var keysWorksWithArguments = Object.keys && (function () {
-    // Safari 5.0 bug
-    return Object.keys(arguments).length === 2;
-}(1, 2));
-var originalKeys = Object.keys;
-defineProperties(Object, {
-    keys: function keys(object) {
-        if (isArguments(object)) {
-            return originalKeys(ArrayPrototype.slice.call(object));
-        } else {
-            return originalKeys(object);
-        }
-    }
-}, !keysWorksWithArguments);
-
-//
-// Date
-// ====
-//
-
-// ES5 15.9.5.43
-// http://es5.github.com/#x15.9.5.43
-// This function returns a String value represent the instance in time
-// represented by this Date object. The format of the String is the Date Time
-// string format defined in 15.9.1.15. All fields are present in the String.
-// The time zone is always UTC, denoted by the suffix Z. If the time value of
-// this object is not a finite Number a RangeError exception is thrown.
-var negativeDate = -62198755200000;
-var negativeYearString = '-000001';
-var hasNegativeDateBug = Date.prototype.toISOString && new Date(negativeDate).toISOString().indexOf(negativeYearString) === -1;
-
-defineProperties(Date.prototype, {
-    toISOString: function toISOString() {
-        var result, length, value, year, month;
-        if (!isFinite(this)) {
-            throw new RangeError('Date.prototype.toISOString called on non-finite value.');
-        }
-
-        year = this.getUTCFullYear();
-
-        month = this.getUTCMonth();
-        // see https://github.com/es-shims/es5-shim/issues/111
-        year += Math.floor(month / 12);
-        month = (month % 12 + 12) % 12;
-
-        // the date time string format is specified in 15.9.1.15.
-        result = [month + 1, this.getUTCDate(), this.getUTCHours(), this.getUTCMinutes(), this.getUTCSeconds()];
-        year = (
-            (year < 0 ? '-' : (year > 9999 ? '+' : '')) +
-            ('00000' + Math.abs(year)).slice((0 <= year && year <= 9999) ? -4 : -6)
-        );
-
-        length = result.length;
-        while (length--) {
-            value = result[length];
-            // pad months, days, hours, minutes, and seconds to have two
-            // digits.
-            if (value < 10) {
-                result[length] = '0' + value;
-            }
-        }
-        // pad milliseconds to have three digits.
-        return (
-            year + '-' + result.slice(0, 2).join('-') +
-            'T' + result.slice(2).join(':') + '.' +
-            ('000' + this.getUTCMilliseconds()).slice(-3) + 'Z'
-        );
-    }
-}, hasNegativeDateBug);
-
-
-// ES5 15.9.5.44
-// http://es5.github.com/#x15.9.5.44
-// This function provides a String representation of a Date object for use by
-// JSON.stringify (15.12.3).
-var dateToJSONIsSupported = false;
-try {
-    dateToJSONIsSupported = (
-        Date.prototype.toJSON &&
-        new Date(NaN).toJSON() === null &&
-        new Date(negativeDate).toJSON().indexOf(negativeYearString) !== -1 &&
-        Date.prototype.toJSON.call({ // generic
-            toISOString: function () {
-                return true;
-            }
-        })
-    );
-} catch (e) {
-}
-if (!dateToJSONIsSupported) {
-    Date.prototype.toJSON = function toJSON(key) {
-        // When the toJSON method is called with argument key, the following
-        // steps are taken:
-
-        // 1.  Let O be the result of calling ToObject, giving it the this
-        // value as its argument.
-        // 2. Let tv be toPrimitive(O, hint Number).
-        var o = Object(this),
-            tv = toPrimitive(o),
-            toISO;
-        // 3. If tv is a Number and is not finite, return null.
-        if (typeof tv === 'number' && !isFinite(tv)) {
-            return null;
-        }
-        // 4. Let toISO be the result of calling the [[Get]] internal method of
-        // O with argument "toISOString".
-        toISO = o.toISOString;
-        // 5. If IsCallable(toISO) is false, throw a TypeError exception.
-        if (typeof toISO !== 'function') {
-            throw new TypeError('toISOString property is not callable');
-        }
-        // 6. Return the result of calling the [[Call]] internal method of
-        //  toISO with O as the this value and an empty argument list.
-        return toISO.call(o);
-
-        // NOTE 1 The argument is ignored.
-
-        // NOTE 2 The toJSON function is intentionally generic; it does not
-        // require that its this value be a Date object. Therefore, it can be
-        // transferred to other kinds of objects for use as a method. However,
-        // it does require that any such object have a toISOString method. An
-        // object is free to use the argument key to filter its
-        // stringification.
-    };
-}
-
-// ES5 15.9.4.2
-// http://es5.github.com/#x15.9.4.2
-// based on work shared by Daniel Friesen (dantman)
-// http://gist.github.com/303249
-var supportsExtendedYears = Date.parse('+033658-09-27T01:46:40.000Z') === 1e15;
-var acceptsInvalidDates = !isNaN(Date.parse('2012-04-04T24:00:00.500Z')) || !isNaN(Date.parse('2012-11-31T23:59:59.000Z'));
-var doesNotParseY2KNewYear = isNaN(Date.parse('2000-01-01T00:00:00.000Z'));
-if (!Date.parse || doesNotParseY2KNewYear || acceptsInvalidDates || !supportsExtendedYears) {
-    // XXX global assignment won't work in embeddings that use
-    // an alternate object for the context.
-    /*global Date: true */
-    /*eslint-disable no-undef*/
-    Date = (function (NativeDate) {
-    /*eslint-enable no-undef*/
-        // Date.length === 7
-        function Date(Y, M, D, h, m, s, ms) {
-            var length = arguments.length;
-            if (this instanceof NativeDate) {
-                var date = length === 1 && String(Y) === Y ? // isString(Y)
-                    // We explicitly pass it through parse:
-                    new NativeDate(Date.parse(Y)) :
-                    // We have to manually make calls depending on argument
-                    // length here
-                    length >= 7 ? new NativeDate(Y, M, D, h, m, s, ms) :
-                    length >= 6 ? new NativeDate(Y, M, D, h, m, s) :
-                    length >= 5 ? new NativeDate(Y, M, D, h, m) :
-                    length >= 4 ? new NativeDate(Y, M, D, h) :
-                    length >= 3 ? new NativeDate(Y, M, D) :
-                    length >= 2 ? new NativeDate(Y, M) :
-                    length >= 1 ? new NativeDate(Y) :
-                                  new NativeDate();
-                // Prevent mixups with unfixed Date object
-                date.constructor = Date;
-                return date;
-            }
-            return NativeDate.apply(this, arguments);
-        }
-
-        // 15.9.1.15 Date Time String Format.
-        var isoDateExpression = new RegExp('^' +
-            '(\\d{4}|[+-]\\d{6})' + // four-digit year capture or sign +
-                                      // 6-digit extended year
-            '(?:-(\\d{2})' + // optional month capture
-            '(?:-(\\d{2})' + // optional day capture
-            '(?:' + // capture hours:minutes:seconds.milliseconds
-                'T(\\d{2})' + // hours capture
-                ':(\\d{2})' + // minutes capture
-                '(?:' + // optional :seconds.milliseconds
-                    ':(\\d{2})' + // seconds capture
-                    '(?:(\\.\\d{1,}))?' + // milliseconds capture
-                ')?' +
-            '(' + // capture UTC offset component
-                'Z|' + // UTC capture
-                '(?:' + // offset specifier +/-hours:minutes
-                    '([-+])' + // sign capture
-                    '(\\d{2})' + // hours offset capture
-                    ':(\\d{2})' + // minutes offset capture
-                ')' +
-            ')?)?)?)?' +
-        '$');
-
-        var months = [
-            0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365
-        ];
-
-        function dayFromMonth(year, month) {
-            var t = month > 1 ? 1 : 0;
-            return (
-                months[month] +
-                Math.floor((year - 1969 + t) / 4) -
-                Math.floor((year - 1901 + t) / 100) +
-                Math.floor((year - 1601 + t) / 400) +
-                365 * (year - 1970)
-            );
-        }
-
-        function toUTC(t) {
-            return Number(new NativeDate(1970, 0, 1, 0, 0, 0, t));
-        }
-
-        // Copy any custom methods a 3rd party library may have added
-        for (var key in NativeDate) {
-            Date[key] = NativeDate[key];
-        }
-
-        // Copy "native" methods explicitly; they may be non-enumerable
-        Date.now = NativeDate.now;
-        Date.UTC = NativeDate.UTC;
-        Date.prototype = NativeDate.prototype;
-        Date.prototype.constructor = Date;
-
-        // Upgrade Date.parse to handle simplified ISO 8601 strings
-        Date.parse = function parse(string) {
-            var match = isoDateExpression.exec(string);
-            if (match) {
-                // parse months, days, hours, minutes, seconds, and milliseconds
-                // provide default values if necessary
-                // parse the UTC offset component
-                var year = Number(match[1]),
-                    month = Number(match[2] || 1) - 1,
-                    day = Number(match[3] || 1) - 1,
-                    hour = Number(match[4] || 0),
-                    minute = Number(match[5] || 0),
-                    second = Number(match[6] || 0),
-                    millisecond = Math.floor(Number(match[7] || 0) * 1000),
-                    // When time zone is missed, local offset should be used
-                    // (ES 5.1 bug)
-                    // see https://bugs.ecmascript.org/show_bug.cgi?id=112
-                    isLocalTime = Boolean(match[4] && !match[8]),
-                    signOffset = match[9] === '-' ? 1 : -1,
-                    hourOffset = Number(match[10] || 0),
-                    minuteOffset = Number(match[11] || 0),
-                    result;
-                if (
-                    hour < (
-                        minute > 0 || second > 0 || millisecond > 0 ?
-                        24 : 25
-                    ) &&
-                    minute < 60 && second < 60 && millisecond < 1000 &&
-                    month > -1 && month < 12 && hourOffset < 24 &&
-                    minuteOffset < 60 && // detect invalid offsets
-                    day > -1 &&
-                    day < (
-                        dayFromMonth(year, month + 1) -
-                        dayFromMonth(year, month)
-                    )
-                ) {
-                    result = (
-                        (dayFromMonth(year, month) + day) * 24 +
-                        hour +
-                        hourOffset * signOffset
-                    ) * 60;
-                    result = (
-                        (result + minute + minuteOffset * signOffset) * 60 +
-                        second
-                    ) * 1000 + millisecond;
-                    if (isLocalTime) {
-                        result = toUTC(result);
-                    }
-                    if (-8.64e15 <= result && result <= 8.64e15) {
-                        return result;
-                    }
-                }
-                return NaN;
-            }
-            return NativeDate.parse.apply(this, arguments);
-        };
-
-        return Date;
-    }(Date));
-    /*global Date: false */
-}
-
-// ES5 15.9.4.4
-// http://es5.github.com/#x15.9.4.4
-if (!Date.now) {
-    Date.now = function now() {
-        return new Date().getTime();
-    };
-}
-
-
-//
-// Number
-// ======
-//
-
-// ES5.1 15.7.4.5
-// http://es5.github.com/#x15.7.4.5
-var hasToFixedBugs = NumberPrototype.toFixed && (
-  (0.00008).toFixed(3) !== '0.000' ||
-  (0.9).toFixed(0) !== '1' ||
-  (1.255).toFixed(2) !== '1.25' ||
-  (1000000000000000128).toFixed(0) !== '1000000000000000128'
-);
-
-var toFixedHelpers = {
-  base: 1e7,
-  size: 6,
-  data: [0, 0, 0, 0, 0, 0],
-  multiply: function multiply(n, c) {
-      var i = -1;
-      while (++i < toFixedHelpers.size) {
-          c += n * toFixedHelpers.data[i];
-          toFixedHelpers.data[i] = c % toFixedHelpers.base;
-          c = Math.floor(c / toFixedHelpers.base);
-      }
-  },
-  divide: function divide(n) {
-      var i = toFixedHelpers.size, c = 0;
-      while (--i >= 0) {
-          c += toFixedHelpers.data[i];
-          toFixedHelpers.data[i] = Math.floor(c / n);
-          c = (c % n) * toFixedHelpers.base;
-      }
-  },
-  numToString: function numToString() {
-      var i = toFixedHelpers.size;
-      var s = '';
-      while (--i >= 0) {
-          if (s !== '' || i === 0 || toFixedHelpers.data[i] !== 0) {
-              var t = String(toFixedHelpers.data[i]);
-              if (s === '') {
-                  s = t;
-              } else {
-                  s += '0000000'.slice(0, 7 - t.length) + t;
-              }
-          }
-      }
-      return s;
-  },
-  pow: function pow(x, n, acc) {
-      return (n === 0 ? acc : (n % 2 === 1 ? pow(x, n - 1, acc * x) : pow(x * x, n / 2, acc)));
-  },
-  log: function log(x) {
-      var n = 0;
-      while (x >= 4096) {
-          n += 12;
-          x /= 4096;
-      }
-      while (x >= 2) {
-          n += 1;
-          x /= 2;
-      }
-      return n;
-  }
-};
-
-defineProperties(NumberPrototype, {
-    toFixed: function toFixed(fractionDigits) {
-        var f, x, s, m, e, z, j, k;
-
-        // Test for NaN and round fractionDigits down
-        f = Number(fractionDigits);
-        f = f !== f ? 0 : Math.floor(f);
-
-        if (f < 0 || f > 20) {
-            throw new RangeError('Number.toFixed called with invalid number of decimals');
-        }
-
-        x = Number(this);
-
-        // Test for NaN
-        if (x !== x) {
-            return 'NaN';
-        }
-
-        // If it is too big or small, return the string value of the number
-        if (x <= -1e21 || x >= 1e21) {
-            return String(x);
-        }
-
-        s = '';
-
-        if (x < 0) {
-            s = '-';
-            x = -x;
-        }
-
-        m = '0';
-
-        if (x > 1e-21) {
-            // 1e-21 < x < 1e21
-            // -70 < log2(x) < 70
-            e = toFixedHelpers.log(x * toFixedHelpers.pow(2, 69, 1)) - 69;
-            z = (e < 0 ? x * toFixedHelpers.pow(2, -e, 1) : x / toFixedHelpers.pow(2, e, 1));
-            z *= 0x10000000000000; // Math.pow(2, 52);
-            e = 52 - e;
-
-            // -18 < e < 122
-            // x = z / 2 ^ e
-            if (e > 0) {
-                toFixedHelpers.multiply(0, z);
-                j = f;
-
-                while (j >= 7) {
-                    toFixedHelpers.multiply(1e7, 0);
-                    j -= 7;
-                }
-
-                toFixedHelpers.multiply(toFixedHelpers.pow(10, j, 1), 0);
-                j = e - 1;
-
-                while (j >= 23) {
-                    toFixedHelpers.divide(1 << 23);
-                    j -= 23;
-                }
-
-                toFixedHelpers.divide(1 << j);
-                toFixedHelpers.multiply(1, 1);
-                toFixedHelpers.divide(2);
-                m = toFixedHelpers.numToString();
-            } else {
-                toFixedHelpers.multiply(0, z);
-                toFixedHelpers.multiply(1 << (-e), 0);
-                m = toFixedHelpers.numToString() + '0.00000000000000000000'.slice(2, 2 + f);
-            }
-        }
-
-        if (f > 0) {
-            k = m.length;
-
-            if (k <= f) {
-                m = s + '0.0000000000000000000'.slice(0, f - k + 2) + m;
-            } else {
-                m = s + m.slice(0, k - f) + '.' + m.slice(k - f);
-            }
-        } else {
-            m = s + m;
-        }
-
-        return m;
-    }
-}, hasToFixedBugs);
-
-
-//
-// String
-// ======
-//
-
-// ES5 15.5.4.14
-// http://es5.github.com/#x15.5.4.14
-
-// [bugfix, IE lt 9, firefox 4, Konqueror, Opera, obscure browsers]
-// Many browsers do not split properly with regular expressions or they
-// do not perform the split correctly under obscure conditions.
-// See http://blog.stevenlevithan.com/archives/cross-browser-split
-// I've tested in many browsers and this seems to cover the deviant ones:
-//    'ab'.split(/(?:ab)*/) should be ["", ""], not [""]
-//    '.'.split(/(.?)(.?)/) should be ["", ".", "", ""], not ["", ""]
-//    'tesst'.split(/(s)*/) should be ["t", undefined, "e", "s", "t"], not
-//       [undefined, "t", undefined, "e", ...]
-//    ''.split(/.?/) should be [], not [""]
-//    '.'.split(/()()/) should be ["."], not ["", "", "."]
-
-var string_split = StringPrototype.split;
-if (
-    'ab'.split(/(?:ab)*/).length !== 2 ||
-    '.'.split(/(.?)(.?)/).length !== 4 ||
-    'tesst'.split(/(s)*/)[1] === 't' ||
-    'test'.split(/(?:)/, -1).length !== 4 ||
-    ''.split(/.?/).length ||
-    '.'.split(/()()/).length > 1
-) {
-    (function () {
-        var compliantExecNpcg = typeof (/()??/).exec('')[1] === 'undefined'; // NPCG: nonparticipating capturing group
-
-        StringPrototype.split = function (separator, limit) {
-            var string = this;
-            if (typeof separator === 'undefined' && limit === 0) {
-                return [];
-            }
-
-            // If `separator` is not a regex, use native split
-            if (to_string.call(separator) !== '[object RegExp]') {
-                return string_split.call(this, separator, limit);
-            }
-
-            var output = [],
-                flags = (separator.ignoreCase ? 'i' : '') +
-                        (separator.multiline ? 'm' : '') +
-                        (separator.extended ? 'x' : '') + // Proposed for ES6
-                        (separator.sticky ? 'y' : ''), // Firefox 3+
-                lastLastIndex = 0,
-                // Make `global` and avoid `lastIndex` issues by working with a copy
-                separator2, match, lastIndex, lastLength;
-            separator = new RegExp(separator.source, flags + 'g');
-            string += ''; // Type-convert
-            if (!compliantExecNpcg) {
-                // Doesn't need flags gy, but they don't hurt
-                separator2 = new RegExp('^' + separator.source + '$(?!\\s)', flags);
-            }
-            /* Values for `limit`, per the spec:
-             * If undefined: 4294967295 // Math.pow(2, 32) - 1
-             * If 0, Infinity, or NaN: 0
-             * If positive number: limit = Math.floor(limit); if (limit > 4294967295) limit -= 4294967296;
-             * If negative number: 4294967296 - Math.floor(Math.abs(limit))
-             * If other: Type-convert, then use the above rules
-             */
-            limit = typeof limit === 'undefined' ?
-                -1 >>> 0 : // Math.pow(2, 32) - 1
-                ES.ToUint32(limit);
-            match = separator.exec(string);
-            while (match) {
-                // `separator.lastIndex` is not reliable cross-browser
-                lastIndex = match.index + match[0].length;
-                if (lastIndex > lastLastIndex) {
-                    output.push(string.slice(lastLastIndex, match.index));
-                    // Fix browsers whose `exec` methods don't consistently return `undefined` for
-                    // nonparticipating capturing groups
-                    if (!compliantExecNpcg && match.length > 1) {
-                        /*eslint-disable no-loop-func */
-                        match[0].replace(separator2, function () {
-                            for (var i = 1; i < arguments.length - 2; i++) {
-                                if (typeof arguments[i] === 'undefined') {
-                                    match[i] = void 0;
-                                }
-                            }
-                        });
-                        /*eslint-enable no-loop-func */
-                    }
-                    if (match.length > 1 && match.index < string.length) {
-                        array_push.apply(output, match.slice(1));
-                    }
-                    lastLength = match[0].length;
-                    lastLastIndex = lastIndex;
-                    if (output.length >= limit) {
-                        break;
-                    }
-                }
-                if (separator.lastIndex === match.index) {
-                    separator.lastIndex++; // Avoid an infinite loop
-                }
-                match = separator.exec(string);
-            }
-            if (lastLastIndex === string.length) {
-                if (lastLength || !separator.test('')) {
-                    output.push('');
-                }
-            } else {
-                output.push(string.slice(lastLastIndex));
-            }
-            return output.length > limit ? output.slice(0, limit) : output;
-        };
-    }());
-
-// [bugfix, chrome]
-// If separator is undefined, then the result array contains just one String,
-// which is the this value (converted to a String). If limit is not undefined,
-// then the output array is truncated so that it contains no more than limit
-// elements.
-// "0".split(undefined, 0) -> []
-} else if ('0'.split(void 0, 0).length) {
-    StringPrototype.split = function split(separator, limit) {
-        if (typeof separator === 'undefined' && limit === 0) { return []; }
-        return string_split.call(this, separator, limit);
-    };
-}
-
-var str_replace = StringPrototype.replace;
-var replaceReportsGroupsCorrectly = (function () {
-    var groups = [];
-    'x'.replace(/x(.)?/g, function (match, group) {
-        groups.push(group);
-    });
-    return groups.length === 1 && typeof groups[0] === 'undefined';
-}());
-
-if (!replaceReportsGroupsCorrectly) {
-    StringPrototype.replace = function replace(searchValue, replaceValue) {
-        var isFn = isFunction(replaceValue);
-        var hasCapturingGroups = isRegex(searchValue) && (/\)[*?]/).test(searchValue.source);
-        if (!isFn || !hasCapturingGroups) {
-            return str_replace.call(this, searchValue, replaceValue);
-        } else {
-            var wrappedReplaceValue = function (match) {
-                var length = arguments.length;
-                var originalLastIndex = searchValue.lastIndex;
-                searchValue.lastIndex = 0;
-                var args = searchValue.exec(match) || [];
-                searchValue.lastIndex = originalLastIndex;
-                args.push(arguments[length - 2], arguments[length - 1]);
-                return replaceValue.apply(this, args);
-            };
-            return str_replace.call(this, searchValue, wrappedReplaceValue);
-        }
-    };
-}
-
-// ECMA-262, 3rd B.2.3
-// Not an ECMAScript standard, although ECMAScript 3rd Edition has a
-// non-normative section suggesting uniform semantics and it should be
-// normalized across all browsers
-// [bugfix, IE lt 9] IE < 9 substr() with negative value not working in IE
-var string_substr = StringPrototype.substr;
-var hasNegativeSubstrBug = ''.substr && '0b'.substr(-1) !== 'b';
-defineProperties(StringPrototype, {
-    substr: function substr(start, length) {
-        return string_substr.call(
-            this,
-            start < 0 ? ((start = this.length + start) < 0 ? 0 : start) : start,
-            length
-        );
-    }
-}, hasNegativeSubstrBug);
-
-// ES5 15.5.4.20
-// whitespace from: http://es5.github.io/#x15.5.4.20
-var ws = '\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003' +
-    '\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028' +
-    '\u2029\uFEFF';
-var zeroWidth = '\u200b';
-var wsRegexChars = '[' + ws + ']';
-var trimBeginRegexp = new RegExp('^' + wsRegexChars + wsRegexChars + '*');
-var trimEndRegexp = new RegExp(wsRegexChars + wsRegexChars + '*$');
-var hasTrimWhitespaceBug = StringPrototype.trim && (ws.trim() || !zeroWidth.trim());
-defineProperties(StringPrototype, {
-    // http://blog.stevenlevithan.com/archives/faster-trim-javascript
-    // http://perfectionkills.com/whitespace-deviations/
-    trim: function trim() {
-        if (typeof this === 'undefined' || this === null) {
-            throw new TypeError("can't convert " + this + ' to object');
-        }
-        return String(this).replace(trimBeginRegexp, '').replace(trimEndRegexp, '');
-    }
-}, hasTrimWhitespaceBug);
-
-// ES-5 15.1.2.2
-if (parseInt(ws + '08') !== 8 || parseInt(ws + '0x16') !== 22) {
-    /*global parseInt: true */
-    parseInt = (function (origParseInt) {
-        var hexRegex = /^0[xX]/;
-        return function parseIntES5(str, radix) {
-            str = String(str).trim();
-            if (!Number(radix)) {
-                radix = hexRegex.test(str) ? 16 : 10;
-            }
-            return origParseInt(str, radix);
-        };
-    }(parseInt));
-}
-
-}));
diff --git a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-shim.map b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-shim.map
deleted file mode 100644
index bf9437b1..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-shim.map
+++ /dev/null
@@ -1 +0,0 @@
-{"version":3,"sources":["es5-shim.js"],"names":["root","factory","define","amd","exports","module","returnExports","this","ArrayPrototype","Array","prototype","ObjectPrototype","Object","FunctionPrototype","Function","StringPrototype","String","NumberPrototype","Number","array_slice","slice","array_splice","splice","array_push","push","array_unshift","unshift","call","to_string","toString","isFunction","val","isRegex","isArray","obj","isString","isArguments","value","str","isArgs","length","callee","defineProperties","has","supportsDescriptors","defineProperty","e","object","name","method","forceAssign","configurable","enumerable","writable","map","hasOwnProperty","toInteger","num","n","Math","floor","abs","isPrimitive","input","type","toPrimitive","valueOf","toStr","TypeError","ES","ToObject","o","ToUint32","x","Empty","bind","that","target","args","arguments","bound","binder","result","apply","concat","boundLength","max","boundArgs","i","join","owns","spliceNoopReturnsEmptyArray","a","start","deleteCount","spliceWorksWithEmptyObject","hasUnshiftReturnValueBug","boxedString","splitString","properlyBoxesContext","properlyBoxed","properlyBoxesNonStrict","properlyBoxesStrict","_","__","context","forEach","fun","self","split","thisp","filter","every","some","reduceCoercesToObject","reduce","___","list","reduceRightCoercesToObject","reduceRight","hasFirefox2IndexOfBug","indexOf","sought","hasFirefox2LastIndexOfBug","lastIndexOf","min","hasDontEnumBug","propertyIsEnumerable","hasProtoEnumBug","hasStringEnumBug","dontEnums","dontEnumsLength","keys","isFn","isObject","isStr","theKeys","skipProto","ctor","constructor","skipConstructor","j","dontEnum","keysWorksWithArguments","originalKeys","negativeDate","negativeYearString","hasNegativeDateBug","Date","toISOString","year","month","isFinite","RangeError","getUTCFullYear","getUTCMonth","getUTCDate","getUTCHours","getUTCMinutes","getUTCSeconds","getUTCMilliseconds","dateToJSONIsSupported","toJSON","NaN","key","tv","toISO","supportsExtendedYears","parse","acceptsInvalidDates","isNaN","doesNotParseY2KNewYear","NativeDate","Y","M","D","h","m","s","ms","date","isoDateExpression","RegExp","months","dayFromMonth","t","toUTC","now","UTC","string","match","exec","day","hour","minute","second","millisecond","isLocalTime","Boolean","signOffset","hourOffset","minuteOffset","getTime","hasToFixedBugs","toFixed","toFixedHelpers","base","size","data","multiply","c","divide","numToString","pow","acc","log","fractionDigits","f","z","k","string_split","compliantExecNpcg","separator","limit","output","flags","ignoreCase","multiline","extended","sticky","lastLastIndex","separator2","lastIndex","lastLength","source","index","replace","test","str_replace","replaceReportsGroupsCorrectly","groups","group","searchValue","replaceValue","hasCapturingGroups","wrappedReplaceValue","originalLastIndex","string_substr","substr","hasNegativeSubstrBug","ws","zeroWidth","wsRegexChars","trimBeginRegexp","trimEndRegexp","hasTrimWhitespaceBug","trim","parseInt","origParseInt","hexRegex","parseIntES5","radix"],"mappings":";;;;;CAaC,SAAUA,EAAMC,GACb,YAEA,UAAWC,UAAW,YAAcA,OAAOC,IAAK,CAE5CD,OAAOD,OACJ,UAAWG,WAAY,SAAU,CAIpCC,OAAOD,QAAUH,QACd,CAEHD,EAAKM,cAAgBL,OAE3BM,KAAM,WAaR,GAAIC,GAAiBC,MAAMC,SAC3B,IAAIC,GAAkBC,OAAOF,SAC7B,IAAIG,GAAoBC,SAASJ,SACjC,IAAIK,GAAkBC,OAAON,SAC7B,IAAIO,GAAkBC,OAAOR,SAC7B,IAAIS,GAAcX,EAAeY,KACjC,IAAIC,GAAeb,EAAec,MAClC,IAAIC,GAAaf,EAAegB,IAChC,IAAIC,GAAgBjB,EAAekB,OACnC,IAAIC,GAAOd,EAAkBc,IAG7B,IAAIC,GAAYjB,EAAgBkB,QAEhC,IAAIC,GAAa,SAAUC,GACvB,MAAOH,GAAUD,KAAKI,KAAS,oBAEnC,IAAIC,GAAU,SAAUD,GACpB,MAAOH,GAAUD,KAAKI,KAAS,kBAEnC,IAAIE,GAAU,QAASA,IAAQC,GAC3B,MAAON,GAAUD,KAAKO,KAAS,iBAEnC,IAAIC,GAAW,QAASA,IAASD,GAC7B,MAAON,GAAUD,KAAKO,KAAS,kBAEnC,IAAIE,GAAc,QAASA,IAAYC,GACnC,GAAIC,GAAMV,EAAUD,KAAKU,EACzB,IAAIE,GAASD,IAAQ,oBACrB,KAAKC,EAAQ,CACTA,GAAUN,EAAQI,IAChBA,IAAU,YACHA,KAAU,gBACVA,GAAMG,SAAW,UACxBH,EAAMG,QAAU,GAChBV,EAAWO,EAAMI,QAEvB,MAAOF,GAIX,IAAIG,GAAoB,SAAUC,GAChC,GAAIC,GAAsBhC,OAAOiC,gBAAmB,WAChD,IACIjC,OAAOiC,kBAAmB,OAC1B,OAAO,MACT,MAAOC,GACL,MAAO,UAMf,IAAID,EACJ,IAAID,EAAqB,CACrBC,EAAiB,SAAUE,EAAQC,EAAMC,EAAQC,GAC7C,IAAKA,GAAgBF,IAAQD,GAAS,CAAE,OACxCnC,OAAOiC,eAAeE,EAAQC,GAC1BG,aAAc,KACdC,WAAY,MACZC,SAAU,KACVhB,MAAOY,SAGZ,CACHJ,EAAiB,SAAUE,EAAQC,EAAMC,EAAQC,GAC7C,IAAKA,GAAgBF,IAAQD,GAAS,CAAE,OACxCA,EAAOC,GAAQC,GAGvB,MAAO,SAASP,GAAiBK,EAAQO,EAAKJ,GAC1C,IAAK,GAAIF,KAAQM,GAAK,CAClB,GAAIX,EAAIhB,KAAK2B,EAAKN,GAAO,CACvBH,EAAeE,EAAQC,EAAMM,EAAIN,GAAOE,OAIlDvC,EAAgB4C,eAWlB,SAASC,GAAUC,GACf,GAAIC,IAAKD,CACT,IAAIC,IAAMA,EAAG,CACTA,EAAI,MACD,IAAIA,IAAM,GAAKA,IAAO,EAAI,GAAMA,MAAQ,EAAI,GAAI,CACnDA,GAAKA,EAAI,IAAM,GAAKC,KAAKC,MAAMD,KAAKE,IAAIH,IAE5C,MAAOA,GAGX,QAASI,GAAYC,GACjB,GAAIC,SAAcD,EAClB,OAAOA,KAAU,MACbC,IAAS,aACTA,IAAS,WACTA,IAAS,UACTA,IAAS,SAGjB,QAASC,GAAYF,GACjB,GAAIhC,GAAKmC,EAASC,CAClB,IAAIL,EAAYC,GAAQ,CACpB,MAAOA,GAEXG,EAAUH,EAAMG,OAChB,IAAIpC,EAAWoC,GAAU,CACrBnC,EAAMmC,EAAQvC,KAAKoC,EACnB,IAAID,EAAY/B,GAAM,CAClB,MAAOA,IAGfoC,EAAQJ,EAAMlC,QACd,IAAIC,EAAWqC,GAAQ,CACnBpC,EAAMoC,EAAMxC,KAAKoC,EACjB,IAAID,EAAY/B,GAAM,CAClB,MAAOA,IAGf,KAAM,IAAIqC,WAGd,GAAIC,IAGAC,SAAU,SAAUC,GAEhB,GAAIA,GAAK,KAAM,CACX,KAAM,IAAIH,WAAU,iBAAmBG,EAAI,cAE/C,MAAO3D,QAAO2D,IAElBC,SAAU,QAASA,IAASC,GACxB,MAAOA,KAAM,GAYrB,IAAIC,GAAQ,QAASA,OAErBhC,GAAiB7B,GACb8D,KAAM,QAASA,IAAKC,GAEhB,GAAIC,GAAStE,IAEb,KAAKuB,EAAW+C,GAAS,CACrB,KAAM,IAAIT,WAAU,kDAAoDS,GAK5E,GAAIC,GAAO3D,EAAYQ,KAAKoD,UAAW,EAUvC,IAAIC,EACJ,IAAIC,GAAS,WAET,GAAI1E,eAAgByE,GAAO,CAiBvB,GAAIE,GAASL,EAAOM,MAChB5E,KACAuE,EAAKM,OAAOjE,EAAYQ,KAAKoD,YAEjC,IAAInE,OAAOsE,KAAYA,EAAQ,CAC3B,MAAOA,GAEX,MAAO3E,UAEJ,CAoBH,MAAOsE,GAAOM,MACVP,EACAE,EAAKM,OAAOjE,EAAYQ,KAAKoD,cAazC,IAAIM,GAAc1B,KAAK2B,IAAI,EAAGT,EAAOrC,OAASsC,EAAKtC,OAInD,IAAI+C,KACJ,KAAK,GAAIC,GAAI,EAAGA,EAAIH,EAAaG,IAAK,CAClCD,EAAU/D,KAAK,IAAMgE,GASzBR,EAAQlE,SAAS,SAAU,oBAAsByE,EAAUE,KAAK,KAAO,8CAA8CR,EAErH,IAAIJ,EAAOnE,UAAW,CAClBgE,EAAMhE,UAAYmE,EAAOnE,SACzBsE,GAAMtE,UAAY,GAAIgE,EAEtBA,GAAMhE,UAAY,KAwBtB,MAAOsE,KAMf,IAAIU,GAAO/D,EAAKgD,KAAKhE,EAAgB4C,eASrC,IAAIoC,GAA+B,WAC/B,GAAIC,IAAK,EAAG,EACZ,IAAIV,GAASU,EAAEtE,QACf,OAAOsE,GAAEpD,SAAW,GAAKP,EAAQiD,IAAWA,EAAO1C,SAAW,IAElEE,GAAiBlC,GAEbc,OAAQ,QAASA,IAAOuE,EAAOC,GAC3B,GAAIf,UAAUvC,SAAW,EAAG,CACxB,aACG,CACH,MAAOnB,GAAa8D,MAAM5E,KAAMwE,eAGxCY,EAEJ,IAAII,GAA8B,WAC9B,GAAI7D,KACJ1B,GAAec,OAAOK,KAAKO,EAAK,EAAG,EAAG,EACtC,OAAOA,GAAIM,SAAW,IAE1BE,GAAiBlC,GACbc,OAAQ,QAASA,IAAOuE,EAAOC,GAC3B,GAAIf,UAAUvC,SAAW,EAAG,CAAE,SAC9B,GAAIsC,GAAOC,SACXxE,MAAKiC,OAASmB,KAAK2B,IAAI9B,EAAUjD,KAAKiC,QAAS,EAC/C,IAAIuC,UAAUvC,OAAS,SAAYsD,KAAgB,SAAU,CACzDhB,EAAO3D,EAAYQ,KAAKoD,UACxB,IAAID,EAAKtC,OAAS,EAAG,CACjBsC,EAAKtD,KAAKjB,KAAKiC,OAASqD,OACrB,CACHf,EAAK,GAAKtB,EAAUsC,IAG5B,MAAOzE,GAAa8D,MAAM5E,KAAMuE,MAEpCiB,EAOJ,IAAIC,MAA8BtE,QAAQ,KAAO,CACjDgB,GAAiBlC,GACbkB,QAAS,WACLD,EAAc0D,MAAM5E,KAAMwE,UAC1B,OAAOxE,MAAKiC,SAEjBwD,EAKHtD,GAAiBjC,OAASwB,QAASA,GAoBnC,IAAIgE,GAAcrF,OAAO,IACzB,IAAIsF,GAAcD,EAAY,KAAO,OAAS,IAAKA,GAEnD,IAAIE,GAAuB,QAASC,IAAcnD,GAE9C,GAAIoD,GAAyB,IAC7B,IAAIC,GAAsB,IAC1B,IAAIrD,EAAQ,CACRA,EAAOtB,KAAK,MAAO,SAAU4E,EAAGC,EAAIC,GAChC,SAAWA,KAAY,SAAU,CAAEJ,EAAyB,QAGhEpD,GAAOtB,MAAM,GAAI,WACb,YACA2E,SAA6B/F,QAAS,UACvC,KAEP,QAAS0C,GAAUoD,GAA0BC,EAGjD5D,GAAiBlC,GACbkG,QAAS,QAASA,IAAQC,GACtB,GAAI5D,GAASsB,EAAGC,SAAS/D,MACrBqG,EAAOV,GAAe/D,EAAS5B,MAAQA,KAAKsG,MAAM,IAAM9D,EACxD+D,EAAQ/B,UAAU,GAClBS,GAAK,EACLhD,EAASoE,EAAKpE,SAAW,CAG7B,KAAKV,EAAW6E,GAAM,CAClB,KAAM,IAAIvC,WAGd,QAASoB,EAAIhD,EAAQ,CACjB,GAAIgD,IAAKoB,GAAM,CAIXD,EAAIhF,KAAKmF,EAAOF,EAAKpB,GAAIA,EAAGzC,QAIxCoD,EAAqB3F,EAAekG,SAKxChE,GAAiBlC,GACb8C,IAAK,QAASA,IAAIqD,GACd,GAAI5D,GAASsB,EAAGC,SAAS/D,MACrBqG,EAAOV,GAAe/D,EAAS5B,MAAQA,KAAKsG,MAAM,IAAM9D,EACxDP,EAASoE,EAAKpE,SAAW,EACzB0C,EAASzE,MAAM+B,GACfsE,EAAQ/B,UAAU,EAGtB,KAAKjD,EAAW6E,GAAM,CAClB,KAAM,IAAIvC,WAAUuC,EAAM,sBAG9B,IAAK,GAAInB,GAAI,EAAGA,EAAIhD,EAAQgD,IAAK,CAC7B,GAAIA,IAAKoB,GAAM,CACX1B,EAAOM,GAAKmB,EAAIhF,KAAKmF,EAAOF,EAAKpB,GAAIA,EAAGzC,IAGhD,MAAOmC,MAEXiB,EAAqB3F,EAAe8C,KAKxCZ,GAAiBlC,GACbuG,OAAQ,QAASA,IAAOJ,GACpB,GAAI5D,GAASsB,EAAGC,SAAS/D,MACrBqG,EAAOV,GAAe/D,EAAS5B,MAAQA,KAAKsG,MAAM,IAAM9D,EACxDP,EAASoE,EAAKpE,SAAW,EACzB0C,KACA7C,EACAyE,EAAQ/B,UAAU,EAGtB,KAAKjD,EAAW6E,GAAM,CAClB,KAAM,IAAIvC,WAAUuC,EAAM,sBAG9B,IAAK,GAAInB,GAAI,EAAGA,EAAIhD,EAAQgD,IAAK,CAC7B,GAAIA,IAAKoB,GAAM,CACXvE,EAAQuE,EAAKpB,EACb,IAAImB,EAAIhF,KAAKmF,EAAOzE,EAAOmD,EAAGzC,GAAS,CACnCmC,EAAO1D,KAAKa,KAIxB,MAAO6C,MAEXiB,EAAqB3F,EAAeuG,QAKxCrE,GAAiBlC,GACbwG,MAAO,QAASA,IAAML,GAClB,GAAI5D,GAASsB,EAAGC,SAAS/D,MACrBqG,EAAOV,GAAe/D,EAAS5B,MAAQA,KAAKsG,MAAM,IAAM9D,EACxDP,EAASoE,EAAKpE,SAAW,EACzBsE,EAAQ/B,UAAU,EAGtB,KAAKjD,EAAW6E,GAAM,CAClB,KAAM,IAAIvC,WAAUuC,EAAM,sBAG9B,IAAK,GAAInB,GAAI,EAAGA,EAAIhD,EAAQgD,IAAK,CAC7B,GAAIA,IAAKoB,KAASD,EAAIhF,KAAKmF,EAAOF,EAAKpB,GAAIA,EAAGzC,GAAS,CACnD,MAAO,QAGf,MAAO,SAEXoD,EAAqB3F,EAAewG,OAKxCtE,GAAiBlC,GACbyG,KAAM,QAASA,IAAKN,GAChB,GAAI5D,GAASsB,EAAGC,SAAS/D,MACrBqG,EAAOV,GAAe/D,EAAS5B,MAAQA,KAAKsG,MAAM,IAAM9D,EACxDP,EAASoE,EAAKpE,SAAW,EACzBsE,EAAQ/B,UAAU,EAGtB,KAAKjD,EAAW6E,GAAM,CAClB,KAAM,IAAIvC,WAAUuC,EAAM,sBAG9B,IAAK,GAAInB,GAAI,EAAGA,EAAIhD,EAAQgD,IAAK,CAC7B,GAAIA,IAAKoB,IAAQD,EAAIhF,KAAKmF,EAAOF,EAAKpB,GAAIA,EAAGzC,GAAS,CAClD,MAAO,OAGf,MAAO,UAEXoD,EAAqB3F,EAAeyG,MAKxC,IAAIC,GAAwB,KAC5B,IAAI1G,EAAe2G,OAAQ,CACvBD,QAA+B1G,GAAe2G,OAAOxF,KAAK,MAAO,SAAU4E,EAAGC,EAAIY,EAAKC,GAAQ,MAAOA,OAAa,SAEvH3E,EAAiBlC,GACb2G,OAAQ,QAASA,IAAOR,GACpB,GAAI5D,GAASsB,EAAGC,SAAS/D,MACrBqG,EAAOV,GAAe/D,EAAS5B,MAAQA,KAAKsG,MAAM,IAAM9D,EACxDP,EAASoE,EAAKpE,SAAW,CAG7B,KAAKV,EAAW6E,GAAM,CAClB,KAAM,IAAIvC,WAAUuC,EAAM,sBAI9B,IAAKnE,GAAUuC,UAAUvC,SAAW,EAAG,CACnC,KAAM,IAAI4B,WAAU,+CAGxB,GAAIoB,GAAI,CACR,IAAIN,EACJ,IAAIH,UAAUvC,QAAU,EAAG,CACvB0C,EAASH,UAAU,OAChB,CACH,EAAG,CACC,GAAIS,IAAKoB,GAAM,CACX1B,EAAS0B,EAAKpB,IACd,OAIJ,KAAMA,GAAKhD,EAAQ,CACf,KAAM,IAAI4B,WAAU,sDAEnB,MAGb,KAAOoB,EAAIhD,EAAQgD,IAAK,CACpB,GAAIA,IAAKoB,GAAM,CACX1B,EAASyB,EAAIhF,SAAU,GAAGuD,EAAQ0B,EAAKpB,GAAIA,EAAGzC,IAItD,MAAOmC,MAEXgC,EAKJ,IAAII,GAA6B,KACjC,IAAI9G,EAAe+G,YAAa,CAC5BD,QAAoC9G,GAAe+G,YAAY5F,KAAK,MAAO,SAAU4E,EAAGC,EAAIY,EAAKC,GAAQ,MAAOA,OAAa,SAEjI3E,EAAiBlC,GACb+G,YAAa,QAASA,IAAYZ,GAC9B,GAAI5D,GAASsB,EAAGC,SAAS/D,MACrBqG,EAAOV,GAAe/D,EAAS5B,MAAQA,KAAKsG,MAAM,IAAM9D,EACxDP,EAASoE,EAAKpE,SAAW,CAG7B,KAAKV,EAAW6E,GAAM,CAClB,KAAM,IAAIvC,WAAUuC,EAAM,sBAI9B,IAAKnE,GAAUuC,UAAUvC,SAAW,EAAG,CACnC,KAAM,IAAI4B,WAAU,oDAGxB,GAAIc,GAAQM,EAAIhD,EAAS,CACzB,IAAIuC,UAAUvC,QAAU,EAAG,CACvB0C,EAASH,UAAU,OAChB,CACH,EAAG,CACC,GAAIS,IAAKoB,GAAM,CACX1B,EAAS0B,EAAKpB,IACd,OAIJ,KAAMA,EAAI,EAAG,CACT,KAAM,IAAIpB,WAAU,2DAEnB,MAGb,GAAIoB,EAAI,EAAG,CACP,MAAON,GAGX,EAAG,CACC,GAAIM,IAAKoB,GAAM,CACX1B,EAASyB,EAAIhF,SAAU,GAAGuD,EAAQ0B,EAAKpB,GAAIA,EAAGzC,UAE7CyC,IAET,OAAON,MAEXoC,EAKJ,IAAIE,GAAwB/G,MAAMC,UAAU+G,UAAY,EAAG,GAAGA,QAAQ,EAAG,MAAQ,CACjF/E,GAAiBlC,GACbiH,QAAS,QAASA,IAAQC,GACtB,GAAId,GAAOV,GAAe/D,EAAS5B,MAAQA,KAAKsG,MAAM,IAAMxC,EAAGC,SAAS/D,MACpEiC,EAASoE,EAAKpE,SAAW,CAE7B,KAAKA,EAAQ,CACT,OAAQ,EAGZ,GAAIgD,GAAI,CACR,IAAIT,UAAUvC,OAAS,EAAG,CACtBgD,EAAIhC,EAAUuB,UAAU,IAI5BS,EAAIA,GAAK,EAAIA,EAAI7B,KAAK2B,IAAI,EAAG9C,EAASgD,EACtC,MAAOA,EAAIhD,EAAQgD,IAAK,CACpB,GAAIA,IAAKoB,IAAQA,EAAKpB,KAAOkC,EAAQ,CACjC,MAAOlC,IAGf,OAAQ,IAEbgC,EAKH,IAAIG,GAA4BlH,MAAMC,UAAUkH,cAAgB,EAAG,GAAGA,YAAY,GAAI,MAAQ,CAC9FlF,GAAiBlC,GACboH,YAAa,QAASA,IAAYF,GAC9B,GAAId,GAAOV,GAAe/D,EAAS5B,MAAQA,KAAKsG,MAAM,IAAMxC,EAAGC,SAAS/D,MACpEiC,EAASoE,EAAKpE,SAAW,CAE7B,KAAKA,EAAQ,CACT,OAAQ,EAEZ,GAAIgD,GAAIhD,EAAS,CACjB,IAAIuC,UAAUvC,OAAS,EAAG,CACtBgD,EAAI7B,KAAKkE,IAAIrC,EAAGhC,EAAUuB,UAAU,KAGxCS,EAAIA,GAAK,EAAIA,EAAIhD,EAASmB,KAAKE,IAAI2B,EACnC,MAAOA,GAAK,EAAGA,IAAK,CAChB,GAAIA,IAAKoB,IAAQc,IAAWd,EAAKpB,GAAI,CACjC,MAAOA,IAGf,OAAQ,IAEbmC,EAWH,IAAIG,KAAoBjG,SAAY,MAAOkG,qBAAqB,YAC5DC,EAAkB,aAAeD,qBAAqB,aACtDE,GAAoBvC,EAAK,IAAK,KAC9BwC,GACI,WACA,iBACA,UACA,iBACA,gBACA,uBACA,eAEJC,EAAkBD,EAAU1F,MAEhCE,GAAiB9B,QACbwH,KAAM,QAASA,IAAKrF,GAChB,GAAIsF,GAAOvG,EAAWiB,GAClBR,EAASH,EAAYW,GACrBuF,EAAWvF,IAAW,YAAeA,KAAW,SAChDwF,EAAQD,GAAYnG,EAASY,EAEjC,KAAKuF,IAAaD,IAAS9F,EAAQ,CAC/B,KAAM,IAAI6B,WAAU,sCAGxB,GAAIoE,KACJ,IAAIC,GAAYT,GAAmBK,CACnC,IAAKE,GAASN,GAAqB1F,EAAQ,CACvC,IAAK,GAAIiD,GAAI,EAAGA,EAAIzC,EAAOP,SAAUgD,EAAG,CACpCgD,EAAQhH,KAAKR,OAAOwE,KAI5B,IAAKjD,EAAQ,CACT,IAAK,GAAIS,KAAQD,GAAQ,CACrB,KAAM0F,GAAazF,IAAS,cAAgB0C,EAAK3C,EAAQC,GAAO,CAC5DwF,EAAQhH,KAAKR,OAAOgC,MAKhC,GAAI8E,EAAgB,CAChB,GAAIY,GAAO3F,EAAO4F,YACdC,EAAkBF,GAAQA,EAAKhI,YAAcqC,CACjD,KAAK,GAAI8F,GAAI,EAAGA,EAAIV,EAAiBU,IAAK,CACtC,GAAIC,GAAWZ,EAAUW,EACzB,MAAMD,GAAmBE,IAAa,gBAAkBpD,EAAK3C,EAAQ+F,GAAW,CAC5EN,EAAQhH,KAAKsH,KAIzB,MAAON,KAIf,IAAIO,GAAyBnI,OAAOwH,MAAS,WAEzC,MAAOxH,QAAOwH,KAAKrD,WAAWvC,SAAW,GAC3C,EAAG,EACL,IAAIwG,GAAepI,OAAOwH,IAC1B1F,GAAiB9B,QACbwH,KAAM,QAASA,IAAKrF,GAChB,GAAIX,EAAYW,GAAS,CACrB,MAAOiG,GAAaxI,EAAeY,MAAMO,KAAKoB,QAC3C,CACH,MAAOiG,GAAajG,OAG5BgG,EAcJ,IAAIE,IAAgB,WACpB,IAAIC,GAAqB,SACzB,IAAIC,GAAqBC,KAAK1I,UAAU2I,aAAe,GAAID,MAAKH,GAAcI,cAAc5B,QAAQyB,MAAyB,CAE7HxG,GAAiB0G,KAAK1I,WAClB2I,YAAa,QAASA,MAClB,GAAInE,GAAQ1C,EAAQH,EAAOiH,EAAMC,CACjC,KAAKC,SAASjJ,MAAO,CACjB,KAAM,IAAIkJ,YAAW,0DAGzBH,EAAO/I,KAAKmJ,gBAEZH,GAAQhJ,KAAKoJ,aAEbL,IAAQ3F,KAAKC,MAAM2F,EAAQ,GAC3BA,IAASA,EAAQ,GAAK,IAAM,EAG5BrE,IAAUqE,EAAQ,EAAGhJ,KAAKqJ,aAAcrJ,KAAKsJ,cAAetJ,KAAKuJ,gBAAiBvJ,KAAKwJ,gBACvFT,IACKA,EAAO,EAAI,IAAOA,EAAO,KAAO,IAAM,KACtC,QAAU3F,KAAKE,IAAIyF,IAAOlI,MAAO,GAAKkI,GAAQA,GAAQ,MAAS,GAAK,EAGzE9G,GAAS0C,EAAO1C,MAChB,OAAOA,IAAU,CACbH,EAAQ6C,EAAO1C,EAGf,IAAIH,EAAQ,GAAI,CACZ6C,EAAO1C,GAAU,IAAMH,GAI/B,MACIiH,GAAO,IAAMpE,EAAO9D,MAAM,EAAG,GAAGqE,KAAK,KACrC,IAAMP,EAAO9D,MAAM,GAAGqE,KAAK,KAAO,KACjC,MAAQlF,KAAKyJ,sBAAsB5I,OAAO,GAAK,MAGzD+H,EAOH,IAAIc,GAAwB,KAC5B,KACIA,EACIb,KAAK1I,UAAUwJ,QACf,GAAId,MAAKe,KAAKD,WAAa,MAC3B,GAAId,MAAKH,GAAciB,SAASzC,QAAQyB,MAAyB,GACjEE,KAAK1I,UAAUwJ,OAAOvI,MAClB0H,YAAa,WACT,MAAO,SAIrB,MAAOvG,IAET,IAAKmH,EAAuB,CACxBb,KAAK1I,UAAUwJ,OAAS,QAASA,IAAOE,GAOpC,GAAI7F,GAAI3D,OAAOL,MACX8J,EAAKpG,EAAYM,GACjB+F,CAEJ,UAAWD,KAAO,WAAab,SAASa,GAAK,CACzC,MAAO,MAIXC,EAAQ/F,EAAE8E,WAEV,UAAWiB,KAAU,WAAY,CAC7B,KAAM,IAAIlG,WAAU,wCAIxB,MAAOkG,GAAM3I,KAAK4C,IAiB1B,GAAIgG,GAAwBnB,KAAKoB,MAAM,iCAAmC,IAC1E,IAAIC,IAAuBC,MAAMtB,KAAKoB,MAAM,+BAAiCE,MAAMtB,KAAKoB,MAAM,4BAC9F,IAAIG,GAAyBD,MAAMtB,KAAKoB,MAAM,4BAC9C,KAAKpB,KAAKoB,OAASG,GAA0BF,IAAwBF,EAAuB,CAKxFnB,KAAQ,SAAUwB,GAGd,QAASxB,GAAKyB,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,GAC5B,GAAI3I,GAASuC,UAAUvC,MACvB,IAAIjC,eAAgBqK,GAAY,CAC5B,GAAIQ,GAAO5I,IAAW,GAAKxB,OAAO6J,KAAOA,EAErC,GAAID,GAAWxB,EAAKoB,MAAMK,IAG1BrI,GAAU,EAAI,GAAIoI,GAAWC,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,GAC/C3I,GAAU,EAAI,GAAIoI,GAAWC,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,GAC5C1I,GAAU,EAAI,GAAIoI,GAAWC,EAAGC,EAAGC,EAAGC,EAAGC,GACzCzI,GAAU,EAAI,GAAIoI,GAAWC,EAAGC,EAAGC,EAAGC,GACtCxI,GAAU,EAAI,GAAIoI,GAAWC,EAAGC,EAAGC,GACnCvI,GAAU,EAAI,GAAIoI,GAAWC,EAAGC,GAChCtI,GAAU,EAAI,GAAIoI,GAAWC,GACf,GAAID,EAEtBQ,GAAKzC,YAAcS,CACnB,OAAOgC,GAEX,MAAOR,GAAWzF,MAAM5E,KAAMwE,WAIlC,GAAIsG,GAAoB,GAAIC,QAAO,IAC/B,sBAEA,eACA,eACA,MACI,YACA,YACA,MACI,YACA,oBACJ,KACJ,IACI,KACA,MACI,SACA,WACA,YACJ,IACJ,WACJ,IAEA,IAAIC,IACA,EAAG,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAG3D,SAASC,GAAalC,EAAMC,GACxB,GAAIkC,GAAIlC,EAAQ,EAAI,EAAI,CACxB,OACIgC,GAAOhC,GACP5F,KAAKC,OAAO0F,EAAO,KAAOmC,GAAK,GAC/B9H,KAAKC,OAAO0F,EAAO,KAAOmC,GAAK,KAC/B9H,KAAKC,OAAO0F,EAAO,KAAOmC,GAAK,KAC/B,KAAOnC,EAAO,MAItB,QAASoC,GAAMD,GACX,MAAOvK,QAAO,GAAI0J,GAAW,KAAM,EAAG,EAAG,EAAG,EAAG,EAAGa,IAItD,IAAK,GAAIrB,KAAOQ,GAAY,CACxBxB,EAAKgB,GAAOQ,EAAWR,GAI3BhB,EAAKuC,IAAMf,EAAWe,GACtBvC,GAAKwC,IAAMhB,EAAWgB,GACtBxC,GAAK1I,UAAYkK,EAAWlK,SAC5B0I,GAAK1I,UAAUiI,YAAcS,CAG7BA,GAAKoB,MAAQ,QAASA,GAAMqB,GACxB,GAAIC,GAAQT,EAAkBU,KAAKF,EACnC,IAAIC,EAAO,CAIP,GAAIxC,GAAOpI,OAAO4K,EAAM,IACpBvC,EAAQrI,OAAO4K,EAAM,IAAM,GAAK,EAChCE,EAAM9K,OAAO4K,EAAM,IAAM,GAAK,EAC9BG,EAAO/K,OAAO4K,EAAM,IAAM,GAC1BI,EAAShL,OAAO4K,EAAM,IAAM,GAC5BK,EAASjL,OAAO4K,EAAM,IAAM,GAC5BM,EAAczI,KAAKC,MAAM1C,OAAO4K,EAAM,IAAM,GAAK,KAIjDO,EAAcC,QAAQR,EAAM,KAAOA,EAAM,IACzCS,EAAaT,EAAM,KAAO,IAAM,GAAK,EACrCU,EAAatL,OAAO4K,EAAM,KAAO,GACjCW,EAAevL,OAAO4K,EAAM,KAAO,GACnC5G,CACJ,IACI+G,GACIC,EAAS,GAAKC,EAAS,GAAKC,EAAc,EAC1C,GAAK,KAETF,EAAS,IAAMC,EAAS,IAAMC,EAAc,KAC5C7C,GAAS,GAAKA,EAAQ,IAAMiD,EAAa,IACzCC,EAAe,IACfT,GAAO,GACPA,EACIR,EAAalC,EAAMC,EAAQ,GAC3BiC,EAAalC,EAAMC,GAEzB,CACErE,IACKsG,EAAalC,EAAMC,GAASyC,GAAO,GACpCC,EACAO,EAAaD,GACb,EACJrH,KACKA,EAASgH,EAASO,EAAeF,GAAc,GAChDJ,GACA,IAAOC,CACX,IAAIC,EAAa,CACbnH,EAASwG,EAAMxG,GAEnB,IAAK,QAAWA,GAAUA,GAAU,OAAS,CACzC,MAAOA,IAGf,MAAOiF,KAEX,MAAOS,GAAWJ,MAAMrF,MAAM5E,KAAMwE,WAGxC,OAAOqE,IACTA,MAMN,IAAKA,KAAKuC,IAAK,CACXvC,KAAKuC,IAAM,QAASA,MAChB,OAAO,GAAIvC,OAAOsD,WAY1B,GAAIC,GAAiB1L,EAAgB2L,UACnC,KAAUA,QAAQ,KAAO,SACzB,GAAMA,QAAQ,KAAO,KACrB,MAAQA,QAAQ,KAAO,QACvB,kBAAsBA,QAAQ,KAAO,sBAGvC,IAAIC,IACFC,KAAM,IACNC,KAAM,EACNC,MAAO,EAAG,EAAG,EAAG,EAAG,EAAG,GACtBC,SAAU,QAASA,IAASvJ,EAAGwJ,GAC3B,GAAI1H,IAAK,CACT,SAASA,EAAIqH,EAAeE,KAAM,CAC9BG,GAAKxJ,EAAImJ,EAAeG,KAAKxH,EAC7BqH,GAAeG,KAAKxH,GAAK0H,EAAIL,EAAeC,IAC5CI,GAAIvJ,KAAKC,MAAMsJ,EAAIL,EAAeC,QAG1CK,OAAQ,QAASA,IAAOzJ,GACpB,GAAI8B,GAAIqH,EAAeE,KAAMG,EAAI,CACjC,SAAS1H,GAAK,EAAG,CACb0H,GAAKL,EAAeG,KAAKxH,EACzBqH,GAAeG,KAAKxH,GAAK7B,KAAKC,MAAMsJ,EAAIxJ,EACxCwJ,GAAKA,EAAIxJ,EAAKmJ,EAAeC,OAGrCM,YAAa,QAASA,MAClB,GAAI5H,GAAIqH,EAAeE,IACvB,IAAI7B,GAAI,EACR,SAAS1F,GAAK,EAAG,CACb,GAAI0F,IAAM,IAAM1F,IAAM,GAAKqH,EAAeG,KAAKxH,KAAO,EAAG,CACrD,GAAIiG,GAAIzK,OAAO6L,EAAeG,KAAKxH,GACnC,IAAI0F,IAAM,GAAI,CACVA,EAAIO,MACD,CACHP,GAAK,UAAU9J,MAAM,EAAG,EAAIqK,EAAEjJ,QAAUiJ,IAIpD,MAAOP,IAEXmC,IAAK,QAASA,IAAI5I,EAAGf,EAAG4J,GACpB,MAAQ5J,KAAM,EAAI4J,EAAO5J,EAAI,IAAM,EAAI2J,GAAI5I,EAAGf,EAAI,EAAG4J,EAAM7I,GAAK4I,GAAI5I,EAAIA,EAAGf,EAAI,EAAG4J,IAEtFC,IAAK,QAASA,IAAI9I,GACd,GAAIf,GAAI,CACR,OAAOe,GAAK,KAAM,CACdf,GAAK,EACLe,IAAK,KAET,MAAOA,GAAK,EAAG,CACXf,GAAK,CACLe,IAAK,EAET,MAAOf,IAIbhB,GAAiBzB,GACb2L,QAAS,QAASA,IAAQY,GACtB,GAAIC,GAAGhJ,EAAGyG,EAAGD,EAAGnI,EAAG4K,EAAG7E,EAAG8E,CAGzBF,GAAIvM,OAAOsM,EACXC,GAAIA,IAAMA,EAAI,EAAI9J,KAAKC,MAAM6J,EAE7B,IAAIA,EAAI,GAAKA,EAAI,GAAI,CACjB,KAAM,IAAIhE,YAAW,yDAGzBhF,EAAIvD,OAAOX,KAGX,IAAIkE,IAAMA,EAAG,CACT,MAAO,MAIX,GAAIA,IAAM,MAAQA,GAAK,KAAM,CACzB,MAAOzD,QAAOyD,GAGlByG,EAAI,EAEJ,IAAIzG,EAAI,EAAG,CACPyG,EAAI,GACJzG,IAAKA,EAGTwG,EAAI,GAEJ,IAAIxG,EAAI,MAAO,CAGX3B,EAAI+J,EAAeU,IAAI9I,EAAIoI,EAAeQ,IAAI,EAAG,GAAI,IAAM,EAC3DK,GAAK5K,EAAI,EAAI2B,EAAIoI,EAAeQ,IAAI,GAAIvK,EAAG,GAAK2B,EAAIoI,EAAeQ,IAAI,EAAGvK,EAAG,EAC7E4K,IAAK,gBACL5K,GAAI,GAAKA,CAIT,IAAIA,EAAI,EAAG,CACP+J,EAAeI,SAAS,EAAGS,EAC3B7E,GAAI4E,CAEJ,OAAO5E,GAAK,EAAG,CACXgE,EAAeI,SAAS,IAAK,EAC7BpE,IAAK,EAGTgE,EAAeI,SAASJ,EAAeQ,IAAI,GAAIxE,EAAG,GAAI,EACtDA,GAAI/F,EAAI,CAER,OAAO+F,GAAK,GAAI,CACZgE,EAAeM,OAAO,GAAK,GAC3BtE,IAAK,GAGTgE,EAAeM,OAAO,GAAKtE,EAC3BgE,GAAeI,SAAS,EAAG,EAC3BJ,GAAeM,OAAO,EACtBlC,GAAI4B,EAAeO,kBAChB,CACHP,EAAeI,SAAS,EAAGS,EAC3Bb,GAAeI,SAAS,IAAOnK,EAAI,EACnCmI,GAAI4B,EAAeO,cAAgB,yBAAyBhM,MAAM,EAAG,EAAIqM,IAIjF,GAAIA,EAAI,EAAG,CACPE,EAAI1C,EAAEzI,MAEN,IAAImL,GAAKF,EAAG,CACRxC,EAAIC,EAAI,wBAAwB9J,MAAM,EAAGqM,EAAIE,EAAI,GAAK1C,MACnD,CACHA,EAAIC,EAAID,EAAE7J,MAAM,EAAGuM,EAAIF,GAAK,IAAMxC,EAAE7J,MAAMuM,EAAIF,QAE/C,CACHxC,EAAIC,EAAID,EAGZ,MAAOA,KAEZ0B,EAuBH,IAAIiB,GAAe7M,EAAgB8F,KACnC,IACI,KAAKA,MAAM,WAAWrE,SAAW,GACjC,IAAIqE,MAAM,YAAYrE,SAAW,GACjC,QAAQqE,MAAM,QAAQ,KAAO,KAC7B,OAAOA,MAAM,QAAS,GAAGrE,SAAW,GACpC,GAAGqE,MAAM,MAAMrE,QACf,IAAIqE,MAAM,QAAQrE,OAAS,EAC7B,EACG,WACG,GAAIqL,SAA2B,OAAS9B,KAAK,IAAI,KAAO,WAExDhL,GAAgB8F,MAAQ,SAAUiH,EAAWC,GACzC,GAAIlC,GAAStL,IACb,UAAWuN,KAAc,aAAeC,IAAU,EAAG,CACjD,SAIJ,GAAInM,EAAUD,KAAKmM,KAAe,kBAAmB,CACjD,MAAOF,GAAajM,KAAKpB,KAAMuN,EAAWC,GAG9C,GAAIC,MACAC,GAASH,EAAUI,WAAa,IAAM,KAC7BJ,EAAUK,UAAY,IAAM,KAC5BL,EAAUM,SAAW,IAAM,KAC3BN,EAAUO,OAAS,IAAM,IAClCC,EAAgB,EAEhBC,EAAYzC,EAAO0C,EAAWC,CAClCX,GAAY,GAAIxC,QAAOwC,EAAUY,OAAQT,EAAQ,IACjDpC,IAAU,EACV,KAAKgC,EAAmB,CAEpBU,EAAa,GAAIjD,QAAO,IAAMwC,EAAUY,OAAS,WAAYT,GASjEF,QAAeA,KAAU,aACpB,IAAM,EACP1J,EAAGG,SAASuJ,EAChBjC,GAAQgC,EAAU/B,KAAKF,EACvB,OAAOC,EAAO,CAEV0C,EAAY1C,EAAM6C,MAAQ7C,EAAM,GAAGtJ,MACnC,IAAIgM,EAAYF,EAAe,CAC3BN,EAAOxM,KAAKqK,EAAOzK,MAAMkN,EAAexC,EAAM6C,OAG9C,KAAKd,GAAqB/B,EAAMtJ,OAAS,EAAG,CAExCsJ,EAAM,GAAG8C,QAAQL,EAAY,WACzB,IAAK,GAAI/I,GAAI,EAAGA,EAAIT,UAAUvC,OAAS,EAAGgD,IAAK,CAC3C,SAAWT,WAAUS,KAAO,YAAa,CACrCsG,EAAMtG,OAAU,OAMhC,GAAIsG,EAAMtJ,OAAS,GAAKsJ,EAAM6C,MAAQ9C,EAAOrJ,OAAQ,CACjDjB,EAAW4D,MAAM6I,EAAQlC,EAAM1K,MAAM,IAEzCqN,EAAa3C,EAAM,GAAGtJ,MACtB8L,GAAgBE,CAChB,IAAIR,EAAOxL,QAAUuL,EAAO,CACxB,OAGR,GAAID,EAAUU,YAAc1C,EAAM6C,MAAO,CACrCb,EAAUU,YAEd1C,EAAQgC,EAAU/B,KAAKF,GAE3B,GAAIyC,IAAkBzC,EAAOrJ,OAAQ,CACjC,GAAIiM,IAAeX,EAAUe,KAAK,IAAK,CACnCb,EAAOxM,KAAK,SAEb,CACHwM,EAAOxM,KAAKqK,EAAOzK,MAAMkN,IAE7B,MAAON,GAAOxL,OAASuL,EAAQC,EAAO5M,MAAM,EAAG2M,GAASC,WAU7D,IAAI,IAAInH,UAAW,GAAG,GAAGrE,OAAQ,CACpCzB,EAAgB8F,MAAQ,QAASA,IAAMiH,EAAWC,GAC9C,SAAWD,KAAc,aAAeC,IAAU,EAAG,CAAE,SACvD,MAAOH,GAAajM,KAAKpB,KAAMuN,EAAWC,IAIlD,GAAIe,GAAc/N,EAAgB6N,OAClC,IAAIG,GAAiC,WACjC,GAAIC,KACJ,KAAIJ,QAAQ,SAAU,SAAU9C,EAAOmD,GACnCD,EAAOxN,KAAKyN,IAEhB,OAAOD,GAAOxM,SAAW,SAAYwM,GAAO,KAAO,cAGvD,KAAKD,EAA+B,CAChChO,EAAgB6N,QAAU,QAASA,IAAQM,EAAaC,GACpD,GAAI9G,GAAOvG,EAAWqN,EACtB,IAAIC,GAAqBpN,EAAQkN,IAAgB,SAAWL,KAAKK,EAAYR,OAC7E,KAAKrG,IAAS+G,EAAoB,CAC9B,MAAON,GAAYnN,KAAKpB,KAAM2O,EAAaC,OACxC,CACH,GAAIE,GAAsB,SAAUvD,GAChC,GAAItJ,GAASuC,UAAUvC,MACvB,IAAI8M,GAAoBJ,EAAYV,SACpCU,GAAYV,UAAY,CACxB,IAAI1J,GAAOoK,EAAYnD,KAAKD,MAC5BoD,GAAYV,UAAYc,CACxBxK,GAAKtD,KAAKuD,UAAUvC,EAAS,GAAIuC,UAAUvC,EAAS,GACpD,OAAO2M,GAAahK,MAAM5E,KAAMuE,GAEpC,OAAOgK,GAAYnN,KAAKpB,KAAM2O,EAAaG,KAUvD,GAAIE,GAAgBxO,EAAgByO,MACpC,IAAIC,IAAuB,GAAGD,QAAU,KAAKA,QAAQ,KAAO,GAC5D9M,GAAiB3B,GACbyO,OAAQ,QAASA,IAAO3J,EAAOrD,GAC3B,MAAO+M,GAAc5N,KACjBpB,KACAsF,EAAQ,GAAMA,EAAQtF,KAAKiC,OAASqD,GAAS,EAAI,EAAIA,EAASA,EAC9DrD,KAGTiN,GAIH,IAAIC,IAAK,oDACL,qEACA,cACJ,IAAIC,IAAY,QAChB,IAAIC,IAAe,IAAMF,GAAK,GAC9B,IAAIG,IAAkB,GAAIvE,QAAO,IAAMsE,GAAeA,GAAe,IACrE,IAAIE,IAAgB,GAAIxE,QAAOsE,GAAeA,GAAe,KAC7D,IAAIG,IAAuBhP,EAAgBiP,OAASN,GAAGM,SAAWL,GAAUK,OAC5EtN,GAAiB3B,GAGbiP,KAAM,QAASA,MACX,SAAWzP,QAAS,aAAeA,OAAS,KAAM,CAC9C,KAAM,IAAI6D,WAAU,iBAAmB7D,KAAO,cAElD,MAAOS,QAAOT,MAAMqO,QAAQiB,GAAiB,IAAIjB,QAAQkB,GAAe,MAE7EC,GAGH,IAAIE,SAASP,GAAK,QAAU,GAAKO,SAASP,GAAK,UAAY,GAAI,CAE3DO,SAAY,SAAUC,GAClB,GAAIC,GAAW,QACf,OAAO,SAASC,GAAY9N,EAAK+N,GAC7B/N,EAAMtB,OAAOsB,GAAK0N,MAClB,KAAK9O,OAAOmP,GAAQ,CAChBA,EAAQF,EAAStB,KAAKvM,GAAO,GAAK,GAEtC,MAAO4N,GAAa5N,EAAK+N,KAE/BJ"}
\ No newline at end of file
diff --git a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-shim.min.js b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-shim.min.js
deleted file mode 100644
index 773caae5..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/es5-shim.min.js
+++ /dev/null
@@ -1,7 +0,0 @@
-/*!
- * https://github.com/es-shims/es5-shim
- * @license es5-shim Copyright 2009-2014 by contributors, MIT License
- * see https://github.com/es-shims/es5-shim/blob/v4.0.6/LICENSE
- */
-(function(t,e){"use strict";if(typeof define==="function"&&define.amd){define(e)}else if(typeof exports==="object"){module.exports=e()}else{t.returnExports=e()}})(this,function(){var t=Array.prototype;var e=Object.prototype;var r=Function.prototype;var n=String.prototype;var i=Number.prototype;var a=t.slice;var o=t.splice;var u=t.push;var l=t.unshift;var s=r.call;var f=e.toString;var c=function(t){return f.call(t)==="[object Function]"};var p=function(t){return f.call(t)==="[object RegExp]"};var h=function ue(t){return f.call(t)==="[object Array]"};var v=function le(t){return f.call(t)==="[object String]"};var g=function se(t){var e=f.call(t);var r=e==="[object Arguments]";if(!r){r=!h(t)&&t!==null&&typeof t==="object"&&typeof t.length==="number"&&t.length>=0&&c(t.callee)}return r};var y=function(t){var e=Object.defineProperty&&function(){try{Object.defineProperty({},"x",{});return true}catch(t){return false}}();var r;if(e){r=function(t,e,r,n){if(!n&&e in t){return}Object.defineProperty(t,e,{configurable:true,enumerable:false,writable:true,value:r})}}else{r=function(t,e,r,n){if(!n&&e in t){return}t[e]=r}}return function n(e,i,a){for(var o in i){if(t.call(i,o)){r(e,o,i[o],a)}}}}(e.hasOwnProperty);function d(t){var e=+t;if(e!==e){e=0}else if(e!==0&&e!==1/0&&e!==-(1/0)){e=(e>0||-1)*Math.floor(Math.abs(e))}return e}function m(t){var e=typeof t;return t===null||e==="undefined"||e==="boolean"||e==="number"||e==="string"}function b(t){var e,r,n;if(m(t)){return t}r=t.valueOf;if(c(r)){e=r.call(t);if(m(e)){return e}}n=t.toString;if(c(n)){e=n.call(t);if(m(e)){return e}}throw new TypeError}var w={ToObject:function(t){if(t==null){throw new TypeError("can't convert "+t+" to object")}return Object(t)},ToUint32:function fe(t){return t>>>0}};var x=function ce(){};y(r,{bind:function pe(t){var e=this;if(!c(e)){throw new TypeError("Function.prototype.bind called on incompatible "+e)}var r=a.call(arguments,1);var n;var i=function(){if(this instanceof n){var i=e.apply(this,r.concat(a.call(arguments)));if(Object(i)===i){return i}return this}else{return e.apply(t,r.concat(a.call(arguments)))}};var o=Math.max(0,e.length-r.length);var u=[];for(var l=0;l<o;l++){u.push("$"+l)}n=Function("binder","return function ("+u.join(",")+"){ return binder.apply(this, arguments); }")(i);if(e.prototype){x.prototype=e.prototype;n.prototype=new x;x.prototype=null}return n}});var O=s.bind(e.hasOwnProperty);var T=function(){var t=[1,2];var e=t.splice();return t.length===2&&h(e)&&e.length===0}();y(t,{splice:function he(t,e){if(arguments.length===0){return[]}else{return o.apply(this,arguments)}}},!T);var j=function(){var e={};t.splice.call(e,0,0,1);return e.length===1}();y(t,{splice:function ve(t,e){if(arguments.length===0){return[]}var r=arguments;this.length=Math.max(d(this.length),0);if(arguments.length>0&&typeof e!=="number"){r=a.call(arguments);if(r.length<2){r.push(this.length-t)}else{r[1]=d(e)}}return o.apply(this,r)}},!j);var S=[].unshift(0)!==1;y(t,{unshift:function(){l.apply(this,arguments);return this.length}},S);y(Array,{isArray:h});var E=Object("a");var N=E[0]!=="a"||!(0 in E);var I=function ge(t){var e=true;var r=true;if(t){t.call("foo",function(t,r,n){if(typeof n!=="object"){e=false}});t.call([1],function(){"use strict";r=typeof this==="string"},"x")}return!!t&&e&&r};y(t,{forEach:function ye(t){var e=w.ToObject(this),r=N&&v(this)?this.split(""):e,n=arguments[1],i=-1,a=r.length>>>0;if(!c(t)){throw new TypeError}while(++i<a){if(i in r){t.call(n,r[i],i,e)}}}},!I(t.forEach));y(t,{map:function de(t){var e=w.ToObject(this),r=N&&v(this)?this.split(""):e,n=r.length>>>0,i=Array(n),a=arguments[1];if(!c(t)){throw new TypeError(t+" is not a function")}for(var o=0;o<n;o++){if(o in r){i[o]=t.call(a,r[o],o,e)}}return i}},!I(t.map));y(t,{filter:function me(t){var e=w.ToObject(this),r=N&&v(this)?this.split(""):e,n=r.length>>>0,i=[],a,o=arguments[1];if(!c(t)){throw new TypeError(t+" is not a function")}for(var u=0;u<n;u++){if(u in r){a=r[u];if(t.call(o,a,u,e)){i.push(a)}}}return i}},!I(t.filter));y(t,{every:function be(t){var e=w.ToObject(this),r=N&&v(this)?this.split(""):e,n=r.length>>>0,i=arguments[1];if(!c(t)){throw new TypeError(t+" is not a function")}for(var a=0;a<n;a++){if(a in r&&!t.call(i,r[a],a,e)){return false}}return true}},!I(t.every));y(t,{some:function we(t){var e=w.ToObject(this),r=N&&v(this)?this.split(""):e,n=r.length>>>0,i=arguments[1];if(!c(t)){throw new TypeError(t+" is not a function")}for(var a=0;a<n;a++){if(a in r&&t.call(i,r[a],a,e)){return true}}return false}},!I(t.some));var D=false;if(t.reduce){D=typeof t.reduce.call("es5",function(t,e,r,n){return n})==="object"}y(t,{reduce:function xe(t){var e=w.ToObject(this),r=N&&v(this)?this.split(""):e,n=r.length>>>0;if(!c(t)){throw new TypeError(t+" is not a function")}if(!n&&arguments.length===1){throw new TypeError("reduce of empty array with no initial value")}var i=0;var a;if(arguments.length>=2){a=arguments[1]}else{do{if(i in r){a=r[i++];break}if(++i>=n){throw new TypeError("reduce of empty array with no initial value")}}while(true)}for(;i<n;i++){if(i in r){a=t.call(void 0,a,r[i],i,e)}}return a}},!D);var M=false;if(t.reduceRight){M=typeof t.reduceRight.call("es5",function(t,e,r,n){return n})==="object"}y(t,{reduceRight:function Oe(t){var e=w.ToObject(this),r=N&&v(this)?this.split(""):e,n=r.length>>>0;if(!c(t)){throw new TypeError(t+" is not a function")}if(!n&&arguments.length===1){throw new TypeError("reduceRight of empty array with no initial value")}var i,a=n-1;if(arguments.length>=2){i=arguments[1]}else{do{if(a in r){i=r[a--];break}if(--a<0){throw new TypeError("reduceRight of empty array with no initial value")}}while(true)}if(a<0){return i}do{if(a in r){i=t.call(void 0,i,r[a],a,e)}}while(a--);return i}},!M);var F=Array.prototype.indexOf&&[0,1].indexOf(1,2)!==-1;y(t,{indexOf:function Te(t){var e=N&&v(this)?this.split(""):w.ToObject(this),r=e.length>>>0;if(!r){return-1}var n=0;if(arguments.length>1){n=d(arguments[1])}n=n>=0?n:Math.max(0,r+n);for(;n<r;n++){if(n in e&&e[n]===t){return n}}return-1}},F);var R=Array.prototype.lastIndexOf&&[0,1].lastIndexOf(0,-3)!==-1;y(t,{lastIndexOf:function je(t){var e=N&&v(this)?this.split(""):w.ToObject(this),r=e.length>>>0;if(!r){return-1}var n=r-1;if(arguments.length>1){n=Math.min(n,d(arguments[1]))}n=n>=0?n:r-Math.abs(n);for(;n>=0;n--){if(n in e&&t===e[n]){return n}}return-1}},R);var U=!{toString:null}.propertyIsEnumerable("toString"),k=function(){}.propertyIsEnumerable("prototype"),C=!O("x","0"),A=["toString","toLocaleString","valueOf","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","constructor"],P=A.length;y(Object,{keys:function Se(t){var e=c(t),r=g(t),n=t!==null&&typeof t==="object",i=n&&v(t);if(!n&&!e&&!r){throw new TypeError("Object.keys called on a non-object")}var a=[];var o=k&&e;if(i&&C||r){for(var u=0;u<t.length;++u){a.push(String(u))}}if(!r){for(var l in t){if(!(o&&l==="prototype")&&O(t,l)){a.push(String(l))}}}if(U){var s=t.constructor,f=s&&s.prototype===t;for(var p=0;p<P;p++){var h=A[p];if(!(f&&h==="constructor")&&O(t,h)){a.push(h)}}}return a}});var Z=Object.keys&&function(){return Object.keys(arguments).length===2}(1,2);var J=Object.keys;y(Object,{keys:function Ee(e){if(g(e)){return J(t.slice.call(e))}else{return J(e)}}},!Z);var z=-621987552e5;var $="-000001";var B=Date.prototype.toISOString&&new Date(z).toISOString().indexOf($)===-1;y(Date.prototype,{toISOString:function Ne(){var t,e,r,n,i;if(!isFinite(this)){throw new RangeError("Date.prototype.toISOString called on non-finite value.")}n=this.getUTCFullYear();i=this.getUTCMonth();n+=Math.floor(i/12);i=(i%12+12)%12;t=[i+1,this.getUTCDate(),this.getUTCHours(),this.getUTCMinutes(),this.getUTCSeconds()];n=(n<0?"-":n>9999?"+":"")+("00000"+Math.abs(n)).slice(0<=n&&n<=9999?-4:-6);e=t.length;while(e--){r=t[e];if(r<10){t[e]="0"+r}}return n+"-"+t.slice(0,2).join("-")+"T"+t.slice(2).join(":")+"."+("000"+this.getUTCMilliseconds()).slice(-3)+"Z"}},B);var H=false;try{H=Date.prototype.toJSON&&new Date(NaN).toJSON()===null&&new Date(z).toJSON().indexOf($)!==-1&&Date.prototype.toJSON.call({toISOString:function(){return true}})}catch(L){}if(!H){Date.prototype.toJSON=function Ie(t){var e=Object(this),r=b(e),n;if(typeof r==="number"&&!isFinite(r)){return null}n=e.toISOString;if(typeof n!=="function"){throw new TypeError("toISOString property is not callable")}return n.call(e)}}var X=Date.parse("+033658-09-27T01:46:40.000Z")===1e15;var Y=!isNaN(Date.parse("2012-04-04T24:00:00.500Z"))||!isNaN(Date.parse("2012-11-31T23:59:59.000Z"));var q=isNaN(Date.parse("2000-01-01T00:00:00.000Z"));if(!Date.parse||q||Y||!X){Date=function(t){function e(r,n,i,a,o,u,l){var s=arguments.length;if(this instanceof t){var f=s===1&&String(r)===r?new t(e.parse(r)):s>=7?new t(r,n,i,a,o,u,l):s>=6?new t(r,n,i,a,o,u):s>=5?new t(r,n,i,a,o):s>=4?new t(r,n,i,a):s>=3?new t(r,n,i):s>=2?new t(r,n):s>=1?new t(r):new t;f.constructor=e;return f}return t.apply(this,arguments)}var r=new RegExp("^"+"(\\d{4}|[+-]\\d{6})"+"(?:-(\\d{2})"+"(?:-(\\d{2})"+"(?:"+"T(\\d{2})"+":(\\d{2})"+"(?:"+":(\\d{2})"+"(?:(\\.\\d{1,}))?"+")?"+"("+"Z|"+"(?:"+"([-+])"+"(\\d{2})"+":(\\d{2})"+")"+")?)?)?)?"+"$");var n=[0,31,59,90,120,151,181,212,243,273,304,334,365];function i(t,e){var r=e>1?1:0;return n[e]+Math.floor((t-1969+r)/4)-Math.floor((t-1901+r)/100)+Math.floor((t-1601+r)/400)+365*(t-1970)}function a(e){return Number(new t(1970,0,1,0,0,0,e))}for(var o in t){e[o]=t[o]}e.now=t.now;e.UTC=t.UTC;e.prototype=t.prototype;e.prototype.constructor=e;e.parse=function u(e){var n=r.exec(e);if(n){var o=Number(n[1]),u=Number(n[2]||1)-1,l=Number(n[3]||1)-1,s=Number(n[4]||0),f=Number(n[5]||0),c=Number(n[6]||0),p=Math.floor(Number(n[7]||0)*1e3),h=Boolean(n[4]&&!n[8]),v=n[9]==="-"?1:-1,g=Number(n[10]||0),y=Number(n[11]||0),d;if(s<(f>0||c>0||p>0?24:25)&&f<60&&c<60&&p<1e3&&u>-1&&u<12&&g<24&&y<60&&l>-1&&l<i(o,u+1)-i(o,u)){d=((i(o,u)+l)*24+s+g*v)*60;d=((d+f+y*v)*60+c)*1e3+p;if(h){d=a(d)}if(-864e13<=d&&d<=864e13){return d}}return NaN}return t.parse.apply(this,arguments)};return e}(Date)}if(!Date.now){Date.now=function De(){return(new Date).getTime()}}var G=i.toFixed&&(8e-5.toFixed(3)!=="0.000"||.9.toFixed(0)!=="1"||1.255.toFixed(2)!=="1.25"||0xde0b6b3a7640080.toFixed(0)!=="1000000000000000128");var K={base:1e7,size:6,data:[0,0,0,0,0,0],multiply:function Me(t,e){var r=-1;while(++r<K.size){e+=t*K.data[r];K.data[r]=e%K.base;e=Math.floor(e/K.base)}},divide:function Fe(t){var e=K.size,r=0;while(--e>=0){r+=K.data[e];K.data[e]=Math.floor(r/t);r=r%t*K.base}},numToString:function Re(){var t=K.size;var e="";while(--t>=0){if(e!==""||t===0||K.data[t]!==0){var r=String(K.data[t]);if(e===""){e=r}else{e+="0000000".slice(0,7-r.length)+r}}}return e},pow:function Ue(t,e,r){return e===0?r:e%2===1?Ue(t,e-1,r*t):Ue(t*t,e/2,r)},log:function ke(t){var e=0;while(t>=4096){e+=12;t/=4096}while(t>=2){e+=1;t/=2}return e}};y(i,{toFixed:function Ce(t){var e,r,n,i,a,o,u,l;e=Number(t);e=e!==e?0:Math.floor(e);if(e<0||e>20){throw new RangeError("Number.toFixed called with invalid number of decimals")}r=Number(this);if(r!==r){return"NaN"}if(r<=-1e21||r>=1e21){return String(r)}n="";if(r<0){n="-";r=-r}i="0";if(r>1e-21){a=K.log(r*K.pow(2,69,1))-69;o=a<0?r*K.pow(2,-a,1):r/K.pow(2,a,1);o*=4503599627370496;a=52-a;if(a>0){K.multiply(0,o);u=e;while(u>=7){K.multiply(1e7,0);u-=7}K.multiply(K.pow(10,u,1),0);u=a-1;while(u>=23){K.divide(1<<23);u-=23}K.divide(1<<u);K.multiply(1,1);K.divide(2);i=K.numToString()}else{K.multiply(0,o);K.multiply(1<<-a,0);i=K.numToString()+"0.00000000000000000000".slice(2,2+e)}}if(e>0){l=i.length;if(l<=e){i=n+"0.0000000000000000000".slice(0,e-l+2)+i}else{i=n+i.slice(0,l-e)+"."+i.slice(l-e)}}else{i=n+i}return i}},G);var Q=n.split;if("ab".split(/(?:ab)*/).length!==2||".".split(/(.?)(.?)/).length!==4||"tesst".split(/(s)*/)[1]==="t"||"test".split(/(?:)/,-1).length!==4||"".split(/.?/).length||".".split(/()()/).length>1){(function(){var t=typeof/()??/.exec("")[1]==="undefined";n.split=function(e,r){var n=this;if(typeof e==="undefined"&&r===0){return[]}if(f.call(e)!=="[object RegExp]"){return Q.call(this,e,r)}var i=[],a=(e.ignoreCase?"i":"")+(e.multiline?"m":"")+(e.extended?"x":"")+(e.sticky?"y":""),o=0,l,s,c,p;e=new RegExp(e.source,a+"g");n+="";if(!t){l=new RegExp("^"+e.source+"$(?!\\s)",a)}r=typeof r==="undefined"?-1>>>0:w.ToUint32(r);s=e.exec(n);while(s){c=s.index+s[0].length;if(c>o){i.push(n.slice(o,s.index));if(!t&&s.length>1){s[0].replace(l,function(){for(var t=1;t<arguments.length-2;t++){if(typeof arguments[t]==="undefined"){s[t]=void 0}}})}if(s.length>1&&s.index<n.length){u.apply(i,s.slice(1))}p=s[0].length;o=c;if(i.length>=r){break}}if(e.lastIndex===s.index){e.lastIndex++}s=e.exec(n)}if(o===n.length){if(p||!e.test("")){i.push("")}}else{i.push(n.slice(o))}return i.length>r?i.slice(0,r):i}})()}else if("0".split(void 0,0).length){n.split=function Ae(t,e){if(typeof t==="undefined"&&e===0){return[]}return Q.call(this,t,e)}}var V=n.replace;var W=function(){var t=[];"x".replace(/x(.)?/g,function(e,r){t.push(r)});return t.length===1&&typeof t[0]==="undefined"}();if(!W){n.replace=function Pe(t,e){var r=c(e);var n=p(t)&&/\)[*?]/.test(t.source);if(!r||!n){return V.call(this,t,e)}else{var i=function(r){var n=arguments.length;var i=t.lastIndex;t.lastIndex=0;var a=t.exec(r)||[];t.lastIndex=i;a.push(arguments[n-2],arguments[n-1]);return e.apply(this,a)};return V.call(this,t,i)}}}var _=n.substr;var te="".substr&&"0b".substr(-1)!=="b";y(n,{substr:function Ze(t,e){return _.call(this,t<0?(t=this.length+t)<0?0:t:t,e)}},te);var ee="	\n\f\r \xa0\u1680\u180e\u2000\u2001\u2002\u2003"+"\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028"+"\u2029\ufeff";var re="\u200b";var ne="["+ee+"]";var ie=new RegExp("^"+ne+ne+"*");var ae=new RegExp(ne+ne+"*$");var oe=n.trim&&(ee.trim()||!re.trim());y(n,{trim:function Je(){if(typeof this==="undefined"||this===null){throw new TypeError("can't convert "+this+" to object")}return String(this).replace(ie,"").replace(ae,"")}},oe);if(parseInt(ee+"08")!==8||parseInt(ee+"0x16")!==22){parseInt=function(t){var e=/^0[xX]/;return function r(n,i){n=String(n).trim();if(!Number(i)){i=e.test(n)?16:10}return t(n,i)}}(parseInt)}});
-//# sourceMappingURL=es5-shim.map
\ No newline at end of file
diff --git a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/package.json b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/package.json
deleted file mode 100644
index 6124a476..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/package.json
+++ /dev/null
@@ -1,74 +0,0 @@
-{
-  "name": "es5-shim",
-  "version": "4.0.6",
-  "description": "ECMAScript 5 compatibility shims for legacy JavaScript engines",
-  "homepage": "http://github.com/es-shims/es5-shim/",
-  "contributors": [
-    "Kris Kowal <kris@cixar.com> (http://github.com/kriskowal/)",
-    "Sami Samhuri <sami.samhuri@gmail.com> (http://samhuri.net/)",
-    "Florian Schäfer <florian.schaefer@gmail.com> (http://github.com/fschaefer)",
-    "Irakli Gozalishvili <rfobic@gmail.com> (http://jeditoolkit.com)",
-    "Kit Cambridge <kitcambridge@gmail.com> (http://kitcambridge.github.com)",
-    "Jordan Harband <ljharb@gmail.com> (https://github.com/ljharb/)"
-  ],
-  "bugs": {
-    "mail": "ljharb@gmail.com",
-    "url": "http://github.com/es-shims/es5-shim/issues"
-  },
-  "licenses": [
-    {
-      "type": "MIT",
-      "url": "http://github.com/es-shims/es5-shim/raw/master/LICENSE"
-    }
-  ],
-  "main": "es5-shim.js",
-  "repository": {
-    "type": "git",
-    "url": "http://github.com/es-shims/es5-shim.git"
-  },
-  "scripts": {
-    "minify": "npm run minify-shim && npm run minify-sham",
-    "minify-shim": "uglifyjs es5-shim.js --comments --source-map=es5-shim.map -m -b ascii_only=true,beautify=false > es5-shim.min.js",
-    "minify-sham": "uglifyjs es5-sham.js --comments --source-map=es5-sham.map -m -b ascii_only=true,beautify=false > es5-sham.min.js",
-    "test": "npm run lint && jasmine-node --matchall ./ tests/spec/",
-    "test-native": "jasmine-node --matchall tests/spec/",
-    "lint": "npm run jscs && npm run eslint",
-    "eslint": "eslint --reset tests/helpers/*.js tests/spec/*.js es5-shim.js es5-sham.js",
-    "jscs": "jscs tests/helpers/*.js tests/spec/*.js es5-shim.js es5-sham.js"
-  },
-  "devDependencies": {
-    "eslint": "~0.12.0",
-    "jasmine-node": "~1.14.5",
-    "jscs": "~1.10.0",
-    "uglify-js": "~2.4.16"
-  },
-  "engines": {
-    "node": ">=0.4.0"
-  },
-  "testling": {
-    "browsers": [
-      "iexplore/6.0..latest",
-      "firefox/3.0..6.0",
-      "firefox/18.0..latest",
-      "firefox/nightly",
-      "chrome/4.0..10.0",
-      "chrome/25.0..latest",
-      "chrome/canary",
-      "opera/10.0..latest",
-      "opera/next",
-      "safari/4.0..latest",
-      "ipad/6.0..latest",
-      "iphone/6.0..latest",
-      "android-browser/4.2"
-    ]
-  },
-  "keywords": [
-    "shim",
-    "es5",
-    "es5 shim",
-    "javascript",
-    "ecmascript",
-    "polyfill"
-  ]
-}
-
diff --git a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/shims.json b/packages/planner/node_modules/deepcopy/bower_components/es5-shim/shims.json
deleted file mode 100644
index 0c5430a8..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/es5-shim/shims.json
+++ /dev/null
@@ -1,7 +0,0 @@
-{
-    "Object": {
-        "prototype": {},
-        "keys": "object-keys"
-    }
-}
-
diff --git a/packages/planner/node_modules/deepcopy/bower_components/mocha/.bower.json b/packages/planner/node_modules/deepcopy/bower_components/mocha/.bower.json
deleted file mode 100644
index 23cbf9a5..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/mocha/.bower.json
+++ /dev/null
@@ -1,56 +0,0 @@
-{
-  "name": "mocha",
-  "version": "2.1.0",
-  "homepage": "http://mocha.github.io/mocha",
-  "description": "simple, flexible, fun test framework",
-  "authors": [
-    "TJ Holowaychuk <tj@vision-media.ca>",
-    "Joshua Appelman <joshua@jbna.nl>",
-    "Oleg Gaidarenko <markelog@gmail.com>",
-    "Christoffer Hallas <christoffer.hallas@gmail.com>",
-    "Christopher Hiller <chiller@badwing.com>",
-    "Travis Jeffery <tj@travisjeffery.com>",
-    "Johnathan Ong <me@jongleberry.com>",
-    "Guillermo Rauch <rauchg@gmail.com>"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/mochajs/mocha.git"
-  },
-  "main": [
-    "mocha.js",
-    "mocha.css"
-  ],
-  "ignore": [
-    "bin",
-    "editors",
-    "images",
-    "lib",
-    "support",
-    "test",
-    ".gitignore",
-    ".npmignore",
-    ".travis.yml",
-    "component.json",
-    "index.js",
-    "Makefile",
-    "package.json"
-  ],
-  "keywords": [
-    "mocha",
-    "test",
-    "bdd",
-    "tdd",
-    "tap"
-  ],
-  "license": "MIT",
-  "_release": "2.1.0",
-  "_resolution": {
-    "type": "version",
-    "tag": "2.1.0",
-    "commit": "5cabbb9f90f85f178aa61d21ddc8abce010ac8e8"
-  },
-  "_source": "git://github.com/mochajs/mocha.git",
-  "_target": "~2.1",
-  "_originalSource": "mocha"
-}
\ No newline at end of file
diff --git a/packages/planner/node_modules/deepcopy/bower_components/mocha/.editorconfig b/packages/planner/node_modules/deepcopy/bower_components/mocha/.editorconfig
deleted file mode 100644
index e3a4859e..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/mocha/.editorconfig
+++ /dev/null
@@ -1,18 +0,0 @@
-# This file is for unifying the coding style for different editors and IDEs
-# editorconfig.org
-
-root = true
-
-[*]
-end_of_line = lf
-charset = utf-8
-insert_final_newline = true
-trim_trailing_whitespace = true
-indent_style = space
-indent_size = 2
-
-[Makefile]
-indent_style = tab
-
-[*.md]
-trim_trailing_whitespace = false
diff --git a/packages/planner/node_modules/deepcopy/bower_components/mocha/.mailmap b/packages/planner/node_modules/deepcopy/bower_components/mocha/.mailmap
deleted file mode 100644
index 70401312..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/mocha/.mailmap
+++ /dev/null
@@ -1 +0,0 @@
-TJ Holowaychuk <tj@vision-media.ca>
\ No newline at end of file
diff --git a/packages/planner/node_modules/deepcopy/bower_components/mocha/CONTRIBUTING.md b/packages/planner/node_modules/deepcopy/bower_components/mocha/CONTRIBUTING.md
deleted file mode 100644
index 6d172f08..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/mocha/CONTRIBUTING.md
+++ /dev/null
@@ -1,49 +0,0 @@
-# Contributing to Mocha
-
-Hi!  We could use your help.  Let us help you help us.  Or something.
-
-## General
-
-1. If you are looking for a place to begin, **please send PRs for bugfixes instead of new features**, and/or **look for issues labeled `PR PLEASE`.**
-
-2.  **Help with documentation and the wiki is always appreciated**.
-
-3.  Please **be courteous and constructive** when commenting on issues, commits, and pull requests.
-
-## Bug Reports & Issues
-
-1.  When reporting a bug, please **provide steps to reproduce**.  If possible, show code.
-  
-2.  Please **show all code in JavaScript**.  We don't all read `<insert-language-that-compiles-to-JavaScript-here>`.  If you do not, you will be asked to.
-
-3.  Because Mocha works with many third-party libraries and tools, **ensure the bug you are reporting is actually within Mocha**.
-
-4.  If you report a bug, and it is inactive for a significant amount of time, it may be closed.  **Please respond promptly to requests for more information**.
-
-## Pull Requests
-
-1. Before sending a large PR, it's recommended to **create an issue to propose the change**.  Nobody wants to write a book of code and throw it away.
-
-2.  Because Mocha should be kept as maintainable as possible, its codebase must be kept slim.  Historically, *most PRs for new features are not merged*.  New features inevitably increase the size of the codebase, and thus reduce maintainability.  Only features *deemed essential* are likely to be merged--this is at the discretion of the maintainer(s).  If your PR for a feature is not merged, this doesn't necessarily mean your PR was a bad idea, wouldn't be used, or otherwise sucks.  It just means **only essential PRs for new features are likely to be merged**. 
-
-3.  Due to the above, before creating a PR for a new feature, **create an issue to propose the feature.**
-
-4.  Please **respect existing coding conventions**, whatever those may be.
-
-5.  If your PR has been waiting in limbo for some time, it's very helpful to **rebase against master**, which will make it easier to merge.
-
-6.  Please **add tests for new code**.
-
-7.  **Always run `npm test` before sending a PR.**  If you break the tests, your PR will not be accepted until they are fixed.
-
-## Source Control
-
-1. Please **squash your commits** when sending a pull request.  If you are unfamiliar with this process, see [this guide](https://help.github.com/articles/about-git-rebase/).  If you have already pushed your changesets and are squashing thereafter, this may necessitate the use of a "force push".  Please [read the docs](http://git-scm.com/docs/git-push) before you attempt this. 
- 
-2. Please **follow the commit message conventions [outlined here](https://medium.com/code-adventures/git-conventions-a940ee20862d).**
-
-## TL;DR
-
-**Be kind, be diligent, look before you leap into a PR, and follow common community conventions**.
-
-*- The Mocha Team*
diff --git a/packages/planner/node_modules/deepcopy/bower_components/mocha/HISTORY.md b/packages/planner/node_modules/deepcopy/bower_components/mocha/HISTORY.md
deleted file mode 100644
index 95f0f0f9..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/mocha/HISTORY.md
+++ /dev/null
@@ -1,801 +0,0 @@
-
-2.1.0 / 2014-12-23
-==================
-
- * showDiff: don’t stringify strings
- * Clean up unused module dependencies.
- * Filter zero-length strings from mocha.opts
- * only write to stdout in reporters
- * Revert "only write to stdout in reporters"
- * Print colored output only to a tty
- * update summary in README.md
- * rename Readme.md/History.md to README.md/HISTORY.md because neurotic
- * add .mailmap to fix "git shortlog" or "git summary" output
- * fixes #1461: nyan-reporter now respects Base.useColors, fixed bug where Base.color would not return a string when str wasn't a string.
- * Use existing test URL builder in failed replay links
- * modify .travis.yml: use travis_retry; closes #1449
- * fix -t 0 behavior; closes #1446
- * fix tests (whoops)
- * improve diff behavior
- * Preserve pathname when linking to individual tests
- * Fix test
- * Tiny typo in comments fixed
- * after hooks now being called on failed tests when using bail, fixes #1093
- * fix throwing undefined/null now makes tests fail, fixes #1395
- * compiler extensions are added as watched extensions, removed non-standard extensions from watch regex, resolves #1221
- * prefix/namespace for suite titles in markdown reporter, fixes #554
- * fix more bad markdown in CONTRIBUTING.md
- * fix bad markdown in CONTRIBUTING.md
- * add setImmediate/clearImmediate to globals; closes #1435
- * Fix buffer diffs (closes #1132, closes #1433)
- * add a CONTRIBUTING.md.  closes #882
- * fix intermittent build failures (maybe). closes #1407
- * add Slack notification to .travis.yml
- * Fix slack link
- * Add slack room to readme
- * Update maintainers
- * update maintainers and contributors
- * resolves #1393: kill children with more effort on SIGINT
- * xunit reporter support for optionally writing to a file
- * if a reporter has a .done method, call it before exiting
- * add support for reporter options
- * only write to stdout in reporters
-
-2.0.0 / 2014-10-21
-==================
-
- * remove: support for node 0.6.x, 0.4.x
- * fix: landing reporter with non ansi characters (#211)
- * fix: html reporter - preserve query params when navigating to suites/tests (#1358)
- * fix: json stream reporter add error message to failed test
- * fix: fixes for visionmedia -> mochajs
- * fix: use stdio, fixes node deprecation warnings (#1391)
-
-1.21.5 / 2014-10-11
-==================
-
- * fix: build for NodeJS v0.6.x
- * fix: do not attempt to highlight syntax when non-HTML reporter is used
- * update: escape-string-regexp to 1.0.2.
- * fix: botched indentation in canonicalize()
- * fix: .gitignore: ignore .patch and .diff files
- * fix: changed 'Catched' to 'Caught' in uncaught exception error handler messages
- * add: `pending` field for json reporter
- * fix: Runner.prototype.uncaught: don't double-end runnables that already have a state.
- * fix: --recursive, broken by f0facd2e
- * update: replaces escapeRegexp with the escape-string-regexp package.
- * update: commander to 2.3.0.
- * update: diff to 1.0.8.
- * fix: ability to disable syntax highlighting (#1329)
- * fix: added empty object to errorJSON() call to catch when no error is present
- * fix: never time out after calling enableTimeouts(false)
- * fix: timeout(0) will work at suite level (#1300)
- * Fix for --watch+only() issue (#888 )
- * fix: respect err.showDiff, add Base reporter test (#810)
-
-1.22.1-3 / 2014-07-27
-==================
-
-  * fix: disabling timeouts with this.timeout(0) (#1301)
-
-1.22.1-3 / 2014-07-27
-==================
-
-  * fix: local uis and reporters (#1288)
-  * fix: building 1.21.0's changes in the browser (#1284)
-
-1.21.0 / 2014-07-23
-==================
-
-  * add: --no-timeouts option (#1262, #1268)
-  * add: --*- deprecation node flags (#1217)
-  * add: --watch-extensions argument (#1247)
-  * change: spec reporter is default (#1228)
-  * fix: diff output showing incorrect +/- (#1182)
-  * fix: diffs of circular structures (#1179)
-  * fix: re-render the progress bar when progress has changed only (#1151)
-  * fix support for environments with global and window (#1159)
-  * fix: reverting to previously defined onerror handler (#1178)
-  * fix: stringify non error objects passed to done() (#1270)
-  * fix: using local ui, reporters (#1267)
-  * fix: cleaning es6 arrows (#1176)
-  * fix: don't include attrs in failure tag for xunit (#1244)
-  * fix: fail tests that return a promise if promise is rejected w/o a reason (#1224)
-  * fix: showing failed tests in doc reporter (#1117)
-  * fix: dot reporter dots being off (#1204)
-  * fix: catch empty throws (#1219)
-  * fix: honoring timeout for sync operations (#1242)
-  * update: growl to 1.8.0
-
-1.20.1 / 2014-06-03
-==================
-
-  * update: should dev dependency to ~4.0.0 (#1231)
-
-1.20.0 / 2014-05-28
-==================
-
-  * add: filenames to suite objects (#1222)
-
-1.19.0 / 2014-05-17
-==================
-
-  * add: browser script option to package.json
-  * add: export file in Mocha.Test objects (#1174)
-  * add: add docs for wrapped node flags
-  * fix: mocha.run() to return error status in browser (#1216)
-  * fix: clean() to show failure details (#1205)
-  * fix: regex that generates html for new keyword (#1201)
-  * fix: sibling suites have inherited but separate contexts (#1164)
-
-
-1.18.2 / 2014-03-18
-==================
-
-  * fix: html runner was prevented from using #mocha as the default root el (#1162)
-
-1.18.1 / 2014-03-18
-==================
-
-  * fix: named before/after hooks in bdd, tdd, qunit interfaces (#1161)
-
-1.18.0 / 2014-03-13
-==================
-
-  * add: promise support (#329)
-  * add: named before/after hooks (#966)
-
-1.17.1 / 2014-01-22
-==================
-
-  * fix: expected messages in should.js (should.js#168)
-  * fix: expect errno global in node versions < v0.9.11 (#1111)
-  * fix: unreliable checkGlobals optimization (#1110)
-
-1.17.0 / 2014-01-09
-==================
-
-  * add: able to require globals (describe, it, etc.) through mocha (#1077)
-  * fix: abort previous run on --watch change (#1100)
-  * fix: reset context for each --watch triggered run (#1099)
-  * fix: error when cli can't resolve path or pattern (#799)
-  * fix: canonicalize objects before stringifying and diffing them (#1079)
-  * fix: make CR call behave like carriage return for non tty (#1087)
-
-
-1.16.2 / 2013-12-23
-==================
-
-  * fix: couple issues with ie 8 (#1082, #1081)
-  * fix: issue running the xunit reporter in browsers (#1068)
-  * fix: issue with firefox < 3.5 (#725)
-
-
-1.16.1 / 2013-12-19
-==================
-
-  * fix: recompiled for missed changes from the last release
-
-
-1.16.0 / 2013-12-19
-==================
-
-  * add: Runnable.globals(arr) for per test global whitelist (#1046)
-  * add: mocha.throwError(err) for assertion libs to call (#985)
-  * remove: --watch's spinner (#806)
-  * fix: duplicate test output for multi-line specs in spec reporter (#1006)
-  * fix: gracefully exit on SIGINT (#1063)
-  * fix expose the specified ui only in the browser (#984)
-  * fix: ensure process exit code is preserved when using --no-exit (#1059)
-  * fix: return true from window.onerror handler (#868)
-  * fix: xunit reporter to use process.stdout.write (#1068)
-  * fix: utils.clean(str) indentation (#761)
-  * fix: xunit reporter returning test duration a NaN (#1039)
-
-1.15.1 / 2013-12-03
-==================
-
-  * fix: recompiled for missed changes from the last release
-
-1.15.0 / 2013-12-02
-==================
-
-  * add: `--no-exit` to prevent `process.exit()` (#1018)
-  * fix: using inline diffs (#1044)
-  * fix: show pending test details in xunit reporter (#1051)
-  * fix: faster global leak detection (#1024)
-  * fix: yui compression (#1035)
-  * fix: wrapping long lines in test results (#1030, #1031)
-  * fix: handle errors in hooks (#1043)
-
-1.14.0 / 2013-11-02
-==================
-
-  * add: unified diff (#862)
-  * add: set MOCHA_COLORS env var to use colors (#965)
-  * add: able to override tests links in html reporters (#776)
-  * remove: teamcity reporter (#954)
-  * update: commander dependency to 2.0.0 (#1010)
-  * fix: mocha --ui will try to require the ui if not built in, as --reporter does (#1022)
-  * fix: send cursor commands only if isatty (#184, #1003)
-  * fix: include assertion message in base reporter (#993, #991)
-  * fix: consistent return of it, it.only, and describe, describe.only (#840)
-
-1.13.0 / 2013-09-15
-==================
-
-  * add: sort test files with --sort (#813)
-  * update: diff depedency to 1.0.7
-  * update: glob dependency to 3.2.3 (#927)
-  * fix: diffs show whitespace differences (#976)
-  * fix: improve global leaks (#783)
-  * fix: firefox window.getInterface leak
-  * fix: accessing iframe via window[iframeIndex] leak
-  * fix: faster global leak checking
-  * fix: reporter pending css selector (#970)
-
-1.12.1 / 2013-08-29
-==================
-
- * remove test.js from .gitignore
- * update included version of ms.js
-
-1.12.0 / 2013-07-01
-==================
-
- * add: prevent diffs for differing types. Closes #900
- * add `Mocha.process` hack for phantomjs
- * fix: use compilers with requires
- * fix regexps in diffs. Closes #890
- * fix xunit NaN on failure. Closes #894
- * fix: strip tab indentation in `clean` utility method
- * fix: textmate bundle installation
-
-1.11.0 / 2013-06-12
-==================
-
- * add --prof support
- * add --harmony support
- * add --harmony-generators support
- * add "Uncaught " prefix to uncaught exceptions
- * add web workers support
- * add `suite.skip()`
- * change to output # of pending / passing even on failures. Closes #872
- * fix: prevent hooks from being called if we are bailing
- * fix `this.timeout(0)`
-
-1.10.0 / 2013-05-21
-==================
-
- * add add better globbing support for windows via `glob` module
- * add support to pass through flags such as --debug-brk=1234. Closes #852
- * add test.only, test.skip to qunit interface
- * change to always use word-based diffs for now. Closes #733
- * change `mocha init` tests.html to index.html
- * fix `process` global leak in the browser
- * fix: use resolve() instead of join() for --require
- * fix: filterLeaks() condition to not consider indices in global object as leaks
- * fix: restrict mocha.css styling to #mocha id
- * fix: save timer references to avoid Sinon interfering in the browser build.
-
-1.9.0 / 2013-04-03
-==================
-
-  * add improved setImmediate implementation
-  * replace --ignore-leaks with --check-leaks
-  * change default of ignoreLeaks to true. Closes #791
-  * remove scrolling for HTML reporter
-  * fix retina support
-  * fix tmbundle, restrict to js scope
-
-1.8.2 / 2013-03-11
-==================
-
-  * add `setImmediate` support for 0.10.x
-  * fix mocha -w spinner on windows
-
-1.8.1 / 2013-01-09
-==================
-
-  * fix .bail() arity check causing it to default to true
-
-1.8.0 / 2013-01-08
-==================
-
-  * add Mocha() options bail support
-  * add `Mocha#bail()` method
-  * add instanceof check back for inheriting from Error
-  * add component.json
-  * add diff.js to browser build
-  * update growl
-  * fix TAP reporter failures comment :D
-
-1.7.4 / 2012-12-06
-==================
-
-  * add total number of passes and failures to TAP
-  * remove .bind() calls. re #680
-  * fix indexOf. Closes #680
-
-1.7.3 / 2012-11-30
-==================
-
-  * fix uncaught error support for the browser
-  * revert uncaught "fix" which breaks node
-
-1.7.2 / 2012-11-28
-==================
-
-  * fix uncaught errors to expose the original error message
-
-1.7.0 / 2012-11-07
-==================
-
-  * add `--async-only` support to prevent false positives for missing `done()`
-  * add sorting by filename in code coverage
-  * add HTML 5 doctype to browser template.
-  * add play button to html reporter to rerun a single test
-  * add `this.timeout(ms)` as Suite#timeout(ms). Closes #599
-  * update growl dependency to 1.6.x
-  * fix encoding of test-case ?grep. Closes #637
-  * fix unicode chars on windows
-  * fix dom globals in Opera/IE. Closes #243
-  * fix markdown reporter a tags
-  * fix `this.timeout("5s")` support
-
-1.6.0 / 2012-10-02
-==================
-
-  * add object diffs when `err.showDiff` is present
-  * add hiding of empty suites when pass/failures are toggled
-  * add faster `.length` checks to `checkGlobals()` before performing the filter
-
-1.5.0 / 2012-09-21
-==================
-
-  * add `ms()` to `.slow()` and `.timeout()`
-  * add `Mocha#checkLeaks()` to re-enable global leak checks
-  * add `this.slow()` option [aheckmann]
-  * add tab, CR, LF to error diffs for now
-  * add faster `.checkGlobals()` solution [guille]
-  * remove `fn.call()` from reduce util
-  * remove `fn.call()` from filter util
-  * fix forEach. Closes #582
-  * fix relaying of signals [TooTallNate]
-  * fix TAP reporter grep number
-
-1.4.2 / 2012-09-01
-==================
-
-  * add support to multiple `Mocha#globals()` calls, and strings
-  * add `mocha.reporter()` constructor support [jfirebaugh]
-  * add `mocha.timeout()`
-  * move query-string parser to utils.js
-  * move highlight code to utils.js
-  * fix third-party reporter support [exogen]
-  * fix client-side API to match node-side [jfirebaugh]
-  * fix mocha in iframe [joliss]
-
-1.4.1 / 2012-08-28
-==================
-
-  * add missing `Markdown` export
-  * fix `Mocha#grep()`, escape regexp strings
-  * fix reference error when `devicePixelRatio` is not defined. Closes #549
-
-1.4.0 / 2012-08-22
-==================
-
-  * add mkdir -p to `mocha init`. Closes #539
-  * add `.only()`. Closes #524
-  * add `.skip()`. Closes #524
-  * change str.trim() to use utils.trim(). Closes #533
-  * fix HTML progress indicator retina display
-  * fix url-encoding of click-to-grep HTML functionality
-
-1.3.2 / 2012-08-01
-==================
-
-  * fix exports double-execution regression. Closes #531
-
-1.3.1 / 2012-08-01
-==================
-
-  * add passes/failures toggling to HTML reporter
-  * add pending state to `xit()` and `xdescribe()` [Brian Moore]
-  * add the @charset "UTF-8"; to fix #522 with FireFox. [Jonathan Creamer]
-  * add border-bottom to #stats links
-  * add check for runnable in `Runner#uncaught()`. Closes #494
-  * add 0.4 and 0.6 back to travis.yml
-  * add `-E, --growl-errors` to growl on failures only
-  * add prefixes to debug() names. Closes #497
-  * add `Mocha#invert()` to js api
-  * change dot reporter to use sexy unicode dots
-  * fix error when clicking pending test in HTML reporter
-  * fix `make tm`
-
-1.3.0 / 2012-07-05
-==================
-
-  * add window scrolling to `HTML` reporter
-  * add v8 `--trace-*` option support
-  * add support for custom reports via `--reporter MODULE`
-  * add `--invert` switch to invert `--grep` matches
-  * fix export of `Nyan` reporter. Closes #495
-  * fix escaping of `HTML` suite titles. Closes #486
-  * fix `done()` called multiple times with an error test
-  * change `--grep` - regexp escape the input
-
-1.2.2 / 2012-06-28
-==================
-
-  * Added 0.8.0 support
-
-1.2.1 / 2012-06-25
-==================
-
-  * Added `this.test.error(err)` support to after each hooks. Closes #287
-  * Added: export top-level suite on global mocha object (mocha.suite). Closes #448
-  * Fixed `js` code block format error in markdown reporter
-  * Fixed deprecation warning when using `path.existsSync`
-  * Fixed --globals with wildcard
-  * Fixed chars in nyan when his head moves back
-  * Remove `--growl` from test/mocha.opts. Closes #289
-
-1.2.0 / 2012-06-17
-==================
-
-  * Added `nyan` reporter [Atsuya Takagi]
-  * Added `mocha init <path>` to copy client files
-  * Added "specify" synonym for "it" [domenic]
-  * Added global leak wildcard support [nathanbowser]
-  * Fixed runner emitter leak. closes #432
-  * Fixed omission of .js extension. Closes #454
-
-1.1.0 / 2012-05-30
-==================
-
-  * Added: check each `mocha(1)` arg for directories to walk
-  * Added `--recursive` [tricknotes]
-  * Added `context` for BDD [hokaccha]
-  * Added styling for new clickable titles
-  * Added clickable suite titles to HTML reporter
-  * Added warning when strings are thrown as errors
-  * Changed: green arrows again in HTML reporter styling
-  * Changed ul/li elements instead of divs for better copy-and-pasting [joliss]
-  * Fixed issue #325 - add better grep support to js api
-  * Fixed: save timer references to avoid Sinon interfering.
-
-1.0.3 / 2012-04-30
-==================
-
-  * Fixed string diff newlines
-  * Fixed: removed mocha.css target. Closes #401
-
-1.0.2 / 2012-04-25
-==================
-
-  * Added HTML reporter duration. Closes #47
-  * Fixed: one postMessage event listener [exogen]
-  * Fixed: allow --globals to be used multiple times. Closes #100 [brendannee]
-  * Fixed #158: removes jquery include from browser tests
-  * Fixed grep. Closes #372 [brendannee]
-  * Fixed #166 - When grepping don't display the empty suites
-  * Removed test/browser/style.css. Closes #385
-
-1.0.1 / 2012-04-04
-==================
-
-  * Fixed `.timeout()` in hooks
-  * Fixed: allow callback for `mocha.run()` in client version
-  * Fixed browser hook error display. Closes #361
-
-1.0.0 / 2012-03-24
-==================
-
-  * Added js API. Closes #265
-  * Added: initial run of tests with `--watch`. Closes #345
-  * Added: mark `location` as a global on the CS. Closes #311
-  * Added `markdown` reporter (github flavour)
-  * Added: scrolling menu to coverage.html. Closes #335
-  * Added source line to html report for Safari [Tyson Tate]
-  * Added "min" reporter, useful for `--watch` [Jakub Nešetřil]
-  * Added support for arbitrary compilers via . Closes #338 [Ian Young]
-  * Added Teamcity export to lib/reporters/index [Michael Riley]
-  * Fixed chopping of first char in error reporting. Closes #334 [reported by topfunky]
-  * Fixed terrible FF / Opera stack traces
-
-0.14.1 / 2012-03-06
-==================
-
-  * Added lib-cov to _.npmignore_
-  * Added reporter to `mocha.run([reporter])` as argument
-  * Added some margin-top to the HTML reporter
-  * Removed jQuery dependency
-  * Fixed `--watch`: purge require cache. Closes #266
-
-0.14.0 / 2012-03-01
-==================
-
-  * Added string diff support for terminal reporters
-
-0.13.0 / 2012-02-23
-==================
-
-  * Added preliminary test coverage support. Closes #5
-  * Added `HTMLCov` reporter
-  * Added `JSONCov` reporter [kunklejr]
-  * Added `xdescribe()` and `xit()` to the BDD interface. Closes #263 (docs   * Changed: make json reporter output pretty json
-  * Fixed node-inspector support, swapped `--debug` for `debug` to match node.
-needed)
-Closes #247
-
-0.12.1 / 2012-02-14
-==================
-
-  * Added `npm docs mocha` support [TooTallNate]
-  * Added a `Context` object used for hook and test-case this. Closes #253
-  * Fixed `Suite#clone()` `.ctx` reference. Closes #262
-
-0.12.0 / 2012-02-02
-==================
-
-  * Added .coffee `--watch` support. Closes #242
-  * Added support to `--require` files relative to the CWD. Closes #241
-  * Added quick n dirty syntax highlighting. Closes #248
-  * Changed: made HTML progress indicator smaller
-  * Fixed xunit errors attribute [dhendo]
-
-0.10.2 / 2012-01-21
-==================
-
-  * Fixed suite count in reporter stats. Closes #222
-  * Fixed `done()` after timeout error reporting [Phil Sung]
-  * Changed the 0-based errors to 1
-
-0.10.1 / 2012-01-17
-==================
-
-  * Added support for node 0.7.x
-  * Fixed absolute path support. Closes #215 [kompiro]
-  * Fixed `--no-colors` option [Jussi Virtanen]
-  * Fixed Arial CSS typo in the correct file
-
-0.10.0 / 2012-01-13
-==================
-
-  * Added `-b, --bail` to exit on first exception [guillermo]
-  * Added support for `-gc` / `--expose-gc` [TooTallNate]
-  * Added `qunit`-inspired interface
-  * Added MIT LICENSE. Closes #194
-  * Added: `--watch` all .js in the CWD. Closes #139
-  * Fixed `self.test` reference in runner. Closes #189
-  * Fixed double reporting of uncaught exceptions after timeout. Closes #195
-
-0.8.2 / 2012-01-05
-==================
-
-  * Added test-case context support. Closes #113
-  * Fixed exit status. Closes #187
-  * Update commander. Closes #190
-
-0.8.1 / 2011-12-30
-==================
-
-  * Fixed reporting of uncaught exceptions. Closes #183
-  * Fixed error message defaulting [indutny]
-  * Changed mocha(1) from bash to node for windows [Nathan Rajlich]
-
-0.8.0 / 2011-12-28
-==================
-
-  * Added `XUnit` reporter [FeeFighters/visionmedia]
-  * Added `say(1)` notification support [Maciej Małecki]
-  * Changed: fail when done() is invoked with a non-Error. Closes #171
-  * Fixed `err.stack`, defaulting to message. Closes #180
-  * Fixed: `make tm` mkdir -p the dest. Closes #137
-  * Fixed mocha(1) --help bin name
-  * Fixed `-d` for `--debug` support
-
-0.7.1 / 2011-12-22
-==================
-
-  * Removed `mocha-debug(1)`, use `mocha --debug`
-  * Fixed CWD relative requires
-  * Fixed growl issue on windows [Raynos]
-  * Fixed: platform specific line endings [TooTallNate]
-  * Fixed: escape strings in HTML reporter. Closes #164
-
-0.7.0 / 2011-12-18
-==================
-
-  * Added support for IE{7,8} [guille]
-  * Changed: better browser nextTick implementation [guille]
-
-0.6.0 / 2011-12-18
-==================
-
-  * Added setZeroTimeout timeout for browser (nicer stack traces). Closes #153
-  * Added "view source" on hover for HTML reporter to make it obvious
-  * Changed: replace custom growl with growl lib
-  * Fixed duplicate reporting for HTML reporter. Closes #154
-  * Fixed silent hook errors in the HTML reporter. Closes #150
-
-0.5.0 / 2011-12-14
-==================
-
-  * Added: push node_modules directory onto module.paths for relative require Closes #93
-  * Added teamcity reporter [blindsey]
-  * Fixed: recover from uncaught exceptions for tests. Closes #94
-  * Fixed: only emit "test end" for uncaught within test, not hook
-
-0.4.0 / 2011-12-14
-==================
-
-  * Added support for test-specific timeouts via `this.timeout(0)`. Closes #134
-  * Added guillermo's client-side EventEmitter. Closes #132
-  * Added progress indicator to the HTML reporter
-  * Fixed slow browser tests. Closes #135
-  * Fixed "suite" color for light terminals
-  * Fixed `require()` leak spotted by [guillermo]
-
-0.3.6 / 2011-12-09
-==================
-
-  * Removed suite merging (for now)
-
-0.3.5 / 2011-12-08
-==================
-
-  * Added support for `window.onerror` [guillermo]
-  * Fixed: clear timeout on uncaught exceptions. Closes #131 [guillermo]
-  * Added `mocha.css` to PHONY list.
-  * Added `mocha.js` to PHONY list.
-
-0.3.4 / 2011-12-08
-==================
-
-  * Added: allow `done()` to be called with non-Error
-  * Added: return Runner from `mocha.run()`. Closes #126
-  * Fixed: run afterEach even on failures. Closes #125
-  * Fixed clobbering of current runnable. Closes #121
-
-0.3.3 / 2011-12-08
-==================
-
-  * Fixed hook timeouts. Closes #120
-  * Fixed uncaught exceptions in hooks
-
-0.3.2 / 2011-12-05
-==================
-
-  * Fixed weird reporting when `err.message` is not present
-
-0.3.1 / 2011-12-04
-==================
-
-  * Fixed hook event emitter leak. Closes #117
-  * Fixed: export `Spec` constructor. Closes #116
-
-0.3.0 / 2011-12-04
-==================
-
-  * Added `-w, --watch`. Closes #72
-  * Added `--ignore-leaks` to ignore global leak checking
-  * Added browser `?grep=pattern` support
-  * Added `--globals <names>` to specify accepted globals. Closes #99
-  * Fixed `mocha-debug(1)` on some systems. Closes #232
-  * Fixed growl total, use `runner.total`
-
-0.2.0 / 2011-11-30
-==================
-
-  * Added `--globals <names>` to specify accepted globals. Closes #99
-  * Fixed funky highlighting of messages. Closes #97
-  * Fixed `mocha-debug(1)`. Closes #232
-  * Fixed growl total, use runner.total
-
-0.1.0 / 2011-11-29
-==================
-
-  * Added `suiteSetup` and `suiteTeardown` to TDD interface [David Henderson]
-  * Added growl icons. Closes #84
-  * Fixed coffee-script support
-
-0.0.8 / 2011-11-25
-==================
-
-  * Fixed: use `Runner#total` for accurate reporting
-
-0.0.7 / 2011-11-25
-==================
-
-  * Added `Hook`
-  * Added `Runnable`
-  * Changed: `Test` is `Runnable`
-  * Fixed global leak reporting in hooks
-  * Fixed: > 2 calls to done() only report the error once
-  * Fixed: clear timer on failure. Closes #80
-
-0.0.6 / 2011-11-25
-==================
-
-  * Fixed return on immediate async error. Closes #80
-
-0.0.5 / 2011-11-24
-==================
-
-  * Fixed: make mocha.opts whitespace less picky [kkaefer]
-
-0.0.4 / 2011-11-24
-==================
-
-  * Added `--interfaces`
-  * Added `--reporters`
-  * Added `-c, --colors`. Closes #69
-  * Fixed hook timeouts
-
-0.0.3 / 2011-11-23
-==================
-
-  * Added `-C, --no-colors` to explicitly disable
-  * Added coffee-script support
-
-0.0.2 / 2011-11-22
-==================
-
-  * Fixed global leak detection due to Safari bind() change
-  * Fixed: escape html entities in Doc reporter
-  * Fixed: escape html entities in HTML reporter
-  * Fixed pending test support for HTML reporter. Closes #66
-
-0.0.1 / 2011-11-22
-==================
-
-  * Added `--timeout` second shorthand support, ex `--timeout 3s`.
-  * Fixed "test end" event for uncaughtExceptions. Closes #61
-
-0.0.1-alpha6 / 2011-11-19
-==================
-
-  * Added travis CI support (needs enabling when public)
-  * Added preliminary browser support
-  * Added `make mocha.css` target. Closes #45
-  * Added stack trace to TAP errors. Closes #52
-  * Renamed tearDown to teardown. Closes #49
-  * Fixed: cascading hooksc. Closes #30
-  * Fixed some colors for non-tty
-  * Fixed errors thrown in sync test-cases due to nextTick
-  * Fixed Base.window.width... again give precedence to 0.6.x
-
-0.0.1-alpha5 / 2011-11-17
-==================
-
-  * Added `doc` reporter. Closes #33
-  * Added suite merging. Closes #28
-  * Added TextMate bundle and `make tm`. Closes #20
-
-0.0.1-alpha4 / 2011-11-15
-==================
-
-  * Fixed getWindowSize() for 0.4.x
-
-0.0.1-alpha3 / 2011-11-15
-==================
-
-  * Added `-s, --slow <ms>` to specify "slow" test threshold
-  * Added `mocha-debug(1)`
-  * Added `mocha.opts` support. Closes #31
-  * Added: default [files] to _test/*.js_
-  * Added protection against multiple calls to `done()`. Closes #35
-  * Changed: bright yellow for slow Dot reporter tests
-
-0.0.1-alpha1 / 2011-11-08
-==================
-
-  * Missed this one :)
-
-0.0.1-alpha1 / 2011-11-08
-==================
-
-  * Initial release
diff --git a/packages/planner/node_modules/deepcopy/bower_components/mocha/LICENSE b/packages/planner/node_modules/deepcopy/bower_components/mocha/LICENSE
deleted file mode 100644
index 1c5d7fa8..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/mocha/LICENSE
+++ /dev/null
@@ -1,22 +0,0 @@
-(The MIT License)
-
-Copyright (c) 2011-2014 TJ Holowaychuk <tj@vision-media.ca>
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-'Software'), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/packages/planner/node_modules/deepcopy/bower_components/mocha/README.md b/packages/planner/node_modules/deepcopy/bower_components/mocha/README.md
deleted file mode 100644
index 1a3a9489..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/mocha/README.md
+++ /dev/null
@@ -1,226 +0,0 @@
- [![Build Status](https://secure.travis-ci.org/mochajs/mocha.png)](http://travis-ci.org/mochajs/mocha)
-
-  [![Mocha test framework](http://f.cl.ly/items/3l1k0n2A1U3M1I1L210p/Screen%20Shot%202012-02-24%20at%202.21.43%20PM.png)](http://mochajs.org)
-
-  Mocha is a simple, flexible, fun JavaScript test framework for node.js and the browser. For more information view the [documentation](http://mochajs.org).
-
-## Contributors
-
-```
- project  : mocha
- repo age : 3 years, 4 months
- active   : 509 days
- commits  : 1575
- files    : 153
- authors  :
-   977	TJ Holowaychuk          62.0%
-   132	Travis Jeffery          8.4%
-    63	Christopher Hiller      4.0%
-    31	Guillermo Rauch         2.0%
-    27	Joshua Appelman         1.7%
-    13	Attila Domokos          0.8%
-    10	John Firebaugh          0.6%
-     8	Nathan Rajlich          0.5%
-     8	Jo Liss                 0.5%
-     6	Mike Pennisi            0.4%
-     6	Brendan Nee             0.4%
-     6	James Carr              0.4%
-     5	Aaron Heckmann          0.3%
-     5	Raynos                  0.3%
-     5	Ryunosuke SATO          0.3%
-     4	hokaccha                0.3%
-     4	Jonathan Ong            0.3%
-     4	Joshua Krall            0.3%
-     4	Domenic Denicola        0.3%
-     4	Forbes Lindesay         0.3%
-     4	Xavier Antoviaque       0.3%
-     4	David da Silva          0.3%
-     3	Ariel Mashraki          0.2%
-     3	Ben Bradley             0.2%
-     3	Merrick Christensen     0.2%
-     3	Andreas Lind Petersen   0.2%
-     3	Nathan Bowser           0.2%
-     3	Cory Thomas             0.2%
-     3	Benjie Gillam           0.2%
-     3	Wil Moore III           0.2%
-     3	Ben Lindsey             0.2%
-     3	Tyson Tate              0.2%
-     3	Paul Miller             0.2%
-     3	eiji.ienaga             0.2%
-     3	Mathieu Desvé           0.2%
-     3	Jesse Dailey            0.2%
-     3	fool2fish               0.2%
-     3	Fredrik Enestad         0.2%
-     3	Sindre Sorhus           0.2%
-     3	Valentin Agachi         0.2%
-     2	jsdevel                 0.1%
-     2	Arian Stolwijk          0.1%
-     2	Juzer Ali               0.1%
-     2	David Henderson         0.1%
-     2	Justin DuJardin         0.1%
-     2	Paul Armstrong          0.1%
-     2	Pete Hawkins            0.1%
-     2	Jonas Westerlund        0.1%
-     2	Quang Van               0.1%
-     2	Simon Gaeremynck        0.1%
-     2	travis jeffery          0.1%
-     2	Dominique Quatravaux    0.1%
-     2	Jacob Wejendorp         0.1%
-     2	Shawn Krisman           0.1%
-     2	FARKAS Máté             0.1%
-     2	Konstantin Käfer        0.1%
-     2	Timo Tijhof             0.1%
-     2	Sean Lang               0.1%
-     2	Quanlong He             0.1%
-     2	Glen Mailer             0.1%
-     2	Alexander Early         0.1%
-     2	Ian Storm Taylor        0.1%
-     2	Brian Beck              0.1%
-     2	Michael Riley           0.1%
-     2	Michael Schoonmaker     0.1%
-     2	domenic                 0.1%
-     2	fcrisci                 0.1%
-     2	Buck Doyle              0.1%
-     2	Nathan Alderson         0.1%
-     1	Mal Graty               0.1%
-     1	Marc Kuo                0.1%
-     1	Matija Marohnić         0.1%
-     1	Matt Robenolt           0.1%
-     1	Matt Smith              0.1%
-     1	Matthew Shanley         0.1%
-     1	Mattias Tidlund         0.1%
-     1	Michael Jackson         0.1%
-     1	Michael Olson           0.1%
-     1	Michal Charemza         0.1%
-     1	Nathan Black            0.1%
-     1	Nick Fitzgerald         0.1%
-     1	Noshir Patel            0.1%
-     1	Panu Horsmalahti        0.1%
-     1	Phil Sung               0.1%
-     1	R56                     0.1%
-     1	Refael Ackermann        0.1%
-     1	Richard Dingwall        0.1%
-     1	Richard Knop            0.1%
-     1	Rob Wu                  0.1%
-     1	Romain Prieto           0.1%
-     1	Roman Neuhauser         0.1%
-     1	Roman Shtylman          0.1%
-     1	Russ Bradberry          0.1%
-     1	Russell Munson          0.1%
-     1	Rustem Mustafin         0.1%
-     1	Salehen Shovon Rahman   0.1%
-     1	Sasha Koss              0.1%
-     1	Seiya Konno             0.1%
-     1	Shaine Hatch            0.1%
-     1	Simon Goumaz            0.1%
-     1	Standa Opichal          0.1%
-     1	Stephen Mathieson       0.1%
-     1	Steve Mason             0.1%
-     1	Tapiwa Kelvin           0.1%
-     1	Teddy Zeenny            0.1%
-     1	Tim Ehat                0.1%
-     1	Vadim Nikitin           0.1%
-     1	Victor Costan           0.1%
-     1	Will Langstroth         0.1%
-     1	Yanis Wang              0.1%
-     1	Yuest Wang              0.1%
-     1	Zsolt Takács            0.1%
-     1	abrkn                   0.1%
-     1	airportyh               0.1%
-     1	badunk                  0.1%
-     1	claudyus                0.1%
-     1	dasilvacontin           0.1%
-     1	fengmk2                 0.1%
-     1	gaye                    0.1%
-     1	grasGendarme            0.1%
-     1	lakmeer                 0.1%
-     1	lodr                    0.1%
-     1	mrShturman              0.1%
-     1	nishigori               0.1%
-     1	omardelarosa            0.1%
-     1	qiuzuhui                0.1%
-     1	samuel goldszmidt       0.1%
-     1	sebv                    0.1%
-     1	startswithaj            0.1%
-     1	tgautier@yahoo.com      0.1%
-     1	traleig1                0.1%
-     1	vlad                    0.1%
-     1	yuitest                 0.1%
-     1	zhiyelee                0.1%
-     1	Adam Crabtree           0.1%
-     1	Andreas Brekken         0.1%
-     1	Andrew Nesbitt          0.1%
-     1	Andrey Popp             0.1%
-     1	Arnaud Brousseau        0.1%
-     1	Atsuya Takagi           0.1%
-     1	Austin Birch            0.1%
-     1	Ben Noordhuis           0.1%
-     1	Bjørge Næss             0.1%
-     1	Brian Lalor             0.1%
-     1	Brian M. Carlson        0.1%
-     1	Brian Moore             0.1%
-     1	Bryan Donovan           0.1%
-     1	C. Scott Ananian        0.1%
-     1	Casey Foster            0.1%
-     1	ChrisWren               0.1%
-     1	Connor Dunn             0.1%
-     1	Corey Butler            0.1%
-     1	Daniel Stockman         0.1%
-     1	Dave McKenna            0.1%
-     1	Denis Bardadym          0.1%
-     1	Devin Weaver            0.1%
-     1	Di Wu                   0.1%
-     1	Diogo Monteiro          0.1%
-     1	Dmitry Shirokov         0.1%
-     1	Dr. Travis Jeffery      0.1%
-     1	Fedor Indutny           0.1%
-     1	Florian Margaine        0.1%
-     1	Frederico Silva         0.1%
-     1	Fredrik Lindin          0.1%
-     1	Gareth Aye              0.1%
-     1	Gareth Murphy           0.1%
-     1	Gavin Mogan             0.1%
-     1	Giovanni Bassi          0.1%
-     1	Glen Huang              0.1%
-     1	Greg Perkins            0.1%
-     1	Harish                  0.1%
-     1	Harry Brundage          0.1%
-     1	Herman Junge            0.1%
-     1	Ian Young               0.1%
-     1	Ivan                    0.1%
-     1	JP Bochi                0.1%
-     1	Jaakko Salonen          0.1%
-     1	Jakub Nešetřil          0.1%
-     1	James Bowes             0.1%
-     1	James Lal               0.1%
-     1	Jan Kopriva             0.1%
-     1	Jason Barry             0.1%
-     1	Javier Aranda           0.1%
-     1	Jean Ponchon            0.1%
-     1	Jeff Kunkle             0.1%
-     1	Jeremy Martin           0.1%
-     1	Jimmy Cuadra            0.1%
-     1	John Doty               0.1%
-     1	Jonathan Creamer        0.1%
-     1	Jonathan Park           0.1%
-     1	Jussi Virtanen          0.1%
-     1	Katie Gengler           0.1%
-     1	Kazuhito Hokamura       0.1%
-     1	Kent C. Dodds           0.1%
-     1	Kevin Conway            0.1%
-     1	Kirill Korolyov         0.1%
-     1	Koen Punt               0.1%
-     1	Laszlo Bacsi            0.1%
-     1	Liam Newman             0.1%
-     1	Linus Unnebäck          0.1%
-     1	László Bácsi            0.1%
-     1	Maciej Małecki          0.1%
-```
-
-## Links
-
-  - [Google Group](http://groups.google.com/group/mochajs)
-  - [Wiki](https://github.com/mochajs/mocha/wiki)
-  - Mocha [Extensions and reporters](https://github.com/mochajs/mocha/wiki)
-
-Mocha also has a chat room on [Slack](https://slack.com). If you'd like to join, [shoot us an email](mailto:tj@travisjeffery.com?subject=mocha%20slack%20room%20invite) from the address you want us to invite you under and we'll happily send you an invite!
diff --git a/packages/planner/node_modules/deepcopy/bower_components/mocha/bower.json b/packages/planner/node_modules/deepcopy/bower_components/mocha/bower.json
deleted file mode 100644
index 3ec9d019..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/mocha/bower.json
+++ /dev/null
@@ -1,47 +0,0 @@
-{
-  "name": "mocha",
-  "version": "2.1.0",
-  "homepage": "http://mocha.github.io/mocha",
-  "description": "simple, flexible, fun test framework",
-  "authors": [
-    "TJ Holowaychuk <tj@vision-media.ca>",
-    "Joshua Appelman <joshua@jbna.nl>",
-    "Oleg Gaidarenko <markelog@gmail.com>",
-    "Christoffer Hallas <christoffer.hallas@gmail.com>",
-    "Christopher Hiller <chiller@badwing.com>",
-    "Travis Jeffery <tj@travisjeffery.com>",
-    "Johnathan Ong <me@jongleberry.com>",
-    "Guillermo Rauch <rauchg@gmail.com>"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/mochajs/mocha.git"
-  },
-  "main": [
-    "mocha.js",
-    "mocha.css"
-  ],
-  "ignore": [
-    "bin",
-    "editors",
-    "images",
-    "lib",
-    "support",
-    "test",
-    ".gitignore",
-    ".npmignore",
-    ".travis.yml",
-    "component.json",
-    "index.js",
-    "Makefile",
-    "package.json"
-  ],
-  "keywords": [
-    "mocha",
-    "test",
-    "bdd",
-    "tdd",
-    "tap"
-  ],
-  "license": "MIT"
-}
\ No newline at end of file
diff --git a/packages/planner/node_modules/deepcopy/bower_components/mocha/media/logo.svg b/packages/planner/node_modules/deepcopy/bower_components/mocha/media/logo.svg
deleted file mode 100644
index 1bed0ce1..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/mocha/media/logo.svg
+++ /dev/null
@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Generator: Adobe Illustrator 17.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="612px" height="792px" viewBox="0 0 612 792" enable-background="new 0 0 612 792" xml:space="preserve">
-<circle fill="#8A6343" cx="306" cy="396" r="306"/>
-<text transform="matrix(1 0 0 1 72.1431 424.7633)" fill="#FFFFFF" font-family="'HelveticaNeue'" font-size="153">mocha</text>
-</svg>
diff --git a/packages/planner/node_modules/deepcopy/bower_components/mocha/mocha.css b/packages/planner/node_modules/deepcopy/bower_components/mocha/mocha.css
deleted file mode 100644
index 42b9798f..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/mocha/mocha.css
+++ /dev/null
@@ -1,270 +0,0 @@
-@charset "utf-8";
-
-body {
-  margin:0;
-}
-
-#mocha {
-  font: 20px/1.5 "Helvetica Neue", Helvetica, Arial, sans-serif;
-  margin: 60px 50px;
-}
-
-#mocha ul,
-#mocha li {
-  margin: 0;
-  padding: 0;
-}
-
-#mocha ul {
-  list-style: none;
-}
-
-#mocha h1,
-#mocha h2 {
-  margin: 0;
-}
-
-#mocha h1 {
-  margin-top: 15px;
-  font-size: 1em;
-  font-weight: 200;
-}
-
-#mocha h1 a {
-  text-decoration: none;
-  color: inherit;
-}
-
-#mocha h1 a:hover {
-  text-decoration: underline;
-}
-
-#mocha .suite .suite h1 {
-  margin-top: 0;
-  font-size: .8em;
-}
-
-#mocha .hidden {
-  display: none;
-}
-
-#mocha h2 {
-  font-size: 12px;
-  font-weight: normal;
-  cursor: pointer;
-}
-
-#mocha .suite {
-  margin-left: 15px;
-}
-
-#mocha .test {
-  margin-left: 15px;
-  overflow: hidden;
-}
-
-#mocha .test.pending:hover h2::after {
-  content: '(pending)';
-  font-family: arial, sans-serif;
-}
-
-#mocha .test.pass.medium .duration {
-  background: #c09853;
-}
-
-#mocha .test.pass.slow .duration {
-  background: #b94a48;
-}
-
-#mocha .test.pass::before {
-  content: '✓';
-  font-size: 12px;
-  display: block;
-  float: left;
-  margin-right: 5px;
-  color: #00d6b2;
-}
-
-#mocha .test.pass .duration {
-  font-size: 9px;
-  margin-left: 5px;
-  padding: 2px 5px;
-  color: #fff;
-  -webkit-box-shadow: inset 0 1px 1px rgba(0,0,0,.2);
-  -moz-box-shadow: inset 0 1px 1px rgba(0,0,0,.2);
-  box-shadow: inset 0 1px 1px rgba(0,0,0,.2);
-  -webkit-border-radius: 5px;
-  -moz-border-radius: 5px;
-  -ms-border-radius: 5px;
-  -o-border-radius: 5px;
-  border-radius: 5px;
-}
-
-#mocha .test.pass.fast .duration {
-  display: none;
-}
-
-#mocha .test.pending {
-  color: #0b97c4;
-}
-
-#mocha .test.pending::before {
-  content: '◦';
-  color: #0b97c4;
-}
-
-#mocha .test.fail {
-  color: #c00;
-}
-
-#mocha .test.fail pre {
-  color: black;
-}
-
-#mocha .test.fail::before {
-  content: '✖';
-  font-size: 12px;
-  display: block;
-  float: left;
-  margin-right: 5px;
-  color: #c00;
-}
-
-#mocha .test pre.error {
-  color: #c00;
-  max-height: 300px;
-  overflow: auto;
-}
-
-/**
- * (1): approximate for browsers not supporting calc
- * (2): 42 = 2*15 + 2*10 + 2*1 (padding + margin + border)
- *      ^^ seriously
- */
-#mocha .test pre {
-  display: block;
-  float: left;
-  clear: left;
-  font: 12px/1.5 monaco, monospace;
-  margin: 5px;
-  padding: 15px;
-  border: 1px solid #eee;
-  max-width: 85%; /*(1)*/
-  max-width: calc(100% - 42px); /*(2)*/
-  word-wrap: break-word;
-  border-bottom-color: #ddd;
-  -webkit-border-radius: 3px;
-  -webkit-box-shadow: 0 1px 3px #eee;
-  -moz-border-radius: 3px;
-  -moz-box-shadow: 0 1px 3px #eee;
-  border-radius: 3px;
-}
-
-#mocha .test h2 {
-  position: relative;
-}
-
-#mocha .test a.replay {
-  position: absolute;
-  top: 3px;
-  right: 0;
-  text-decoration: none;
-  vertical-align: middle;
-  display: block;
-  width: 15px;
-  height: 15px;
-  line-height: 15px;
-  text-align: center;
-  background: #eee;
-  font-size: 15px;
-  -moz-border-radius: 15px;
-  border-radius: 15px;
-  -webkit-transition: opacity 200ms;
-  -moz-transition: opacity 200ms;
-  transition: opacity 200ms;
-  opacity: 0.3;
-  color: #888;
-}
-
-#mocha .test:hover a.replay {
-  opacity: 1;
-}
-
-#mocha-report.pass .test.fail {
-  display: none;
-}
-
-#mocha-report.fail .test.pass {
-  display: none;
-}
-
-#mocha-report.pending .test.pass,
-#mocha-report.pending .test.fail {
-  display: none;
-}
-#mocha-report.pending .test.pass.pending {
-  display: block;
-}
-
-#mocha-error {
-  color: #c00;
-  font-size: 1.5em;
-  font-weight: 100;
-  letter-spacing: 1px;
-}
-
-#mocha-stats {
-  position: fixed;
-  top: 15px;
-  right: 10px;
-  font-size: 12px;
-  margin: 0;
-  color: #888;
-  z-index: 1;
-}
-
-#mocha-stats .progress {
-  float: right;
-  padding-top: 0;
-}
-
-#mocha-stats em {
-  color: black;
-}
-
-#mocha-stats a {
-  text-decoration: none;
-  color: inherit;
-}
-
-#mocha-stats a:hover {
-  border-bottom: 1px solid #eee;
-}
-
-#mocha-stats li {
-  display: inline-block;
-  margin: 0 5px;
-  list-style: none;
-  padding-top: 11px;
-}
-
-#mocha-stats canvas {
-  width: 40px;
-  height: 40px;
-}
-
-#mocha code .comment { color: #ddd; }
-#mocha code .init { color: #2f6fad; }
-#mocha code .string { color: #5890ad; }
-#mocha code .keyword { color: #8a6343; }
-#mocha code .number { color: #2f6fad; }
-
-@media screen and (max-device-width: 480px) {
-  #mocha {
-    margin: 60px 0px;
-  }
-
-  #mocha #stats {
-    position: absolute;
-  }
-}
diff --git a/packages/planner/node_modules/deepcopy/bower_components/mocha/mocha.js b/packages/planner/node_modules/deepcopy/bower_components/mocha/mocha.js
deleted file mode 100644
index 22d1a9f3..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/mocha/mocha.js
+++ /dev/null
@@ -1,6298 +0,0 @@
-;(function(){
-
-// CommonJS require()
-
-function require(p){
-    var path = require.resolve(p)
-      , mod = require.modules[path];
-    if (!mod) throw new Error('failed to require "' + p + '"');
-    if (!mod.exports) {
-      mod.exports = {};
-      mod.call(mod.exports, mod, mod.exports, require.relative(path));
-    }
-    return mod.exports;
-  }
-
-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.register = function (path, fn){
-    require.modules[path] = fn;
-  };
-
-require.relative = function (parent) {
-    return function(p){
-      if ('.' != p.charAt(0)) 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('/'));
-    };
-  };
-
-
-require.register("browser/debug.js", function(module, exports, require){
-module.exports = function(type){
-  return function(){
-  }
-};
-
-}); // module: browser/debug.js
-
-require.register("browser/diff.js", function(module, exports, require){
-/* See LICENSE file for terms of use */
-
-/*
- * Text diff implementation.
- *
- * This library supports the following APIS:
- * JsDiff.diffChars: Character by character diff
- * JsDiff.diffWords: Word (as defined by \b regex) diff which ignores whitespace
- * JsDiff.diffLines: Line based diff
- *
- * JsDiff.diffCss: Diff targeted at CSS content
- *
- * These methods are based on the implementation proposed in
- * "An O(ND) Difference Algorithm and its Variations" (Myers, 1986).
- * http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.4.6927
- */
-var JsDiff = (function() {
-  /*jshint maxparams: 5*/
-  function clonePath(path) {
-    return { newPos: path.newPos, components: path.components.slice(0) };
-  }
-  function removeEmpty(array) {
-    var ret = [];
-    for (var i = 0; i < array.length; i++) {
-      if (array[i]) {
-        ret.push(array[i]);
-      }
-    }
-    return ret;
-  }
-  function escapeHTML(s) {
-    var n = s;
-    n = n.replace(/&/g, '&amp;');
-    n = n.replace(/</g, '&lt;');
-    n = n.replace(/>/g, '&gt;');
-    n = n.replace(/"/g, '&quot;');
-
-    return n;
-  }
-
-  var Diff = function(ignoreWhitespace) {
-    this.ignoreWhitespace = ignoreWhitespace;
-  };
-  Diff.prototype = {
-      diff: function(oldString, newString) {
-        // Handle the identity case (this is due to unrolling editLength == 0
-        if (newString === oldString) {
-          return [{ value: newString }];
-        }
-        if (!newString) {
-          return [{ value: oldString, removed: true }];
-        }
-        if (!oldString) {
-          return [{ value: newString, added: true }];
-        }
-
-        newString = this.tokenize(newString);
-        oldString = this.tokenize(oldString);
-
-        var newLen = newString.length, oldLen = oldString.length;
-        var maxEditLength = newLen + oldLen;
-        var bestPath = [{ newPos: -1, components: [] }];
-
-        // Seed editLength = 0
-        var oldPos = this.extractCommon(bestPath[0], newString, oldString, 0);
-        if (bestPath[0].newPos+1 >= newLen && oldPos+1 >= oldLen) {
-          return bestPath[0].components;
-        }
-
-        for (var editLength = 1; editLength <= maxEditLength; editLength++) {
-          for (var diagonalPath = -1*editLength; diagonalPath <= editLength; diagonalPath+=2) {
-            var basePath;
-            var addPath = bestPath[diagonalPath-1],
-                removePath = bestPath[diagonalPath+1];
-            oldPos = (removePath ? removePath.newPos : 0) - diagonalPath;
-            if (addPath) {
-              // No one else is going to attempt to use this value, clear it
-              bestPath[diagonalPath-1] = undefined;
-            }
-
-            var canAdd = addPath && addPath.newPos+1 < newLen;
-            var canRemove = removePath && 0 <= oldPos && oldPos < oldLen;
-            if (!canAdd && !canRemove) {
-              bestPath[diagonalPath] = undefined;
-              continue;
-            }
-
-            // Select the diagonal that we want to branch from. We select the prior
-            // path whose position in the new string is the farthest from the origin
-            // and does not pass the bounds of the diff graph
-            if (!canAdd || (canRemove && addPath.newPos < removePath.newPos)) {
-              basePath = clonePath(removePath);
-              this.pushComponent(basePath.components, oldString[oldPos], undefined, true);
-            } else {
-              basePath = clonePath(addPath);
-              basePath.newPos++;
-              this.pushComponent(basePath.components, newString[basePath.newPos], true, undefined);
-            }
-
-            var oldPos = this.extractCommon(basePath, newString, oldString, diagonalPath);
-
-            if (basePath.newPos+1 >= newLen && oldPos+1 >= oldLen) {
-              return basePath.components;
-            } else {
-              bestPath[diagonalPath] = basePath;
-            }
-          }
-        }
-      },
-
-      pushComponent: function(components, value, added, removed) {
-        var last = components[components.length-1];
-        if (last && last.added === added && last.removed === removed) {
-          // We need to clone here as the component clone operation is just
-          // as shallow array clone
-          components[components.length-1] =
-            {value: this.join(last.value, value), added: added, removed: removed };
-        } else {
-          components.push({value: value, added: added, removed: removed });
-        }
-      },
-      extractCommon: function(basePath, newString, oldString, diagonalPath) {
-        var newLen = newString.length,
-            oldLen = oldString.length,
-            newPos = basePath.newPos,
-            oldPos = newPos - diagonalPath;
-        while (newPos+1 < newLen && oldPos+1 < oldLen && this.equals(newString[newPos+1], oldString[oldPos+1])) {
-          newPos++;
-          oldPos++;
-
-          this.pushComponent(basePath.components, newString[newPos], undefined, undefined);
-        }
-        basePath.newPos = newPos;
-        return oldPos;
-      },
-
-      equals: function(left, right) {
-        var reWhitespace = /\S/;
-        if (this.ignoreWhitespace && !reWhitespace.test(left) && !reWhitespace.test(right)) {
-          return true;
-        } else {
-          return left === right;
-        }
-      },
-      join: function(left, right) {
-        return left + right;
-      },
-      tokenize: function(value) {
-        return value;
-      }
-  };
-
-  var CharDiff = new Diff();
-
-  var WordDiff = new Diff(true);
-  var WordWithSpaceDiff = new Diff();
-  WordDiff.tokenize = WordWithSpaceDiff.tokenize = function(value) {
-    return removeEmpty(value.split(/(\s+|\b)/));
-  };
-
-  var CssDiff = new Diff(true);
-  CssDiff.tokenize = function(value) {
-    return removeEmpty(value.split(/([{}:;,]|\s+)/));
-  };
-
-  var LineDiff = new Diff();
-  LineDiff.tokenize = function(value) {
-    var retLines = [],
-        lines = value.split(/^/m);
-
-    for(var i = 0; i < lines.length; i++) {
-      var line = lines[i],
-          lastLine = lines[i - 1];
-
-      // Merge lines that may contain windows new lines
-      if (line == '\n' && lastLine && lastLine[lastLine.length - 1] === '\r') {
-        retLines[retLines.length - 1] += '\n';
-      } else if (line) {
-        retLines.push(line);
-      }
-    }
-
-    return retLines;
-  };
-
-  return {
-    Diff: Diff,
-
-    diffChars: function(oldStr, newStr) { return CharDiff.diff(oldStr, newStr); },
-    diffWords: function(oldStr, newStr) { return WordDiff.diff(oldStr, newStr); },
-    diffWordsWithSpace: function(oldStr, newStr) { return WordWithSpaceDiff.diff(oldStr, newStr); },
-    diffLines: function(oldStr, newStr) { return LineDiff.diff(oldStr, newStr); },
-
-    diffCss: function(oldStr, newStr) { return CssDiff.diff(oldStr, newStr); },
-
-    createPatch: function(fileName, oldStr, newStr, oldHeader, newHeader) {
-      var ret = [];
-
-      ret.push('Index: ' + fileName);
-      ret.push('===================================================================');
-      ret.push('--- ' + fileName + (typeof oldHeader === 'undefined' ? '' : '\t' + oldHeader));
-      ret.push('+++ ' + fileName + (typeof newHeader === 'undefined' ? '' : '\t' + newHeader));
-
-      var diff = LineDiff.diff(oldStr, newStr);
-      if (!diff[diff.length-1].value) {
-        diff.pop();   // Remove trailing newline add
-      }
-      diff.push({value: '', lines: []});   // Append an empty value to make cleanup easier
-
-      function contextLines(lines) {
-        return lines.map(function(entry) { return ' ' + entry; });
-      }
-      function eofNL(curRange, i, current) {
-        var last = diff[diff.length-2],
-            isLast = i === diff.length-2,
-            isLastOfType = i === diff.length-3 && (current.added !== last.added || current.removed !== last.removed);
-
-        // Figure out if this is the last line for the given file and missing NL
-        if (!/\n$/.test(current.value) && (isLast || isLastOfType)) {
-          curRange.push('\\ No newline at end of file');
-        }
-      }
-
-      var oldRangeStart = 0, newRangeStart = 0, curRange = [],
-          oldLine = 1, newLine = 1;
-      for (var i = 0; i < diff.length; i++) {
-        var current = diff[i],
-            lines = current.lines || current.value.replace(/\n$/, '').split('\n');
-        current.lines = lines;
-
-        if (current.added || current.removed) {
-          if (!oldRangeStart) {
-            var prev = diff[i-1];
-            oldRangeStart = oldLine;
-            newRangeStart = newLine;
-
-            if (prev) {
-              curRange = contextLines(prev.lines.slice(-4));
-              oldRangeStart -= curRange.length;
-              newRangeStart -= curRange.length;
-            }
-          }
-          curRange.push.apply(curRange, lines.map(function(entry) { return (current.added?'+':'-') + entry; }));
-          eofNL(curRange, i, current);
-
-          if (current.added) {
-            newLine += lines.length;
-          } else {
-            oldLine += lines.length;
-          }
-        } else {
-          if (oldRangeStart) {
-            // Close out any changes that have been output (or join overlapping)
-            if (lines.length <= 8 && i < diff.length-2) {
-              // Overlapping
-              curRange.push.apply(curRange, contextLines(lines));
-            } else {
-              // end the range and output
-              var contextSize = Math.min(lines.length, 4);
-              ret.push(
-                  '@@ -' + oldRangeStart + ',' + (oldLine-oldRangeStart+contextSize)
-                  + ' +' + newRangeStart + ',' + (newLine-newRangeStart+contextSize)
-                  + ' @@');
-              ret.push.apply(ret, curRange);
-              ret.push.apply(ret, contextLines(lines.slice(0, contextSize)));
-              if (lines.length <= 4) {
-                eofNL(ret, i, current);
-              }
-
-              oldRangeStart = 0;  newRangeStart = 0; curRange = [];
-            }
-          }
-          oldLine += lines.length;
-          newLine += lines.length;
-        }
-      }
-
-      return ret.join('\n') + '\n';
-    },
-
-    applyPatch: function(oldStr, uniDiff) {
-      var diffstr = uniDiff.split('\n');
-      var diff = [];
-      var remEOFNL = false,
-          addEOFNL = false;
-
-      for (var i = (diffstr[0][0]==='I'?4:0); i < diffstr.length; i++) {
-        if(diffstr[i][0] === '@') {
-          var meh = diffstr[i].split(/@@ -(\d+),(\d+) \+(\d+),(\d+) @@/);
-          diff.unshift({
-            start:meh[3],
-            oldlength:meh[2],
-            oldlines:[],
-            newlength:meh[4],
-            newlines:[]
-          });
-        } else if(diffstr[i][0] === '+') {
-          diff[0].newlines.push(diffstr[i].substr(1));
-        } else if(diffstr[i][0] === '-') {
-          diff[0].oldlines.push(diffstr[i].substr(1));
-        } else if(diffstr[i][0] === ' ') {
-          diff[0].newlines.push(diffstr[i].substr(1));
-          diff[0].oldlines.push(diffstr[i].substr(1));
-        } else if(diffstr[i][0] === '\\') {
-          if (diffstr[i-1][0] === '+') {
-            remEOFNL = true;
-          } else if(diffstr[i-1][0] === '-') {
-            addEOFNL = true;
-          }
-        }
-      }
-
-      var str = oldStr.split('\n');
-      for (var i = diff.length - 1; i >= 0; i--) {
-        var d = diff[i];
-        for (var j = 0; j < d.oldlength; j++) {
-          if(str[d.start-1+j] !== d.oldlines[j]) {
-            return false;
-          }
-        }
-        Array.prototype.splice.apply(str,[d.start-1,+d.oldlength].concat(d.newlines));
-      }
-
-      if (remEOFNL) {
-        while (!str[str.length-1]) {
-          str.pop();
-        }
-      } else if (addEOFNL) {
-        str.push('');
-      }
-      return str.join('\n');
-    },
-
-    convertChangesToXML: function(changes){
-      var ret = [];
-      for ( var i = 0; i < changes.length; i++) {
-        var change = changes[i];
-        if (change.added) {
-          ret.push('<ins>');
-        } else if (change.removed) {
-          ret.push('<del>');
-        }
-
-        ret.push(escapeHTML(change.value));
-
-        if (change.added) {
-          ret.push('</ins>');
-        } else if (change.removed) {
-          ret.push('</del>');
-        }
-      }
-      return ret.join('');
-    },
-
-    // See: http://code.google.com/p/google-diff-match-patch/wiki/API
-    convertChangesToDMP: function(changes){
-      var ret = [], change;
-      for ( var i = 0; i < changes.length; i++) {
-        change = changes[i];
-        ret.push([(change.added ? 1 : change.removed ? -1 : 0), change.value]);
-      }
-      return ret;
-    }
-  };
-})();
-
-if (typeof module !== 'undefined') {
-    module.exports = JsDiff;
-}
-
-}); // module: browser/diff.js
-
-require.register("browser/escape-string-regexp.js", function(module, exports, require){
-'use strict';
-
-var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
-
-module.exports = function (str) {
-  if (typeof str !== 'string') {
-    throw new TypeError('Expected a string');
-  }
-
-  return str.replace(matchOperatorsRe,  '\\$&');
-};
-
-}); // module: browser/escape-string-regexp.js
-
-require.register("browser/events.js", function(module, exports, require){
-/**
- * Module exports.
- */
-
-exports.EventEmitter = EventEmitter;
-
-/**
- * Check if `obj` is an array.
- */
-
-function isArray(obj) {
-  return '[object Array]' == {}.toString.call(obj);
-}
-
-/**
- * Event emitter constructor.
- *
- * @api public
- */
-
-function EventEmitter(){};
-
-/**
- * Adds a listener.
- *
- * @api public
- */
-
-EventEmitter.prototype.on = function (name, fn) {
-  if (!this.$events) {
-    this.$events = {};
-  }
-
-  if (!this.$events[name]) {
-    this.$events[name] = fn;
-  } else if (isArray(this.$events[name])) {
-    this.$events[name].push(fn);
-  } else {
-    this.$events[name] = [this.$events[name], fn];
-  }
-
-  return this;
-};
-
-EventEmitter.prototype.addListener = EventEmitter.prototype.on;
-
-/**
- * Adds a volatile listener.
- *
- * @api public
- */
-
-EventEmitter.prototype.once = function (name, fn) {
-  var self = this;
-
-  function on () {
-    self.removeListener(name, on);
-    fn.apply(this, arguments);
-  };
-
-  on.listener = fn;
-  this.on(name, on);
-
-  return this;
-};
-
-/**
- * Removes a listener.
- *
- * @api public
- */
-
-EventEmitter.prototype.removeListener = function (name, fn) {
-  if (this.$events && this.$events[name]) {
-    var list = this.$events[name];
-
-    if (isArray(list)) {
-      var pos = -1;
-
-      for (var i = 0, l = list.length; i < l; i++) {
-        if (list[i] === fn || (list[i].listener && list[i].listener === fn)) {
-          pos = i;
-          break;
-        }
-      }
-
-      if (pos < 0) {
-        return this;
-      }
-
-      list.splice(pos, 1);
-
-      if (!list.length) {
-        delete this.$events[name];
-      }
-    } else if (list === fn || (list.listener && list.listener === fn)) {
-      delete this.$events[name];
-    }
-  }
-
-  return this;
-};
-
-/**
- * Removes all listeners for an event.
- *
- * @api public
- */
-
-EventEmitter.prototype.removeAllListeners = function (name) {
-  if (name === undefined) {
-    this.$events = {};
-    return this;
-  }
-
-  if (this.$events && this.$events[name]) {
-    this.$events[name] = null;
-  }
-
-  return this;
-};
-
-/**
- * Gets all listeners for a certain event.
- *
- * @api public
- */
-
-EventEmitter.prototype.listeners = function (name) {
-  if (!this.$events) {
-    this.$events = {};
-  }
-
-  if (!this.$events[name]) {
-    this.$events[name] = [];
-  }
-
-  if (!isArray(this.$events[name])) {
-    this.$events[name] = [this.$events[name]];
-  }
-
-  return this.$events[name];
-};
-
-/**
- * Emits an event.
- *
- * @api public
- */
-
-EventEmitter.prototype.emit = function (name) {
-  if (!this.$events) {
-    return false;
-  }
-
-  var handler = this.$events[name];
-
-  if (!handler) {
-    return false;
-  }
-
-  var args = [].slice.call(arguments, 1);
-
-  if ('function' == typeof handler) {
-    handler.apply(this, args);
-  } else if (isArray(handler)) {
-    var listeners = handler.slice();
-
-    for (var i = 0, l = listeners.length; i < l; i++) {
-      listeners[i].apply(this, args);
-    }
-  } else {
-    return false;
-  }
-
-  return true;
-};
-
-}); // module: browser/events.js
-
-require.register("browser/fs.js", function(module, exports, require){
-
-}); // module: browser/fs.js
-
-require.register("browser/glob.js", function(module, exports, require){
-
-}); // module: browser/glob.js
-
-require.register("browser/path.js", function(module, exports, require){
-
-}); // module: browser/path.js
-
-require.register("browser/progress.js", function(module, exports, require){
-/**
- * Expose `Progress`.
- */
-
-module.exports = Progress;
-
-/**
- * Initialize a new `Progress` indicator.
- */
-
-function Progress() {
-  this.percent = 0;
-  this.size(0);
-  this.fontSize(11);
-  this.font('helvetica, arial, sans-serif');
-}
-
-/**
- * Set progress size to `n`.
- *
- * @param {Number} n
- * @return {Progress} for chaining
- * @api public
- */
-
-Progress.prototype.size = function(n){
-  this._size = n;
-  return this;
-};
-
-/**
- * Set text to `str`.
- *
- * @param {String} str
- * @return {Progress} for chaining
- * @api public
- */
-
-Progress.prototype.text = function(str){
-  this._text = str;
-  return this;
-};
-
-/**
- * Set font size to `n`.
- *
- * @param {Number} n
- * @return {Progress} for chaining
- * @api public
- */
-
-Progress.prototype.fontSize = function(n){
-  this._fontSize = n;
-  return this;
-};
-
-/**
- * Set font `family`.
- *
- * @param {String} family
- * @return {Progress} for chaining
- */
-
-Progress.prototype.font = function(family){
-  this._font = family;
-  return this;
-};
-
-/**
- * Update percentage to `n`.
- *
- * @param {Number} n
- * @return {Progress} for chaining
- */
-
-Progress.prototype.update = function(n){
-  this.percent = n;
-  return this;
-};
-
-/**
- * Draw on `ctx`.
- *
- * @param {CanvasRenderingContext2d} ctx
- * @return {Progress} for chaining
- */
-
-Progress.prototype.draw = function(ctx){
-  try {
-    var percent = Math.min(this.percent, 100)
-      , size = this._size
-      , half = size / 2
-      , x = half
-      , y = half
-      , rad = half - 1
-      , fontSize = this._fontSize;
-
-    ctx.font = fontSize + 'px ' + this._font;
-
-    var angle = Math.PI * 2 * (percent / 100);
-    ctx.clearRect(0, 0, size, size);
-
-    // outer circle
-    ctx.strokeStyle = '#9f9f9f';
-    ctx.beginPath();
-    ctx.arc(x, y, rad, 0, angle, false);
-    ctx.stroke();
-
-    // inner circle
-    ctx.strokeStyle = '#eee';
-    ctx.beginPath();
-    ctx.arc(x, y, rad - 1, 0, angle, true);
-    ctx.stroke();
-
-    // text
-    var text = this._text || (percent | 0) + '%'
-      , w = ctx.measureText(text).width;
-
-    ctx.fillText(
-        text
-      , x - w / 2 + 1
-      , y + fontSize / 2 - 1);
-  } catch (ex) {} //don't fail if we can't render progress
-  return this;
-};
-
-}); // module: browser/progress.js
-
-require.register("browser/tty.js", function(module, exports, require){
-exports.isatty = function(){
-  return true;
-};
-
-exports.getWindowSize = function(){
-  if ('innerHeight' in global) {
-    return [global.innerHeight, global.innerWidth];
-  } else {
-    // In a Web Worker, the DOM Window is not available.
-    return [640, 480];
-  }
-};
-
-}); // module: browser/tty.js
-
-require.register("context.js", function(module, exports, require){
-/**
- * Expose `Context`.
- */
-
-module.exports = Context;
-
-/**
- * Initialize a new `Context`.
- *
- * @api private
- */
-
-function Context(){}
-
-/**
- * Set or get the context `Runnable` to `runnable`.
- *
- * @param {Runnable} runnable
- * @return {Context}
- * @api private
- */
-
-Context.prototype.runnable = function(runnable){
-  if (0 == arguments.length) return this._runnable;
-  this.test = this._runnable = runnable;
-  return this;
-};
-
-/**
- * Set test timeout `ms`.
- *
- * @param {Number} ms
- * @return {Context} self
- * @api private
- */
-
-Context.prototype.timeout = function(ms){
-  if (arguments.length === 0) return this.runnable().timeout();
-  this.runnable().timeout(ms);
-  return this;
-};
-
-/**
- * Set test timeout `enabled`.
- *
- * @param {Boolean} enabled
- * @return {Context} self
- * @api private
- */
-
-Context.prototype.enableTimeouts = function (enabled) {
-  this.runnable().enableTimeouts(enabled);
-  return this;
-};
-
-
-/**
- * Set test slowness threshold `ms`.
- *
- * @param {Number} ms
- * @return {Context} self
- * @api private
- */
-
-Context.prototype.slow = function(ms){
-  this.runnable().slow(ms);
-  return this;
-};
-
-/**
- * Inspect the context void of `._runnable`.
- *
- * @return {String}
- * @api private
- */
-
-Context.prototype.inspect = function(){
-  return JSON.stringify(this, function(key, val){
-    if ('_runnable' == key) return;
-    if ('test' == key) return;
-    return val;
-  }, 2);
-};
-
-}); // module: context.js
-
-require.register("hook.js", function(module, exports, require){
-/**
- * Module dependencies.
- */
-
-var Runnable = require('./runnable');
-
-/**
- * Expose `Hook`.
- */
-
-module.exports = Hook;
-
-/**
- * Initialize a new `Hook` with the given `title` and callback `fn`.
- *
- * @param {String} title
- * @param {Function} fn
- * @api private
- */
-
-function Hook(title, fn) {
-  Runnable.call(this, title, fn);
-  this.type = 'hook';
-}
-
-/**
- * Inherit from `Runnable.prototype`.
- */
-
-function F(){};
-F.prototype = Runnable.prototype;
-Hook.prototype = new F;
-Hook.prototype.constructor = Hook;
-
-
-/**
- * Get or set the test `err`.
- *
- * @param {Error} err
- * @return {Error}
- * @api public
- */
-
-Hook.prototype.error = function(err){
-  if (0 == arguments.length) {
-    var err = this._error;
-    this._error = null;
-    return err;
-  }
-
-  this._error = err;
-};
-
-}); // module: hook.js
-
-require.register("interfaces/bdd.js", function(module, exports, require){
-/**
- * Module dependencies.
- */
-
-var Suite = require('../suite')
-  , Test = require('../test')
-  , utils = require('../utils')
-  , escapeRe = require('browser/escape-string-regexp');
-
-/**
- * BDD-style interface:
- *
- *      describe('Array', function(){
- *        describe('#indexOf()', function(){
- *          it('should return -1 when not present', function(){
- *
- *          });
- *
- *          it('should return the index when present', function(){
- *
- *          });
- *        });
- *      });
- *
- */
-
-module.exports = function(suite){
-  var suites = [suite];
-
-  suite.on('pre-require', function(context, file, mocha){
-
-    /**
-     * Execute before running tests.
-     */
-
-    context.before = function(name, fn){
-      suites[0].beforeAll(name, fn);
-    };
-
-    /**
-     * Execute after running tests.
-     */
-
-    context.after = function(name, fn){
-      suites[0].afterAll(name, fn);
-    };
-
-    /**
-     * Execute before each test case.
-     */
-
-    context.beforeEach = function(name, fn){
-      suites[0].beforeEach(name, fn);
-    };
-
-    /**
-     * Execute after each test case.
-     */
-
-    context.afterEach = function(name, fn){
-      suites[0].afterEach(name, fn);
-    };
-
-    /**
-     * Describe a "suite" with the given `title`
-     * and callback `fn` containing nested suites
-     * and/or tests.
-     */
-
-    context.describe = context.context = function(title, fn){
-      var suite = Suite.create(suites[0], title);
-      suite.file = file;
-      suites.unshift(suite);
-      fn.call(suite);
-      suites.shift();
-      return suite;
-    };
-
-    /**
-     * Pending describe.
-     */
-
-    context.xdescribe =
-    context.xcontext =
-    context.describe.skip = function(title, fn){
-      var suite = Suite.create(suites[0], title);
-      suite.pending = true;
-      suites.unshift(suite);
-      fn.call(suite);
-      suites.shift();
-    };
-
-    /**
-     * Exclusive suite.
-     */
-
-    context.describe.only = function(title, fn){
-      var suite = context.describe(title, fn);
-      mocha.grep(suite.fullTitle());
-      return suite;
-    };
-
-    /**
-     * Describe a specification or test-case
-     * with the given `title` and callback `fn`
-     * acting as a thunk.
-     */
-
-    context.it = context.specify = function(title, fn){
-      var suite = suites[0];
-      if (suite.pending) fn = null;
-      var test = new Test(title, fn);
-      test.file = file;
-      suite.addTest(test);
-      return test;
-    };
-
-    /**
-     * Exclusive test-case.
-     */
-
-    context.it.only = function(title, fn){
-      var test = context.it(title, fn);
-      var reString = '^' + escapeRe(test.fullTitle()) + '$';
-      mocha.grep(new RegExp(reString));
-      return test;
-    };
-
-    /**
-     * Pending test case.
-     */
-
-    context.xit =
-    context.xspecify =
-    context.it.skip = function(title){
-      context.it(title);
-    };
-  });
-};
-
-}); // module: interfaces/bdd.js
-
-require.register("interfaces/exports.js", function(module, exports, require){
-/**
- * Module dependencies.
- */
-
-var Suite = require('../suite')
-  , Test = require('../test');
-
-/**
- * TDD-style interface:
- *
- *     exports.Array = {
- *       '#indexOf()': {
- *         'should return -1 when the value is not present': function(){
- *
- *         },
- *
- *         'should return the correct index when the value is present': function(){
- *
- *         }
- *       }
- *     };
- *
- */
-
-module.exports = function(suite){
-  var suites = [suite];
-
-  suite.on('require', visit);
-
-  function visit(obj, file) {
-    var suite;
-    for (var key in obj) {
-      if ('function' == typeof obj[key]) {
-        var fn = obj[key];
-        switch (key) {
-          case 'before':
-            suites[0].beforeAll(fn);
-            break;
-          case 'after':
-            suites[0].afterAll(fn);
-            break;
-          case 'beforeEach':
-            suites[0].beforeEach(fn);
-            break;
-          case 'afterEach':
-            suites[0].afterEach(fn);
-            break;
-          default:
-            var test = new Test(key, fn);
-            test.file = file;
-            suites[0].addTest(test);
-        }
-      } else {
-        suite = Suite.create(suites[0], key);
-        suites.unshift(suite);
-        visit(obj[key]);
-        suites.shift();
-      }
-    }
-  }
-};
-
-}); // module: interfaces/exports.js
-
-require.register("interfaces/index.js", function(module, exports, require){
-exports.bdd = require('./bdd');
-exports.tdd = require('./tdd');
-exports.qunit = require('./qunit');
-exports.exports = require('./exports');
-
-}); // module: interfaces/index.js
-
-require.register("interfaces/qunit.js", function(module, exports, require){
-/**
- * Module dependencies.
- */
-
-var Suite = require('../suite')
-  , Test = require('../test')
-  , escapeRe = require('browser/escape-string-regexp')
-  , utils = require('../utils');
-
-/**
- * QUnit-style interface:
- *
- *     suite('Array');
- *
- *     test('#length', function(){
- *       var arr = [1,2,3];
- *       ok(arr.length == 3);
- *     });
- *
- *     test('#indexOf()', function(){
- *       var arr = [1,2,3];
- *       ok(arr.indexOf(1) == 0);
- *       ok(arr.indexOf(2) == 1);
- *       ok(arr.indexOf(3) == 2);
- *     });
- *
- *     suite('String');
- *
- *     test('#length', function(){
- *       ok('foo'.length == 3);
- *     });
- *
- */
-
-module.exports = function(suite){
-  var suites = [suite];
-
-  suite.on('pre-require', function(context, file, mocha){
-
-    /**
-     * Execute before running tests.
-     */
-
-    context.before = function(name, fn){
-      suites[0].beforeAll(name, fn);
-    };
-
-    /**
-     * Execute after running tests.
-     */
-
-    context.after = function(name, fn){
-      suites[0].afterAll(name, fn);
-    };
-
-    /**
-     * Execute before each test case.
-     */
-
-    context.beforeEach = function(name, fn){
-      suites[0].beforeEach(name, fn);
-    };
-
-    /**
-     * Execute after each test case.
-     */
-
-    context.afterEach = function(name, fn){
-      suites[0].afterEach(name, fn);
-    };
-
-    /**
-     * Describe a "suite" with the given `title`.
-     */
-
-    context.suite = function(title){
-      if (suites.length > 1) suites.shift();
-      var suite = Suite.create(suites[0], title);
-      suite.file = file;
-      suites.unshift(suite);
-      return suite;
-    };
-
-    /**
-     * Exclusive test-case.
-     */
-
-    context.suite.only = function(title, fn){
-      var suite = context.suite(title, fn);
-      mocha.grep(suite.fullTitle());
-    };
-
-    /**
-     * Describe a specification or test-case
-     * with the given `title` and callback `fn`
-     * acting as a thunk.
-     */
-
-    context.test = function(title, fn){
-      var test = new Test(title, fn);
-      test.file = file;
-      suites[0].addTest(test);
-      return test;
-    };
-
-    /**
-     * Exclusive test-case.
-     */
-
-    context.test.only = function(title, fn){
-      var test = context.test(title, fn);
-      var reString = '^' + escapeRe(test.fullTitle()) + '$';
-      mocha.grep(new RegExp(reString));
-    };
-
-    /**
-     * Pending test case.
-     */
-
-    context.test.skip = function(title){
-      context.test(title);
-    };
-  });
-};
-
-}); // module: interfaces/qunit.js
-
-require.register("interfaces/tdd.js", function(module, exports, require){
-/**
- * Module dependencies.
- */
-
-var Suite = require('../suite')
-  , Test = require('../test')
-  , escapeRe = require('browser/escape-string-regexp')
-  , utils = require('../utils');
-
-/**
- * TDD-style interface:
- *
- *      suite('Array', function(){
- *        suite('#indexOf()', function(){
- *          suiteSetup(function(){
- *
- *          });
- *
- *          test('should return -1 when not present', function(){
- *
- *          });
- *
- *          test('should return the index when present', function(){
- *
- *          });
- *
- *          suiteTeardown(function(){
- *
- *          });
- *        });
- *      });
- *
- */
-
-module.exports = function(suite){
-  var suites = [suite];
-
-  suite.on('pre-require', function(context, file, mocha){
-
-    /**
-     * Execute before each test case.
-     */
-
-    context.setup = function(name, fn){
-      suites[0].beforeEach(name, fn);
-    };
-
-    /**
-     * Execute after each test case.
-     */
-
-    context.teardown = function(name, fn){
-      suites[0].afterEach(name, fn);
-    };
-
-    /**
-     * Execute before the suite.
-     */
-
-    context.suiteSetup = function(name, fn){
-      suites[0].beforeAll(name, fn);
-    };
-
-    /**
-     * Execute after the suite.
-     */
-
-    context.suiteTeardown = function(name, fn){
-      suites[0].afterAll(name, fn);
-    };
-
-    /**
-     * Describe a "suite" with the given `title`
-     * and callback `fn` containing nested suites
-     * and/or tests.
-     */
-
-    context.suite = function(title, fn){
-      var suite = Suite.create(suites[0], title);
-      suite.file = file;
-      suites.unshift(suite);
-      fn.call(suite);
-      suites.shift();
-      return suite;
-    };
-
-    /**
-     * Pending suite.
-     */
-    context.suite.skip = function(title, fn) {
-      var suite = Suite.create(suites[0], title);
-      suite.pending = true;
-      suites.unshift(suite);
-      fn.call(suite);
-      suites.shift();
-    };
-
-    /**
-     * Exclusive test-case.
-     */
-
-    context.suite.only = function(title, fn){
-      var suite = context.suite(title, fn);
-      mocha.grep(suite.fullTitle());
-    };
-
-    /**
-     * Describe a specification or test-case
-     * with the given `title` and callback `fn`
-     * acting as a thunk.
-     */
-
-    context.test = function(title, fn){
-      var suite = suites[0];
-      if (suite.pending) fn = null;
-      var test = new Test(title, fn);
-      test.file = file;
-      suite.addTest(test);
-      return test;
-    };
-
-    /**
-     * Exclusive test-case.
-     */
-
-    context.test.only = function(title, fn){
-      var test = context.test(title, fn);
-      var reString = '^' + escapeRe(test.fullTitle()) + '$';
-      mocha.grep(new RegExp(reString));
-    };
-
-    /**
-     * Pending test case.
-     */
-
-    context.test.skip = function(title){
-      context.test(title);
-    };
-  });
-};
-
-}); // module: interfaces/tdd.js
-
-require.register("mocha.js", function(module, exports, require){
-/*!
- * mocha
- * Copyright(c) 2011 TJ Holowaychuk <tj@vision-media.ca>
- * MIT Licensed
- */
-
-/**
- * Module dependencies.
- */
-
-var path = require('browser/path')
-  , escapeRe = require('browser/escape-string-regexp')
-  , utils = require('./utils');
-
-/**
- * Expose `Mocha`.
- */
-
-exports = module.exports = Mocha;
-
-/**
- * To require local UIs and reporters when running in node.
- */
-
-if (typeof process !== 'undefined' && typeof process.cwd === 'function') {
-  var join = path.join
-    , cwd = process.cwd();
-  module.paths.push(cwd, join(cwd, 'node_modules'));
-}
-
-/**
- * Expose internals.
- */
-
-exports.utils = utils;
-exports.interfaces = require('./interfaces');
-exports.reporters = require('./reporters');
-exports.Runnable = require('./runnable');
-exports.Context = require('./context');
-exports.Runner = require('./runner');
-exports.Suite = require('./suite');
-exports.Hook = require('./hook');
-exports.Test = require('./test');
-
-/**
- * Return image `name` path.
- *
- * @param {String} name
- * @return {String}
- * @api private
- */
-
-function image(name) {
-  return __dirname + '/../images/' + name + '.png';
-}
-
-/**
- * Setup mocha with `options`.
- *
- * Options:
- *
- *   - `ui` name "bdd", "tdd", "exports" etc
- *   - `reporter` reporter instance, defaults to `mocha.reporters.spec`
- *   - `globals` array of accepted globals
- *   - `timeout` timeout in milliseconds
- *   - `bail` bail on the first test failure
- *   - `slow` milliseconds to wait before considering a test slow
- *   - `ignoreLeaks` ignore global leaks
- *   - `grep` string or regexp to filter tests with
- *
- * @param {Object} options
- * @api public
- */
-
-function Mocha(options) {
-  options = options || {};
-  this.files = [];
-  this.options = options;
-  this.grep(options.grep);
-  this.suite = new exports.Suite('', new exports.Context);
-  this.ui(options.ui);
-  this.bail(options.bail);
-  this.reporter(options.reporter, options.reporterOptions);
-  if (null != options.timeout) this.timeout(options.timeout);
-  this.useColors(options.useColors)
-  if (options.enableTimeouts !== null) this.enableTimeouts(options.enableTimeouts);
-  if (options.slow) this.slow(options.slow);
-
-  this.suite.on('pre-require', function (context) {
-    exports.afterEach = context.afterEach || context.teardown;
-    exports.after = context.after || context.suiteTeardown;
-    exports.beforeEach = context.beforeEach || context.setup;
-    exports.before = context.before || context.suiteSetup;
-    exports.describe = context.describe || context.suite;
-    exports.it = context.it || context.test;
-    exports.setup = context.setup || context.beforeEach;
-    exports.suiteSetup = context.suiteSetup || context.before;
-    exports.suiteTeardown = context.suiteTeardown || context.after;
-    exports.suite = context.suite || context.describe;
-    exports.teardown = context.teardown || context.afterEach;
-    exports.test = context.test || context.it;
-  });
-}
-
-/**
- * Enable or disable bailing on the first failure.
- *
- * @param {Boolean} [bail]
- * @api public
- */
-
-Mocha.prototype.bail = function(bail){
-  if (0 == arguments.length) bail = true;
-  this.suite.bail(bail);
-  return this;
-};
-
-/**
- * Add test `file`.
- *
- * @param {String} file
- * @api public
- */
-
-Mocha.prototype.addFile = function(file){
-  this.files.push(file);
-  return this;
-};
-
-/**
- * Set reporter to `reporter`, defaults to "spec".
- *
- * @param {String|Function} reporter name or constructor
- * @param {Object} reporterOptions optional options
- * @api public
- */
-Mocha.prototype.reporter = function(reporter, reporterOptions){
-  if ('function' == typeof reporter) {
-    this._reporter = reporter;
-  } else {
-    reporter = reporter || 'spec';
-    var _reporter;
-    try { _reporter = require('./reporters/' + reporter); } catch (err) {};
-    if (!_reporter) try { _reporter = require(reporter); } catch (err) {};
-    if (!_reporter && reporter === 'teamcity')
-      console.warn('The Teamcity reporter was moved to a package named ' +
-        'mocha-teamcity-reporter ' +
-        '(https://npmjs.org/package/mocha-teamcity-reporter).');
-    if (!_reporter) throw new Error('invalid reporter "' + reporter + '"');
-    this._reporter = _reporter;
-  }
-  this.options.reporterOptions = reporterOptions;
-  return this;
-};
-
-/**
- * Set test UI `name`, defaults to "bdd".
- *
- * @param {String} bdd
- * @api public
- */
-
-Mocha.prototype.ui = function(name){
-  name = name || 'bdd';
-  this._ui = exports.interfaces[name];
-  if (!this._ui) try { this._ui = require(name); } catch (err) {};
-  if (!this._ui) throw new Error('invalid interface "' + name + '"');
-  this._ui = this._ui(this.suite);
-  return this;
-};
-
-/**
- * Load registered files.
- *
- * @api private
- */
-
-Mocha.prototype.loadFiles = function(fn){
-  var self = this;
-  var suite = this.suite;
-  var pending = this.files.length;
-  this.files.forEach(function(file){
-    file = path.resolve(file);
-    suite.emit('pre-require', global, file, self);
-    suite.emit('require', require(file), file, self);
-    suite.emit('post-require', global, file, self);
-    --pending || (fn && fn());
-  });
-};
-
-/**
- * Enable growl support.
- *
- * @api private
- */
-
-Mocha.prototype._growl = function(runner, reporter) {
-  var notify = require('growl');
-
-  runner.on('end', function(){
-    var stats = reporter.stats;
-    if (stats.failures) {
-      var msg = stats.failures + ' of ' + runner.total + ' tests failed';
-      notify(msg, { name: 'mocha', title: 'Failed', image: image('error') });
-    } else {
-      notify(stats.passes + ' tests passed in ' + stats.duration + 'ms', {
-          name: 'mocha'
-        , title: 'Passed'
-        , image: image('ok')
-      });
-    }
-  });
-};
-
-/**
- * Add regexp to grep, if `re` is a string it is escaped.
- *
- * @param {RegExp|String} re
- * @return {Mocha}
- * @api public
- */
-
-Mocha.prototype.grep = function(re){
-  this.options.grep = 'string' == typeof re
-    ? new RegExp(escapeRe(re))
-    : re;
-  return this;
-};
-
-/**
- * Invert `.grep()` matches.
- *
- * @return {Mocha}
- * @api public
- */
-
-Mocha.prototype.invert = function(){
-  this.options.invert = true;
-  return this;
-};
-
-/**
- * Ignore global leaks.
- *
- * @param {Boolean} ignore
- * @return {Mocha}
- * @api public
- */
-
-Mocha.prototype.ignoreLeaks = function(ignore){
-  this.options.ignoreLeaks = !!ignore;
-  return this;
-};
-
-/**
- * Enable global leak checking.
- *
- * @return {Mocha}
- * @api public
- */
-
-Mocha.prototype.checkLeaks = function(){
-  this.options.ignoreLeaks = false;
-  return this;
-};
-
-/**
- * Enable growl support.
- *
- * @return {Mocha}
- * @api public
- */
-
-Mocha.prototype.growl = function(){
-  this.options.growl = true;
-  return this;
-};
-
-/**
- * Ignore `globals` array or string.
- *
- * @param {Array|String} globals
- * @return {Mocha}
- * @api public
- */
-
-Mocha.prototype.globals = function(globals){
-  this.options.globals = (this.options.globals || []).concat(globals);
-  return this;
-};
-
-/**
- * Emit color output.
- *
- * @param {Boolean} colors
- * @return {Mocha}
- * @api public
- */
-
-Mocha.prototype.useColors = function(colors){
-  if (colors !== undefined) {
-    this.options.useColors = colors;
-  }
-  return this;
-};
-
-/**
- * Use inline diffs rather than +/-.
- *
- * @param {Boolean} inlineDiffs
- * @return {Mocha}
- * @api public
- */
-
-Mocha.prototype.useInlineDiffs = function(inlineDiffs) {
-  this.options.useInlineDiffs = arguments.length && inlineDiffs != undefined
-  ? inlineDiffs
-  : false;
-  return this;
-};
-
-/**
- * Set the timeout in milliseconds.
- *
- * @param {Number} timeout
- * @return {Mocha}
- * @api public
- */
-
-Mocha.prototype.timeout = function(timeout){
-  this.suite.timeout(timeout);
-  return this;
-};
-
-/**
- * Set slowness threshold in milliseconds.
- *
- * @param {Number} slow
- * @return {Mocha}
- * @api public
- */
-
-Mocha.prototype.slow = function(slow){
-  this.suite.slow(slow);
-  return this;
-};
-
-/**
- * Enable timeouts.
- *
- * @param {Boolean} enabled
- * @return {Mocha}
- * @api public
- */
-
-Mocha.prototype.enableTimeouts = function(enabled) {
-  this.suite.enableTimeouts(arguments.length && enabled !== undefined
-    ? enabled
-    : true);
-  return this
-};
-
-/**
- * Makes all tests async (accepting a callback)
- *
- * @return {Mocha}
- * @api public
- */
-
-Mocha.prototype.asyncOnly = function(){
-  this.options.asyncOnly = true;
-  return this;
-};
-
-/**
- * Disable syntax highlighting (in browser).
- * @returns {Mocha}
- * @api public
- */
-Mocha.prototype.noHighlighting = function() {
-  this.options.noHighlighting = true;
-  return this;
-};
-
-/**
- * Run tests and invoke `fn()` when complete.
- *
- * @param {Function} fn
- * @return {Runner}
- * @api public
- */
-
-Mocha.prototype.run = function(fn){
-  if (this.files.length) this.loadFiles();
-  var suite = this.suite;
-  var options = this.options;
-  options.files = this.files;
-  var runner = new exports.Runner(suite);
-  var reporter = new this._reporter(runner, options);
-  runner.ignoreLeaks = false !== options.ignoreLeaks;
-  runner.asyncOnly = options.asyncOnly;
-  if (options.grep) runner.grep(options.grep, options.invert);
-  if (options.globals) runner.globals(options.globals);
-  if (options.growl) this._growl(runner, reporter);
-  if (options.useColors !== undefined) {
-    exports.reporters.Base.useColors = options.useColors;
-  }
-  exports.reporters.Base.inlineDiffs = options.useInlineDiffs;
-
-  function done(failures) {
-      if (reporter.done) {
-          reporter.done(failures, fn);
-      } else {
-          fn(failures);
-      }
-  }
-
-  return runner.run(done);
-};
-
-}); // module: mocha.js
-
-require.register("ms.js", function(module, exports, require){
-/**
- * Helpers.
- */
-
-var s = 1000;
-var m = s * 60;
-var h = m * 60;
-var d = h * 24;
-var y = d * 365.25;
-
-/**
- * Parse or format the given `val`.
- *
- * Options:
- *
- *  - `long` verbose formatting [false]
- *
- * @param {String|Number} val
- * @param {Object} options
- * @return {String|Number}
- * @api public
- */
-
-module.exports = function(val, options){
-  options = options || {};
-  if ('string' == typeof val) return parse(val);
-  return options['long'] ? longFormat(val) : shortFormat(val);
-};
-
-/**
- * Parse the given `str` and return milliseconds.
- *
- * @param {String} str
- * @return {Number}
- * @api private
- */
-
-function parse(str) {
-  var match = /^((?:\d+)?\.?\d+) *(ms|seconds?|s|minutes?|m|hours?|h|days?|d|years?|y)?$/i.exec(str);
-  if (!match) return;
-  var n = parseFloat(match[1]);
-  var type = (match[2] || 'ms').toLowerCase();
-  switch (type) {
-    case 'years':
-    case 'year':
-    case 'y':
-      return n * y;
-    case 'days':
-    case 'day':
-    case 'd':
-      return n * d;
-    case 'hours':
-    case 'hour':
-    case 'h':
-      return n * h;
-    case 'minutes':
-    case 'minute':
-    case 'm':
-      return n * m;
-    case 'seconds':
-    case 'second':
-    case 's':
-      return n * s;
-    case 'ms':
-      return n;
-  }
-}
-
-/**
- * Short format for `ms`.
- *
- * @param {Number} ms
- * @return {String}
- * @api private
- */
-
-function shortFormat(ms) {
-  if (ms >= d) return Math.round(ms / d) + 'd';
-  if (ms >= h) return Math.round(ms / h) + 'h';
-  if (ms >= m) return Math.round(ms / m) + 'm';
-  if (ms >= s) return Math.round(ms / s) + 's';
-  return ms + 'ms';
-}
-
-/**
- * Long format for `ms`.
- *
- * @param {Number} ms
- * @return {String}
- * @api private
- */
-
-function longFormat(ms) {
-  return plural(ms, d, 'day')
-    || plural(ms, h, 'hour')
-    || plural(ms, m, 'minute')
-    || plural(ms, s, 'second')
-    || ms + ' ms';
-}
-
-/**
- * Pluralization helper.
- */
-
-function plural(ms, n, name) {
-  if (ms < n) return;
-  if (ms < n * 1.5) return Math.floor(ms / n) + ' ' + name;
-  return Math.ceil(ms / n) + ' ' + name + 's';
-}
-
-}); // module: ms.js
-
-require.register("reporters/base.js", function(module, exports, require){
-/**
- * Module dependencies.
- */
-
-var tty = require('browser/tty')
-  , diff = require('browser/diff')
-  , ms = require('../ms')
-  , utils = require('../utils');
-
-/**
- * Save timer references to avoid Sinon interfering (see GH-237).
- */
-
-var Date = global.Date
-  , setTimeout = global.setTimeout
-  , setInterval = global.setInterval
-  , clearTimeout = global.clearTimeout
-  , clearInterval = global.clearInterval;
-
-/**
- * Check if both stdio streams are associated with a tty.
- */
-
-var isatty = tty.isatty(1) && tty.isatty(2);
-
-/**
- * Expose `Base`.
- */
-
-exports = module.exports = Base;
-
-/**
- * Enable coloring by default.
- */
-
-exports.useColors = isatty || (process.env.MOCHA_COLORS !== undefined);
-
-/**
- * Inline diffs instead of +/-
- */
-
-exports.inlineDiffs = false;
-
-/**
- * Default color map.
- */
-
-exports.colors = {
-    'pass': 90
-  , 'fail': 31
-  , 'bright pass': 92
-  , 'bright fail': 91
-  , 'bright yellow': 93
-  , 'pending': 36
-  , 'suite': 0
-  , 'error title': 0
-  , 'error message': 31
-  , 'error stack': 90
-  , 'checkmark': 32
-  , 'fast': 90
-  , 'medium': 33
-  , 'slow': 31
-  , 'green': 32
-  , 'light': 90
-  , 'diff gutter': 90
-  , 'diff added': 42
-  , 'diff removed': 41
-};
-
-/**
- * Default symbol map.
- */
-
-exports.symbols = {
-  ok: '✓',
-  err: '✖',
-  dot: '․'
-};
-
-// With node.js on Windows: use symbols available in terminal default fonts
-if ('win32' == process.platform) {
-  exports.symbols.ok = '\u221A';
-  exports.symbols.err = '\u00D7';
-  exports.symbols.dot = '.';
-}
-
-/**
- * Color `str` with the given `type`,
- * allowing colors to be disabled,
- * as well as user-defined color
- * schemes.
- *
- * @param {String} type
- * @param {String} str
- * @return {String}
- * @api private
- */
-
-var color = exports.color = function(type, str) {
-  if (!exports.useColors) return String(str);
-  return '\u001b[' + exports.colors[type] + 'm' + str + '\u001b[0m';
-};
-
-/**
- * Expose term window size, with some
- * defaults for when stderr is not a tty.
- */
-
-exports.window = {
-  width: isatty
-    ? process.stdout.getWindowSize
-      ? process.stdout.getWindowSize(1)[0]
-      : tty.getWindowSize()[1]
-    : 75
-};
-
-/**
- * Expose some basic cursor interactions
- * that are common among reporters.
- */
-
-exports.cursor = {
-  hide: function(){
-    isatty && process.stdout.write('\u001b[?25l');
-  },
-
-  show: function(){
-    isatty && process.stdout.write('\u001b[?25h');
-  },
-
-  deleteLine: function(){
-    isatty && process.stdout.write('\u001b[2K');
-  },
-
-  beginningOfLine: function(){
-    isatty && process.stdout.write('\u001b[0G');
-  },
-
-  CR: function(){
-    if (isatty) {
-      exports.cursor.deleteLine();
-      exports.cursor.beginningOfLine();
-    } else {
-      process.stdout.write('\r');
-    }
-  }
-};
-
-/**
- * Outut the given `failures` as a list.
- *
- * @param {Array} failures
- * @api public
- */
-
-exports.list = function(failures){
-  console.log();
-  failures.forEach(function(test, i){
-    // format
-    var fmt = color('error title', '  %s) %s:\n')
-      + color('error message', '     %s')
-      + color('error stack', '\n%s\n');
-
-    // msg
-    var err = test.err
-      , message = err.message || ''
-      , stack = err.stack || message
-      , index = stack.indexOf(message) + message.length
-      , msg = stack.slice(0, index)
-      , actual = err.actual
-      , expected = err.expected
-      , escape = true;
-
-    // uncaught
-    if (err.uncaught) {
-      msg = 'Uncaught ' + msg;
-    }
-
-    // explicitly show diff
-    if (err.showDiff && sameType(actual, expected)) {
-
-      if ('string' !== typeof actual) {
-        escape = false;
-        err.actual = actual = utils.stringify(actual);
-        err.expected = expected = utils.stringify(expected);
-      }
-
-      fmt = color('error title', '  %s) %s:\n%s') + color('error stack', '\n%s\n');
-      var match = message.match(/^([^:]+): expected/);
-      msg = '\n      ' + color('error message', match ? match[1] : msg);
-
-      if (exports.inlineDiffs) {
-        msg += inlineDiff(err, escape);
-      } else {
-        msg += unifiedDiff(err, escape);
-      }
-    }
-
-    // indent stack trace without msg
-    stack = stack.slice(index ? index + 1 : index)
-      .replace(/^/gm, '  ');
-
-    console.log(fmt, (i + 1), test.fullTitle(), msg, stack);
-  });
-};
-
-/**
- * Initialize a new `Base` reporter.
- *
- * All other reporters generally
- * inherit from this reporter, providing
- * stats such as test duration, number
- * of tests passed / failed etc.
- *
- * @param {Runner} runner
- * @api public
- */
-
-function Base(runner) {
-  var self = this
-    , stats = this.stats = { suites: 0, tests: 0, passes: 0, pending: 0, failures: 0 }
-    , failures = this.failures = [];
-
-  if (!runner) return;
-  this.runner = runner;
-
-  runner.stats = stats;
-
-  runner.on('start', function(){
-    stats.start = new Date;
-  });
-
-  runner.on('suite', function(suite){
-    stats.suites = stats.suites || 0;
-    suite.root || stats.suites++;
-  });
-
-  runner.on('test end', function(test){
-    stats.tests = stats.tests || 0;
-    stats.tests++;
-  });
-
-  runner.on('pass', function(test){
-    stats.passes = stats.passes || 0;
-
-    var medium = test.slow() / 2;
-    test.speed = test.duration > test.slow()
-      ? 'slow'
-      : test.duration > medium
-        ? 'medium'
-        : 'fast';
-
-    stats.passes++;
-  });
-
-  runner.on('fail', function(test, err){
-    stats.failures = stats.failures || 0;
-    stats.failures++;
-    test.err = err;
-    failures.push(test);
-  });
-
-  runner.on('end', function(){
-    stats.end = new Date;
-    stats.duration = new Date - stats.start;
-  });
-
-  runner.on('pending', function(){
-    stats.pending++;
-  });
-}
-
-/**
- * Output common epilogue used by many of
- * the bundled reporters.
- *
- * @api public
- */
-
-Base.prototype.epilogue = function(){
-  var stats = this.stats;
-  var tests;
-  var fmt;
-
-  console.log();
-
-  // passes
-  fmt = color('bright pass', ' ')
-    + color('green', ' %d passing')
-    + color('light', ' (%s)');
-
-  console.log(fmt,
-    stats.passes || 0,
-    ms(stats.duration));
-
-  // pending
-  if (stats.pending) {
-    fmt = color('pending', ' ')
-      + color('pending', ' %d pending');
-
-    console.log(fmt, stats.pending);
-  }
-
-  // failures
-  if (stats.failures) {
-    fmt = color('fail', '  %d failing');
-
-    console.log(fmt, stats.failures);
-
-    Base.list(this.failures);
-    console.log();
-  }
-
-  console.log();
-};
-
-/**
- * Pad the given `str` to `len`.
- *
- * @param {String} str
- * @param {String} len
- * @return {String}
- * @api private
- */
-
-function pad(str, len) {
-  str = String(str);
-  return Array(len - str.length + 1).join(' ') + str;
-}
-
-
-/**
- * Returns an inline diff between 2 strings with coloured ANSI output
- *
- * @param {Error} Error with actual/expected
- * @return {String} Diff
- * @api private
- */
-
-function inlineDiff(err, escape) {
-  var msg = errorDiff(err, 'WordsWithSpace', escape);
-
-  // linenos
-  var lines = msg.split('\n');
-  if (lines.length > 4) {
-    var width = String(lines.length).length;
-    msg = lines.map(function(str, i){
-      return pad(++i, width) + ' |' + ' ' + str;
-    }).join('\n');
-  }
-
-  // legend
-  msg = '\n'
-    + color('diff removed', 'actual')
-    + ' '
-    + color('diff added', 'expected')
-    + '\n\n'
-    + msg
-    + '\n';
-
-  // indent
-  msg = msg.replace(/^/gm, '      ');
-  return msg;
-}
-
-/**
- * Returns a unified diff between 2 strings
- *
- * @param {Error} Error with actual/expected
- * @return {String} Diff
- * @api private
- */
-
-function unifiedDiff(err, escape) {
-  var indent = '      ';
-  function cleanUp(line) {
-    if (escape) {
-      line = escapeInvisibles(line);
-    }
-    if (line[0] === '+') return indent + colorLines('diff added', line);
-    if (line[0] === '-') return indent + colorLines('diff removed', line);
-    if (line.match(/\@\@/)) return null;
-    if (line.match(/\\ No newline/)) return null;
-    else return indent + line;
-  }
-  function notBlank(line) {
-    return line != null;
-  }
-  msg = diff.createPatch('string', err.actual, err.expected);
-  var lines = msg.split('\n').splice(4);
-  return '\n      '
-         + colorLines('diff added',   '+ expected') + ' '
-         + colorLines('diff removed', '- actual')
-         + '\n\n'
-         + lines.map(cleanUp).filter(notBlank).join('\n');
-}
-
-/**
- * Return a character diff for `err`.
- *
- * @param {Error} err
- * @return {String}
- * @api private
- */
-
-function errorDiff(err, type, escape) {
-  var actual   = escape ? escapeInvisibles(err.actual)   : err.actual;
-  var expected = escape ? escapeInvisibles(err.expected) : err.expected;
-  return diff['diff' + type](actual, expected).map(function(str){
-    if (str.added) return colorLines('diff added', str.value);
-    if (str.removed) return colorLines('diff removed', str.value);
-    return str.value;
-  }).join('');
-}
-
-/**
- * Returns a string with all invisible characters in plain text
- *
- * @param {String} line
- * @return {String}
- * @api private
- */
-function escapeInvisibles(line) {
-    return line.replace(/\t/g, '<tab>')
-               .replace(/\r/g, '<CR>')
-               .replace(/\n/g, '<LF>\n');
-}
-
-/**
- * Color lines for `str`, using the color `name`.
- *
- * @param {String} name
- * @param {String} str
- * @return {String}
- * @api private
- */
-
-function colorLines(name, str) {
-  return str.split('\n').map(function(str){
-    return color(name, str);
-  }).join('\n');
-}
-
-/**
- * Check that a / b have the same type.
- *
- * @param {Object} a
- * @param {Object} b
- * @return {Boolean}
- * @api private
- */
-
-function sameType(a, b) {
-  a = Object.prototype.toString.call(a);
-  b = Object.prototype.toString.call(b);
-  return a == b;
-}
-
-}); // module: reporters/base.js
-
-require.register("reporters/doc.js", function(module, exports, require){
-/**
- * Module dependencies.
- */
-
-var Base = require('./base')
-  , utils = require('../utils');
-
-/**
- * Expose `Doc`.
- */
-
-exports = module.exports = Doc;
-
-/**
- * Initialize a new `Doc` reporter.
- *
- * @param {Runner} runner
- * @api public
- */
-
-function Doc(runner) {
-  Base.call(this, runner);
-
-  var self = this
-    , stats = this.stats
-    , total = runner.total
-    , indents = 2;
-
-  function indent() {
-    return Array(indents).join('  ');
-  }
-
-  runner.on('suite', function(suite){
-    if (suite.root) return;
-    ++indents;
-    console.log('%s<section class="suite">', indent());
-    ++indents;
-    console.log('%s<h1>%s</h1>', indent(), utils.escape(suite.title));
-    console.log('%s<dl>', indent());
-  });
-
-  runner.on('suite end', function(suite){
-    if (suite.root) return;
-    console.log('%s</dl>', indent());
-    --indents;
-    console.log('%s</section>', indent());
-    --indents;
-  });
-
-  runner.on('pass', function(test){
-    console.log('%s  <dt>%s</dt>', indent(), utils.escape(test.title));
-    var code = utils.escape(utils.clean(test.fn.toString()));
-    console.log('%s  <dd><pre><code>%s</code></pre></dd>', indent(), code);
-  });
-
-  runner.on('fail', function(test, err){
-    console.log('%s  <dt class="error">%s</dt>', indent(), utils.escape(test.title));
-    var code = utils.escape(utils.clean(test.fn.toString()));
-    console.log('%s  <dd class="error"><pre><code>%s</code></pre></dd>', indent(), code);
-    console.log('%s  <dd class="error">%s</dd>', indent(), utils.escape(err));
-  });
-}
-
-}); // module: reporters/doc.js
-
-require.register("reporters/dot.js", function(module, exports, require){
-/**
- * Module dependencies.
- */
-
-var Base = require('./base')
-  , color = Base.color;
-
-/**
- * Expose `Dot`.
- */
-
-exports = module.exports = Dot;
-
-/**
- * Initialize a new `Dot` matrix test reporter.
- *
- * @param {Runner} runner
- * @api public
- */
-
-function Dot(runner) {
-  Base.call(this, runner);
-
-  var self = this
-    , stats = this.stats
-    , width = Base.window.width * .75 | 0
-    , n = -1;
-
-  runner.on('start', function(){
-    process.stdout.write('\n  ');
-  });
-
-  runner.on('pending', function(test){
-    if (++n % width == 0) process.stdout.write('\n  ');
-    process.stdout.write(color('pending', Base.symbols.dot));
-  });
-
-  runner.on('pass', function(test){
-    if (++n % width == 0) process.stdout.write('\n  ');
-    if ('slow' == test.speed) {
-      process.stdout.write(color('bright yellow', Base.symbols.dot));
-    } else {
-      process.stdout.write(color(test.speed, Base.symbols.dot));
-    }
-  });
-
-  runner.on('fail', function(test, err){
-    if (++n % width == 0) process.stdout.write('\n  ');
-    process.stdout.write(color('fail', Base.symbols.dot));
-  });
-
-  runner.on('end', function(){
-    console.log();
-    self.epilogue();
-  });
-}
-
-/**
- * Inherit from `Base.prototype`.
- */
-
-function F(){};
-F.prototype = Base.prototype;
-Dot.prototype = new F;
-Dot.prototype.constructor = Dot;
-
-
-}); // module: reporters/dot.js
-
-require.register("reporters/html-cov.js", function(module, exports, require){
-/**
- * Module dependencies.
- */
-
-var JSONCov = require('./json-cov')
-  , fs = require('browser/fs');
-
-/**
- * Expose `HTMLCov`.
- */
-
-exports = module.exports = HTMLCov;
-
-/**
- * Initialize a new `JsCoverage` reporter.
- *
- * @param {Runner} runner
- * @api public
- */
-
-function HTMLCov(runner) {
-  var jade = require('jade')
-    , file = __dirname + '/templates/coverage.jade'
-    , str = fs.readFileSync(file, 'utf8')
-    , fn = jade.compile(str, { filename: file })
-    , self = this;
-
-  JSONCov.call(this, runner, false);
-
-  runner.on('end', function(){
-    process.stdout.write(fn({
-        cov: self.cov
-      , coverageClass: coverageClass
-    }));
-  });
-}
-
-/**
- * Return coverage class for `n`.
- *
- * @return {String}
- * @api private
- */
-
-function coverageClass(n) {
-  if (n >= 75) return 'high';
-  if (n >= 50) return 'medium';
-  if (n >= 25) return 'low';
-  return 'terrible';
-}
-
-}); // module: reporters/html-cov.js
-
-require.register("reporters/html.js", function(module, exports, require){
-/**
- * Module dependencies.
- */
-
-var Base = require('./base')
-  , utils = require('../utils')
-  , Progress = require('../browser/progress')
-  , escape = utils.escape;
-
-/**
- * Save timer references to avoid Sinon interfering (see GH-237).
- */
-
-var Date = global.Date
-  , setTimeout = global.setTimeout
-  , setInterval = global.setInterval
-  , clearTimeout = global.clearTimeout
-  , clearInterval = global.clearInterval;
-
-/**
- * Expose `HTML`.
- */
-
-exports = module.exports = HTML;
-
-/**
- * Stats template.
- */
-
-var statsTemplate = '<ul id="mocha-stats">'
-  + '<li class="progress"><canvas width="40" height="40"></canvas></li>'
-  + '<li class="passes"><a href="#">passes:</a> <em>0</em></li>'
-  + '<li class="failures"><a href="#">failures:</a> <em>0</em></li>'
-  + '<li class="duration">duration: <em>0</em>s</li>'
-  + '</ul>';
-
-/**
- * Initialize a new `HTML` reporter.
- *
- * @param {Runner} runner
- * @api public
- */
-
-function HTML(runner) {
-  Base.call(this, runner);
-
-  var self = this
-    , stats = this.stats
-    , total = runner.total
-    , stat = fragment(statsTemplate)
-    , items = stat.getElementsByTagName('li')
-    , passes = items[1].getElementsByTagName('em')[0]
-    , passesLink = items[1].getElementsByTagName('a')[0]
-    , failures = items[2].getElementsByTagName('em')[0]
-    , failuresLink = items[2].getElementsByTagName('a')[0]
-    , duration = items[3].getElementsByTagName('em')[0]
-    , canvas = stat.getElementsByTagName('canvas')[0]
-    , report = fragment('<ul id="mocha-report"></ul>')
-    , stack = [report]
-    , progress
-    , ctx
-    , root = document.getElementById('mocha');
-
-  if (canvas.getContext) {
-    var ratio = window.devicePixelRatio || 1;
-    canvas.style.width = canvas.width;
-    canvas.style.height = canvas.height;
-    canvas.width *= ratio;
-    canvas.height *= ratio;
-    ctx = canvas.getContext('2d');
-    ctx.scale(ratio, ratio);
-    progress = new Progress;
-  }
-
-  if (!root) return error('#mocha div missing, add it to your document');
-
-  // pass toggle
-  on(passesLink, 'click', function(){
-    unhide();
-    var name = /pass/.test(report.className) ? '' : ' pass';
-    report.className = report.className.replace(/fail|pass/g, '') + name;
-    if (report.className.trim()) hideSuitesWithout('test pass');
-  });
-
-  // failure toggle
-  on(failuresLink, 'click', function(){
-    unhide();
-    var name = /fail/.test(report.className) ? '' : ' fail';
-    report.className = report.className.replace(/fail|pass/g, '') + name;
-    if (report.className.trim()) hideSuitesWithout('test fail');
-  });
-
-  root.appendChild(stat);
-  root.appendChild(report);
-
-  if (progress) progress.size(40);
-
-  runner.on('suite', function(suite){
-    if (suite.root) return;
-
-    // suite
-    var url = self.suiteURL(suite);
-    var el = fragment('<li class="suite"><h1><a href="%s">%s</a></h1></li>', url, escape(suite.title));
-
-    // container
-    stack[0].appendChild(el);
-    stack.unshift(document.createElement('ul'));
-    el.appendChild(stack[0]);
-  });
-
-  runner.on('suite end', function(suite){
-    if (suite.root) return;
-    stack.shift();
-  });
-
-  runner.on('fail', function(test, err){
-    if ('hook' == test.type) runner.emit('test end', test);
-  });
-
-  runner.on('test end', function(test){
-    // TODO: add to stats
-    var percent = stats.tests / this.total * 100 | 0;
-    if (progress) progress.update(percent).draw(ctx);
-
-    // update stats
-    var ms = new Date - stats.start;
-    text(passes, stats.passes);
-    text(failures, stats.failures);
-    text(duration, (ms / 1000).toFixed(2));
-
-    // test
-    if ('passed' == test.state) {
-      var url = self.testURL(test);
-      var el = fragment('<li class="test pass %e"><h2>%e<span class="duration">%ems</span> <a href="%s" class="replay">‣</a></h2></li>', test.speed, test.title, test.duration, url);
-    } else if (test.pending) {
-      var el = fragment('<li class="test pass pending"><h2>%e</h2></li>', test.title);
-    } else {
-      var el = fragment('<li class="test fail"><h2>%e <a href="%e" class="replay">‣</a></h2></li>', test.title, self.testURL(test));
-      var str = test.err.stack || test.err.toString();
-
-      // FF / Opera do not add the message
-      if (!~str.indexOf(test.err.message)) {
-        str = test.err.message + '\n' + str;
-      }
-
-      // <=IE7 stringifies to [Object Error]. Since it can be overloaded, we
-      // check for the result of the stringifying.
-      if ('[object Error]' == str) str = test.err.message;
-
-      // Safari doesn't give you a stack. Let's at least provide a source line.
-      if (!test.err.stack && test.err.sourceURL && test.err.line !== undefined) {
-        str += "\n(" + test.err.sourceURL + ":" + test.err.line + ")";
-      }
-
-      el.appendChild(fragment('<pre class="error">%e</pre>', str));
-    }
-
-    // toggle code
-    // TODO: defer
-    if (!test.pending) {
-      var h2 = el.getElementsByTagName('h2')[0];
-
-      on(h2, 'click', function(){
-        pre.style.display = 'none' == pre.style.display
-          ? 'block'
-          : 'none';
-      });
-
-      var pre = fragment('<pre><code>%e</code></pre>', utils.clean(test.fn.toString()));
-      el.appendChild(pre);
-      pre.style.display = 'none';
-    }
-
-    // Don't call .appendChild if #mocha-report was already .shift()'ed off the stack.
-    if (stack[0]) stack[0].appendChild(el);
-  });
-}
-
-/**
- * Makes a URL, preserving querystring ("search") parameters.
- * @param {string} s
- * @returns {string} your new URL
- */
-var makeUrl = function makeUrl(s) {
-  var search = window.location.search;
-  return window.location.pathname + (search ? search + '&' : '?' ) + 'grep=' + encodeURIComponent(s);
-};
-
-/**
- * Provide suite URL
- *
- * @param {Object} [suite]
- */
-HTML.prototype.suiteURL = function(suite){
-  return makeUrl(suite.fullTitle());
-};
-
-/**
- * Provide test URL
- *
- * @param {Object} [test]
- */
-
-HTML.prototype.testURL = function(test){
-  return makeUrl(test.fullTitle());
-};
-
-/**
- * Display error `msg`.
- */
-
-function error(msg) {
-  document.body.appendChild(fragment('<div id="mocha-error">%s</div>', msg));
-}
-
-/**
- * Return a DOM fragment from `html`.
- */
-
-function fragment(html) {
-  var args = arguments
-    , div = document.createElement('div')
-    , i = 1;
-
-  div.innerHTML = html.replace(/%([se])/g, function(_, type){
-    switch (type) {
-      case 's': return String(args[i++]);
-      case 'e': return escape(args[i++]);
-    }
-  });
-
-  return div.firstChild;
-}
-
-/**
- * Check for suites that do not have elements
- * with `classname`, and hide them.
- */
-
-function hideSuitesWithout(classname) {
-  var suites = document.getElementsByClassName('suite');
-  for (var i = 0; i < suites.length; i++) {
-    var els = suites[i].getElementsByClassName(classname);
-    if (0 == els.length) suites[i].className += ' hidden';
-  }
-}
-
-/**
- * Unhide .hidden suites.
- */
-
-function unhide() {
-  var els = document.getElementsByClassName('suite hidden');
-  for (var i = 0; i < els.length; ++i) {
-    els[i].className = els[i].className.replace('suite hidden', 'suite');
-  }
-}
-
-/**
- * Set `el` text to `str`.
- */
-
-function text(el, str) {
-  if (el.textContent) {
-    el.textContent = str;
-  } else {
-    el.innerText = str;
-  }
-}
-
-/**
- * Listen on `event` with callback `fn`.
- */
-
-function on(el, event, fn) {
-  if (el.addEventListener) {
-    el.addEventListener(event, fn, false);
-  } else {
-    el.attachEvent('on' + event, fn);
-  }
-}
-
-}); // module: reporters/html.js
-
-require.register("reporters/index.js", function(module, exports, require){
-exports.Base = require('./base');
-exports.Dot = require('./dot');
-exports.Doc = require('./doc');
-exports.TAP = require('./tap');
-exports.JSON = require('./json');
-exports.HTML = require('./html');
-exports.List = require('./list');
-exports.Min = require('./min');
-exports.Spec = require('./spec');
-exports.Nyan = require('./nyan');
-exports.XUnit = require('./xunit');
-exports.Markdown = require('./markdown');
-exports.Progress = require('./progress');
-exports.Landing = require('./landing');
-exports.JSONCov = require('./json-cov');
-exports.HTMLCov = require('./html-cov');
-exports.JSONStream = require('./json-stream');
-
-}); // module: reporters/index.js
-
-require.register("reporters/json-cov.js", function(module, exports, require){
-/**
- * Module dependencies.
- */
-
-var Base = require('./base');
-
-/**
- * Expose `JSONCov`.
- */
-
-exports = module.exports = JSONCov;
-
-/**
- * Initialize a new `JsCoverage` reporter.
- *
- * @param {Runner} runner
- * @param {Boolean} output
- * @api public
- */
-
-function JSONCov(runner, output) {
-  var self = this
-    , output = 1 == arguments.length ? true : output;
-
-  Base.call(this, runner);
-
-  var tests = []
-    , failures = []
-    , passes = [];
-
-  runner.on('test end', function(test){
-    tests.push(test);
-  });
-
-  runner.on('pass', function(test){
-    passes.push(test);
-  });
-
-  runner.on('fail', function(test){
-    failures.push(test);
-  });
-
-  runner.on('end', function(){
-    var cov = global._$jscoverage || {};
-    var result = self.cov = map(cov);
-    result.stats = self.stats;
-    result.tests = tests.map(clean);
-    result.failures = failures.map(clean);
-    result.passes = passes.map(clean);
-    if (!output) return;
-    process.stdout.write(JSON.stringify(result, null, 2 ));
-  });
-}
-
-/**
- * Map jscoverage data to a JSON structure
- * suitable for reporting.
- *
- * @param {Object} cov
- * @return {Object}
- * @api private
- */
-
-function map(cov) {
-  var ret = {
-      instrumentation: 'node-jscoverage'
-    , sloc: 0
-    , hits: 0
-    , misses: 0
-    , coverage: 0
-    , files: []
-  };
-
-  for (var filename in cov) {
-    var data = coverage(filename, cov[filename]);
-    ret.files.push(data);
-    ret.hits += data.hits;
-    ret.misses += data.misses;
-    ret.sloc += data.sloc;
-  }
-
-  ret.files.sort(function(a, b) {
-    return a.filename.localeCompare(b.filename);
-  });
-
-  if (ret.sloc > 0) {
-    ret.coverage = (ret.hits / ret.sloc) * 100;
-  }
-
-  return ret;
-}
-
-/**
- * Map jscoverage data for a single source file
- * to a JSON structure suitable for reporting.
- *
- * @param {String} filename name of the source file
- * @param {Object} data jscoverage coverage data
- * @return {Object}
- * @api private
- */
-
-function coverage(filename, data) {
-  var ret = {
-    filename: filename,
-    coverage: 0,
-    hits: 0,
-    misses: 0,
-    sloc: 0,
-    source: {}
-  };
-
-  data.source.forEach(function(line, num){
-    num++;
-
-    if (data[num] === 0) {
-      ret.misses++;
-      ret.sloc++;
-    } else if (data[num] !== undefined) {
-      ret.hits++;
-      ret.sloc++;
-    }
-
-    ret.source[num] = {
-        source: line
-      , coverage: data[num] === undefined
-        ? ''
-        : data[num]
-    };
-  });
-
-  ret.coverage = ret.hits / ret.sloc * 100;
-
-  return ret;
-}
-
-/**
- * Return a plain-object representation of `test`
- * free of cyclic properties etc.
- *
- * @param {Object} test
- * @return {Object}
- * @api private
- */
-
-function clean(test) {
-  return {
-      title: test.title
-    , fullTitle: test.fullTitle()
-    , duration: test.duration
-  }
-}
-
-}); // module: reporters/json-cov.js
-
-require.register("reporters/json-stream.js", function(module, exports, require){
-/**
- * Module dependencies.
- */
-
-var Base = require('./base')
-  , color = Base.color;
-
-/**
- * Expose `List`.
- */
-
-exports = module.exports = List;
-
-/**
- * Initialize a new `List` test reporter.
- *
- * @param {Runner} runner
- * @api public
- */
-
-function List(runner) {
-  Base.call(this, runner);
-
-  var self = this
-    , stats = this.stats
-    , total = runner.total;
-
-  runner.on('start', function(){
-    console.log(JSON.stringify(['start', { total: total }]));
-  });
-
-  runner.on('pass', function(test){
-    console.log(JSON.stringify(['pass', clean(test)]));
-  });
-
-  runner.on('fail', function(test, err){
-    test = clean(test);
-    test.err = err.message;
-    console.log(JSON.stringify(['fail', test]));
-  });
-
-  runner.on('end', function(){
-    process.stdout.write(JSON.stringify(['end', self.stats]));
-  });
-}
-
-/**
- * Return a plain-object representation of `test`
- * free of cyclic properties etc.
- *
- * @param {Object} test
- * @return {Object}
- * @api private
- */
-
-function clean(test) {
-  return {
-      title: test.title
-    , fullTitle: test.fullTitle()
-    , duration: test.duration
-  }
-}
-
-}); // module: reporters/json-stream.js
-
-require.register("reporters/json.js", function(module, exports, require){
-/**
- * Module dependencies.
- */
-
-var Base = require('./base')
-  , cursor = Base.cursor
-  , color = Base.color;
-
-/**
- * Expose `JSON`.
- */
-
-exports = module.exports = JSONReporter;
-
-/**
- * Initialize a new `JSON` reporter.
- *
- * @param {Runner} runner
- * @api public
- */
-
-function JSONReporter(runner) {
-  var self = this;
-  Base.call(this, runner);
-
-  var tests = []
-    , pending = []
-    , failures = []
-    , passes = [];
-
-  runner.on('test end', function(test){
-    tests.push(test);
-  });
-
-  runner.on('pass', function(test){
-    passes.push(test);
-  });
-
-  runner.on('fail', function(test){
-    failures.push(test);
-  });
-
-  runner.on('pending', function(test){
-    pending.push(test);
-  });
-
-  runner.on('end', function(){
-    var obj = {
-      stats: self.stats,
-      tests: tests.map(clean),
-      pending: pending.map(clean),
-      failures: failures.map(clean),
-      passes: passes.map(clean)
-    };
-
-    runner.testResults = obj;
-
-    process.stdout.write(JSON.stringify(obj, null, 2));
-  });
-}
-
-/**
- * Return a plain-object representation of `test`
- * free of cyclic properties etc.
- *
- * @param {Object} test
- * @return {Object}
- * @api private
- */
-
-function clean(test) {
-  return {
-    title: test.title,
-    fullTitle: test.fullTitle(),
-    duration: test.duration,
-    err: errorJSON(test.err || {})
-  }
-}
-
-/**
- * Transform `error` into a JSON object.
- * @param {Error} err
- * @return {Object}
- */
-
-function errorJSON(err) {
-  var res = {};
-  Object.getOwnPropertyNames(err).forEach(function(key) {
-    res[key] = err[key];
-  }, err);
-  return res;
-}
-
-}); // module: reporters/json.js
-
-require.register("reporters/landing.js", function(module, exports, require){
-/**
- * Module dependencies.
- */
-
-var Base = require('./base')
-  , cursor = Base.cursor
-  , color = Base.color;
-
-/**
- * Expose `Landing`.
- */
-
-exports = module.exports = Landing;
-
-/**
- * Airplane color.
- */
-
-Base.colors.plane = 0;
-
-/**
- * Airplane crash color.
- */
-
-Base.colors['plane crash'] = 31;
-
-/**
- * Runway color.
- */
-
-Base.colors.runway = 90;
-
-/**
- * Initialize a new `Landing` reporter.
- *
- * @param {Runner} runner
- * @api public
- */
-
-function Landing(runner) {
-  Base.call(this, runner);
-
-  var self = this
-    , stats = this.stats
-    , width = Base.window.width * .75 | 0
-    , total = runner.total
-    , stream = process.stdout
-    , plane = color('plane', '✈')
-    , crashed = -1
-    , n = 0;
-
-  function runway() {
-    var buf = Array(width).join('-');
-    return '  ' + color('runway', buf);
-  }
-
-  runner.on('start', function(){
-    stream.write('\n\n\n  ');
-    cursor.hide();
-  });
-
-  runner.on('test end', function(test){
-    // check if the plane crashed
-    var col = -1 == crashed
-      ? width * ++n / total | 0
-      : crashed;
-
-    // show the crash
-    if ('failed' == test.state) {
-      plane = color('plane crash', '✈');
-      crashed = col;
-    }
-
-    // render landing strip
-    stream.write('\u001b['+(width+1)+'D\u001b[2A');
-    stream.write(runway());
-    stream.write('\n  ');
-    stream.write(color('runway', Array(col).join('⋅')));
-    stream.write(plane)
-    stream.write(color('runway', Array(width - col).join('⋅') + '\n'));
-    stream.write(runway());
-    stream.write('\u001b[0m');
-  });
-
-  runner.on('end', function(){
-    cursor.show();
-    console.log();
-    self.epilogue();
-  });
-}
-
-/**
- * Inherit from `Base.prototype`.
- */
-
-function F(){};
-F.prototype = Base.prototype;
-Landing.prototype = new F;
-Landing.prototype.constructor = Landing;
-
-
-}); // module: reporters/landing.js
-
-require.register("reporters/list.js", function(module, exports, require){
-/**
- * Module dependencies.
- */
-
-var Base = require('./base')
-  , cursor = Base.cursor
-  , color = Base.color;
-
-/**
- * Expose `List`.
- */
-
-exports = module.exports = List;
-
-/**
- * Initialize a new `List` test reporter.
- *
- * @param {Runner} runner
- * @api public
- */
-
-function List(runner) {
-  Base.call(this, runner);
-
-  var self = this
-    , stats = this.stats
-    , n = 0;
-
-  runner.on('start', function(){
-    console.log();
-  });
-
-  runner.on('test', function(test){
-    process.stdout.write(color('pass', '    ' + test.fullTitle() + ': '));
-  });
-
-  runner.on('pending', function(test){
-    var fmt = color('checkmark', '  -')
-      + color('pending', ' %s');
-    console.log(fmt, test.fullTitle());
-  });
-
-  runner.on('pass', function(test){
-    var fmt = color('checkmark', '  '+Base.symbols.dot)
-      + color('pass', ' %s: ')
-      + color(test.speed, '%dms');
-    cursor.CR();
-    console.log(fmt, test.fullTitle(), test.duration);
-  });
-
-  runner.on('fail', function(test, err){
-    cursor.CR();
-    console.log(color('fail', '  %d) %s'), ++n, test.fullTitle());
-  });
-
-  runner.on('end', self.epilogue.bind(self));
-}
-
-/**
- * Inherit from `Base.prototype`.
- */
-
-function F(){};
-F.prototype = Base.prototype;
-List.prototype = new F;
-List.prototype.constructor = List;
-
-
-}); // module: reporters/list.js
-
-require.register("reporters/markdown.js", function(module, exports, require){
-/**
- * Module dependencies.
- */
-
-var Base = require('./base')
-  , utils = require('../utils');
-
-/**
- * Constants
- */
-
-var SUITE_PREFIX = '$';
-
-/**
- * Expose `Markdown`.
- */
-
-exports = module.exports = Markdown;
-
-/**
- * Initialize a new `Markdown` reporter.
- *
- * @param {Runner} runner
- * @api public
- */
-
-function Markdown(runner) {
-  Base.call(this, runner);
-
-  var self = this
-    , stats = this.stats
-    , level = 0
-    , buf = '';
-
-  function title(str) {
-    return Array(level).join('#') + ' ' + str;
-  }
-
-  function indent() {
-    return Array(level).join('  ');
-  }
-
-  function mapTOC(suite, obj) {
-    var ret = obj,
-        key = SUITE_PREFIX + suite.title;
-    obj = obj[key] = obj[key] || { suite: suite };
-    suite.suites.forEach(function(suite){
-      mapTOC(suite, obj);
-    });
-    return ret;
-  }
-
-  function stringifyTOC(obj, level) {
-    ++level;
-    var buf = '';
-    var link;
-    for (var key in obj) {
-      if ('suite' == key) continue;
-      if (key !== SUITE_PREFIX) {
-        link = ' - [' + key.substring(1) + ']';
-        link += '(#' + utils.slug(obj[key].suite.fullTitle()) + ')\n';
-        buf += Array(level).join('  ') + link;
-      }
-      buf += stringifyTOC(obj[key], level);
-    }
-    return buf;
-  }
-
-  function generateTOC(suite) {
-    var obj = mapTOC(suite, {});
-    return stringifyTOC(obj, 0);
-  }
-
-  generateTOC(runner.suite);
-
-  runner.on('suite', function(suite){
-    ++level;
-    var slug = utils.slug(suite.fullTitle());
-    buf += '<a name="' + slug + '"></a>' + '\n';
-    buf += title(suite.title) + '\n';
-  });
-
-  runner.on('suite end', function(suite){
-    --level;
-  });
-
-  runner.on('pass', function(test){
-    var code = utils.clean(test.fn.toString());
-    buf += test.title + '.\n';
-    buf += '\n```js\n';
-    buf += code + '\n';
-    buf += '```\n\n';
-  });
-
-  runner.on('end', function(){
-    process.stdout.write('# TOC\n');
-    process.stdout.write(generateTOC(runner.suite));
-    process.stdout.write(buf);
-  });
-}
-
-}); // module: reporters/markdown.js
-
-require.register("reporters/min.js", function(module, exports, require){
-/**
- * Module dependencies.
- */
-
-var Base = require('./base');
-
-/**
- * Expose `Min`.
- */
-
-exports = module.exports = Min;
-
-/**
- * Initialize a new `Min` minimal test reporter (best used with --watch).
- *
- * @param {Runner} runner
- * @api public
- */
-
-function Min(runner) {
-  Base.call(this, runner);
-
-  runner.on('start', function(){
-    // clear screen
-    process.stdout.write('\u001b[2J');
-    // set cursor position
-    process.stdout.write('\u001b[1;3H');
-  });
-
-  runner.on('end', this.epilogue.bind(this));
-}
-
-/**
- * Inherit from `Base.prototype`.
- */
-
-function F(){};
-F.prototype = Base.prototype;
-Min.prototype = new F;
-Min.prototype.constructor = Min;
-
-
-}); // module: reporters/min.js
-
-require.register("reporters/nyan.js", function(module, exports, require){
-/**
- * Module dependencies.
- */
-
-var Base = require('./base');
-
-/**
- * Expose `Dot`.
- */
-
-exports = module.exports = NyanCat;
-
-/**
- * Initialize a new `Dot` matrix test reporter.
- *
- * @param {Runner} runner
- * @api public
- */
-
-function NyanCat(runner) {
-  Base.call(this, runner);
-  var self = this
-    , stats = this.stats
-    , width = Base.window.width * .75 | 0
-    , rainbowColors = this.rainbowColors = self.generateColors()
-    , colorIndex = this.colorIndex = 0
-    , numerOfLines = this.numberOfLines = 4
-    , trajectories = this.trajectories = [[], [], [], []]
-    , nyanCatWidth = this.nyanCatWidth = 11
-    , trajectoryWidthMax = this.trajectoryWidthMax = (width - nyanCatWidth)
-    , scoreboardWidth = this.scoreboardWidth = 5
-    , tick = this.tick = 0
-    , n = 0;
-
-  runner.on('start', function(){
-    Base.cursor.hide();
-    self.draw();
-  });
-
-  runner.on('pending', function(test){
-    self.draw();
-  });
-
-  runner.on('pass', function(test){
-    self.draw();
-  });
-
-  runner.on('fail', function(test, err){
-    self.draw();
-  });
-
-  runner.on('end', function(){
-    Base.cursor.show();
-    for (var i = 0; i < self.numberOfLines; i++) write('\n');
-    self.epilogue();
-  });
-}
-
-/**
- * Draw the nyan cat
- *
- * @api private
- */
-
-NyanCat.prototype.draw = function(){
-  this.appendRainbow();
-  this.drawScoreboard();
-  this.drawRainbow();
-  this.drawNyanCat();
-  this.tick = !this.tick;
-};
-
-/**
- * Draw the "scoreboard" showing the number
- * of passes, failures and pending tests.
- *
- * @api private
- */
-
-NyanCat.prototype.drawScoreboard = function(){
-  var stats = this.stats;
-
-  function draw(type, n) {
-    write(' ');
-    write(Base.color(type, n));
-    write('\n');
-  }
-
-  draw('green', stats.passes);
-  draw('fail', stats.failures);
-  draw('pending', stats.pending);
-  write('\n');
-
-  this.cursorUp(this.numberOfLines);
-};
-
-/**
- * Append the rainbow.
- *
- * @api private
- */
-
-NyanCat.prototype.appendRainbow = function(){
-  var segment = this.tick ? '_' : '-';
-  var rainbowified = this.rainbowify(segment);
-
-  for (var index = 0; index < this.numberOfLines; index++) {
-    var trajectory = this.trajectories[index];
-    if (trajectory.length >= this.trajectoryWidthMax) trajectory.shift();
-    trajectory.push(rainbowified);
-  }
-};
-
-/**
- * Draw the rainbow.
- *
- * @api private
- */
-
-NyanCat.prototype.drawRainbow = function(){
-  var self = this;
-
-  this.trajectories.forEach(function(line, index) {
-    write('\u001b[' + self.scoreboardWidth + 'C');
-    write(line.join(''));
-    write('\n');
-  });
-
-  this.cursorUp(this.numberOfLines);
-};
-
-/**
- * Draw the nyan cat
- *
- * @api private
- */
-
-NyanCat.prototype.drawNyanCat = function() {
-  var self = this;
-  var startWidth = this.scoreboardWidth + this.trajectories[0].length;
-  var dist = '\u001b[' + startWidth + 'C';
-  var padding = '';
-
-  write(dist);
-  write('_,------,');
-  write('\n');
-
-  write(dist);
-  padding = self.tick ? '  ' : '   ';
-  write('_|' + padding + '/\\_/\\ ');
-  write('\n');
-
-  write(dist);
-  padding = self.tick ? '_' : '__';
-  var tail = self.tick ? '~' : '^';
-  var face;
-  write(tail + '|' + padding + this.face() + ' ');
-  write('\n');
-
-  write(dist);
-  padding = self.tick ? ' ' : '  ';
-  write(padding + '""  "" ');
-  write('\n');
-
-  this.cursorUp(this.numberOfLines);
-};
-
-/**
- * Draw nyan cat face.
- *
- * @return {String}
- * @api private
- */
-
-NyanCat.prototype.face = function() {
-  var stats = this.stats;
-  if (stats.failures) {
-    return '( x .x)';
-  } else if (stats.pending) {
-    return '( o .o)';
-  } else if(stats.passes) {
-    return '( ^ .^)';
-  } else {
-    return '( - .-)';
-  }
-};
-
-/**
- * Move cursor up `n`.
- *
- * @param {Number} n
- * @api private
- */
-
-NyanCat.prototype.cursorUp = function(n) {
-  write('\u001b[' + n + 'A');
-};
-
-/**
- * Move cursor down `n`.
- *
- * @param {Number} n
- * @api private
- */
-
-NyanCat.prototype.cursorDown = function(n) {
-  write('\u001b[' + n + 'B');
-};
-
-/**
- * Generate rainbow colors.
- *
- * @return {Array}
- * @api private
- */
-
-NyanCat.prototype.generateColors = function(){
-  var colors = [];
-
-  for (var i = 0; i < (6 * 7); i++) {
-    var pi3 = Math.floor(Math.PI / 3);
-    var n = (i * (1.0 / 6));
-    var r = Math.floor(3 * Math.sin(n) + 3);
-    var g = Math.floor(3 * Math.sin(n + 2 * pi3) + 3);
-    var b = Math.floor(3 * Math.sin(n + 4 * pi3) + 3);
-    colors.push(36 * r + 6 * g + b + 16);
-  }
-
-  return colors;
-};
-
-/**
- * Apply rainbow to the given `str`.
- *
- * @param {String} str
- * @return {String}
- * @api private
- */
-
-NyanCat.prototype.rainbowify = function(str){
-  if (!Base.useColors)
-    return str;
-  var color = this.rainbowColors[this.colorIndex % this.rainbowColors.length];
-  this.colorIndex += 1;
-  return '\u001b[38;5;' + color + 'm' + str + '\u001b[0m';
-};
-
-/**
- * Stdout helper.
- */
-
-function write(string) {
-  process.stdout.write(string);
-}
-
-/**
- * Inherit from `Base.prototype`.
- */
-
-function F(){};
-F.prototype = Base.prototype;
-NyanCat.prototype = new F;
-NyanCat.prototype.constructor = NyanCat;
-
-
-}); // module: reporters/nyan.js
-
-require.register("reporters/progress.js", function(module, exports, require){
-/**
- * Module dependencies.
- */
-
-var Base = require('./base')
-  , cursor = Base.cursor
-  , color = Base.color;
-
-/**
- * Expose `Progress`.
- */
-
-exports = module.exports = Progress;
-
-/**
- * General progress bar color.
- */
-
-Base.colors.progress = 90;
-
-/**
- * Initialize a new `Progress` bar test reporter.
- *
- * @param {Runner} runner
- * @param {Object} options
- * @api public
- */
-
-function Progress(runner, options) {
-  Base.call(this, runner);
-
-  var self = this
-    , options = options || {}
-    , stats = this.stats
-    , width = Base.window.width * .50 | 0
-    , total = runner.total
-    , complete = 0
-    , max = Math.max
-    , lastN = -1;
-
-  // default chars
-  options.open = options.open || '[';
-  options.complete = options.complete || '▬';
-  options.incomplete = options.incomplete || Base.symbols.dot;
-  options.close = options.close || ']';
-  options.verbose = false;
-
-  // tests started
-  runner.on('start', function(){
-    console.log();
-    cursor.hide();
-  });
-
-  // tests complete
-  runner.on('test end', function(){
-    complete++;
-    var incomplete = total - complete
-      , percent = complete / total
-      , n = width * percent | 0
-      , i = width - n;
-
-    if (lastN === n && !options.verbose) {
-      // Don't re-render the line if it hasn't changed
-      return;
-    }
-    lastN = n;
-
-    cursor.CR();
-    process.stdout.write('\u001b[J');
-    process.stdout.write(color('progress', '  ' + options.open));
-    process.stdout.write(Array(n).join(options.complete));
-    process.stdout.write(Array(i).join(options.incomplete));
-    process.stdout.write(color('progress', options.close));
-    if (options.verbose) {
-      process.stdout.write(color('progress', ' ' + complete + ' of ' + total));
-    }
-  });
-
-  // tests are complete, output some stats
-  // and the failures if any
-  runner.on('end', function(){
-    cursor.show();
-    console.log();
-    self.epilogue();
-  });
-}
-
-/**
- * Inherit from `Base.prototype`.
- */
-
-function F(){};
-F.prototype = Base.prototype;
-Progress.prototype = new F;
-Progress.prototype.constructor = Progress;
-
-
-}); // module: reporters/progress.js
-
-require.register("reporters/spec.js", function(module, exports, require){
-/**
- * Module dependencies.
- */
-
-var Base = require('./base')
-  , cursor = Base.cursor
-  , color = Base.color;
-
-/**
- * Expose `Spec`.
- */
-
-exports = module.exports = Spec;
-
-/**
- * Initialize a new `Spec` test reporter.
- *
- * @param {Runner} runner
- * @api public
- */
-
-function Spec(runner) {
-  Base.call(this, runner);
-
-  var self = this
-    , stats = this.stats
-    , indents = 0
-    , n = 0;
-
-  function indent() {
-    return Array(indents).join('  ')
-  }
-
-  runner.on('start', function(){
-    console.log();
-  });
-
-  runner.on('suite', function(suite){
-    ++indents;
-    console.log(color('suite', '%s%s'), indent(), suite.title);
-  });
-
-  runner.on('suite end', function(suite){
-    --indents;
-    if (1 == indents) console.log();
-  });
-
-  runner.on('pending', function(test){
-    var fmt = indent() + color('pending', '  - %s');
-    console.log(fmt, test.title);
-  });
-
-  runner.on('pass', function(test){
-    if ('fast' == test.speed) {
-      var fmt = indent()
-        + color('checkmark', '  ' + Base.symbols.ok)
-        + color('pass', ' %s ');
-      cursor.CR();
-      console.log(fmt, test.title);
-    } else {
-      var fmt = indent()
-        + color('checkmark', '  ' + Base.symbols.ok)
-        + color('pass', ' %s ')
-        + color(test.speed, '(%dms)');
-      cursor.CR();
-      console.log(fmt, test.title, test.duration);
-    }
-  });
-
-  runner.on('fail', function(test, err){
-    cursor.CR();
-    console.log(indent() + color('fail', '  %d) %s'), ++n, test.title);
-  });
-
-  runner.on('end', self.epilogue.bind(self));
-}
-
-/**
- * Inherit from `Base.prototype`.
- */
-
-function F(){};
-F.prototype = Base.prototype;
-Spec.prototype = new F;
-Spec.prototype.constructor = Spec;
-
-
-}); // module: reporters/spec.js
-
-require.register("reporters/tap.js", function(module, exports, require){
-/**
- * Module dependencies.
- */
-
-var Base = require('./base')
-  , cursor = Base.cursor
-  , color = Base.color;
-
-/**
- * Expose `TAP`.
- */
-
-exports = module.exports = TAP;
-
-/**
- * Initialize a new `TAP` reporter.
- *
- * @param {Runner} runner
- * @api public
- */
-
-function TAP(runner) {
-  Base.call(this, runner);
-
-  var self = this
-    , stats = this.stats
-    , n = 1
-    , passes = 0
-    , failures = 0;
-
-  runner.on('start', function(){
-    var total = runner.grepTotal(runner.suite);
-    console.log('%d..%d', 1, total);
-  });
-
-  runner.on('test end', function(){
-    ++n;
-  });
-
-  runner.on('pending', function(test){
-    console.log('ok %d %s # SKIP -', n, title(test));
-  });
-
-  runner.on('pass', function(test){
-    passes++;
-    console.log('ok %d %s', n, title(test));
-  });
-
-  runner.on('fail', function(test, err){
-    failures++;
-    console.log('not ok %d %s', n, title(test));
-    if (err.stack) console.log(err.stack.replace(/^/gm, '  '));
-  });
-
-  runner.on('end', function(){
-    console.log('# tests ' + (passes + failures));
-    console.log('# pass ' + passes);
-    console.log('# fail ' + failures);
-  });
-}
-
-/**
- * Return a TAP-safe title of `test`
- *
- * @param {Object} test
- * @return {String}
- * @api private
- */
-
-function title(test) {
-  return test.fullTitle().replace(/#/g, '');
-}
-
-}); // module: reporters/tap.js
-
-require.register("reporters/xunit.js", function(module, exports, require){
-/**
- * Module dependencies.
- */
-
-var Base = require('./base')
-  , utils = require('../utils')
-  , fs = require('browser/fs')
-  , escape = utils.escape;
-
-/**
- * Save timer references to avoid Sinon interfering (see GH-237).
- */
-
-var Date = global.Date
-  , setTimeout = global.setTimeout
-  , setInterval = global.setInterval
-  , clearTimeout = global.clearTimeout
-  , clearInterval = global.clearInterval;
-
-/**
- * Expose `XUnit`.
- */
-
-exports = module.exports = XUnit;
-
-/**
- * Initialize a new `XUnit` reporter.
- *
- * @param {Runner} runner
- * @api public
- */
-
-function XUnit(runner, options) {
-  Base.call(this, runner);
-  var stats = this.stats
-    , tests = []
-    , self = this;
-
-  if (options.reporterOptions && options.reporterOptions.output) {
-      if (! fs.createWriteStream) {
-          throw new Error('file output not supported in browser');
-      }
-      self.fileStream = fs.createWriteStream(options.reporterOptions.output);
-  }
-
-  runner.on('pending', function(test){
-    tests.push(test);
-  });
-
-  runner.on('pass', function(test){
-    tests.push(test);
-  });
-
-  runner.on('fail', function(test){
-    tests.push(test);
-  });
-
-  runner.on('end', function(){
-    self.write(tag('testsuite', {
-        name: 'Mocha Tests'
-      , tests: stats.tests
-      , failures: stats.failures
-      , errors: stats.failures
-      , skipped: stats.tests - stats.failures - stats.passes
-      , timestamp: (new Date).toUTCString()
-      , time: (stats.duration / 1000) || 0
-    }, false));
-
-    tests.forEach(function(t) { self.test(t); });
-    self.write('</testsuite>');
-  });
-}
-
-/**
- * Override done to close the stream (if it's a file).
- */
-XUnit.prototype.done = function(failures, fn) {
-    if (this.fileStream) {
-        this.fileStream.end(function() {
-            fn(failures);
-        });
-    } else {
-        fn(failures);
-    }
-};
-
-/**
- * Inherit from `Base.prototype`.
- */
-
-function F(){};
-F.prototype = Base.prototype;
-XUnit.prototype = new F;
-XUnit.prototype.constructor = XUnit;
-
-
-/**
- * Write out the given line
- */
-XUnit.prototype.write = function(line) {
-    if (this.fileStream) {
-        this.fileStream.write(line + '\n');
-    } else {
-        console.log(line);
-    }
-};
-
-/**
- * Output tag for the given `test.`
- */
-
-XUnit.prototype.test = function(test, ostream) {
-  var attrs = {
-      classname: test.parent.fullTitle()
-    , name: test.title
-    , time: (test.duration / 1000) || 0
-  };
-
-  if ('failed' == test.state) {
-    var err = test.err;
-    this.write(tag('testcase', attrs, false, tag('failure', {}, false, cdata(escape(err.message) + "\n" + err.stack))));
-  } else if (test.pending) {
-    this.write(tag('testcase', attrs, false, tag('skipped', {}, true)));
-  } else {
-    this.write(tag('testcase', attrs, true) );
-  }
-};
-
-/**
- * HTML tag helper.
- */
-
-function tag(name, attrs, close, content) {
-  var end = close ? '/>' : '>'
-    , pairs = []
-    , tag;
-
-  for (var key in attrs) {
-    pairs.push(key + '="' + escape(attrs[key]) + '"');
-  }
-
-  tag = '<' + name + (pairs.length ? ' ' + pairs.join(' ') : '') + end;
-  if (content) tag += content + '</' + name + end;
-  return tag;
-}
-
-/**
- * Return cdata escaped CDATA `str`.
- */
-
-function cdata(str) {
-  return '<![CDATA[' + escape(str) + ']]>';
-}
-
-}); // module: reporters/xunit.js
-
-require.register("runnable.js", function(module, exports, require){
-/**
- * Module dependencies.
- */
-
-var EventEmitter = require('browser/events').EventEmitter
-  , debug = require('browser/debug')('mocha:runnable')
-  , milliseconds = require('./ms')
-  , utils = require('./utils');
-
-/**
- * Save timer references to avoid Sinon interfering (see GH-237).
- */
-
-var Date = global.Date
-  , setTimeout = global.setTimeout
-  , setInterval = global.setInterval
-  , clearTimeout = global.clearTimeout
-  , clearInterval = global.clearInterval;
-
-/**
- * Object#toString().
- */
-
-var toString = Object.prototype.toString;
-
-/**
- * Expose `Runnable`.
- */
-
-module.exports = Runnable;
-
-/**
- * Initialize a new `Runnable` with the given `title` and callback `fn`.
- *
- * @param {String} title
- * @param {Function} fn
- * @api private
- */
-
-function Runnable(title, fn) {
-  this.title = title;
-  this.fn = fn;
-  this.async = fn && fn.length;
-  this.sync = ! this.async;
-  this._timeout = 2000;
-  this._slow = 75;
-  this._enableTimeouts = true;
-  this.timedOut = false;
-  this._trace = new Error('done() called multiple times')
-}
-
-/**
- * Inherit from `EventEmitter.prototype`.
- */
-
-function F(){};
-F.prototype = EventEmitter.prototype;
-Runnable.prototype = new F;
-Runnable.prototype.constructor = Runnable;
-
-
-/**
- * Set & get timeout `ms`.
- *
- * @param {Number|String} ms
- * @return {Runnable|Number} ms or self
- * @api private
- */
-
-Runnable.prototype.timeout = function(ms){
-  if (0 == arguments.length) return this._timeout;
-  if (ms === 0) this._enableTimeouts = false;
-  if ('string' == typeof ms) ms = milliseconds(ms);
-  debug('timeout %d', ms);
-  this._timeout = ms;
-  if (this.timer) this.resetTimeout();
-  return this;
-};
-
-/**
- * Set & get slow `ms`.
- *
- * @param {Number|String} ms
- * @return {Runnable|Number} ms or self
- * @api private
- */
-
-Runnable.prototype.slow = function(ms){
-  if (0 === arguments.length) return this._slow;
-  if ('string' == typeof ms) ms = milliseconds(ms);
-  debug('timeout %d', ms);
-  this._slow = ms;
-  return this;
-};
-
-/**
- * Set and & get timeout `enabled`.
- *
- * @param {Boolean} enabled
- * @return {Runnable|Boolean} enabled or self
- * @api private
- */
-
-Runnable.prototype.enableTimeouts = function(enabled){
-  if (arguments.length === 0) return this._enableTimeouts;
-  debug('enableTimeouts %s', enabled);
-  this._enableTimeouts = enabled;
-  return this;
-};
-
-/**
- * Return the full title generated by recursively
- * concatenating the parent's full title.
- *
- * @return {String}
- * @api public
- */
-
-Runnable.prototype.fullTitle = function(){
-  return this.parent.fullTitle() + ' ' + this.title;
-};
-
-/**
- * Clear the timeout.
- *
- * @api private
- */
-
-Runnable.prototype.clearTimeout = function(){
-  clearTimeout(this.timer);
-};
-
-/**
- * Inspect the runnable void of private properties.
- *
- * @return {String}
- * @api private
- */
-
-Runnable.prototype.inspect = function(){
-  return JSON.stringify(this, function(key, val){
-    if ('_' == key[0]) return;
-    if ('parent' == key) return '#<Suite>';
-    if ('ctx' == key) return '#<Context>';
-    return val;
-  }, 2);
-};
-
-/**
- * Reset the timeout.
- *
- * @api private
- */
-
-Runnable.prototype.resetTimeout = function(){
-  var self = this;
-  var ms = this.timeout() || 1e9;
-
-  if (!this._enableTimeouts) return;
-  this.clearTimeout();
-  this.timer = setTimeout(function(){
-    if (!self._enableTimeouts) return;
-    self.callback(new Error('timeout of ' + ms + 'ms exceeded'));
-    self.timedOut = true;
-  }, ms);
-};
-
-/**
- * Whitelist these globals for this test run
- *
- * @api private
- */
-Runnable.prototype.globals = function(arr){
-  var self = this;
-  this._allowedGlobals = arr;
-};
-
-/**
- * Run the test and invoke `fn(err)`.
- *
- * @param {Function} fn
- * @api private
- */
-
-Runnable.prototype.run = function(fn){
-  var self = this
-    , start = new Date
-    , ctx = this.ctx
-    , finished
-    , emitted;
-
-  // Some times the ctx exists but it is not runnable
-  if (ctx && ctx.runnable) ctx.runnable(this);
-
-  // called multiple times
-  function multiple(err) {
-    if (emitted) return;
-    emitted = true;
-    self.emit('error', err || new Error('done() called multiple times; stacktrace may be inaccurate'));
-  }
-
-  // finished
-  function done(err) {
-    var ms = self.timeout();
-    if (self.timedOut) return;
-    if (finished) return multiple(err || self._trace);
-    self.clearTimeout();
-    self.duration = new Date - start;
-    finished = true;
-    if (!err && self.duration > ms && self._enableTimeouts) err = new Error('timeout of ' + ms + 'ms exceeded');
-    fn(err);
-  }
-
-  // for .resetTimeout()
-  this.callback = done;
-
-  // explicit async with `done` argument
-  if (this.async) {
-    this.resetTimeout();
-
-    try {
-      this.fn.call(ctx, function(err){
-        if (err instanceof Error || toString.call(err) === "[object Error]") return done(err);
-        if (null != err) {
-          if (Object.prototype.toString.call(err) === '[object Object]') {
-            return done(new Error('done() invoked with non-Error: ' + JSON.stringify(err)));
-          } else {
-            return done(new Error('done() invoked with non-Error: ' + err));
-          }
-        }
-        done();
-      });
-    } catch (err) {
-      done(utils.getError(err));
-    }
-    return;
-  }
-
-  if (this.asyncOnly) {
-    return done(new Error('--async-only option in use without declaring `done()`'));
-  }
-
-  // sync or promise-returning
-  try {
-    if (this.pending) {
-      done();
-    } else {
-      callFn(this.fn);
-    }
-  } catch (err) {
-    done(utils.getError(err));
-  }
-
-  function callFn(fn) {
-    var result = fn.call(ctx);
-    if (result && typeof result.then === 'function') {
-      self.resetTimeout();
-      result
-        .then(function() {
-          done()
-        },
-        function(reason) {
-          done(reason || new Error('Promise rejected with no or falsy reason'))
-        });
-    } else {
-      done();
-    }
-  }
-};
-
-}); // module: runnable.js
-
-require.register("runner.js", function(module, exports, require){
-/**
- * Module dependencies.
- */
-
-var EventEmitter = require('browser/events').EventEmitter
-  , debug = require('browser/debug')('mocha:runner')
-  , Test = require('./test')
-  , utils = require('./utils')
-  , filter = utils.filter
-  , keys = utils.keys;
-
-/**
- * Non-enumerable globals.
- */
-
-var globals = [
-  'setTimeout',
-  'clearTimeout',
-  'setInterval',
-  'clearInterval',
-  'XMLHttpRequest',
-  'Date',
-  'setImmediate',
-  'clearImmediate'
-];
-
-/**
- * Expose `Runner`.
- */
-
-module.exports = Runner;
-
-/**
- * Initialize a `Runner` for the given `suite`.
- *
- * Events:
- *
- *   - `start`  execution started
- *   - `end`  execution complete
- *   - `suite`  (suite) test suite execution started
- *   - `suite end`  (suite) all tests (and sub-suites) have finished
- *   - `test`  (test) test execution started
- *   - `test end`  (test) test completed
- *   - `hook`  (hook) hook execution started
- *   - `hook end`  (hook) hook complete
- *   - `pass`  (test) test passed
- *   - `fail`  (test, err) test failed
- *   - `pending`  (test) test pending
- *
- * @api public
- */
-
-function Runner(suite) {
-  var self = this;
-  this._globals = [];
-  this._abort = false;
-  this.suite = suite;
-  this.total = suite.total();
-  this.failures = 0;
-  this.on('test end', function(test){ self.checkGlobals(test); });
-  this.on('hook end', function(hook){ self.checkGlobals(hook); });
-  this.grep(/.*/);
-  this.globals(this.globalProps().concat(extraGlobals()));
-}
-
-/**
- * Wrapper for setImmediate, process.nextTick, or browser polyfill.
- *
- * @param {Function} fn
- * @api private
- */
-
-Runner.immediately = global.setImmediate || process.nextTick;
-
-/**
- * Inherit from `EventEmitter.prototype`.
- */
-
-function F(){};
-F.prototype = EventEmitter.prototype;
-Runner.prototype = new F;
-Runner.prototype.constructor = Runner;
-
-
-/**
- * Run tests with full titles matching `re`. Updates runner.total
- * with number of tests matched.
- *
- * @param {RegExp} re
- * @param {Boolean} invert
- * @return {Runner} for chaining
- * @api public
- */
-
-Runner.prototype.grep = function(re, invert){
-  debug('grep %s', re);
-  this._grep = re;
-  this._invert = invert;
-  this.total = this.grepTotal(this.suite);
-  return this;
-};
-
-/**
- * Returns the number of tests matching the grep search for the
- * given suite.
- *
- * @param {Suite} suite
- * @return {Number}
- * @api public
- */
-
-Runner.prototype.grepTotal = function(suite) {
-  var self = this;
-  var total = 0;
-
-  suite.eachTest(function(test){
-    var match = self._grep.test(test.fullTitle());
-    if (self._invert) match = !match;
-    if (match) total++;
-  });
-
-  return total;
-};
-
-/**
- * Return a list of global properties.
- *
- * @return {Array}
- * @api private
- */
-
-Runner.prototype.globalProps = function() {
-  var props = utils.keys(global);
-
-  // non-enumerables
-  for (var i = 0; i < globals.length; ++i) {
-    if (~utils.indexOf(props, globals[i])) continue;
-    props.push(globals[i]);
-  }
-
-  return props;
-};
-
-/**
- * Allow the given `arr` of globals.
- *
- * @param {Array} arr
- * @return {Runner} for chaining
- * @api public
- */
-
-Runner.prototype.globals = function(arr){
-  if (0 == arguments.length) return this._globals;
-  debug('globals %j', arr);
-  this._globals = this._globals.concat(arr);
-  return this;
-};
-
-/**
- * Check for global variable leaks.
- *
- * @api private
- */
-
-Runner.prototype.checkGlobals = function(test){
-  if (this.ignoreLeaks) return;
-  var ok = this._globals;
-
-  var globals = this.globalProps();
-  var leaks;
-
-  if (test) {
-    ok = ok.concat(test._allowedGlobals || []);
-  }
-
-  if(this.prevGlobalsLength == globals.length) return;
-  this.prevGlobalsLength = globals.length;
-
-  leaks = filterLeaks(ok, globals);
-  this._globals = this._globals.concat(leaks);
-
-  if (leaks.length > 1) {
-    this.fail(test, new Error('global leaks detected: ' + leaks.join(', ') + ''));
-  } else if (leaks.length) {
-    this.fail(test, new Error('global leak detected: ' + leaks[0]));
-  }
-};
-
-/**
- * Fail the given `test`.
- *
- * @param {Test} test
- * @param {Error} err
- * @api private
- */
-
-Runner.prototype.fail = function(test, err){
-  ++this.failures;
-  test.state = 'failed';
-
-  if ('string' == typeof err) {
-    err = new Error('the string "' + err + '" was thrown, throw an Error :)');
-  }
-
-  this.emit('fail', test, err);
-};
-
-/**
- * Fail the given `hook` with `err`.
- *
- * Hook failures work in the following pattern:
- * - If bail, then exit
- * - Failed `before` hook skips all tests in a suite and subsuites,
- *   but jumps to corresponding `after` hook
- * - Failed `before each` hook skips remaining tests in a
- *   suite and jumps to corresponding `after each` hook,
- *   which is run only once
- * - Failed `after` hook does not alter
- *   execution order
- * - Failed `after each` hook skips remaining tests in a
- *   suite and subsuites, but executes other `after each`
- *   hooks
- *
- * @param {Hook} hook
- * @param {Error} err
- * @api private
- */
-
-Runner.prototype.failHook = function(hook, err){
-  this.fail(hook, err);
-  if (this.suite.bail()) {
-    this.emit('end');
-  }
-};
-
-/**
- * Run hook `name` callbacks and then invoke `fn()`.
- *
- * @param {String} name
- * @param {Function} function
- * @api private
- */
-
-Runner.prototype.hook = function(name, fn){
-  var suite = this.suite
-    , hooks = suite['_' + name]
-    , self = this
-    , timer;
-
-  function next(i) {
-    var hook = hooks[i];
-    if (!hook) return fn();
-    self.currentRunnable = hook;
-
-    hook.ctx.currentTest = self.test;
-
-    self.emit('hook', hook);
-
-    hook.on('error', function(err){
-      self.failHook(hook, err);
-    });
-
-    hook.run(function(err){
-      hook.removeAllListeners('error');
-      var testError = hook.error();
-      if (testError) self.fail(self.test, testError);
-      if (err) {
-        self.failHook(hook, err);
-
-        // stop executing hooks, notify callee of hook err
-        return fn(err);
-      }
-      self.emit('hook end', hook);
-      delete hook.ctx.currentTest;
-      next(++i);
-    });
-  }
-
-  Runner.immediately(function(){
-    next(0);
-  });
-};
-
-/**
- * Run hook `name` for the given array of `suites`
- * in order, and callback `fn(err, errSuite)`.
- *
- * @param {String} name
- * @param {Array} suites
- * @param {Function} fn
- * @api private
- */
-
-Runner.prototype.hooks = function(name, suites, fn){
-  var self = this
-    , orig = this.suite;
-
-  function next(suite) {
-    self.suite = suite;
-
-    if (!suite) {
-      self.suite = orig;
-      return fn();
-    }
-
-    self.hook(name, function(err){
-      if (err) {
-        var errSuite = self.suite;
-        self.suite = orig;
-        return fn(err, errSuite);
-      }
-
-      next(suites.pop());
-    });
-  }
-
-  next(suites.pop());
-};
-
-/**
- * Run hooks from the top level down.
- *
- * @param {String} name
- * @param {Function} fn
- * @api private
- */
-
-Runner.prototype.hookUp = function(name, fn){
-  var suites = [this.suite].concat(this.parents()).reverse();
-  this.hooks(name, suites, fn);
-};
-
-/**
- * Run hooks from the bottom up.
- *
- * @param {String} name
- * @param {Function} fn
- * @api private
- */
-
-Runner.prototype.hookDown = function(name, fn){
-  var suites = [this.suite].concat(this.parents());
-  this.hooks(name, suites, fn);
-};
-
-/**
- * Return an array of parent Suites from
- * closest to furthest.
- *
- * @return {Array}
- * @api private
- */
-
-Runner.prototype.parents = function(){
-  var suite = this.suite
-    , suites = [];
-  while (suite = suite.parent) suites.push(suite);
-  return suites;
-};
-
-/**
- * Run the current test and callback `fn(err)`.
- *
- * @param {Function} fn
- * @api private
- */
-
-Runner.prototype.runTest = function(fn){
-  var test = this.test
-    , self = this;
-
-  if (this.asyncOnly) test.asyncOnly = true;
-
-  try {
-    test.on('error', function(err){
-      self.fail(test, err);
-    });
-    test.run(fn);
-  } catch (err) {
-    fn(err);
-  }
-};
-
-/**
- * Run tests in the given `suite` and invoke
- * the callback `fn()` when complete.
- *
- * @param {Suite} suite
- * @param {Function} fn
- * @api private
- */
-
-Runner.prototype.runTests = function(suite, fn){
-  var self = this
-    , tests = suite.tests.slice()
-    , test;
-
-
-  function hookErr(err, errSuite, after) {
-    // before/after Each hook for errSuite failed:
-    var orig = self.suite;
-
-    // for failed 'after each' hook start from errSuite parent,
-    // otherwise start from errSuite itself
-    self.suite = after ? errSuite.parent : errSuite;
-
-    if (self.suite) {
-      // call hookUp afterEach
-      self.hookUp('afterEach', function(err2, errSuite2) {
-        self.suite = orig;
-        // some hooks may fail even now
-        if (err2) return hookErr(err2, errSuite2, true);
-        // report error suite
-        fn(errSuite);
-      });
-    } else {
-      // there is no need calling other 'after each' hooks
-      self.suite = orig;
-      fn(errSuite);
-    }
-  }
-
-  function next(err, errSuite) {
-    // if we bail after first err
-    if (self.failures && suite._bail) return fn();
-
-    if (self._abort) return fn();
-
-    if (err) return hookErr(err, errSuite, true);
-
-    // next test
-    test = tests.shift();
-
-    // all done
-    if (!test) return fn();
-
-    // grep
-    var match = self._grep.test(test.fullTitle());
-    if (self._invert) match = !match;
-    if (!match) return next();
-
-    // pending
-    if (test.pending) {
-      self.emit('pending', test);
-      self.emit('test end', test);
-      return next();
-    }
-
-    // execute test and hook(s)
-    self.emit('test', self.test = test);
-    self.hookDown('beforeEach', function(err, errSuite){
-
-      if (err) return hookErr(err, errSuite, false);
-
-      self.currentRunnable = self.test;
-      self.runTest(function(err){
-        test = self.test;
-
-        if (err) {
-          self.fail(test, err);
-          self.emit('test end', test);
-          return self.hookUp('afterEach', next);
-        }
-
-        test.state = 'passed';
-        self.emit('pass', test);
-        self.emit('test end', test);
-        self.hookUp('afterEach', next);
-      });
-    });
-  }
-
-  this.next = next;
-  next();
-};
-
-/**
- * Run the given `suite` and invoke the
- * callback `fn()` when complete.
- *
- * @param {Suite} suite
- * @param {Function} fn
- * @api private
- */
-
-Runner.prototype.runSuite = function(suite, fn){
-  var total = this.grepTotal(suite)
-    , self = this
-    , i = 0;
-
-  debug('run suite %s', suite.fullTitle());
-
-  if (!total) return fn();
-
-  this.emit('suite', this.suite = suite);
-
-  function next(errSuite) {
-    if (errSuite) {
-      // current suite failed on a hook from errSuite
-      if (errSuite == suite) {
-        // if errSuite is current suite
-        // continue to the next sibling suite
-        return done();
-      } else {
-        // errSuite is among the parents of current suite
-        // stop execution of errSuite and all sub-suites
-        return done(errSuite);
-      }
-    }
-
-    if (self._abort) return done();
-
-    var curr = suite.suites[i++];
-    if (!curr) return done();
-    self.runSuite(curr, next);
-  }
-
-  function done(errSuite) {
-    self.suite = suite;
-    self.hook('afterAll', function(){
-      self.emit('suite end', suite);
-      fn(errSuite);
-    });
-  }
-
-  this.hook('beforeAll', function(err){
-    if (err) return done();
-    self.runTests(suite, next);
-  });
-};
-
-/**
- * Handle uncaught exceptions.
- *
- * @param {Error} err
- * @api private
- */
-
-Runner.prototype.uncaught = function(err){
-  if (err) {
-    debug('uncaught exception %s', err !== function () {
-      return this;
-    }.call(err) ? err : ( err.message || err ));
-  } else {
-    debug('uncaught undefined exception');
-    err = utils.undefinedError();
-  }
-  err.uncaught = true;
-
-  var runnable = this.currentRunnable;
-  if (!runnable) return;
-
-  var wasAlreadyDone = runnable.state;
-  this.fail(runnable, err);
-
-  runnable.clearTimeout();
-
-  if (wasAlreadyDone) return;
-
-  // recover from test
-  if ('test' == runnable.type) {
-    this.emit('test end', runnable);
-    this.hookUp('afterEach', this.next);
-    return;
-  }
-
-  // bail on hooks
-  this.emit('end');
-};
-
-/**
- * Run the root suite and invoke `fn(failures)`
- * on completion.
- *
- * @param {Function} fn
- * @return {Runner} for chaining
- * @api public
- */
-
-Runner.prototype.run = function(fn){
-  var self = this
-    , fn = fn || function(){};
-
-  function uncaught(err){
-    self.uncaught(err);
-  }
-
-  debug('start');
-
-  // callback
-  this.on('end', function(){
-    debug('end');
-    process.removeListener('uncaughtException', uncaught);
-    fn(self.failures);
-  });
-
-  // run suites
-  this.emit('start');
-  this.runSuite(this.suite, function(){
-    debug('finished running');
-    self.emit('end');
-  });
-
-  // uncaught exception
-  process.on('uncaughtException', uncaught);
-
-  return this;
-};
-
-/**
- * Cleanly abort execution
- *
- * @return {Runner} for chaining
- * @api public
- */
-Runner.prototype.abort = function(){
-  debug('aborting');
-  this._abort = true;
-};
-
-/**
- * Filter leaks with the given globals flagged as `ok`.
- *
- * @param {Array} ok
- * @param {Array} globals
- * @return {Array}
- * @api private
- */
-
-function filterLeaks(ok, globals) {
-  return filter(globals, function(key){
-    // Firefox and Chrome exposes iframes as index inside the window object
-    if (/^d+/.test(key)) return false;
-
-    // in firefox
-    // if runner runs in an iframe, this iframe's window.getInterface method not init at first
-    // it is assigned in some seconds
-    if (global.navigator && /^getInterface/.test(key)) return false;
-
-    // an iframe could be approached by window[iframeIndex]
-    // in ie6,7,8 and opera, iframeIndex is enumerable, this could cause leak
-    if (global.navigator && /^\d+/.test(key)) return false;
-
-    // Opera and IE expose global variables for HTML element IDs (issue #243)
-    if (/^mocha-/.test(key)) return false;
-
-    var matched = filter(ok, function(ok){
-      if (~ok.indexOf('*')) return 0 == key.indexOf(ok.split('*')[0]);
-      return key == ok;
-    });
-    return matched.length == 0 && (!global.navigator || 'onerror' !== key);
-  });
-}
-
-/**
- * Array of globals dependent on the environment.
- *
- * @return {Array}
- * @api private
- */
-
- function extraGlobals() {
-  if (typeof(process) === 'object' &&
-      typeof(process.version) === 'string') {
-
-    var nodeVersion = process.version.split('.').reduce(function(a, v) {
-      return a << 8 | v;
-    });
-
-    // 'errno' was renamed to process._errno in v0.9.11.
-
-    if (nodeVersion < 0x00090B) {
-      return ['errno'];
-    }
-  }
-
-  return [];
- }
-
-}); // module: runner.js
-
-require.register("suite.js", function(module, exports, require){
-/**
- * Module dependencies.
- */
-
-var EventEmitter = require('browser/events').EventEmitter
-  , debug = require('browser/debug')('mocha:suite')
-  , milliseconds = require('./ms')
-  , utils = require('./utils')
-  , Hook = require('./hook');
-
-/**
- * Expose `Suite`.
- */
-
-exports = module.exports = Suite;
-
-/**
- * Create a new `Suite` with the given `title`
- * and parent `Suite`. When a suite with the
- * same title is already present, that suite
- * is returned to provide nicer reporter
- * and more flexible meta-testing.
- *
- * @param {Suite} parent
- * @param {String} title
- * @return {Suite}
- * @api public
- */
-
-exports.create = function(parent, title){
-  var suite = new Suite(title, parent.ctx);
-  suite.parent = parent;
-  if (parent.pending) suite.pending = true;
-  title = suite.fullTitle();
-  parent.addSuite(suite);
-  return suite;
-};
-
-/**
- * Initialize a new `Suite` with the given
- * `title` and `ctx`.
- *
- * @param {String} title
- * @param {Context} ctx
- * @api private
- */
-
-function Suite(title, parentContext) {
-  this.title = title;
-  var context = function() {};
-  context.prototype = parentContext;
-  this.ctx = new context();
-  this.suites = [];
-  this.tests = [];
-  this.pending = false;
-  this._beforeEach = [];
-  this._beforeAll = [];
-  this._afterEach = [];
-  this._afterAll = [];
-  this.root = !title;
-  this._timeout = 2000;
-  this._enableTimeouts = true;
-  this._slow = 75;
-  this._bail = false;
-}
-
-/**
- * Inherit from `EventEmitter.prototype`.
- */
-
-function F(){};
-F.prototype = EventEmitter.prototype;
-Suite.prototype = new F;
-Suite.prototype.constructor = Suite;
-
-
-/**
- * Return a clone of this `Suite`.
- *
- * @return {Suite}
- * @api private
- */
-
-Suite.prototype.clone = function(){
-  var suite = new Suite(this.title);
-  debug('clone');
-  suite.ctx = this.ctx;
-  suite.timeout(this.timeout());
-  suite.enableTimeouts(this.enableTimeouts());
-  suite.slow(this.slow());
-  suite.bail(this.bail());
-  return suite;
-};
-
-/**
- * Set timeout `ms` or short-hand such as "2s".
- *
- * @param {Number|String} ms
- * @return {Suite|Number} for chaining
- * @api private
- */
-
-Suite.prototype.timeout = function(ms){
-  if (0 == arguments.length) return this._timeout;
-  if (ms.toString() === '0') this._enableTimeouts = false;
-  if ('string' == typeof ms) ms = milliseconds(ms);
-  debug('timeout %d', ms);
-  this._timeout = parseInt(ms, 10);
-  return this;
-};
-
-/**
-  * Set timeout `enabled`.
-  *
-  * @param {Boolean} enabled
-  * @return {Suite|Boolean} self or enabled
-  * @api private
-  */
-
-Suite.prototype.enableTimeouts = function(enabled){
-  if (arguments.length === 0) return this._enableTimeouts;
-  debug('enableTimeouts %s', enabled);
-  this._enableTimeouts = enabled;
-  return this;
-};
-
-/**
- * Set slow `ms` or short-hand such as "2s".
- *
- * @param {Number|String} ms
- * @return {Suite|Number} for chaining
- * @api private
- */
-
-Suite.prototype.slow = function(ms){
-  if (0 === arguments.length) return this._slow;
-  if ('string' == typeof ms) ms = milliseconds(ms);
-  debug('slow %d', ms);
-  this._slow = ms;
-  return this;
-};
-
-/**
- * Sets whether to bail after first error.
- *
- * @param {Boolean} bail
- * @return {Suite|Number} for chaining
- * @api private
- */
-
-Suite.prototype.bail = function(bail){
-  if (0 == arguments.length) return this._bail;
-  debug('bail %s', bail);
-  this._bail = bail;
-  return this;
-};
-
-/**
- * Run `fn(test[, done])` before running tests.
- *
- * @param {Function} fn
- * @return {Suite} for chaining
- * @api private
- */
-
-Suite.prototype.beforeAll = function(title, fn){
-  if (this.pending) return this;
-  if ('function' === typeof title) {
-    fn = title;
-    title = fn.name;
-  }
-  title = '"before all" hook' + (title ? ': ' + title : '');
-
-  var hook = new Hook(title, fn);
-  hook.parent = this;
-  hook.timeout(this.timeout());
-  hook.enableTimeouts(this.enableTimeouts());
-  hook.slow(this.slow());
-  hook.ctx = this.ctx;
-  this._beforeAll.push(hook);
-  this.emit('beforeAll', hook);
-  return this;
-};
-
-/**
- * Run `fn(test[, done])` after running tests.
- *
- * @param {Function} fn
- * @return {Suite} for chaining
- * @api private
- */
-
-Suite.prototype.afterAll = function(title, fn){
-  if (this.pending) return this;
-  if ('function' === typeof title) {
-    fn = title;
-    title = fn.name;
-  }
-  title = '"after all" hook' + (title ? ': ' + title : '');
-
-  var hook = new Hook(title, fn);
-  hook.parent = this;
-  hook.timeout(this.timeout());
-  hook.enableTimeouts(this.enableTimeouts());
-  hook.slow(this.slow());
-  hook.ctx = this.ctx;
-  this._afterAll.push(hook);
-  this.emit('afterAll', hook);
-  return this;
-};
-
-/**
- * Run `fn(test[, done])` before each test case.
- *
- * @param {Function} fn
- * @return {Suite} for chaining
- * @api private
- */
-
-Suite.prototype.beforeEach = function(title, fn){
-  if (this.pending) return this;
-  if ('function' === typeof title) {
-    fn = title;
-    title = fn.name;
-  }
-  title = '"before each" hook' + (title ? ': ' + title : '');
-
-  var hook = new Hook(title, fn);
-  hook.parent = this;
-  hook.timeout(this.timeout());
-  hook.enableTimeouts(this.enableTimeouts());
-  hook.slow(this.slow());
-  hook.ctx = this.ctx;
-  this._beforeEach.push(hook);
-  this.emit('beforeEach', hook);
-  return this;
-};
-
-/**
- * Run `fn(test[, done])` after each test case.
- *
- * @param {Function} fn
- * @return {Suite} for chaining
- * @api private
- */
-
-Suite.prototype.afterEach = function(title, fn){
-  if (this.pending) return this;
-  if ('function' === typeof title) {
-    fn = title;
-    title = fn.name;
-  }
-  title = '"after each" hook' + (title ? ': ' + title : '');
-
-  var hook = new Hook(title, fn);
-  hook.parent = this;
-  hook.timeout(this.timeout());
-  hook.enableTimeouts(this.enableTimeouts());
-  hook.slow(this.slow());
-  hook.ctx = this.ctx;
-  this._afterEach.push(hook);
-  this.emit('afterEach', hook);
-  return this;
-};
-
-/**
- * Add a test `suite`.
- *
- * @param {Suite} suite
- * @return {Suite} for chaining
- * @api private
- */
-
-Suite.prototype.addSuite = function(suite){
-  suite.parent = this;
-  suite.timeout(this.timeout());
-  suite.enableTimeouts(this.enableTimeouts());
-  suite.slow(this.slow());
-  suite.bail(this.bail());
-  this.suites.push(suite);
-  this.emit('suite', suite);
-  return this;
-};
-
-/**
- * Add a `test` to this suite.
- *
- * @param {Test} test
- * @return {Suite} for chaining
- * @api private
- */
-
-Suite.prototype.addTest = function(test){
-  test.parent = this;
-  test.timeout(this.timeout());
-  test.enableTimeouts(this.enableTimeouts());
-  test.slow(this.slow());
-  test.ctx = this.ctx;
-  this.tests.push(test);
-  this.emit('test', test);
-  return this;
-};
-
-/**
- * Return the full title generated by recursively
- * concatenating the parent's full title.
- *
- * @return {String}
- * @api public
- */
-
-Suite.prototype.fullTitle = function(){
-  if (this.parent) {
-    var full = this.parent.fullTitle();
-    if (full) return full + ' ' + this.title;
-  }
-  return this.title;
-};
-
-/**
- * Return the total number of tests.
- *
- * @return {Number}
- * @api public
- */
-
-Suite.prototype.total = function(){
-  return utils.reduce(this.suites, function(sum, suite){
-    return sum + suite.total();
-  }, 0) + this.tests.length;
-};
-
-/**
- * Iterates through each suite recursively to find
- * all tests. Applies a function in the format
- * `fn(test)`.
- *
- * @param {Function} fn
- * @return {Suite}
- * @api private
- */
-
-Suite.prototype.eachTest = function(fn){
-  utils.forEach(this.tests, fn);
-  utils.forEach(this.suites, function(suite){
-    suite.eachTest(fn);
-  });
-  return this;
-};
-
-}); // module: suite.js
-
-require.register("test.js", function(module, exports, require){
-/**
- * Module dependencies.
- */
-
-var Runnable = require('./runnable');
-
-/**
- * Expose `Test`.
- */
-
-module.exports = Test;
-
-/**
- * Initialize a new `Test` with the given `title` and callback `fn`.
- *
- * @param {String} title
- * @param {Function} fn
- * @api private
- */
-
-function Test(title, fn) {
-  Runnable.call(this, title, fn);
-  this.pending = !fn;
-  this.type = 'test';
-}
-
-/**
- * Inherit from `Runnable.prototype`.
- */
-
-function F(){};
-F.prototype = Runnable.prototype;
-Test.prototype = new F;
-Test.prototype.constructor = Test;
-
-
-}); // module: test.js
-
-require.register("utils.js", function(module, exports, require){
-/**
- * Module dependencies.
- */
-
-var fs = require('browser/fs')
-  , path = require('browser/path')
-  , basename = path.basename
-  , exists = fs.existsSync || path.existsSync
-  , glob = require('browser/glob')
-  , join = path.join
-  , debug = require('browser/debug')('mocha:watch');
-
-/**
- * Ignored directories.
- */
-
-var ignore = ['node_modules', '.git'];
-
-/**
- * Escape special characters in the given string of html.
- *
- * @param  {String} html
- * @return {String}
- * @api private
- */
-
-exports.escape = function(html){
-  return String(html)
-    .replace(/&/g, '&amp;')
-    .replace(/"/g, '&quot;')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;');
-};
-
-/**
- * Array#forEach (<=IE8)
- *
- * @param {Array} array
- * @param {Function} fn
- * @param {Object} scope
- * @api private
- */
-
-exports.forEach = function(arr, fn, scope){
-  for (var i = 0, l = arr.length; i < l; i++)
-    fn.call(scope, arr[i], i);
-};
-
-/**
- * Array#map (<=IE8)
- *
- * @param {Array} array
- * @param {Function} fn
- * @param {Object} scope
- * @api private
- */
-
-exports.map = function(arr, fn, scope){
-  var result = [];
-  for (var i = 0, l = arr.length; i < l; i++)
-    result.push(fn.call(scope, arr[i], i));
-  return result;
-};
-
-/**
- * Array#indexOf (<=IE8)
- *
- * @parma {Array} arr
- * @param {Object} obj to find index of
- * @param {Number} start
- * @api private
- */
-
-exports.indexOf = function(arr, obj, start){
-  for (var i = start || 0, l = arr.length; i < l; i++) {
-    if (arr[i] === obj)
-      return i;
-  }
-  return -1;
-};
-
-/**
- * Array#reduce (<=IE8)
- *
- * @param {Array} array
- * @param {Function} fn
- * @param {Object} initial value
- * @api private
- */
-
-exports.reduce = function(arr, fn, val){
-  var rval = val;
-
-  for (var i = 0, l = arr.length; i < l; i++) {
-    rval = fn(rval, arr[i], i, arr);
-  }
-
-  return rval;
-};
-
-/**
- * Array#filter (<=IE8)
- *
- * @param {Array} array
- * @param {Function} fn
- * @api private
- */
-
-exports.filter = function(arr, fn){
-  var ret = [];
-
-  for (var i = 0, l = arr.length; i < l; i++) {
-    var val = arr[i];
-    if (fn(val, i, arr)) ret.push(val);
-  }
-
-  return ret;
-};
-
-/**
- * Object.keys (<=IE8)
- *
- * @param {Object} obj
- * @return {Array} keys
- * @api private
- */
-
-exports.keys = Object.keys || function(obj) {
-  var keys = []
-    , has = Object.prototype.hasOwnProperty // for `window` on <=IE8
-
-  for (var key in obj) {
-    if (has.call(obj, key)) {
-      keys.push(key);
-    }
-  }
-
-  return keys;
-};
-
-/**
- * Watch the given `files` for changes
- * and invoke `fn(file)` on modification.
- *
- * @param {Array} files
- * @param {Function} fn
- * @api private
- */
-
-exports.watch = function(files, fn){
-  var options = { interval: 100 };
-  files.forEach(function(file){
-    debug('file %s', file);
-    fs.watchFile(file, options, function(curr, prev){
-      if (prev.mtime < curr.mtime) fn(file);
-    });
-  });
-};
-
-/**
- * Ignored files.
- */
-
-function ignored(path){
-  return !~ignore.indexOf(path);
-}
-
-/**
- * Lookup files in the given `dir`.
- *
- * @return {Array}
- * @api private
- */
-
-exports.files = function(dir, ext, ret){
-  ret = ret || [];
-  ext = ext || ['js'];
-
-  var re = new RegExp('\\.(' + ext.join('|') + ')$');
-
-  fs.readdirSync(dir)
-  .filter(ignored)
-  .forEach(function(path){
-    path = join(dir, path);
-    if (fs.statSync(path).isDirectory()) {
-      exports.files(path, ext, ret);
-    } else if (path.match(re)) {
-      ret.push(path);
-    }
-  });
-
-  return ret;
-};
-
-/**
- * Compute a slug from the given `str`.
- *
- * @param {String} str
- * @return {String}
- * @api private
- */
-
-exports.slug = function(str){
-  return str
-    .toLowerCase()
-    .replace(/ +/g, '-')
-    .replace(/[^-\w]/g, '');
-};
-
-/**
- * Strip the function definition from `str`,
- * and re-indent for pre whitespace.
- */
-
-exports.clean = function(str) {
-  str = str
-    .replace(/\r\n?|[\n\u2028\u2029]/g, "\n").replace(/^\uFEFF/, '')
-    .replace(/^function *\(.*\) *{|\(.*\) *=> *{?/, '')
-    .replace(/\s+\}$/, '');
-
-  var spaces = str.match(/^\n?( *)/)[1].length
-    , tabs = str.match(/^\n?(\t*)/)[1].length
-    , re = new RegExp('^\n?' + (tabs ? '\t' : ' ') + '{' + (tabs ? tabs : spaces) + '}', 'gm');
-
-  str = str.replace(re, '');
-
-  return exports.trim(str);
-};
-
-/**
- * Trim the given `str`.
- *
- * @param {String} str
- * @return {String}
- * @api private
- */
-
-exports.trim = function(str){
-  return str.replace(/^\s+|\s+$/g, '');
-};
-
-/**
- * Parse the given `qs`.
- *
- * @param {String} qs
- * @return {Object}
- * @api private
- */
-
-exports.parseQuery = function(qs){
-  return exports.reduce(qs.replace('?', '').split('&'), function(obj, pair){
-    var i = pair.indexOf('=')
-      , key = pair.slice(0, i)
-      , val = pair.slice(++i);
-
-    obj[key] = decodeURIComponent(val);
-    return obj;
-  }, {});
-};
-
-/**
- * Highlight the given string of `js`.
- *
- * @param {String} js
- * @return {String}
- * @api private
- */
-
-function highlight(js) {
-  return js
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;')
-    .replace(/\/\/(.*)/gm, '<span class="comment">//$1</span>')
-    .replace(/('.*?')/gm, '<span class="string">$1</span>')
-    .replace(/(\d+\.\d+)/gm, '<span class="number">$1</span>')
-    .replace(/(\d+)/gm, '<span class="number">$1</span>')
-    .replace(/\bnew[ \t]+(\w+)/gm, '<span class="keyword">new</span> <span class="init">$1</span>')
-    .replace(/\b(function|new|throw|return|var|if|else)\b/gm, '<span class="keyword">$1</span>')
-}
-
-/**
- * Highlight the contents of tag `name`.
- *
- * @param {String} name
- * @api private
- */
-
-exports.highlightTags = function(name) {
-  var code = document.getElementById('mocha').getElementsByTagName(name);
-  for (var i = 0, len = code.length; i < len; ++i) {
-    code[i].innerHTML = highlight(code[i].innerHTML);
-  }
-};
-
-/**
- * If a value could have properties, and has none, this function is called, which returns
- * a string representation of the empty value.
- *
- * Functions w/ no properties return `'[Function]'`
- * Arrays w/ length === 0 return `'[]'`
- * Objects w/ no properties return `'{}'`
- * All else: return result of `value.toString()`
- *
- * @param {*} value Value to inspect
- * @param {string} [type] The type of the value, if known.
- * @returns {string}
- */
-var emptyRepresentation = function emptyRepresentation(value, type) {
-  type = type || exports.type(value);
-
-  switch(type) {
-    case 'function':
-      return '[Function]';
-    case 'object':
-      return '{}';
-    case 'array':
-      return '[]';
-    default:
-      return value.toString();
-  }
-};
-
-/**
- * Takes some variable and asks `{}.toString()` what it thinks it is.
- * @param {*} value Anything
- * @example
- * type({}) // 'object'
- * type([]) // 'array'
- * type(1) // 'number'
- * type(false) // 'boolean'
- * type(Infinity) // 'number'
- * type(null) // 'null'
- * type(new Date()) // 'date'
- * type(/foo/) // 'regexp'
- * type('type') // 'string'
- * type(global) // 'global'
- * @api private
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toString
- * @returns {string}
- */
-exports.type = function type(value) {
-  if (typeof Buffer !== 'undefined' && Buffer.isBuffer(value)) {
-    return 'buffer';
-  }
-  return Object.prototype.toString.call(value)
-    .replace(/^\[.+\s(.+?)\]$/, '$1')
-    .toLowerCase();
-};
-
-/**
- * @summary Stringify `value`.
- * @description Different behavior depending on type of value.
- * - If `value` is undefined or null, return `'[undefined]'` or `'[null]'`, respectively.
- * - If `value` is not an object, function or array, return result of `value.toString()` wrapped in double-quotes.
- * - If `value` is an *empty* object, function, or array, return result of function
- *   {@link emptyRepresentation}.
- * - If `value` has properties, call {@link exports.canonicalize} on it, then return result of
- *   JSON.stringify().
- *
- * @see exports.type
- * @param {*} value
- * @return {string}
- * @api private
- */
-
-exports.stringify = function(value) {
-  var prop,
-    type = exports.type(value);
-
-  if (type === 'null' || type === 'undefined') {
-    return '[' + type + ']';
-  }
-
-  if (type === 'date') {
-    return '[Date: ' + value.toISOString() + ']';
-  }
-
-  if (!~exports.indexOf(['object', 'array', 'function'], type)) {
-    return value.toString();
-  }
-
-  for (prop in value) {
-    if (value.hasOwnProperty(prop)) {
-      return JSON.stringify(exports.canonicalize(value), null, 2).replace(/,(\n|$)/g, '$1');
-    }
-  }
-
-  return emptyRepresentation(value, type);
-};
-
-/**
- * Return if obj is a Buffer
- * @param {Object} arg
- * @return {Boolean}
- * @api private
- */
-exports.isBuffer = function (arg) {
-  return typeof Buffer !== 'undefined' && Buffer.isBuffer(arg);
-};
-
-/**
- * @summary Return a new Thing that has the keys in sorted order.  Recursive.
- * @description If the Thing...
- * - has already been seen, return string `'[Circular]'`
- * - is `undefined`, return string `'[undefined]'`
- * - is `null`, return value `null`
- * - is some other primitive, return the value
- * - is not a primitive or an `Array`, `Object`, or `Function`, return the value of the Thing's `toString()` method
- * - is a non-empty `Array`, `Object`, or `Function`, return the result of calling this function again.
- * - is an empty `Array`, `Object`, or `Function`, return the result of calling `emptyRepresentation()`
- *
- * @param {*} value Thing to inspect.  May or may not have properties.
- * @param {Array} [stack=[]] Stack of seen values
- * @return {(Object|Array|Function|string|undefined)}
- * @see {@link exports.stringify}
- * @api private
- */
-
-exports.canonicalize = function(value, stack) {
-  var canonicalizedObj,
-    type = exports.type(value),
-    prop,
-    withStack = function withStack(value, fn) {
-      stack.push(value);
-      fn();
-      stack.pop();
-    };
-
-  stack = stack || [];
-
-  if (exports.indexOf(stack, value) !== -1) {
-    return '[Circular]';
-  }
-
-  switch(type) {
-    case 'undefined':
-      canonicalizedObj = '[undefined]';
-      break;
-    case 'buffer':
-    case 'null':
-      canonicalizedObj = value;
-      break;
-    case 'array':
-      withStack(value, function () {
-        canonicalizedObj = exports.map(value, function (item) {
-          return exports.canonicalize(item, stack);
-        });
-      });
-      break;
-    case 'date':
-      canonicalizedObj = '[Date: ' + value.toISOString() + ']';
-      break;
-    case 'function':
-      for (prop in value) {
-        canonicalizedObj = {};
-        break;
-      }
-      if (!canonicalizedObj) {
-        canonicalizedObj = emptyRepresentation(value, type);
-        break;
-      }
-    /* falls through */
-    case 'object':
-      canonicalizedObj = canonicalizedObj || {};
-      withStack(value, function () {
-        exports.forEach(exports.keys(value).sort(), function (key) {
-          canonicalizedObj[key] = exports.canonicalize(value[key], stack);
-        });
-      });
-      break;
-    case 'number':
-    case 'boolean':
-      canonicalizedObj = value;
-      break;
-    default:
-      canonicalizedObj = value.toString();
-  }
-
-  return canonicalizedObj;
-};
-
-/**
- * Lookup file names at the given `path`.
- */
-exports.lookupFiles = function lookupFiles(path, extensions, recursive) {
-  var files = [];
-  var re = new RegExp('\\.(' + extensions.join('|') + ')$');
-
-  if (!exists(path)) {
-    if (exists(path + '.js')) {
-      path += '.js';
-    } else {
-      files = glob.sync(path);
-      if (!files.length) throw new Error("cannot resolve path (or pattern) '" + path + "'");
-      return files;
-    }
-  }
-
-  try {
-    var stat = fs.statSync(path);
-    if (stat.isFile()) return path;
-  }
-  catch (ignored) {
-    return;
-  }
-
-  fs.readdirSync(path).forEach(function(file){
-    file = join(path, file);
-    try {
-      var stat = fs.statSync(file);
-      if (stat.isDirectory()) {
-        if (recursive) {
-          files = files.concat(lookupFiles(file, extensions, recursive));
-        }
-        return;
-      }
-    }
-    catch (ignored) {
-      return;
-    }
-    if (!stat.isFile() || !re.test(file) || basename(file)[0] === '.') return;
-    files.push(file);
-  });
-
-  return files;
-};
-
-/**
- * Generate an undefined error with a message warning the user.
- *
- * @return {Error}
- */
-
-exports.undefinedError = function(){
-  return new Error('Caught undefined error, did you throw without specifying what?');
-};
-
-/**
- * Generate an undefined error if `err` is not defined.
- *
- * @param {Error} err
- * @return {Error}
- */
-
-exports.getError = function(err){
-  return err || exports.undefinedError();
-};
-
-
-}); // module: utils.js
-// The global object is "self" in Web Workers.
-var global = (function() { return this; })();
-
-/**
- * Save timer references to avoid Sinon interfering (see GH-237).
- */
-
-var Date = global.Date;
-var setTimeout = global.setTimeout;
-var setInterval = global.setInterval;
-var clearTimeout = global.clearTimeout;
-var clearInterval = global.clearInterval;
-
-/**
- * Node shims.
- *
- * These are meant only to allow
- * mocha.js to run untouched, not
- * to allow running node code in
- * the browser.
- */
-
-var process = {};
-process.exit = function(status){};
-process.stdout = {};
-
-var uncaughtExceptionHandlers = [];
-
-var originalOnerrorHandler = global.onerror;
-
-/**
- * Remove uncaughtException listener.
- * Revert to original onerror handler if previously defined.
- */
-
-process.removeListener = function(e, fn){
-  if ('uncaughtException' == e) {
-    if (originalOnerrorHandler) {
-      global.onerror = originalOnerrorHandler;
-    } else {
-      global.onerror = function() {};
-    }
-    var i = Mocha.utils.indexOf(uncaughtExceptionHandlers, fn);
-    if (i != -1) { uncaughtExceptionHandlers.splice(i, 1); }
-  }
-};
-
-/**
- * Implements uncaughtException listener.
- */
-
-process.on = function(e, fn){
-  if ('uncaughtException' == e) {
-    global.onerror = function(err, url, line){
-      fn(new Error(err + ' (' + url + ':' + line + ')'));
-      return true;
-    };
-    uncaughtExceptionHandlers.push(fn);
-  }
-};
-
-/**
- * Expose mocha.
- */
-
-var Mocha = global.Mocha = require('mocha'),
-    mocha = global.mocha = new Mocha({ reporter: 'html' });
-
-// The BDD UI is registered by default, but no UI will be functional in the
-// browser without an explicit call to the overridden `mocha.ui` (see below).
-// Ensure that this default UI does not expose its methods to the global scope.
-mocha.suite.removeAllListeners('pre-require');
-
-var immediateQueue = []
-  , immediateTimeout;
-
-function timeslice() {
-  var immediateStart = new Date().getTime();
-  while (immediateQueue.length && (new Date().getTime() - immediateStart) < 100) {
-    immediateQueue.shift()();
-  }
-  if (immediateQueue.length) {
-    immediateTimeout = setTimeout(timeslice, 0);
-  } else {
-    immediateTimeout = null;
-  }
-}
-
-/**
- * High-performance override of Runner.immediately.
- */
-
-Mocha.Runner.immediately = function(callback) {
-  immediateQueue.push(callback);
-  if (!immediateTimeout) {
-    immediateTimeout = setTimeout(timeslice, 0);
-  }
-};
-
-/**
- * Function to allow assertion libraries to throw errors directly into mocha.
- * This is useful when running tests in a browser because window.onerror will
- * only receive the 'message' attribute of the Error.
- */
-mocha.throwError = function(err) {
-  Mocha.utils.forEach(uncaughtExceptionHandlers, function (fn) {
-    fn(err);
-  });
-  throw err;
-};
-
-/**
- * Override ui to ensure that the ui functions are initialized.
- * Normally this would happen in Mocha.prototype.loadFiles.
- */
-
-mocha.ui = function(ui){
-  Mocha.prototype.ui.call(this, ui);
-  this.suite.emit('pre-require', global, null, this);
-  return this;
-};
-
-/**
- * Setup mocha with the given setting options.
- */
-
-mocha.setup = function(opts){
-  if ('string' == typeof opts) opts = { ui: opts };
-  for (var opt in opts) this[opt](opts[opt]);
-  return this;
-};
-
-/**
- * Run mocha, returning the Runner.
- */
-
-mocha.run = function(fn){
-  var options = mocha.options;
-  mocha.globals('location');
-
-  var query = Mocha.utils.parseQuery(global.location.search || '');
-  if (query.grep) mocha.grep(query.grep);
-  if (query.invert) mocha.invert();
-
-  return Mocha.prototype.run.call(mocha, function(err){
-    // The DOM Document is not available in Web Workers.
-    var document = global.document;
-    if (document && document.getElementById('mocha') && options.noHighlighting !== true) {
-      Mocha.utils.highlightTags('code');
-    }
-    if (fn) fn(err);
-  });
-};
-
-/**
- * Expose the process shim.
- */
-
-Mocha.process = process;
-})();
diff --git a/packages/planner/node_modules/deepcopy/bower_components/power-assert/.bower.json b/packages/planner/node_modules/deepcopy/bower_components/power-assert/.bower.json
deleted file mode 100644
index c721f682..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/power-assert/.bower.json
+++ /dev/null
@@ -1,56 +0,0 @@
-{
-  "name": "power-assert",
-  "description": "Power Assert in JavaScript",
-  "main": "build/power-assert.js",
-  "license": "MIT",
-  "ignore": [
-    "**/.*",
-    "package.json",
-    "index.js",
-    "test",
-    "enable_power_assert.js"
-  ],
-  "keywords": [
-    "power-assert",
-    "test",
-    "assert",
-    "testing",
-    "ecmascript",
-    "ast"
-  ],
-  "authors": [
-    {
-      "name": "Takuto Wada",
-      "email": "takuto.wada@gmail.com",
-      "homepage": "https://github.com/twada"
-    },
-    {
-      "name": "azu",
-      "url": "https://github.com/azu"
-    },
-    {
-      "name": "vvakame",
-      "url": "https://github.com/vvakame"
-    }
-  ],
-  "homepage": "https://github.com/twada/power-assert",
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/twada/power-assert.git"
-  },
-  "devDependencies": {
-    "expect": "~0.3.1",
-    "mocha": "~2.1.0",
-    "requirejs": "~2.1.15"
-  },
-  "version": "0.10.2",
-  "_release": "0.10.2",
-  "_resolution": {
-    "type": "version",
-    "tag": "v0.10.2",
-    "commit": "dae8b2b1dd7896e2167b043ca5a5625b7e1c0c3d"
-  },
-  "_source": "git://github.com/twada/power-assert.git",
-  "_target": "~0.10",
-  "_originalSource": "power-assert"
-}
\ No newline at end of file
diff --git a/packages/planner/node_modules/deepcopy/bower_components/power-assert/CHANGELOG.md b/packages/planner/node_modules/deepcopy/bower_components/power-assert/CHANGELOG.md
deleted file mode 100644
index 33b6aba4..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/power-assert/CHANGELOG.md
+++ /dev/null
@@ -1,217 +0,0 @@
-### [0.10.2](https://github.com/twada/power-assert/releases/tag/v0.10.2) (2015-02-16)
-
-
-#### Bug Fixes
-
-* **power-assert:**
-  * update power-assert-formatter to 0.10.2 ([2c0f9624](https://github.com/twada/power-assert/commit/2c0f962415d60e59affb8f009ae4822f7b503c92)) to apply [stringifier fix]([67a9fa72](https://github.com/twada/stringifier/commit/67a9fa725c7602f948772f4f5f5a74806809ee34))
-
-
-#### Features
-
-* **power-assert:**
-  * ship npm module with built bundle for browsers ([431769f3](https://github.com/twada/power-assert/commit/431769f3d5da68c279ebf59b0cfd1231fa385361))
-  * add Node 0.12 and io.js to Travis build ([dd9629f9](https://github.com/twada/power-assert/commit/dd9629f96f3a204f6c24156f648b172f7c6abd4c))
-
-
-### [0.10.1](https://github.com/twada/power-assert/releases/tag/v0.10.1) (2015-01-09)
-
-
-#### Bug Fixes
-
-* **power-assert:**
-  * apply [assert.deepEqual fix](https://github.com/substack/node-browserify/pull/1041) in browserify 8.1.0 ([96302406](https://github.com/twada/power-assert/commit/963024062e6c144f2d5487d788e883f418a9c746))
-  * apply [dereserve](https://github.com/twada/dereserve) to browser build
-
-
-## [0.10.0](https://github.com/twada/power-assert/releases/tag/v0.10.0) (2014-11-12)
-
-
-#### Features
-
-* **power-assert:**
-  * [provide API for customization](https://github.com/twada/power-assert/pull/14) (see [CUSTOMIZATION API](https://github.com/twada/power-assert#customization-api))
-
-* **power-assert-formatter:**
-  * [diff option to make string diff function pluggable](https://github.com/twada/power-assert-formatter/pull/11) (new option [options.diff](https://github.com/twada/power-assert-formatter#optionsdiff))
-  * [outputOffset option to configure number of spaces inserted at the left](https://github.com/twada/power-assert-formatter/pull/12) (new option [options.outputOffset](https://github.com/twada/power-assert-formatter#optionsoutputoffset))
-  * [ambiguousEastAsianCharWidth option to make ambiguous east asian character width configurable](https://github.com/twada/power-assert-formatter/pull/13) (new option [options.ambiguousEastAsianCharWidth](https://github.com/twada/power-assert-formatter#optionsambiguouseastasiancharwidth))
-
-* **espowerify:**
-  * [transform file if and only if it is listed in browserify entries](https://github.com/twada/espowerify/pull/5)
-
-
-### 0.9.1 (2014-10-08)
-
-
-#### Bug Fixes
-
-* **empower:**
-  * power-assert output doesn't appear in Node 0.11.x ([53e882e0](https://github.com/twada/empower/commit/53e882e00ad3dd8b45f262ab14ac782ed582b954))
-
-
-## 0.9.0 (2014-09-02)
-
-
-#### Features
-
-Now power-assert 0.9.0 supports multi-stage sourcemaps.
-
-* **power-assert:**
-  * update empower and power-assert-formatter to 0.9.0 ([a84ca4e1](https://github.com/twada/power-assert/commit/a84ca4e1e67e6146452622743915bd78a5f417d0))
-
-* **empower:**
-  * There's no significant changes
-
-* **power-assert-formatter:**
-  * [Customizable Renderers](https://github.com/twada/power-assert-formatter/pull/10)
-  * move built-in renderers to ./built-in/ ([acf85109](https://github.com/twada/power-assert-formatter/commit/acf85109bcb579109b80a36a8a6439c4e028066d))
-  * customize rendering by using custom renderer constructor in `renderers` option ([265d3539](https://github.com/twada/power-assert-formatter/commit/265d353997f7321e9e24c5252c7aa0f4c696624a))
-  * use EventEmitter to make renderers customizable ([7c190e11](https://github.com/twada/power-assert-formatter/commit/7c190e1170de8c96129a2ccd3e67fd9f14623732))
-
-* **espower:**
-  * [SourceMap support](https://github.com/twada/espower/pull/11)
-  * adjust filepath in power-assert output if sourceMap option is given ([f919d59d](https://github.com/twada/espower/commit/f919d59d6eea764881e0266f562724b7142f7695))
-  * adjust line number in power-assert output if sourceMap option is given ([8c035d89](https://github.com/twada/espower/commit/8c035d89ae88c8554cb8ca0b6bd0f7d6fe2008b0))
-
-* **espower-source:**
-  * backport espowerify to support multi-stage sourcemaps ([71de737c](https://github.com/twada/espower-source/commit/71de737cb16231db852a44592e896a43c447298b))
-
-* **espower-loader:**
-  * use espower-source 0.9.0 ([c5329f39](https://github.com/twada/espower-loader/commit/c5329f397d4ab8e434a1788d0fa1c2eb7670a25c))
-
-* **grunt-espower:**
-  * [support multistage sourcemap by @vvakame](https://github.com/twada/grunt-espower/pull/2)
-  * Thanks @vvakame for the great contribution!
-
-* **gulp-espower:**
-  * [support gulp-sourcemaps](https://github.com/twada/gulp-espower/pull/2)
-
-* **espowerify:**
-  * use espower-source directly since espower-source 0.9.0 is backported from espowerify ([625cf55d](https://github.com/twada/espowerify/commit/625cf55d5b73893f4babd00c07489590ef786be0))
-  * use multi-stage-sourcemap module to generate more accurate sourcemaps ([b1f939fa](https://github.com/twada/espowerify/commit/b1f939faa84be7f4fde82313b2257042b336d25c))
-  * if upstream SourceMap is given, decode and offset it ([a1683475](https://github.com/twada/espowerify/commit/a1683475a588b0a5b0aee040f23dfb04ad902b11))
-
-* **espower-coffee:**
-  * interact with coffeescript compiler to adjust line number in power-assert output ([9c159205](https://github.com/twada/espower-coffee/commit/9c159205608e6a556f61167d1fb65123ae2421ab))
-
-
-#### Breaking Changes
-
-**No change is required if you are using default configuration.**
-
-* **power-assert-formatter:**
-  * built-in renderers are listed as relative path
-
-If you are customizing renderers by `options.renderers`, you may have to migrate.
-
-To migrate, change your code from the following:
-
-```
-[
-    'file',
-    'assertion',
-    'diagram',
-    'binary-expression'
-]
-```
-
-To:
-
-```
- [
-    './built-in/file',
-    './built-in/assertion',
-    './built-in/diagram',
-    './built-in/binary-expression'
- ]
-```
-
- ([265d3539](https://github.com/twada/power-assert-formatter/commit/265d353997f7321e9e24c5252c7aa0f4c696624a)), ([acf85109](https://github.com/twada/power-assert-formatter/commit/acf85109bcb579109b80a36a8a6439c4e028066d))
-
-
-## 0.8.0 (2014-08-12)
-
-
-#### Features
-
-* **power-assert:**
-  * use single index.js ([e8fa666a](https://github.com/twada/power-assert/commit/e8fa666aa8197747ae56ca1a55fb171d30d7534c))
-  * update empower and power-assert-formatter to 0.8.0 ([8f760aa0](https://github.com/twada/power-assert/commit/8f760aa07271f3bcd52576dc503f3d301d67110c))
-
-* **empower:**
-  * [built and modularized by browserify](https://github.com/twada/empower/pull/12)
-  * use `escallmatch` module to describe target patterns ([533a21a0](https://github.com/twada/empower/commit/533a21a0374f23f5ca4e198c17d1e20f10d705fa))
-  * support assertion methods with three or more arguments ([d31dca86](https://github.com/twada/empower/commit/d31dca86de2b05ee88ca5df15579308368657d43))
-  * if not in patterns, do not empower assertion function itself ([1d73a756](https://github.com/twada/empower/commit/1d73a7560ef586a45a0a9259e57c143b3b60caaa))
-  * option `targetMethods` does not required any more ([8ffcc49f](https://github.com/twada/empower/commit/8ffcc49fcdb5523eb38e63a0e7cca34f752d9302))
-  * rename `saveContextOnFail` option to `saveContextOnRethrow` ([1f6133b2](https://github.com/twada/empower/commit/1f6133b24be672f32cfd3b66522a7d14ca5d22e1))
-  * rename `modifyMessageOnFail` option to `modifyMessageOnRethrow` ([0c8a88f0](https://github.com/twada/empower/commit/0c8a88f0592917ba15ac0c1bf21c8f39f39ab350))
-
-* **power-assert-formatter:**
-  * [built and modularized by browserify](https://github.com/twada/power-assert-formatter/pull/8)
-  * [use spun-off stringifier module](https://github.com/twada/power-assert-formatter/pull/9)
-
-* **espower:**
-  * [built and modularized by browserify](https://github.com/twada/espower/pull/9)
-  * [use escallmatch module to describe instrumentation target patterns](https://github.com/twada/espower/pull/10)
-  * support chained callee like `browser.assert.element(selector)` ([ea0a3ce9](https://github.com/twada/espower/commit/ea0a3ce96f56034ab6735365184e1e397f6561c0))
-
-* **espower-source:**
-  * update espower to 0.8.0 ([ae15a229](https://github.com/twada/espower-source/commit/ae15a229367c65a7a590104f3fb0fc0b2a7582d0))
-  * simple xtend would be better for options handling ([6bea0a92](https://github.com/twada/espower-source/commit/6bea0a9241aba71f2dcae9c285561e68d91531bb))
-
-* **espower-loader:**
-  * update espower-source to 0.8.0 ([54c2143b](https://github.com/twada/espower-loader/commit/54c2143bba3966aaf61f1a4d331f3543257f9222))
-
-* **grunt-espower:**
-  * update espower-source to 0.8.0 ([55110fa4](https://github.com/twada/grunt-espower/commit/55110fa4bffab62045d207d0460eaa864cc9fa8e))
-
-* **gulp-espower:**
-  * update espower-source to 0.8.0 ([a9ab1f7d](https://github.com/twada/gulp-espower/commit/a9ab1f7de7275b717589bd8eb8048b89bc575763))
-  * now supports streams as well ([ada19f90](https://github.com/twada/gulp-espower/commit/ada19f90f0dfc674405342310259e31ddd3a6dd0))
-
-* **espowerify:**
-  * update espower-source to 0.8.0 ([026bd0c6](https://github.com/twada/espowerify/commit/026bd0c6e2d1200084051612dc262ab5509a5652))
-
-* **espower-coffee:**
-  * update espower-source to 0.8.0 ([8702d847](https://github.com/twada/espower-coffee/commit/8702d84704d659919e96801014c4653539b7b3f0))
-  * [now in beta stage](https://github.com/twada/espower-coffee/commit/a357b3d35460b9abd17517375d737a8a0bce98dd)
-
-
-#### Breaking Changes
-
-First of all, **No change is required if you are using default configuration.**
-
-* **instrumentors:**
-
-  Version 0.8.0 introduces [escallmatch](https://github.com/twada/escallmatch) syntax for configuration.
-  
-  If you are:
-    * using instrumentors such as `espower-loader`, `grunt-espower`, `gulp-espower`, `espowerify` and `espower-coffee`
-    * or using `espower-source` or `espower` directly
-
-  And
-
-    * having custom instrumentation pattern using `powerAssertVariableName` or `targetMethods` property
-  
-  Then you need to migarte. To migrate, please see CHANGELOG for the instrumentor you choose.
-
-  * [espower-loader CHANGELOG](https://github.com/twada/espower-loader/blob/master/CHANGELOG.md)
-  * [grunt-espower CHANGELOG](https://github.com/twada/grunt-espower/blob/master/CHANGELOG.md)
-  * [gulp-espower CHANGELOG](https://github.com/twada/gulp-espower/blob/master/CHANGELOG.md)
-  * [espowerify CHANGELOG](https://github.com/twada/espowerify/blob/master/CHANGELOG.md)
-  * [espower-coffee CHANGELOG](https://github.com/twada/espower-coffee/blob/master/CHANGELOG.md)
-  * [espower-source CHANGELOG](https://github.com/twada/espower-source/blob/master/CHANGELOG.md)
-  * [espower CHANGELOG](https://github.com/twada/espower/blob/master/CHANGELOG.md)
-
-
-* **empower:**
-  * `saveContextOnFail` option is renamed to `saveContextOnRethrow`
-  * `modifyMessageOnFail` option is renamed to `modifyMessageOnRethrow`
-  * option `targetMethods` does not required any more
-  * Please see [empower CHANGELOG](https://github.com/twada/empower/blob/master/CHANGELOG.md) for more details.
-
-* **power-assert-formatter:**
-  * option `stringifyDepth` does not supported any more. use `maxDepth` option instead.
-  * Please see [power-assert-formatter CHANGELOG](https://github.com/twada/power-assert-formatter/blob/master/CHANGELOG.md) for more details.
diff --git a/packages/planner/node_modules/deepcopy/bower_components/power-assert/MIT-LICENSE.txt b/packages/planner/node_modules/deepcopy/bower_components/power-assert/MIT-LICENSE.txt
deleted file mode 100644
index 60e64e43..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/power-assert/MIT-LICENSE.txt
+++ /dev/null
@@ -1,20 +0,0 @@
-Copyright (c) 2013-2015 Takuto Wada, https://github.com/twada/power-assert
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/packages/planner/node_modules/deepcopy/bower_components/power-assert/README.md b/packages/planner/node_modules/deepcopy/bower_components/power-assert/README.md
deleted file mode 100644
index 00a1558f..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/power-assert/README.md
+++ /dev/null
@@ -1,982 +0,0 @@
-power-assert
-================================
-
-Power Assert in JavaScript. Provides descriptive assertion messages through standard [assert](http://nodejs.org/api/assert.html) interface.
-
-[![Build Status][travis-image]][travis-url]
-[![NPM package][npm-image]][npm-url]
-[![Bower package][bower-image]][bower-url]
-[![Dependency Status][depstat-image]][depstat-url]
-[![License][license-image]][license-url]
-
-
-DESCRIPTION
----------------------------------------
-
-What is `power-assert`?
-
- * is an implementation of "Power Assert" concept in JavaScript.
- * provides descriptive assertion messages through standard [assert](http://nodejs.org/api/assert.html) interface.
- * see slides: ["power-assert, mechanism and philosophy"](http://www.slideshare.net/t_wada/power-assert-nodefest-2014) -- talk at NodeFest 2014.
- * to use power-assert, you need to transform your test code to show power-assert output.
- * with power-assert, you don't need to learn many assertion library APIs. It's just [assert](http://nodejs.org/api/assert.html).
- * fully compatible with [assert](http://nodejs.org/api/assert.html). So you can stop using power-assert and back to assert easily.
- * has [online demo site](http://azu.github.io/power-assert-demo/).
- * works both on server side and browser side.
- * available via [npm](https://www.npmjs.com/package/power-assert) and [bower](http://bower.io/search/?q=power-assert). 
- * supports sourcemaps so you can debug as usual.
- * provides [browserify transform](http://github.com/twada/espowerify).
- * provides [webpack loader](https://github.com/zoncoen/webpack-espower-loader).
- * provides [grunt task](http://github.com/twada/grunt-espower) and [gulp plugin](http://github.com/twada/gulp-espower).
- * provides [command](http://github.com/twada/espower-cli).
- * provides [custom module loader](http://github.com/twada/espower-loader) and its [convenient config module](https://github.com/azu/intelli-espower-loader).
- * provides [karma preprocessor](https://github.com/vvakame/karma-espower-preprocessor).
- * supports ES6 through [Traceur Compiler](https://github.com/yosuke-furukawa/espower-traceur) or [Babel](https://github.com/azu/espower-babel).
- * supports [CoffeeScript](http://github.com/twada/espower-coffee).
- * has [TypeScript type definition](https://github.com/borisyankov/DefinitelyTyped/blob/master/power-assert/power-assert.d.ts)
- * is a beta version product. Pull-requests, issue reports and patches are always welcomed.
-
-
-`power-assert` provides descriptive assertion messages for your tests, like this.
-
-      1) Array #indexOf() should return index when the value is present:
-         AssertionError: # /path/to/test/mocha_node.js:10
-    
-      assert(this.ary.indexOf(zero) === two)
-                  |   |       |     |   |
-                  |   |       |     |   2
-                  |   -1      0     false
-                  [1,2,3]
-    
-      [number] two
-      => 2
-      [number] this.ary.indexOf(zero)
-      => -1
-
-
-API
----------------------------------------
-
-power-assert enhances these assert functions. Produces descriptive message when assertion is failed.
-
-* `assert(value, [message])`
-* `assert.ok(value, [message])`
-* `assert.equal(actual, expected, [message])`
-* `assert.notEqual(actual, expected, [message])`
-* `assert.strictEqual(actual, expected, [message])`
-* `assert.notStrictEqual(actual, expected, [message])`
-* `assert.deepEqual(actual, expected, [message])`
-* `assert.notDeepEqual(actual, expected, [message])`
-
-power-assert is fully compatible with [assert](http://nodejs.org/api/assert.html). So functions below are also available though they are not enhanced (does not produce descriptive message).
-
-* `assert.fail(actual, expected, message, operator)`
-* `assert.throws(block, [error], [message])`
-* `assert.doesNotThrow(block, [message])`
-* `assert.ifError(value)`
-
-power-assert provides an [API for customization](https://github.com/twada/power-assert#customization-api).
-
-* `assert.customize(options)`
-
-As written below, power-assert is constructed with many family modules. See more details of [empower](http://github.com/twada/empower) and others.
-
-
-CHANGELOG
----------------------------------------
-See [CHANGELOG](https://github.com/twada/power-assert/blob/master/CHANGELOG.md)
-
-
-EXAMPLE
----------------------------------------
-
-See [HOW TO USE](https://github.com/twada/power-assert#how-to-use) section for more details.
-
-__Note:__ There is an [online demo site](http://azu.github.io/power-assert-demo/) available.
-
-
-### Target test code (using Mocha in this example)
-
-```javascript
-var assert = require('power-assert');
-
-describe('Array', function(){
-    beforeEach(function(){
-        this.ary = [1,2,3];
-    });
-    describe('#indexOf()', function(){
-        it('should return index when the value is present', function(){
-            var zero = 0, two = 2;
-            assert(this.ary.indexOf(zero) === two);
-        });
-        it('should return -1 when the value is not present', function(){
-            var minusOne = -1, two = 2;
-            assert.ok(this.ary.indexOf(two) === minusOne, 'THIS IS AN ASSERTION MESSAGE');
-        });
-    });
-});
-
-describe('various types', function(){
-    function Person(name, age) {
-        this.name = name;
-        this.age = age;
-    }
-    beforeEach(function(){
-        this.types = [
-            'string', 98.6, true, false, null, undefined,
-            ['nested', 'array'],
-            {object: true},
-            NaN, Infinity,
-            /^not/,
-            new Person('alice', 3)
-        ];
-    });
-    it('demo', function(){
-        var index = this.types.length -1,
-            bob = new Person('bob', 5);
-        assert(this.types[index].name === bob.name);
-    });
-});
-```
-
-### Be sure to transform test code
-
-To use power-assert, you need to transform your test code for power-assert output.
-
-Code transform is done by instrumentors below:
-
- - [espower-loader](http://github.com/twada/espower-loader) (with [intelli-espower-loader](https://github.com/azu/intelli-espower-loader))
- - [espower-cli](http://github.com/twada/espower-cli)
- - [espowerify](http://github.com/twada/espowerify)
- - [webpack-espower-loader](https://github.com/zoncoen/webpack-espower-loader).
- - [grunt-espower](http://github.com/twada/grunt-espower)
- - [gulp-espower](http://github.com/twada/gulp-espower)
- - [karma-espower-preprocessor](https://github.com/vvakame/karma-espower-preprocessor)
- - [espower-coffee](http://github.com/twada/espower-coffee)
- - [espower-traceur](https://github.com/yosuke-furukawa/espower-traceur)
- - [espower-babel](https://github.com/azu/espower-babel)
-
-If you are using Node.js only, the easiest way is to use [intelli-espower-loader](https://github.com/azu/intelli-espower-loader). Steps are as follows.
-
-
-### Setup
-
-`npm install --save-dev mocha power-assert intelli-espower-loader`
-
-### Add directories to package.json
-
-```json
-  "directories": {
-    "test": "test/"
-  },
-```
-
-### See the power-assert output appears.
-
-      $ mocha --require intelli-espower-loader /path/to/test/mocha_node.js
-    
-      Array
-        #indexOf()
-          1) should return index when the value is present
-          2) should return -1 when the value is not present
-      
-      various types
-        3) demo    
-    
-      0 passing (14 ms)
-      3 failing
-    
-      1) Array #indexOf() should return index when the value is present:
-         AssertionError: # /path/to/test/mocha_node.js:10
-      
-        assert(this.ary.indexOf(zero) === two)
-                    |   |       |     |   |
-                    |   |       |     |   2
-                    |   -1      0     false
-                    [1,2,3]
-        
-        [number] two
-        => 2
-        [number] this.ary.indexOf(zero)
-        => -1
-
-          at decoratedAssert (/path/to/node_modules/power-assert/node_modules/empower/lib/decorate.js:44:26)
-          at powerAssert (/path/to/node_modules/power-assert/node_modules/empower/index.js:57:32)
-          at Context.<anonymous> (/path/to/test/mocha_node.js:13:13)
-      
-      
-      2) Array #indexOf() should return -1 when the value is not present:
-         AssertionError: THIS IS AN ASSERTION MESSAGE # /path/to/test/mocha_node.js:14
-    
-        assert.ok(this.ary.indexOf(two) === minusOne, 'THIS IS AN ASSERTION MESSAGE')
-                       |   |       |    |   |
-                       |   |       |    |   -1
-                       |   1       2    false
-                       [1,2,3]
-        
-        [number] minusOne
-        => -1
-        [number] this.ary.indexOf(two)
-        => 1
-      
-          at Function.decoratedAssert [as ok] (/path/to/node_modules/power-assert/node_modules/empower/lib/decorate.js:44:26)
-          at Context.<anonymous> (/path/to/test/mocha_node.js:21:20)
-      
-      
-      3) various types demo:
-         AssertionError: # /path/to/test/mocha_node.js:37
-    
-        assert(this.types[index].name === bob.name)
-                    |    ||      |    |   |   |
-                    |    ||      |    |   |   "bob"
-                    |    ||      |    |   Person{name:"bob",age:5}
-                    |    ||      |    false
-                    |    |11     "alice"
-                    |    Person{name:"alice",age:3}
-                    ["string",98.6,true,false,null,undefined,#Array#,#Object#,NaN,Infinity,/^not/,#Person#]
-        
-        --- [string] bob.name
-        +++ [string] this.types[index].name
-        @@ -1,3 +1,5 @@
-        -bob
-        +alice
-        
-        
-          at decoratedAssert (/path/to/node_modules/power-assert/node_modules/empower/lib/decorate.js:44:26)
-          at powerAssert (/path/to/node_modules/power-assert/node_modules/empower/index.js:57:32)
-          at Context.<anonymous> (/path/to/test/mocha_node.js:55:9)
-
-
-SEED PROJECTS
----------------------------------------
-
-Some seed projects are available to help you start with power-assert.
-
-| module | env | tech stack |
-|:-------|:------------|:------------|
-| [power-assert-node-seed](https://github.com/azu/power-assert-node-seed) | Node.js | power-assert + [intelli-espower-loader](https://github.com/azu/intelli-espower-loader) |
-| [power-assert-testem-seed](https://github.com/azu/power-assert-testem-seed) | Browsers(by [testem](https://github.com/airportyh/testem)) | power-assert + [gulp-espower](http://github.com/twada/gulp-espower) + [testem](https://github.com/airportyh/testem). |
-| [power-assert-karma-seed](https://github.com/azu/power-assert-karma-seed) | Browsers(by [Karma](http://karma-runner.github.io/)) | power-assert + [espowerify](http://github.com/twada/espowerify) + [browserify](http://browserify.org/) + [Karma](http://karma-runner.github.io/). |
-
-
-HOW TO USE
----------------------------------------
-
-There are four ways to use power-assert. (If you want to see running examples, see [SEED PROJECTS](#seed-projects))
-
-1. `power-assert` + `espower-loader`: Highly recommended but only works under Node.
-2. `power-assert` + `espower-coffee` or `espower-traceur` or `espower-babel` : Use power-assert through transpilers. Recommended but only works under Node.
-3. `power-assert` + `espowerify` or `webpack-espower-loader`: Recommended if you are using [browserify](http://browserify.org/) or [webpack](http://webpack.github.io/).
-4. `power-assert` + `espower-cli` or `grunt-espower` or `gulp-espower` : Generate instrumented code so works anywhere.
-
-
-### using `espower-loader`
-
-If you are writing Node.js app/module, you can instrument Power Assert feature without code generation by using `espower-loader`.
-
-First, install `power-assert` and `espower-loader` via npm.
-
-    $ npm install --save-dev power-assert espower-loader
-
-Second, require `power-assert` in your test.
-
-    --- a/test/your_test.js
-    +++ b/test/your_test.js
-    @@ -1,4 +1,4 @@
-    -var assert = require('assert');
-    +var assert = require('power-assert');
-
-
-Third, put `enable-power-assert.js` somewhere in your project, where `pattern` matches to target test files.
-
-```javascript
-require('espower-loader')({
-    // directory where match starts with
-    cwd: process.cwd(),
-    // glob pattern using minimatch module
-    pattern: 'test/**/*.js'
-});
-```
-
-Then run mocha, with `--require` option. No code generation required.
-
-    $ mocha --require ./path/to/enable-power-assert test/your_test.js
-
-
-FYI: You may be interested in [intelli-espower-loader](https://github.com/azu/intelli-espower-loader) to go one step further. With [intelli-espower-loader](https://github.com/azu/intelli-espower-loader), you don't need to create loader file (like `enable-power-assert.js`). Just define test directory in `package.json` wow!
-
-
-### using `espower-coffee`
-
-If you are writing Node.js app/module in CoffeeScript, you can instrument Power Assert feature without code generation by using `espower-coffee`.
-
-see [espower-coffee README](https://github.com/twada/espower-coffee).
-
-
-### using `espower-traceur` or `espower-babel`
-
-If you are writing Node.js app/module in ES6, you can instrument Power Assert feature without code generation by using `espower-traceur` or `espower-babel`. `espower-traceur` uses [Traceur Compiler](https://github.com/google/traceur-compiler/), `espower-babel` uses [Babel](https://babeljs.io/).
-
-see [espower-traceur README](https://github.com/yosuke-furukawa/espower-traceur) or [espower-babel README](https://github.com/azu/espower-babel).
-
-
-### using `espowerify`
-
-On the browser side and you are using [browserify](http://browserify.org/), you can instrument Power Assert feature via `espowerify`.
-
-see [espowerify README](https://github.com/twada/espowerify).
-
-
-### using `webpack-espower-loader`
-
-If you are using [webpack](http://webpack.github.io/), you can instrument Power Assert feature via `webpack-espower-loader`.
-
-see [webpack-espower-loader README](https://github.com/zoncoen/webpack-espower-loader).
-
-
-
-### using `espower-cli`
-
-On the browser side and you don't want to use grunt,gulp or browserify, you can use `power-assert` via bower, with generated code by `espower-cli`
-
-First, install `power-assert` via bower and `espower-cli` via npm. This means that you run `espower` command (on Node), then run tests on browser.
-
-    $ bower install --save-dev power-assert
-    $ npm install --save-dev espower-cli
-
-Second, require `build/power-assert.js` (all-in-one build for browsers) in your test html.
-
-    <script type="text/javascript" src="./path/to/bower_components/power-assert/build/power-assert.js"></script>
-
-Then, generate espowered code.
-
-    $ espower test/your_test.js > powered/your_test.js
-
-Lastly, run your test in your way. For example,
-
-    $ mocha-phantomjs path/to/test.html
-
-
-
-### using `grunt-espower`
-
-On the browser side and you are not using [browserify](http://browserify.org/) but [bower](http://bower.io/) and [Grunt](http://gruntjs.com/), you can use `power-assert` via bower, with generated code by `grunt-espower`
-
-First, install `power-assert` via bower and `grunt-espower` via npm. This means that you run grunt (on Node), then run tests on browser.
-
-    $ bower install --save-dev power-assert
-    $ npm install --save-dev grunt-espower
-
-Second, require `build/power-assert.js` (all-in-one build for browsers) in your test html.
-
-    <script type="text/javascript" src="./path/to/bower_components/power-assert/build/power-assert.js"></script>
-
-Third, configure `grunt-espower` task to  generate espowered code.
-
-```javascript
-grunt.initConfig({
-
-  . . . 
-
-  espower: {
-    test: {
-      files: [
-        {
-          expand: true,        // Enable dynamic expansion.
-          cwd: 'test/',        // Src matches are relative to this path.
-          src: ['**/*.js'],    // Actual pattern(s) to match.
-          dest: 'espowered/',  // Destination path prefix.
-          ext: '.js'           // Dest filepaths will have this extension.
-        }
-      ]
-    },
-  },
-
-  . . . 
-
-})
-```
-
-Then, generate espowered code using `espower` task.
-
-    $ grunt espower:test
-
-Lastly, run your test in your way. For example,
-
-    $ grunt test
-
-
-
-
-### using `gulp-espower`
-
-On the browser side and you are not using [browserify](http://browserify.org/) but [bower](http://bower.io/) and [gulp](http://gulpjs.com/), you can use `power-assert` via bower, with generated code by `gulp-espower`
-
-First, install `power-assert` via bower and `gulp-espower` via npm. This means that you run gulp (on Node), then run tests on browser.
-
-    $ bower install --save-dev power-assert
-    $ npm install --save-dev gulp-espower
-
-Second, require `build/power-assert.js` (all-in-one build for browsers) in your test html.
-
-    <script type="text/javascript" src="./path/to/bower_components/power-assert/build/power-assert.js"></script>
-
-Third, configure `gulp-espower` task to generate espowered code.
-
-```javascript
-var gulp = require('gulp'),
-    espower = require('gulp-espower');
-  . . . 
-gulp.task('espower', function() {
-    return gulp
-        .src('test/**/*_test.js', {base: './test/'})
-        .pipe(espower())
-        .pipe(gulp.dest('espowered'));
-});
-  . . . 
-})
-```
-
-Then, generate espowered code (in this example, using `espower` task).
-
-    $ gulp espower
-
-Lastly, run your test in your way. For example,
-
-    $ gulp test
-
-
-
-
-CUSTOMIZATION API
----------------------------------------
-
-`power-assert` provides an API for customization.
-
-### var assert = assert.customize(options)
-
-Through this API, you can customize power-assert by changing some options.
-
-```javascript
-var assert = require('power-assert').customize({
-    output: {
-        maxDepth: 2
-    }
-});
-```
-
-### options
-
-`options` has two top-level keys. `assertion` and `output`.
-
-#### options.assertion
-
-customization options for [empower](http://github.com/twada/empower) module. See [empower API documentation](https://github.com/twada/empower#api) for details. Note that some default values are different from `empower`'s (`modifyMessageOnRethrow: true` and `saveContextOnRethrow: true`).
-
-#### options.output
-
-customization options for [power-assert-formatter](http://github.com/twada/power-assert-formatter) module. See [power-assert-formatter API documentation](https://github.com/twada/power-assert-formatter#api) for details.
-
-#### default values
-
-customizable properties and their default values are as follows.
-
-```
-var assert = require('power-assert').customize({
-    assertion: {
-        destructive: false,
-        modifyMessageOnRethrow: true,
-        saveContextOnRethrow: true,
-        patterns: [
-            'assert(value, [message])',
-            'assert.ok(value, [message])',
-            'assert.equal(actual, expected, [message])',
-            'assert.notEqual(actual, expected, [message])',
-            'assert.strictEqual(actual, expected, [message])',
-            'assert.notStrictEqual(actual, expected, [message])',
-            'assert.deepEqual(actual, expected, [message])',
-            'assert.notDeepEqual(actual, expected, [message])'
-        ]
-    },
-    output: {
-        lineDiffThreshold: 5,
-        maxDepth: 1,
-        anonymous: 'Object',
-        circular: '#@Circular#',
-        lineSeparator: '\n',
-        ambiguousEastAsianCharWidth: 2,
-        widthOf: (Function to calculate width of string. Please see power-assert-formatter's documentation)
-        stringify: (Function to stringify any target value. Please see power-assert-formatter's documentation)
-        diff: (Function to create diff string between two strings. Please see power-assert-formatter's documentation)
-        writerClass: (Constructor Function for output writer class. Please see power-assert-formatter's documentation)
-        renderers: [
-            './built-in/file',
-            './built-in/assertion',
-            './built-in/diagram',
-            './built-in/binary-expression'
-        ]
-    }
-});
-```
-
-
-INTERNAL DESIGN
----------------------------------------
-
-`power-assert` family provides 1 main module, 4 core modules and many more instrumentors.
-
-
-Main (facade) module is,
-
-| module | description |
-|:-------|:------------|
-| [power-assert](http://github.com/twada/power-assert) | Standard `assert` function on top of `empower` and `power-assert-formatter` |
-
-core modules are,
-
-| module | description |
-|:-------|:------------|
-| [empower](http://github.com/twada/empower) | Power Assert feature enhancer for assert function/object. |
-| [power-assert-formatter](http://github.com/twada/power-assert-formatter) | Power Assert output formatter. |
-| [espower](http://github.com/twada/espower) | Power Assert feature instrumentor core based on the [Mozilla JavaScript AST](https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API). |
-| [espower-source](http://github.com/twada/espower-source) | Power Assert instrumentor from source to source, with source-map. (Thin wrapper of `espower`). |
-
-and instrumentors are,
-
-| module | description |
-|:-------|:------------|
-| [espower-cli](http://github.com/twada/espower-cli) | Command line tool for power-assert. |
-| [espower-loader](http://github.com/twada/espower-loader) | Node module loader to apply `espower` on the fly. |
-| [intelli-espower-loader](https://github.com/azu/intelli-espower-loader) | configure `espower-loader` with ease. |
-| [espowerify](http://github.com/twada/espowerify) | [Browserify](http://browserify.org/) transform to apply `espower` to target files. |
-| [webpack-espower-loader](https://github.com/zoncoen/webpack-espower-loader) | Power Assert instrumentor module for [webpack](http://webpack.github.io/). |
-| [grunt-espower](http://github.com/twada/grunt-espower) | Grunt task to apply `espower` to target files. |
-| [gulp-espower](http://github.com/twada/gulp-espower) | Gulp plugin to apply `espower` to target files. |
-| [karma-espower-preprocessor](https://github.com/vvakame/karma-espower-preprocessor) | karma-preprocessor for power-assert. |
-| [espower-coffee](http://github.com/twada/espower-coffee) | power-assert instrumentor for CoffeeScript. |
-| [espower-traceur](https://github.com/yosuke-furukawa/espower-traceur) | power-assert instrumentor for ES6 using [Traceur Compiler](https://github.com/google/traceur-compiler/). |
-| [espower-babel](https://github.com/azu/espower-babel) | power-assert instrumentor for ES6 using [Babel](https://babeljs.io/). |
-
-
-`power-assert` provides standard [assert](http://nodejs.org/api/assert.html) compatible function with Power Assert feature.
-(Best fit with [Mocha](http://visionmedia.github.io/mocha/). If you use assert-like objects provided by various testing frameworks such as [QUnit](http://qunitjs.com/) or [nodeunit](https://github.com/caolan/nodeunit). Please use [empower](http://github.com/twada/empower) and [power-assert-formatter](http://github.com/twada/power-assert-formatter) modules directly).
-
-
-Internally, `power-assert` uses [empower](http://github.com/twada/empower) module to enhance power assert feature into the standard [assert](http://nodejs.org/api/assert.html) module, to run with the power assert feature added code by [espower](http://github.com/twada/espower) module, and prettify output using [power-assert-formatter](http://github.com/twada/power-assert-formatter).
-
-
-See [power-assert-demo](http://github.com/twada/power-assert-demo) project for power-assert Demo running with mocha.
-
-
-TESTED FRAMEWORKS
----------------------------------------
-* [Mocha](http://visionmedia.github.io/mocha/)
-* [QUnit](http://qunitjs.com/)
-* [nodeunit](https://github.com/caolan/nodeunit)
-* [buster-assertions](http://docs.busterjs.org/en/latest/modules/buster-assertions/)
-
-
-TESTED ENVIRONMENTS
----------------------------------------
-* [Node.js](http://nodejs.org/)
-* [Rhino](https://developer.mozilla.org/en/Rhino)
-* [PhantomJS](http://phantomjs.org/)
-* [RequireJS](http://requirejs.org/)
-* [Browserify](http://browserify.org/)
-
-
-AUTHOR
----------------------------------------
-* [Takuto Wada](http://github.com/twada)
-
-
-CONTRIBUTORS
----------------------------------------
-* [azu](https://github.com/azu)
-* [vvakame](https://github.com/vvakame)
-
-
-LICENSE
----------------------------------------
-Licensed under the [MIT](https://github.com/twada/power-assert/blob/master/MIT-LICENSE.txt) license.
-
-
-
-MORE OUTPUT EXAMPLES
----------------------------------------
-
-### Target test code (using QUnit in this example)
-
-```javascript
-var q = require('qunitjs');
-
-(function () {
-    var empower = require('empower'),
-        formatter = require('power-assert-formatter'),
-        qunitTap = require("qunit-tap");
-    empower(q.assert, formatter(), {destructive: true});
-    qunitTap(q, require('util').puts, {showSourceOnFailure: false});
-    q.config.autorun = false;
-})();
-
-q.test('spike', function (assert) {
-    assert.ok(true);
-
-    var hoge = 'foo';
-    var fuga = 'bar';
-    assert.ok(hoge === fuga, 'comment');
-
-    var piyo = 3;
-    assert.ok(fuga === piyo);
-
-    var longString = 'very very loooooooooooooooooooooooooooooooooooooooooooooooooooong message';
-    var anotherLongString = 'yet another loooooooooooooooooooooooooooooooooooooooooooooooooooong message';
-    assert.ok(longString === anotherLongString);
-
-    assert.ok(4 === piyo);
-
-    assert.ok(4 !== 4);
-
-    var falsyStr = '';
-    assert.ok(falsyStr);
-
-    var falsyNum = 0;
-    assert.ok(falsyNum);
-
-    var ary1 = ['foo', 'bar'];
-    var ary2 = ['aaa', 'bbb', 'ccc'];
-    assert.ok(ary1.length === ary2.length);
-    assert.deepEqual(ary1, ary2);
-
-    var actual = 16;
-    assert.ok(5 < actual && actual < 13);
-
-    actual = 4;
-    assert.ok(5 < actual && actual < 13);
-
-    actual = 10;
-    assert.ok(actual < 5 || 13 < actual);
-
-
-    var propName = 'bar',
-        foo = {
-            bar: {
-                baz: false
-            }
-        };
-
-    assert.ok(foo.bar.baz);
-    assert.ok(foo['bar'].baz);
-    assert.ok(foo[propName]['baz']);
-
-
-    var truth = true;
-    assert.ok(!truth);
-
-
-    var func = function () { return false; };
-    assert.ok(func());
-
-
-    var obj = {
-        age: function () {
-            return 0;
-        }
-    };
-    assert.ok(obj.age());
-
-
-    var isFalsy = function (arg) {
-        return !(arg);
-    };
-    var positiveInt = 50;
-    assert.ok(isFalsy(positiveInt));
-
-
-    var sum = function () {
-        var result = 0;
-        for (var i = 0; i < arguments.length; i += 1) {
-            result += arguments[i];
-        }
-        return result;
-    };
-    var one = 1, two = 2, three = 3, seven = 7, ten = 10;
-    assert.ok(sum(one, two, three) === seven);
-    assert.ok(sum(sum(one, two), three) === sum(sum(two, three), seven));
-    assert.ok((three * (seven * ten)) === three);
-
-
-    var math = {
-        calc: {
-            sum: function () {
-                var result = 0;
-                for (var i = 0; i < arguments.length; i += 1) {
-                    result += arguments[i];
-                }
-                return result;
-            }
-        }
-    };
-    assert.ok(math.calc.sum(one, two, three) === seven);
-});
-
-q.load();
-```
-
-
-### `espower` code above then running under Node.js
-    
-```
-# module: undefined
-# test: spike
-ok 1 - okay
-not ok 2 - comment # /path/to/examples/qunit_node.js:17
-#
-# assert.ok(hoge === fuga, 'comment')
-#           |    |   |
-#           |    |   "bar"
-#           |    false
-#           "foo"
-#
-# --- [string] fuga
-# +++ [string] hoge
-# @@ -1,3 +1,3 @@
-# -bar
-# +foo
-#
-# , test: spike
-not ok 3 - # /path/to/examples/qunit_node.js:20
-#
-# assert.ok(fuga === piyo)
-#           |    |   |
-#           |    |   3
-#           |    false
-#           "bar"
-#
-# [number] piyo
-# => 3
-# [string] fuga
-# => "bar"
-
-# , test: spike
-not ok 4 - # /path/to/examples/qunit_node.js:24
-#
-# assert.ok(longString === anotherLongString)
-#           |          |   |
-#           |          |   "yet another loooooooooooooooooooooooooooooooooooooooooooooooooooong message"
-#           |          false
-#           "very very loooooooooooooooooooooooooooooooooooooooooooooooooooong message"
-#
-# --- [string] anotherLongString
-# +++ [string] longString
-# @@ -1,15 +1,13 @@
-# -yet anoth
-# +very v
-#  er
-# +y
-#   loo
-#
-# , test: spike
-not ok 5 - # /path/to/examples/qunit_node.js:26
-#
-# assert.ok(4 === piyo)
-#             |   |
-#             |   3
-#             false
-#
-# [number] piyo
-# => 3
-# [number] 4
-# => 4
-# , test: spike
-not ok 6 - # /path/to/examples/qunit_node.js:28
-#
-# assert.ok(4 !== 4)
-#             |
-#             false
-# , test: spike
-not ok 7 - # /path/to/examples/qunit_node.js:31
-#
-# assert.ok(falsyStr)
-#           |
-#           ""
-# , test: spike
-not ok 8 - # /path/to/examples/qunit_node.js:34
-#
-# assert.ok(falsyNum)
-#           |
-#           0
-# , test: spike
-not ok 9 - # /path/to/examples/qunit_node.js:38
-#
-# assert.ok(ary1.length === ary2.length)
-#           |    |      |   |    |
-#           |    |      |   |    3
-#           |    |      |   ["aaa","bbb","ccc"]
-#           |    2      false
-#           ["foo","bar"]
-#
-# [number] ary2.length
-# => 3
-# [number] ary1.length
-# => 2
-# , test: spike
-not ok 10 - # /path/to/examples/qunit_node.js:39
-#
-# assert.deepEqual(ary1, ary2)
-#                  |     |
-#                  |     ["aaa","bbb","ccc"]
-#                  ["foo","bar"]
-# , expected: [
-#   "aaa",
-#   "bbb",
-#   "ccc"
-# ], got: [
-#   "foo",
-#   "bar"
-# ], test: spike
-not ok 11 - # /path/to/examples/qunit_node.js:42
-#
-# assert.ok(5 < actual && actual < 13)
-#             | |      |  |      |
-#             | |      |  16     false
-#             | 16     false
-#             true
-# , test: spike
-not ok 12 - # /path/to/examples/qunit_node.js:45
-#
-# assert.ok(5 < actual && actual < 13)
-#             | |      |
-#             | 4      false
-#             false
-# , test: spike
-not ok 13 - # /path/to/examples/qunit_node.js:48
-#
-# assert.ok(actual < 5 || 13 < actual)
-#           |      |   |     | |
-#           |      |   |     | 10
-#           |      |   false false
-#           10     false
-# , test: spike
-not ok 14 - # /path/to/examples/qunit_node.js:58
-#
-# assert.ok(foo.bar.baz)
-#           |   |   |
-#           |   |   false
-#           |   Object{baz:false}
-#           Object{bar:#Object#}
-# , test: spike
-not ok 15 - # /path/to/examples/qunit_node.js:59
-#
-# assert.ok(foo['bar'].baz)
-#           |  |       |
-#           |  |       false
-#           |  Object{baz:false}
-#           Object{bar:#Object#}
-# , test: spike
-not ok 16 - # /path/to/examples/qunit_node.js:60
-#
-# assert.ok(foo[propName]['baz'])
-#           |  ||        |
-#           |  |"bar"    false
-#           |  Object{baz:false}
-#           Object{bar:#Object#}
-# , test: spike
-not ok 17 - # /path/to/examples/qunit_node.js:64
-#
-# assert.ok(!truth)
-#           ||
-#           |true
-#           false
-# , test: spike
-not ok 18 - # /path/to/examples/qunit_node.js:68
-#
-# assert.ok(func())
-#           |
-#           false
-# , test: spike
-not ok 19 - # /path/to/examples/qunit_node.js:76
-#
-# assert.ok(obj.age())
-#           |   |
-#           |   0
-#           Object{age:#function#}
-# , test: spike
-not ok 20 - # /path/to/examples/qunit_node.js:83
-#
-# assert.ok(isFalsy(positiveInt))
-#           |       |
-#           false   50
-# , test: spike
-not ok 21 - # /path/to/examples/qunit_node.js:94
-#
-# assert.ok(sum(one, two, three) === seven)
-#           |   |    |    |      |   |
-#           |   |    |    |      |   7
-#           6   1    2    3      false
-#
-# [number] seven
-# => 7
-# [number] sum(one, two, three)
-# => 6
-# , test: spike
-not ok 22 - # /path/to/examples/qunit_node.js:95
-#
-# assert.ok(sum(sum(one, two), three) === sum(sum(two, three), seven))
-#           |   |   |    |     |      |   |   |   |    |       |
-#           |   |   |    |     |      |   12  5   2    3       7
-#           6   3   1    2     3      false
-#
-# [number] sum(sum(two, three), seven)
-# => 12
-# [number] sum(sum(one, two), three)
-# => 6
-# , test: spike
-not ok 23 - # /path/to/examples/qunit_node.js:96
-#
-# assert.ok(three * (seven * ten) === three)
-#           |     |  |     | |    |   |
-#           |     |  |     | |    |   3
-#           |     |  |     | 10   false
-#           |     |  7     70
-#           3     210
-#
-# [number] three
-# => 3
-# [number] three * (seven * ten)
-# => 210
-# , test: spike
-not ok 24 - # /path/to/examples/qunit_node.js:110
-#
-# assert.ok(math.calc.sum(one, two, three) === seven)
-#           |    |    |   |    |    |      |   |
-#           |    |    |   |    |    |      |   7
-#           |    |    6   1    2    3      false
-#           |    Object{sum:#function#}
-#           Object{calc:#Object#}
-#
-# [number] seven
-# => 7
-# [number] math.calc.sum(one, two, three)
-# => 6
-# , test: spike
-1..24
-```
-
-Have fun!
-
-
-[npm-url]: https://npmjs.org/package/power-assert
-[npm-image]: https://badge.fury.io/js/power-assert.svg
-
-[bower-url]: http://badge.fury.io/bo/power-assert
-[bower-image]: https://badge.fury.io/bo/power-assert.svg
-
-[travis-url]: http://travis-ci.org/twada/power-assert
-[travis-image]: https://secure.travis-ci.org/twada/power-assert.svg?branch=master
-
-[depstat-url]: https://gemnasium.com/twada/power-assert
-[depstat-image]: https://gemnasium.com/twada/power-assert.svg
-
-[license-url]: https://github.com/twada/power-assert/blob/master/MIT-LICENSE.txt
-[license-image]: http://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat
diff --git a/packages/planner/node_modules/deepcopy/bower_components/power-assert/bower.json b/packages/planner/node_modules/deepcopy/bower_components/power-assert/bower.json
deleted file mode 100644
index 5cf8cdf8..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/power-assert/bower.json
+++ /dev/null
@@ -1,46 +0,0 @@
-{
-  "name": "power-assert",
-  "description": "Power Assert in JavaScript",
-  "main": "build/power-assert.js",
-  "license": "MIT",
-  "ignore": [
-    "**/.*",
-    "package.json",
-    "index.js",
-    "test",
-    "enable_power_assert.js"
-  ],
-  "keywords": [
-    "power-assert",
-    "test",
-    "assert",
-    "testing",
-    "ecmascript",
-    "ast"
-  ],
-  "authors": [
-    {
-      "name": "Takuto Wada",
-      "email": "takuto.wada@gmail.com",
-      "homepage": "https://github.com/twada"
-    },
-    {
-      "name": "azu",
-      "url": "https://github.com/azu"
-    },
-    {
-      "name": "vvakame",
-      "url": "https://github.com/vvakame"
-    }
-  ],
-  "homepage": "https://github.com/twada/power-assert",
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/twada/power-assert.git"
-  },
-  "devDependencies": {
-    "expect": "~0.3.1",
-    "mocha": "~2.1.0",
-    "requirejs": "~2.1.15"
-  }
-}
diff --git a/packages/planner/node_modules/deepcopy/bower_components/power-assert/build/power-assert.js b/packages/planner/node_modules/deepcopy/bower_components/power-assert/build/power-assert.js
deleted file mode 100644
index 113289bb..00000000
--- a/packages/planner/node_modules/deepcopy/bower_components/power-assert/build/power-assert.js
+++ /dev/null
@@ -1,11647 +0,0 @@
-!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.assert=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw (f.code="MODULE_NOT_FOUND", f)}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
-// http://wiki.commonjs.org/wiki/Unit_Testing/1.0
-//
-// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!
-//
-// Originally from narwhal.js (http://narwhaljs.org)
-// Copyright (c) 2009 Thomas Robinson <280north.com>
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the 'Software'), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-// when used in node, this will actually load the util module we depend on
-// versus loading the builtin util module as happens otherwise
-// this is a bug in node module loading as far as I am concerned
-var util = _dereq_('util/');
-
-var pSlice = Array.prototype.slice;
-var hasOwn = Object.prototype.hasOwnProperty;
-
-// 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;
-
-  if (Error.captureStackTrace) {
-    Error.captureStackTrace(this, stackStartFunction);
-  }
-  else {
-    // non v8 browsers so we can have a stacktrace
-    var err = new Error();
-    if (err.stack) {
-      var out = err.stack;
-
-      // try to strip useless frames
-      var fn_name = stackStartFunction.name;
-      var idx = out.indexOf('\n' + fn_name);
-      if (idx >= 0) {
-        // once we have located the function frame
-        // we need to strip out everything before it (and its line)
-        var next_line = out.indexOf('\n', idx + 1);
-        out = out.substring(next_line + 1);
-      }
-
-      this.stack = out;
-    }
-  }
-};
-
-// assert.AssertionError instanceof Error
-util.inherits(assert.AssertionError, Error);
-
-function replacer(key, value) {
-  if (util.isUndefined(value)) {
-    return '' + value;
-  }
-  if (util.isNumber(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.isBuffer(actual) && util.isBuffer(expected)) {
-    if (actual.length != expected.length) return false;
-
-    for (var i = 0; i < actual.length; i++) {
-      if (actual[i] !== expected[i]) return false;
-    }
-
-    return true;
-
-  // 7.2. If the expected value is a Date object, the actual value is
-  // equivalent if it is also a Date object that refers to the same time.
-  } 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;
-  // if one is a primitive, the other must be same
-  if (util.isPrimitive(a) || util.isPrimitive(b)) {
-    return a === b;
-  }
-  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);
-  }
-  var ka = objectKeys(a),
-      kb = objectKeys(b),
-      key, i;
-  // 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;}};
-
-var objectKeys = Object.keys || function (obj) {
-  var keys = [];
-  for (var key in obj) {
-    if (hasOwn.call(obj, key)) keys.push(key);
-  }
-  return keys;
-};
-
-},{"util/":6}],2:[function(_dereq_,module,exports){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-function EventEmitter() {
-  this._events = this._events || {};
-  this._maxListeners = this._maxListeners || undefined;
-}
-module.exports = EventEmitter;
-
-// Backwards-compat with node 0.10.x
-EventEmitter.EventEmitter = EventEmitter;
-
-EventEmitter.prototype._events = undefined;
-EventEmitter.prototype._maxListeners = undefined;
-
-// By default EventEmitters will print a warning if more than 10 listeners are
-// added to it. This is a useful default which helps finding memory leaks.
-EventEmitter.defaultMaxListeners = 10;
-
-// Obviously not all Emitters should be limited to 10. This function allows
-// that to be increased. Set to zero for unlimited.
-EventEmitter.prototype.setMaxListeners = function(n) {
-  if (!isNumber(n) || n < 0 || isNaN(n))
-    throw TypeError('n must be a positive number');
-  this._maxListeners = n;
-  return this;
-};
-
-EventEmitter.prototype.emit = function(type) {
-  var er, handler, len, args, i, listeners;
-
-  if (!this._events)
-    this._events = {};
-
-  // If there is no 'error' event listener then throw.
-  if (type === 'error') {
-    if (!this._events.error ||
-        (isObject(this._events.error) && !this._events.error.length)) {
-      er = arguments[1];
-      if (er instanceof Error) {
-        throw er; // Unhandled 'error' event
-      }
-      throw TypeError('Uncaught, unspecified "error" event.');
-    }
-  }
-
-  handler = this._events[type];
-
-  if (isUndefined(handler))
-    return false;
-
-  if (isFunction(handler)) {
-    switch (arguments.length) {
-      // fast cases
-      case 1:
-        handler.call(this);
-        break;
-      case 2:
-        handler.call(this, arguments[1]);
-        break;
-      case 3:
-        handler.call(this, arguments[1], arguments[2]);
-        break;
-      // slower
-      default:
-        len = arguments.length;
-        args = new Array(len - 1);
-        for (i = 1; i < len; i++)
-          args[i - 1] = arguments[i];
-        handler.apply(this, args);
-    }
-  } else if (isObject(handler)) {
-    len = arguments.length;
-    args = new Array(len - 1);
-    for (i = 1; i < len; i++)
-      args[i - 1] = arguments[i];
-
-    listeners = handler.slice();
-    len = listeners.length;
-    for (i = 0; i < len; i++)
-      listeners[i].apply(this, args);
-  }
-
-  return true;
-};
-
-EventEmitter.prototype.addListener = function(type, listener) {
-  var m;
-
-  if (!isFunction(listener))
-    throw TypeError('listener must be a function');
-
-  if (!this._events)
-    this._events = {};
-
-  // To avoid recursion in the case that type === "newListener"! Before
-  // adding it to the listeners, first emit "newListener".
-  if (this._events.newListener)
-    this.emit('newListener', type,
-              isFunction(listener.listener) ?
-              listener.listener : listener);
-
-  if (!this._events[type])
-    // Optimize the case of one listener. Don't need the extra array object.
-    this._events[type] = listener;
-  else if (isObject(this._events[type]))
-    // If we've already got an array, just append.
-    this._events[type].push(listener);
-  else
-    // Adding the second element, need to change to array.
-    this._events[type] = [this._events[type], listener];
-
-  // Check for listener leak
-  if (isObject(this._events[type]) && !this._events[type].warned) {
-    var m;
-    if (!isUndefined(this._maxListeners)) {
-      m = this._maxListeners;
-    } else {
-      m = EventEmitter.defaultMaxListeners;
-    }
-
-    if (m && m > 0 && this._events[type].length > m) {
-      this._events[type].warned = true;
-      console.error('(node) warning: possible EventEmitter memory ' +
-                    'leak detected. %d listeners added. ' +
-                    'Use emitter.setMaxListeners() to increase limit.',
-                    this._events[type].length);
-      if (typeof console.trace === 'function') {
-        // not supported in IE 10
-        console.trace();
-      }
-    }
-  }
-
-  return this;
-};
-
-EventEmitter.prototype.on = EventEmitter.prototype.addListener;
-
-EventEmitter.prototype.once = function(type, listener) {
-  if (!isFunction(listener))
-    throw TypeError('listener must be a function');
-
-  var fired = false;
-
-  function g() {
-    this.removeListener(type, g);
-
-    if (!fired) {
-      fired = true;
-      listener.apply(this, arguments);
-    }
-  }
-
-  g.listener = listener;
-  this.on(type, g);
-
-  return this;
-};
-
-// emits a 'removeListener' event iff the listener was removed
-EventEmitter.prototype.removeListener = function(type, listener) {
-  var list, position, length, i;
-
-  if (!isFunction(listener))
-    throw TypeError('listener must be a function');
-
-  if (!this._events || !this._events[type])
-    return this;
-
-  list = this._events[type];
-  length = list.length;
-  position = -1;
-
-  if (list === listener ||
-      (isFunction(list.listener) && list.listener === listener)) {
-    delete this._events[type];
-    if (this._events.removeListener)
-      this.emit('removeListener', type, listener);
-
-  } else if (isObject(list)) {
-    for (i = length; i-- > 0;) {
-      if (list[i] === listener ||
-          (list[i].listener && list[i].listener === listener)) {
-        position = i;
-        break;
-      }
-    }
-
-    if (position < 0)
-      return this;
-
-    if (list.length === 1) {
-      list.length = 0;
-      delete this._events[type];
-    } else {
-      list.splice(position, 1);
-    }
-
-    if (this._events.removeListener)
-      this.emit('removeListener', type, listener);
-  }
-
-  return this;
-};
-
-EventEmitter.prototype.removeAllListeners = function(type) {
-  var key, listeners;
-
-  if (!this._events)
-    return this;
-
-  // not listening for removeListener, no need to emit
-  if (!this._events.removeListener) {
-    if (arguments.length === 0)
-      this._events = {};
-    else if (this._events[type])
-      delete this._events[type];
-    return this;
-  }
-
-  // emit removeListener for all listeners on all events
-  if (arguments.length === 0) {
-    for (key in this._events) {
-      if (key === 'removeListener') continue;
-      this.removeAllListeners(key);
-    }
-    this.removeAllListeners('removeListener');
-    this._events = {};
-    return this;
-  }
-
-  listeners = this._events[type];
-
-  if (isFunction(listeners)) {
-    this.removeListener(type, listeners);
-  } else {
-    // LIFO order
-    while (listeners.length)
-      this.removeListener(type, listeners[listeners.length - 1]);
-  }
-  delete this._events[type];
-
-  return this;
-};
-
-EventEmitter.prototype.listeners = function(type) {
-  var ret;
-  if (!this._events || !this._events[type])
-    ret = [];
-  else if (isFunction(this._events[type]))
-    ret = [this._events[type]];
-  else
-    ret = this._events[type].slice();
-  return ret;
-};
-
-EventEmitter.listenerCount = function(emitter, type) {
-  var ret;
-  if (!emitter._events || !emitter._events[type])
-    ret = 0;
-  else if (isFunction(emitter._events[type]))
-    ret = 1;
-  else
-    ret = emitter._events[type].length;
-  return ret;
-};
-
-function isFunction(arg) {
-  return typeof arg === 'function';
-}
-
-function isNumber(arg) {
-  return typeof arg === 'number';
-}
-
-function isObject(arg) {
-  return typeof arg === 'object' && arg !== null;
-}
-
-function isUndefined(arg) {
-  return arg === void 0;
-}
-
-},{}],3:[function(_dereq_,module,exports){
-if (typeof Object.create === 'function') {
-  // implementation from standard node.js 'util' module
-  module.exports = function inherits(ctor, superCtor) {
-    ctor.super_ = superCtor
-    ctor.prototype = Object.create(superCtor.prototype, {
-      constructor: {
-        value: ctor,
-        enumerable: false,
-        writable: true,
-        configurable: true
-      }
-    });
-  };
-} else {
-  // old school shim for old browsers
-  module.exports = function inherits(ctor, superCtor) {
-    ctor.super_ = superCtor
-    var TempCtor = function () {}
-    TempCtor.prototype = superCtor.prototype
-    ctor.prototype = new TempCtor()
-    ctor.prototype.constructor = ctor
-  }
-}
-
-},{}],4:[function(_dereq_,module,exports){
-// shim for using process in browser
-
-var process = module.exports = {};
-var queue = [];
-var draining = false;
-
-function drainQueue() {
-    if (draining) {
-        return;
-    }
-    draining = true;
-    var currentQueue;
-    var len = queue.length;
-    while(len) {
-        currentQueue = queue;
-        queue = [];
-        var i = -1;
-        while (++i < len) {
-            currentQueue[i]();
-        }
-        len = queue.length;
-    }
-    draining = false;
-}
-process.nextTick = function (fun) {
-    queue.push(fun);
-    if (!draining) {
-        setTimeout(drainQueue, 0);
-    }
-};
-
-process.title = 'browser';
-process.browser = true;
-process.env = {};
-process.argv = [];
-process.version = ''; // empty string to avoid regexp issues
-
-function noop() {}
-
-process.on = noop;
-process.addListener = noop;
-process.once = noop;
-process.off = noop;
-process.removeListener = noop;
-process.removeAllListeners = noop;
-process.emit = noop;
-
-process.binding = function (name) {
-    throw new Error('process.binding is not supported');
-};
-
-// TODO(shtylman)
-process.cwd = function () { return '/' };
-process.chdir = function (dir) {
-    throw new Error('process.chdir is not supported');
-};
-process.umask = function() { return 0; };
-
-},{}],5:[function(_dereq_,module,exports){
-module.exports = function isBuffer(arg) {
-  return arg && typeof arg === 'object'
-    && typeof arg.copy === 'function'
-    && typeof arg.fill === 'function'
-    && typeof arg.readUInt8 === 'function';
-}
-},{}],6:[function(_dereq_,module,exports){
-(function (process,global){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-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);
-  }
-
-  // IE doesn't make error fields non-enumerable
-  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
-  if (isError(value)
-      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
-    return formatError(value);
-  }
-
-  // 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);
-    }
-  }
-
-  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);
-  }
-
-  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))
-    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 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, "'");
-      name = ctx.stylize(name, 'string');
-    }
-  }
-
-  return name + ': ' + str;
-}
-
-
-function reduceToSingleString(output, base, braces) {
-  var numLinesEst = 0;
-  var length = output.reduce(function(prev, cur) {
-    numLinesEst++;
-    if (cur.indexOf('\n') >= 0) numLinesEst++;
-    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()`.
-function isArray(ar) {
-  return Array.isArray(ar);
-}
-exports.isArray = 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;
-
-exports.isBuffer = _dereq_('./support/isBuffer');
-
-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));
-};
-
-
-/**
- * Inherit the prototype methods from one constructor into another.
- *
- * The Function.prototype.inherits from lang.js rewritten as a standalone
- * function (not on Function.prototype). NOTE: If this file is to be loaded
- * during bootstrapping this function needs to be rewritten using some native
- * functions as prototype setup using normal JavaScript does not work as
- * expected during bootstrapping (see mirror.js in r114903).
- *
- * @param {function} ctor Constructor function which needs to inherit the
- *     prototype.
- * @param {function} superCtor Constructor function to inherit prototype from.
- */
-exports.inherits = _dereq_('inherits');
-
-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);
-}
-
-}).call(this,_dereq_('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{"./support/isBuffer":5,"_process":4,"inherits":3}],7:[function(_dereq_,module,exports){
-/**
- * power-assert.js - Power Assert in JavaScript.
- *
- * https://github.com/twada/power-assert
- *
- * Copyright (c) 2013-2015 Takuto Wada
- * Licensed under the MIT license.
- *   https://github.com/twada/power-assert/blob/master/MIT-LICENSE.txt
- */
-'use strict';
-
-var baseAssert = _dereq_('assert'),
-    empower = _dereq_('empower'),
-    formatter = _dereq_('power-assert-formatter'),
-    extend = _dereq_('xtend'),
-    empowerOptions = {modifyMessageOnRethrow: true, saveContextOnRethrow: true};
-
-function customize (customOptions) {
-    var options = customOptions || {};
-    var poweredAssert = empower(
-        baseAssert,
-        formatter(options.output),
-        extend(empowerOptions, options.assertion)
-    );
-    poweredAssert.customize = customize;
-    return poweredAssert;
-}
-
-module.exports = customize();
-
-},{"assert":1,"empower":8,"power-assert-formatter":22,"xtend":45}],8:[function(_dereq_,module,exports){
-/**
- * empower - Power Assert feature enhancer for assert function/object.
- *
- * https://github.com/twada/empower
- *
- * Copyright (c) 2013-2014 Takuto Wada
- * Licensed under the MIT license.
- *   https://github.com/twada/empower/blob/master/MIT-LICENSE.txt
- */
-var defaultOptions = _dereq_('./lib/default-options'),
-    Decorator = _dereq_('./lib/decorator'),
-    slice = Array.prototype.slice,
-    extend = _dereq_('xtend/mutable');
-
-/**
- * Enhance Power Assert feature to assert function/object.
- * @param assert target assert function or object to enhance
- * @param formatter power assert format function
- * @param options enhancement options
- * @return enhanced assert function/object
- */
-function empower (assert, formatter, options) {
-    var typeOfAssert = (typeof assert),
-        config;
-    if ((typeOfAssert !== 'object' && typeOfAssert !== 'function') || assert === null) {
-        throw new TypeError('empower argument should be a function or object.');
-    }
-    if (isEmpowered(assert)) {
-        return assert;
-    }
-    config = extend(defaultOptions(), options);
-    switch (typeOfAssert) {
-    case 'function':
-        return empowerAssertFunction(assert, formatter, config);
-    case 'object':
-        return empowerAssertObject(assert, formatter, config);
-    default:
-        throw new Error('Cannot be here');
-    }
-}
-
-function empowerAssertObject (assertObject, formatter, config) {
-    var target = config.destructive ? assertObject : Object.create(assertObject);
-    var decorator = new Decorator(target, formatter, config);
-    return extend(target, decorator.enhancement());
-}
-
-function empowerAssertFunction (assertFunction, formatter, config) {
-    if (config.destructive) {
-        throw new Error('cannot use destructive:true to function.');
-    }
-    var decorator = new Decorator(assertFunction, formatter, config);
-    var enhancement = decorator.enhancement();
-    var powerAssert;
-    if (typeof enhancement === 'function') {
-        powerAssert = function powerAssert () {
-            return enhancement.apply(null, slice.apply(arguments));
-        };
-    } else {
-        powerAssert = function powerAssert () {
-            return assertFunction.apply(null, slice.apply(arguments));
-        };
-    }
-    extend(powerAssert, assertFunction);
-    return extend(powerAssert, enhancement);
-}
-
-function isEmpowered (assertObjectOrFunction) {
-    return (typeof assertObjectOrFunction._capt === 'function') && (typeof assertObjectOrFunction._expr === 'function');
-}
-
-empower.defaultOptions = defaultOptions;
-module.exports = empower;
-
-},{"./lib/decorator":11,"./lib/default-options":12,"xtend/mutable":46}],9:[function(_dereq_,module,exports){
-'use strict';
-
-module.exports = function capturable () {
-    var events = [];
-
-    function _capt (value, espath) {
-        events.push({value: value, espath: espath});
-        return value;
-    }
-
-    function _expr (value, args) {
-        var captured = events;
-        events = [];
-        return {
-            powerAssertContext: {
-                value: value,
-                events: captured
-            },
-            source: {
-                content: args.content,
-                filepath: args.filepath,
-                line: args.line
-            }
-        };
-    }
-
-    return {
-        _capt: _capt,
-        _expr: _expr
-    };
-};
-
-},{}],10:[function(_dereq_,module,exports){
-'use strict';
-
-var slice = Array.prototype.slice;
-
-function decorate (callSpec, decorator) {
-    var func = callSpec.func,
-        thisObj = callSpec.thisObj,
-        numArgsToCapture = callSpec.numArgsToCapture;
-
-    return function decoratedAssert () {
-        var context, message, args = slice.apply(arguments);
-
-        if (args.every(isNotCaptured)) {
-            return func.apply(thisObj, args);
-        }
-
-        var values = args.slice(0, numArgsToCapture).map(function (arg) {
-            if (isNotCaptured(arg)) {
-                return arg;
-            }
-            if (!context) {
-                context = {
-                    source: arg.source,
-                    args: []
-                };
-            }
-            context.args.push({
-                value: arg.powerAssertContext.value,
-                events: arg.powerAssertContext.events
-            });
-            return arg.powerAssertContext.value;
-        });
-
-        if (numArgsToCapture === (args.length - 1)) {
-            message = args[args.length - 1];
-        }
-
-        var invocation = {
-            thisObj: thisObj,
-            func: func,
-            values: values,
-            message: message
-        };
-        return decorator.concreteAssert(invocation, context);
-    };
-}
-
-function isNotCaptured (value) {
-    return !isCaptured(value);
-}
-
-function isCaptured (value) {
-    return (typeof value === 'object') &&
-        (value !== null) &&
-        (typeof value.powerAssertContext !== 'undefined');
-}
-
-module.exports = decorate;
-
-},{}],11:[function(_dereq_,module,exports){
-'use strict';
-
-var escallmatch = _dereq_('escallmatch'),
-    extend = _dereq_('xtend/mutable'),
-    capturable = _dereq_('./capturable'),
-    decorate = _dereq_('./decorate');
-
-
-function Decorator (receiver, formatter, config) {
-    this.receiver = receiver;
-    this.formatter = formatter;
-    this.config = config;
-    this.matchers = config.patterns.map(escallmatch);
-    this.eagerEvaluation = !(config.modifyMessageOnRethrow || config.saveContextOnRethrow);
-}
-
-Decorator.prototype.enhancement = function () {
-    var that = this;
-    var container = this.container();
-    this.matchers.filter(methodCall).forEach(function (matcher) {
-        var methodName = detectMethodName(matcher.calleeAst());
-        if (typeof that.receiver[methodName] === 'function') {
-            var callSpec = {
-                thisObj: that.receiver,
-                func: that.receiver[methodName],
-                numArgsToCapture: numberOfArgumentsToCapture(matcher)
-            };
-            container[methodName] = decorate(callSpec, that);
-        }
-    });
-    extend(container, capturable());
-    return container;
-};
-
-Decorator.prototype.container = function () {
-    var basement = {};
-    if (typeof this.receiver === 'function') {
-        var candidates = this.matchers.filter(functionCall);
-        if (candidates.length === 1) {
-            var callSpec = {
-                thisObj: null,
-                func: this.receiver,
-                numArgsToCapture: numberOfArgumentsToCapture(candidates[0])
-            };
-            basement = decorate(callSpec, this);
-        }
-    }
-    return basement;
-};
-
-Decorator.prototype.concreteAssert = function (invocation, context) {
-    var func = invocation.func,
-        thisObj = invocation.thisObj,
-        args = invocation.values,
-        message = invocation.message;
-    if (this.eagerEvaluation) {
-        var poweredMessage = this.buildPowerAssertText(message, context);
-        return func.apply(thisObj, args.concat(poweredMessage));
-    }
-    try {
-        return func.apply(thisObj, args.concat(message));
-    } catch (e) {
-        throw this.errorToRethrow(e, message, context);
-    }
-};
-
-Decorator.prototype.errorToRethrow = function (e, originalMessage, context) {
-    if (e.name !== 'AssertionError') {
-        return e;
-    }
-    if (typeof this.receiver.AssertionError !== 'function') {
-        return e;
-    }
-    var f = new this.receiver.AssertionError({
-        actual: e.actual,
-        expected: e.expected,
-        operator: e.operator,
-        message: this.config.modifyMessageOnRethrow ? this.buildPowerAssertText(originalMessage, context) : e.message,
-        stackStartFunction: Decorator.prototype.concreteAssert
-    });
-    if (this.config.saveContextOnRethrow) {
-        f.powerAssertContext = context;
-    }
-    return f;
-};
-
-Decorator.prototype.buildPowerAssertText = function (message, context) {
-    var powerAssertText = this.formatter(context);
-    return message ? message + ' ' + powerAssertText : powerAssertText;
-};
-
-
-function numberOfArgumentsToCapture (matcher) {
-    var argSpecs = matcher.argumentSignatures(),
-        len = argSpecs.length,
-        lastArg;
-    if (0 < len) {
-        lastArg = argSpecs[len - 1];
-        if (lastArg.name === 'message' && lastArg.kind === 'optional') {
-            len -= 1;
-        }
-    }
-    return len;
-}
-
-
-function detectMethodName (node) {
-    if (node.type === 'MemberExpression') {
-        return node.property.name;
-    }
-    return null;
-}
-
-
-function functionCall (matcher) {
-    return matcher.calleeAst().type === 'Identifier';
-}
-
-
-function methodCall (matcher) {
-    return matcher.calleeAst().type === 'MemberExpression';
-}
-
-
-module.exports = Decorator;
-
-},{"./capturable":9,"./decorate":10,"escallmatch":13,"xtend/mutable":46}],12:[function(_dereq_,module,exports){
-'use strict';
-
-module.exports = function defaultOptions () {
-    return {
-        destructive: false,
-        modifyMessageOnRethrow: false,
-        saveContextOnRethrow: false,
-        patterns: [
-            'assert(value, [message])',
-            'assert.ok(value, [message])',
-            'assert.equal(actual, expected, [message])',
-            'assert.notEqual(actual, expected, [message])',
-            'assert.strictEqual(actual, expected, [message])',
-            'assert.notStrictEqual(actual, expected, [message])',
-            'assert.deepEqual(actual, expected, [message])',
-            'assert.notDeepEqual(actual, expected, [message])'
-        ]
-    };
-};
-
-},{}],13:[function(_dereq_,module,exports){
-/**
- * escallmatch:
- *   ECMAScript CallExpression matcher made from function/method signature
- * 
- * https://github.com/twada/escallmatch
- *
- * Copyright (c) 2014 Takuto Wada
- * Licensed under the MIT license.
- *   http://twada.mit-license.org/
- */
-'use strict';
-/* jshint -W024 */
-
-var esprima = _dereq_('esprima'),
-    estraverse = _dereq_('estraverse'),
-    espurify = _dereq_('espurify'),
-    syntax = estraverse.Syntax,
-    hasOwn = Object.prototype.hasOwnProperty,
-    deepEqual = _dereq_('deep-equal'),
-    notCallExprMessage = 'Argument should be in the form of CallExpression',
-    duplicatedArgMessage = 'Duplicate argument name: ',
-    invalidFormMessage = 'Argument should be in the form of `name` or `[name]`';
-
-function createMatcher (signatureStr) {
-    var ast = extractExpressionFrom(esprima.parse(signatureStr));
-    return new Matcher(ast);
-}
-
-function Matcher (signatureAst) {
-    this.signatureAst = signatureAst;
-    this.signatureCalleeDepth = astDepth(signatureAst.callee);
-    this.numMaxArgs = this.signatureAst.arguments.length;
-    this.numMinArgs = this.signatureAst.arguments.filter(identifiers).length;
-}
-
-Matcher.prototype.test = function (currentNode) {
-    var calleeMatched = isCalleeMatched(this.signatureAst, this.signatureCalleeDepth, currentNode),
-        numArgs;
-    if (calleeMatched) {
-        numArgs = currentNode.arguments.length;
-        return this.numMinArgs <= numArgs && numArgs <= this.numMaxArgs;
-    }
-    return false;
-};
-
-Matcher.prototype.matchArgument = function (currentNode, parentNode) {
-    if (isCalleeOfParent(currentNode, parentNode)) {
-        return null;
-    }
-    if (this.test(parentNode)) {
-        var indexOfCurrentArg = parentNode.arguments.indexOf(currentNode);
-        var numOptional = parentNode.arguments.length - this.numMinArgs;
-        var matchedSignatures = this.argumentSignatures().reduce(function (accum, argSig) {
-            if (argSig.kind === 'mandatory') {
-                accum.push(argSig);
-            }
-            if (argSig.kind === 'optional' && 0 < numOptional) {
-                numOptional -= 1;
-                accum.push(argSig);
-            }
-            return accum;
-        }, []);
-        return matchedSignatures[indexOfCurrentArg];
-    }
-    return null;
-};
-
-Matcher.prototype.calleeAst = function () {
-    return espurify(this.signatureAst.callee);
-};
-
-Matcher.prototype.argumentSignatures = function () {
-    return this.signatureAst.arguments.map(toArgumentSignature);
-};
-
-function toArgumentSignature (argSignatureNode) {
-    switch(argSignatureNode.type) {
-    case syntax.Identifier:
-        return {
-            name: argSignatureNode.name,
-            kind: 'mandatory'
-        };
-    case syntax.ArrayExpression:
-        return {
-            name: argSignatureNode.elements[0].name,
-            kind: 'optional'
-        };
-    default:
-        return null;
-    }
-}
-
-function isCalleeMatched(callSignature, signatureCalleeDepth, node) {
-    if (!isCallExpression(node)) {
-        return false;
-    }
-    if (!isSameAstDepth(node.callee, signatureCalleeDepth)) {
-        return false;
-    }
-    return deepEqual(espurify(callSignature.callee), espurify(node.callee));
-}
-
-function isSameAstDepth (ast, depth) {
-    var currentDepth = 0;
-    estraverse.traverse(ast, {
-        enter: function (currentNode, parentNode) {
-            var path = this.path(),
-                pathDepth = path ? path.length : 0;
-            if (currentDepth < pathDepth) {
-                currentDepth = pathDepth;
-            }
-            if (depth < currentDepth) {
-                this['break']();
-            }
-        }
-    });
-    return (depth === currentDepth);
-}
-
-function astDepth (ast) {
-    var maxDepth = 0;
-    estraverse.traverse(ast, {
-        enter: function (currentNode, parentNode) {
-            var path = this.path(),
-                pathDepth = path ? path.length : 0;
-            if (maxDepth < pathDepth) {
-                maxDepth = pathDepth;
-            }
-        }
-    });
-    return maxDepth;
-}
-
-function isCallExpression (node) {
-    return node && node.type === syntax.CallExpression;
-}
-
-function isCalleeOfParent(currentNode, parentNode) {
-    return parentNode && currentNode &&
-        parentNode.type === syntax.CallExpression &&
-        parentNode.callee === currentNode;
-}
-
-function identifiers (node) {
-    return node.type === syntax.Identifier;
-}
-
-function validateApiExpression (callExpression) {
-    if (callExpression.type !== syntax.CallExpression) {
-        throw new Error(notCallExprMessage);
-    }
-    var names = {};
-    callExpression.arguments.forEach(function (arg) {
-        var name = validateArg(arg);
-        if (hasOwn.call(names, name)) {
-            throw new Error(duplicatedArgMessage + name);
-        } else {
-            names[name] = name;
-        }
-    });
-}
-
-function validateArg (arg) {
-    var inner;
-    switch(arg.type) {
-    case syntax.Identifier:
-        return arg.name;
-    case syntax.ArrayExpression:
-        if (arg.elements.length !== 1) {
-            throw new Error(invalidFormMessage);
-        }
-        inner = arg.elements[0];
-        if (inner.type !== syntax.Identifier) {
-            throw new Error(invalidFormMessage);
-        }
-        return inner.name;
-    default:
-        throw new Error(invalidFormMessage);
-    }
-}
-
-function extractExpressionFrom (tree) {
-    var statement, expression;
-    statement = tree.body[0];
-    if (statement.type !== syntax.ExpressionStatement) {
-        throw new Error(notCallExprMessage);
-    }
-    expression = statement.expression;
-    validateApiExpression(expression);
-    return expression;
-}
-
-module.exports = createMatcher;
-
-},{"deep-equal":14,"esprima":21,"espurify":17,"estraverse":20}],14:[function(_dereq_,module,exports){
-var pSlice = Array.prototype.slice;
-var objectKeys = _dereq_('./lib/keys.js');
-var isArguments = _dereq_('./lib/is_arguments.js');
-
-var deepEqual = module.exports = function (actual, expected, opts) {
-  if (!opts) opts = {};
-  // 7.1. All identical values are equivalent, as determined by ===.
-  if (actual === expected) {
-    return true;
-
-  } else if (actual instanceof Date && expected instanceof Date) {
-    return actual.getTime() === expected.getTime();
-
-  // 7.3. Other pairs that do not both pass typeof value == 'object',
-  // equivalence is determined by ==.
-  } else if (typeof actual != 'object' && typeof expected != 'object') {
-    return opts.strict ? actual === expected : actual == expected;
-
-  // 7.4. 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, opts);
-  }
-}
-
-function isUndefinedOrNull(value) {
-  return value === null || value === undefined;
-}
-
-function isBuffer (x) {
-  if (!x || typeof x !== 'object' || typeof x.length !== 'number') return false;
-  if (typeof x.copy !== 'function' || typeof x.slice !== 'function') {
-    return false;
-  }
-  if (x.length > 0 && typeof x[0] !== 'number') return false;
-  return true;
-}
-
-function objEquiv(a, b, opts) {
-  var i, key;
-  if (isUndefinedOrNull(a) || isUndefinedOrNull(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.
-  if (isArguments(a)) {
-    if (!isArguments(b)) {
-      return false;
-    }
-    a = pSlice.call(a);
-    b = pSlice.call(b);
-    return deepEqual(a, b, opts);
-  }
-  if (isBuffer(a)) {
-    if (!isBuffer(b)) {
-      return false;
-    }
-    if (a.length !== b.length) return false;
-    for (i = 0; i < a.length; i++) {
-      if (a[i] !== b[i]) return false;
-    }
-    return true;
-  }
-  try {
-    var ka = objectKeys(a),
-        kb = objectKeys(b);
-  } 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], opts)) return false;
-  }
-  return typeof a === typeof b;
-}
-
-},{"./lib/is_arguments.js":15,"./lib/keys.js":16}],15:[function(_dereq_,module,exports){
-var supportsArgumentsClass = (function(){
-  return Object.prototype.toString.call(arguments)
-})() == '[object Arguments]';
-
-exports = module.exports = supportsArgumentsClass ? supported : unsupported;
-
-exports.supported = supported;
-function supported(object) {
-  return Object.prototype.toString.call(object) == '[object Arguments]';
-};
-
-exports.unsupported = unsupported;
-function unsupported(object){
-  return object &&
-    typeof object == 'object' &&
-    typeof object.length == 'number' &&
-    Object.prototype.hasOwnProperty.call(object, 'callee') &&
-    !Object.prototype.propertyIsEnumerable.call(object, 'callee') ||
-    false;
-};
-
-},{}],16:[function(_dereq_,module,exports){
-exports = module.exports = typeof Object.keys === 'function'
-  ? Object.keys : shim;
-
-exports.shim = shim;
-function shim (obj) {
-  var keys = [];
-  for (var key in obj) keys.push(key);
-  return keys;
-}
-
-},{}],17:[function(_dereq_,module,exports){
-/**
- * espurify - Clone new AST without extra properties
- * 
- * https://github.com/twada/espurify
- *
- * Copyright (c) 2014 Takuto Wada
- * Licensed under the MIT license.
- *   http://twada.mit-license.org/
- */
-'use strict';
-
-var traverse = _dereq_('traverse'),
-    deepCopy = _dereq_('./lib/ast-deepcopy'),
-    astProps = _dereq_('./lib/ast-properties'),
-    hasOwn = Object.prototype.hasOwnProperty;
-
-function espurify (node) {
-    var result = deepCopy(node);
-    traverse(result).forEach(function (x) {
-        if (this.parent &&
-            this.parent.node &&
-            this.parent.node.type &&
-            isSupportedNodeType(this.parent.node.type) &&
-            !isSupportedKey(this.parent.node.type, this.key))
-        {
-            this.remove(true);
-        }
-    });
-    return result;
-}
-
-function isSupportedNodeType (type) {
-    return hasOwn.call(astProps, type);
-}
-
-function isSupportedKey (type, key) {
-    return astProps[type].indexOf(key) !== -1;
-}
-
-module.exports = espurify;
-
-},{"./lib/ast-deepcopy":18,"./lib/ast-properties":19,"traverse":44}],18:[function(_dereq_,module,exports){
-/**
- * Copyright (C) 2012 Yusuke Suzuki (twitter: @Constellation) and other contributors.
- * Released under the BSD license.
- * https://github.com/Constellation/esmangle/blob/master/LICENSE.BSD
- */
-'use strict';
-
-var isArray = Array.isArray || function isArray (array) {
-    return Object.prototype.toString.call(array) === '[object Array]';
-};
-
-function deepCopyInternal (obj, result) {
-    var key, val;
-    for (key in obj) {
-        if (key.lastIndexOf('__', 0) === 0) {
-            continue;
-        }
-        if (obj.hasOwnProperty(key)) {
-            val = obj[key];
-            if (typeof val === 'object' && val !== null) {
-                if (val instanceof RegExp) {
-                    val = new RegExp(val);
-                } else {
-                    val = deepCopyInternal(val, isArray(val) ? [] : {});
-                }
-            }
-            result[key] = val;
-        }
-    }
-    return result;
-}
-
-function deepCopy (obj) {
-    return deepCopyInternal(obj, isArray(obj) ? [] : {});
-}
-
-module.exports = deepCopy;
-
-},{}],19:[function(_dereq_,module,exports){
-module.exports = {
-    AssignmentExpression: ['type', 'operator', 'left', 'right'],
-    ArrayExpression: ['type', 'elements'],
-    ArrayPattern: ['type', 'elements'],
-    // ArrowFunctionExpression: ['type', 'params', 'defaults', 'rest', 'body', 'generator', 'expression'],
-    BlockStatement: ['type', 'body'],
-    BinaryExpression: ['type', 'operator', 'left', 'right'],
-    BreakStatement: ['type', 'label'],
-    CallExpression: ['type', 'callee', 'arguments'],
-    CatchClause: ['type', 'param', 'guard', 'body'],
-    // ClassBody: ['type', 'body'],
-    // ClassDeclaration: ['type', 'id', 'body', 'superClass'],
-    // ClassExpression: ['type', 'id', 'body', 'superClass'],
-    ConditionalExpression: ['type', 'test', 'consequent', 'alternate'],
-    ContinueStatement: ['type', 'label'],
-    DebuggerStatement: ['type'],
-    // DirectiveStatement: ['type'],
-    DoWhileStatement: ['type', 'body', 'test'],
-    EmptyStatement: ['type'],
-    ExpressionStatement: ['type', 'expression'],
-    ForStatement: ['type', 'init', 'test', 'update', 'body'],
-    ForInStatement: ['type', 'left', 'right', 'body', 'each'],
-    FunctionDeclaration: ['type', 'id', 'params', 'defaults', 'rest', 'body', 'generator', 'expression'],
-    FunctionExpression: ['type', 'id', 'params', 'defaults', 'rest', 'body', 'generator', 'expression'],
-    Identifier: ['type', 'name'],
-    IfStatement: ['type', 'test', 'consequent', 'alternate'],
-    Literal: ['type', 'value'],
-    LabeledStatement: ['type', 'label', 'body'],
-    LogicalExpression: ['type', 'operator', 'left', 'right'],
-    MemberExpression: ['type', 'object', 'property', 'computed'],
-    // MethodDefinition: ['type', 'key', 'value'],
-    NewExpression: ['type', 'callee', 'arguments'],
-    ObjectExpression: ['type', 'properties'],
-    ObjectPattern: ['type', 'properties'],
-    Program: ['type', 'body'],
-    Property: ['type', 'key', 'value', 'kind'],
-    ReturnStatement: ['type', 'argument'],
-    SequenceExpression: ['type', 'expressions'],
-    SwitchStatement: ['type', 'discriminant', 'cases', 'lexical'],
-    SwitchCase: ['type', 'test', 'consequent'],
-    ThisExpression: ['type'],
-    ThrowStatement: ['type', 'argument'],
-    TryStatement: ['type', 'block', 'handlers', 'handler', 'guardedHandlers', 'finalizer'],
-    UnaryExpression: ['type', 'operator', 'prefix', 'argument'],
-    UpdateExpression: ['type', 'operator', 'argument', 'prefix'],
-    VariableDeclaration: ['type', 'declarations', 'kind'],
-    VariableDeclarator: ['type', 'id', 'init'],
-    WhileStatement: ['type', 'test', 'body'],
-    WithStatement: ['type', 'object', 'body'],
-    YieldExpression: ['type', 'argument']
-};
-
-},{}],20:[function(_dereq_,module,exports){
-/*
-  Copyright (C) 2012-2013 Yusuke Suzuki <utatane.tea@gmail.com>
-  Copyright (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com>
-
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-/*jslint vars:false, bitwise:true*/
-/*jshint indent:4*/
-/*global exports:true, define:true*/
-(function (root, factory) {
-    'use strict';
-
-    // Universal Module Definition (UMD) to support AMD, CommonJS/Node.js,
-    // and plain browser loading,
-    if (typeof define === 'function' && define.amd) {
-        define(['exports'], factory);
-    } else if (typeof exports !== 'undefined') {
-        factory(exports);
-    } else {
-        factory((root.estraverse = {}));
-    }
-}(this, function (exports) {
-    'use strict';
-
-    var Syntax,
-        isArray,
-        VisitorOption,
-        VisitorKeys,
-        objectCreate,
-        objectKeys,
-        BREAK,
-        SKIP,
-        REMOVE;
-
-    function ignoreJSHintError() { }
-
-    isArray = Array.isArray;
-    if (!isArray) {
-        isArray = function isArray(array) {
-            return Object.prototype.toString.call(array) === '[object Array]';
-        };
-    }
-
-    function deepCopy(obj) {
-        var ret = {}, key, val;
-        for (key in obj) {
-            if (obj.hasOwnProperty(key)) {
-                val = obj[key];
-                if (typeof val === 'object' && val !== null) {
-                    ret[key] = deepCopy(val);
-                } else {
-                    ret[key] = val;
-                }
-            }
-        }
-        return ret;
-    }
-
-    function shallowCopy(obj) {
-        var ret = {}, key;
-        for (key in obj) {
-            if (obj.hasOwnProperty(key)) {
-                ret[key] = obj[key];
-            }
-        }
-        return ret;
-    }
-    ignoreJSHintError(shallowCopy);
-
-    // based on LLVM libc++ upper_bound / lower_bound
-    // MIT License
-
-    function upperBound(array, func) {
-        var diff, len, i, current;
-
-        len = array.length;
-        i = 0;
-
-        while (len) {
-            diff = len >>> 1;
-            current = i + diff;
-            if (func(array[current])) {
-                len = diff;
-            } else {
-                i = current + 1;
-                len -= diff + 1;
-            }
-        }
-        return i;
-    }
-
-    function lowerBound(array, func) {
-        var diff, len, i, current;
-
-        len = array.length;
-        i = 0;
-
-        while (len) {
-            diff = len >>> 1;
-            current = i + diff;
-            if (func(array[current])) {
-                i = current + 1;
-                len -= diff + 1;
-            } else {
-                len = diff;
-            }
-        }
-        return i;
-    }
-    ignoreJSHintError(lowerBound);
-
-    objectCreate = Object.create || (function () {
-        function F() { }
-
-        return function (o) {
-            F.prototype = o;
-            return new F();
-        };
-    })();
-
-    objectKeys = Object.keys || function (o) {
-        var keys = [], key;
-        for (key in o) {
-            keys.push(key);
-        }
-        return keys;
-    };
-
-    function extend(to, from) {
-        objectKeys(from).forEach(function (key) {
-            to[key] = from[key];
-        });
-        return to;
-    }
-
-    Syntax = {
-        AssignmentExpression: 'AssignmentExpression',
-        ArrayExpression: 'ArrayExpression',
-        ArrayPattern: 'ArrayPattern',
-        ArrowFunctionExpression: 'ArrowFunctionExpression',
-        BlockStatement: 'BlockStatement',
-        BinaryExpression: 'BinaryExpression',
-        BreakStatement: 'BreakStatement',
-        CallExpression: 'CallExpression',
-        CatchClause: 'CatchClause',
-        ClassBody: 'ClassBody',
-        ClassDeclaration: 'ClassDeclaration',
-        ClassExpression: 'ClassExpression',
-        ComprehensionBlock: 'ComprehensionBlock',  // CAUTION: It's deferred to ES7.
-        ComprehensionExpression: 'ComprehensionExpression',  // CAUTION: It's deferred to ES7.
-        ConditionalExpression: 'ConditionalExpression',
-        ContinueStatement: 'ContinueStatement',
-        DebuggerStatement: 'DebuggerStatement',
-        DirectiveStatement: 'DirectiveStatement',
-        DoWhileStatement: 'DoWhileStatement',
-        EmptyStatement: 'EmptyStatement',
-        ExportBatchSpecifier: 'ExportBatchSpecifier',
-        ExportDeclaration: 'ExportDeclaration',
-        ExportSpecifier: 'ExportSpecifier',
-        ExpressionStatement: 'ExpressionStatement',
-        ForStatement: 'ForStatement',
-        ForInStatement: 'ForInStatement',
-        ForOfStatement: 'ForOfStatement',
-        FunctionDeclaration: 'FunctionDeclaration',
-        FunctionExpression: 'FunctionExpression',
-        GeneratorExpression: 'GeneratorExpression',  // CAUTION: It's deferred to ES7.
-        Identifier: 'Identifier',
-        IfStatement: 'IfStatement',
-        ImportDeclaration: 'ImportDeclaration',
-        ImportDefaultSpecifier: 'ImportDefaultSpecifier',
-        ImportNamespaceSpecifier: 'ImportNamespaceSpecifier',
-        ImportSpecifier: 'ImportSpecifier',
-        Literal: 'Literal',
-        LabeledStatement: 'LabeledStatement',
-        LogicalExpression: 'LogicalExpression',
-        MemberExpression: 'MemberExpression',
-        MethodDefinition: 'MethodDefinition',
-        ModuleSpecifier: 'ModuleSpecifier',
-        NewExpression: 'NewExpression',
-        ObjectExpression: 'ObjectExpression',
-        ObjectPattern: 'ObjectPattern',
-        Program: 'Program',
-        Property: 'Property',
-        ReturnStatement: 'ReturnStatement',
-        SequenceExpression: 'SequenceExpression',
-        SpreadElement: 'SpreadElement',
-        SwitchStatement: 'SwitchStatement',
-        SwitchCase: 'SwitchCase',
-        TaggedTemplateExpression: 'TaggedTemplateExpression',
-        TemplateElement: 'TemplateElement',
-        TemplateLiteral: 'TemplateLiteral',
-        ThisExpression: 'ThisExpression',
-        ThrowStatement: 'ThrowStatement',
-        TryStatement: 'TryStatement',
-        UnaryExpression: 'UnaryExpression',
-        UpdateExpression: 'UpdateExpression',
-        VariableDeclaration: 'VariableDeclaration',
-        VariableDeclarator: 'VariableDeclarator',
-        WhileStatement: 'WhileStatement',
-        WithStatement: 'WithStatement',
-        YieldExpression: 'YieldExpression'
-    };
-
-    VisitorKeys = {
-        AssignmentExpression: ['left', 'right'],
-        ArrayExpression: ['elements'],
-        ArrayPattern: ['elements'],
-        ArrowFunctionExpression: ['params', 'defaults', 'rest', 'body'],
-        BlockStatement: ['body'],
-        BinaryExpression: ['left', 'right'],
-        BreakStatement: ['label'],
-        CallExpression: ['callee', 'arguments'],
-        CatchClause: ['param', 'body'],
-        ClassBody: ['body'],
-        ClassDeclaration: ['id', 'body', 'superClass'],
-        ClassExpression: ['id', 'body', 'superClass'],
-        ComprehensionBlock: ['left', 'right'],  // CAUTION: It's deferred to ES7.
-        ComprehensionExpression: ['blocks', 'filter', 'body'],  // CAUTION: It's deferred to ES7.
-        ConditionalExpression: ['test', 'consequent', 'alternate'],
-        ContinueStatement: ['label'],
-        DebuggerStatement: [],
-        DirectiveStatement: [],
-        DoWhileStatement: ['body', 'test'],
-        EmptyStatement: [],
-        ExportBatchSpecifier: [],
-        ExportDeclaration: ['declaration', 'specifiers', 'source'],
-        ExportSpecifier: ['id', 'name'],
-        ExpressionStatement: ['expression'],
-        ForStatement: ['init', 'test', 'update', 'body'],
-        ForInStatement: ['left', 'right', 'body'],
-        ForOfStatement: ['left', 'right', 'body'],
-        FunctionDeclaration: ['id', 'params', 'defaults', 'rest', 'body'],
-        FunctionExpression: ['id', 'params', 'defaults', 'rest', 'body'],
-        GeneratorExpression: ['blocks', 'filter', 'body'],  // CAUTION: It's deferred to ES7.
-        Identifier: [],
-        IfStatement: ['test', 'consequent', 'alternate'],
-        ImportDeclaration: ['specifiers', 'source'],
-        ImportDefaultSpecifier: ['id'],
-        ImportNamespaceSpecifier: ['id'],
-        ImportSpecifier: ['id', 'name'],
-        Literal: [],
-        LabeledStatement: ['label', 'body'],
-        LogicalExpression: ['left', 'right'],
-        MemberExpression: ['object', 'property'],
-        MethodDefinition: ['key', 'value'],
-        ModuleSpecifier: [],
-        NewExpression: ['callee', 'arguments'],
-        ObjectExpression: ['properties'],
-        ObjectPattern: ['properties'],
-        Program: ['body'],
-        Property: ['key', 'value'],
-        ReturnStatement: ['argument'],
-        SequenceExpression: ['expressions'],
-        SpreadElement: ['argument'],
-        SwitchStatement: ['discriminant', 'cases'],
-        SwitchCase: ['test', 'consequent'],
-        TaggedTemplateExpression: ['tag', 'quasi'],
-        TemplateElement: [],
-        TemplateLiteral: ['quasis', 'expressions'],
-        ThisExpression: [],
-        ThrowStatement: ['argument'],
-        TryStatement: ['block', 'handlers', 'handler', 'guardedHandlers', 'finalizer'],
-        UnaryExpression: ['argument'],
-        UpdateExpression: ['argument'],
-        VariableDeclaration: ['declarations'],
-        VariableDeclarator: ['id', 'init'],
-        WhileStatement: ['test', 'body'],
-        WithStatement: ['object', 'body'],
-        YieldExpression: ['argument']
-    };
-
-    // unique id
-    BREAK = {};
-    SKIP = {};
-    REMOVE = {};
-
-    VisitorOption = {
-        Break: BREAK,
-        Skip: SKIP,
-        Remove: REMOVE
-    };
-
-    function Reference(parent, key) {
-        this.parent = parent;
-        this.key = key;
-    }
-
-    Reference.prototype.replace = function replace(node) {
-        this.parent[this.key] = node;
-    };
-
-    Reference.prototype.remove = function remove() {
-        if (isArray(this.parent)) {
-            this.parent.splice(this.key, 1);
-            return true;
-        } else {
-            this.replace(null);
-            return false;
-        }
-    };
-
-    function Element(node, path, wrap, ref) {
-        this.node = node;
-        this.path = path;
-        this.wrap = wrap;
-        this.ref = ref;
-    }
-
-    function Controller() { }
-
-    // API:
-    // return property path array from root to current node
-    Controller.prototype.path = function path() {
-        var i, iz, j, jz, result, element;
-
-        function addToPath(result, path) {
-            if (isArray(path)) {
-                for (j = 0, jz = path.length; j < jz; ++j) {
-                    result.push(path[j]);
-                }
-            } else {
-                result.push(path);
-            }
-        }
-
-        // root node
-        if (!this.__current.path) {
-            return null;
-        }
-
-        // first node is sentinel, second node is root element
-        result = [];
-        for (i = 2, iz = this.__leavelist.length; i < iz; ++i) {
-            element = this.__leavelist[i];
-            addToPath(result, element.path);
-        }
-        addToPath(result, this.__current.path);
-        return result;
-    };
-
-    // API:
-    // return type of current node
-    Controller.prototype.type = function () {
-        var node = this.current();
-        return node.type || this.__current.wrap;
-    };
-
-    // API:
-    // return array of parent elements
-    Controller.prototype.parents = function parents() {
-        var i, iz, result;
-
-        // first node is sentinel
-        result = [];
-        for (i = 1, iz = this.__leavelist.length; i < iz; ++i) {
-            result.push(this.__leavelist[i].node);
-        }
-
-        return result;
-    };
-
-    // API:
-    // return current node
-    Controller.prototype.current = function current() {
-        return this.__current.node;
-    };
-
-    Controller.prototype.__execute = function __execute(callback, element) {
-        var previous, result;
-
-        result = undefined;
-
-        previous  = this.__current;
-        this.__current = element;
-        this.__state = null;
-        if (callback) {
-            result = callback.call(this, element.node, this.__leavelist[this.__leavelist.length - 1].node);
-        }
-        this.__current = previous;
-
-        return result;
-    };
-
-    // API:
-    // notify control skip / break
-    Controller.prototype.notify = function notify(flag) {
-        this.__state = flag;
-    };
-
-    // API:
-    // skip child nodes of current node
-    Controller.prototype.skip = function () {
-        this.notify(SKIP);
-    };
-
-    // API:
-    // break traversals
-    Controller.prototype['break'] = function () {
-        this.notify(BREAK);
-    };
-
-    // API:
-    // remove node
-    Controller.prototype.remove = function () {
-        this.notify(REMOVE);
-    };
-
-    Controller.prototype.__initialize = function(root, visitor) {
-        this.visitor = visitor;
-        this.root = root;
-        this.__worklist = [];
-        this.__leavelist = [];
-        this.__current = null;
-        this.__state = null;
-        this.__fallback = visitor.fallback === 'iteration';
-        this.__keys = VisitorKeys;
-        if (visitor.keys) {
-            this.__keys = extend(objectCreate(this.__keys), visitor.keys);
-        }
-    };
-
-    function isNode(node) {
-        if (node == null) {
-            return false;
-        }
-        return typeof node === 'object' && typeof node.type === 'string';
-    }
-
-    function isProperty(nodeType, key) {
-        return (nodeType === Syntax.ObjectExpression || nodeType === Syntax.ObjectPattern) && 'properties' === key;
-    }
-
-    Controller.prototype.traverse = function traverse(root, visitor) {
-        var worklist,
-            leavelist,
-            element,
-            node,
-            nodeType,
-            ret,
-            key,
-            current,
-            current2,
-            candidates,
-            candidate,
-            sentinel;
-
-        this.__initialize(root, visitor);
-
-        sentinel = {};
-
-        // reference
-        worklist = this.__worklist;
-        leavelist = this.__leavelist;
-
-        // initialize
-        worklist.push(new Element(root, null, null, null));
-        leavelist.push(new Element(null, null, null, null));
-
-        while (worklist.length) {
-            element = worklist.pop();
-
-            if (element === sentinel) {
-                element = leavelist.pop();
-
-                ret = this.__execute(visitor.leave, element);
-
-                if (this.__state === BREAK || ret === BREAK) {
-                    return;
-                }
-                continue;
-            }
-
-            if (element.node) {
-
-                ret = this.__execute(visitor.enter, element);
-
-                if (this.__state === BREAK || ret === BREAK) {
-                    return;
-                }
-
-                worklist.push(sentinel);
-                leavelist.push(element);
-
-                if (this.__state === SKIP || ret === SKIP) {
-                    continue;
-                }
-
-                node = element.node;
-                nodeType = element.wrap || node.type;
-                candidates = this.__keys[nodeType];
-                if (!candidates) {
-                    if (this.__fallback) {
-                        candidates = objectKeys(node);
-                    } else {
-                        throw new Error('Unknown node type ' + nodeType + '.');
-                    }
-                }
-
-                current = candidates.length;
-                while ((current -= 1) >= 0) {
-                    key = candidates[current];
-                    candidate = node[key];
-                    if (!candidate) {
-                        continue;
-                    }
-
-                    if (isArray(candidate)) {
-                        current2 = candidate.length;
-                        while ((current2 -= 1) >= 0) {
-                            if (!candidate[current2]) {
-                                continue;
-                            }
-                            if (isProperty(nodeType, candidates[current])) {
-                                element = new Element(candidate[current2], [key, current2], 'Property', null);
-                            } else if (isNode(candidate[current2])) {
-                                element = new Element(candidate[current2], [key, current2], null, null);
-                            } else {
-                                continue;
-                            }
-                            worklist.push(element);
-                        }
-                    } else if (isNode(candidate)) {
-                        worklist.push(new Element(candidate, key, null, null));
-                    }
-                }
-            }
-        }
-    };
-
-    Controller.prototype.replace = function replace(root, visitor) {
-        function removeElem(element) {
-            var i,
-                key,
-                nextElem,
-                parent;
-
-            if (element.ref.remove()) {
-                // When the reference is an element of an array.
-                key = element.ref.key;
-                parent = element.ref.parent;
-
-                // If removed from array, then decrease following items' keys.
-                i = worklist.length;
-                while (i--) {
-                    nextElem = worklist[i];
-                    if (nextElem.ref && nextElem.ref.parent === parent) {
-                        if  (nextElem.ref.key < key) {
-                            break;
-                        }
-                        --nextElem.ref.key;
-                    }
-                }
-            }
-        }
-
-        var worklist,
-            leavelist,
-            node,
-            nodeType,
-            target,
-            element,
-            current,
-            current2,
-            candidates,
-            candidate,
-            sentinel,
-            outer,
-            key;
-
-        this.__initialize(root, visitor);
-
-        sentinel = {};
-
-        // reference
-        worklist = this.__worklist;
-        leavelist = this.__leavelist;
-
-        // initialize
-        outer = {
-            root: root
-        };
-        element = new Element(root, null, null, new Reference(outer, 'root'));
-        worklist.push(element);
-        leavelist.push(element);
-
-        while (worklist.length) {
-            element = worklist.pop();
-
-            if (element === sentinel) {
-                element = leavelist.pop();
-
-                target = this.__execute(visitor.leave, element);
-
-                // node may be replaced with null,
-                // so distinguish between undefined and null in this place
-                if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
-                    // replace
-                    element.ref.replace(target);
-                }
-
-                if (this.__state === REMOVE || target === REMOVE) {
-                    removeElem(element);
-                }
-
-                if (this.__state === BREAK || target === BREAK) {
-                    return outer.root;
-                }
-                continue;
-            }
-
-            target = this.__execute(visitor.enter, element);
-
-            // node may be replaced with null,
-            // so distinguish between undefined and null in this place
-            if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
-                // replace
-                element.ref.replace(target);
-                element.node = target;
-            }
-
-            if (this.__state === REMOVE || target === REMOVE) {
-                removeElem(element);
-                element.node = null;
-            }
-
-            if (this.__state === BREAK || target === BREAK) {
-                return outer.root;
-            }
-
-            // node may be null
-            node = element.node;
-            if (!node) {
-                continue;
-            }
-
-            worklist.push(sentinel);
-            leavelist.push(element);
-
-            if (this.__state === SKIP || target === SKIP) {
-                continue;
-            }
-
-            nodeType = element.wrap || node.type;
-            candidates = this.__keys[nodeType];
-            if (!candidates) {
-                if (this.__fallback) {
-                    candidates = objectKeys(node);
-                } else {
-                    throw new Error('Unknown node type ' + nodeType + '.');
-                }
-            }
-
-            current = candidates.length;
-            while ((current -= 1) >= 0) {
-                key = candidates[current];
-                candidate = node[key];
-                if (!candidate) {
-                    continue;
-                }
-
-                if (isArray(candidate)) {
-                    current2 = candidate.length;
-                    while ((current2 -= 1) >= 0) {
-                        if (!candidate[current2]) {
-                            continue;
-                        }
-                        if (isProperty(nodeType, candidates[current])) {
-                            element = new Element(candidate[current2], [key, current2], 'Property', new Reference(candidate, current2));
-                        } else if (isNode(candidate[current2])) {
-                            element = new Element(candidate[current2], [key, current2], null, new Reference(candidate, current2));
-                        } else {
-                            continue;
-                        }
-                        worklist.push(element);
-                    }
-                } else if (isNode(candidate)) {
-                    worklist.push(new Element(candidate, key, null, new Reference(node, key)));
-                }
-            }
-        }
-
-        return outer.root;
-    };
-
-    function traverse(root, visitor) {
-        var controller = new Controller();
-        return controller.traverse(root, visitor);
-    }
-
-    function replace(root, visitor) {
-        var controller = new Controller();
-        return controller.replace(root, visitor);
-    }
-
-    function extendCommentRange(comment, tokens) {
-        var target;
-
-        target = upperBound(tokens, function search(token) {
-            return token.range[0] > comment.range[0];
-        });
-
-        comment.extendedRange = [comment.range[0], comment.range[1]];
-
-        if (target !== tokens.length) {
-            comment.extendedRange[1] = tokens[target].range[0];
-        }
-
-        target -= 1;
-        if (target >= 0) {
-            comment.extendedRange[0] = tokens[target].range[1];
-        }
-
-        return comment;
-    }
-
-    function attachComments(tree, providedComments, tokens) {
-        // At first, we should calculate extended comment ranges.
-        var comments = [], comment, len, i, cursor;
-
-        if (!tree.range) {
-            throw new Error('attachComments needs range information');
-        }
-
-        // tokens array is empty, we attach comments to tree as 'leadingComments'
-        if (!tokens.length) {
-            if (providedComments.length) {
-                for (i = 0, len = providedComments.length; i < len; i += 1) {
-                    comment = deepCopy(providedComments[i]);
-                    comment.extendedRange = [0, tree.range[0]];
-                    comments.push(comment);
-                }
-                tree.leadingComments = comments;
-            }
-            return tree;
-        }
-
-        for (i = 0, len = providedComments.length; i < len; i += 1) {
-            comments.push(extendCommentRange(deepCopy(providedComments[i]), tokens));
-        }
-
-        // This is based on John Freeman's implementation.
-        cursor = 0;
-        traverse(tree, {
-            enter: function (node) {
-                var comment;
-
-                while (cursor < comments.length) {
-                    comment = comments[cursor];
-                    if (comment.extendedRange[1] > node.range[0]) {
-                        break;
-                    }
-
-                    if (comment.extendedRange[1] === node.range[0]) {
-                        if (!node.leadingComments) {
-                            node.leadingComments = [];
-                        }
-                        node.leadingComments.push(comment);
-                        comments.splice(cursor, 1);
-                    } else {
-                        cursor += 1;
-                    }
-                }
-
-                // already out of owned node
-                if (cursor === comments.length) {
-                    return VisitorOption.Break;
-                }
-
-                if (comments[cursor].extendedRange[0] > node.range[1]) {
-                    return VisitorOption.Skip;
-                }
-            }
-        });
-
-        cursor = 0;
-        traverse(tree, {
-            leave: function (node) {
-                var comment;
-
-                while (cursor < comments.length) {
-                    comment = comments[cursor];
-                    if (node.range[1] < comment.extendedRange[0]) {
-                        break;
-                    }
-
-                    if (node.range[1] === comment.extendedRange[0]) {
-                        if (!node.trailingComments) {
-                            node.trailingComments = [];
-                        }
-                        node.trailingComments.push(comment);
-                        comments.splice(cursor, 1);
-                    } else {
-                        cursor += 1;
-                    }
-                }
-
-                // already out of owned node
-                if (cursor === comments.length) {
-                    return VisitorOption.Break;
-                }
-
-                if (comments[cursor].extendedRange[0] > node.range[1]) {
-                    return VisitorOption.Skip;
-                }
-            }
-        });
-
-        return tree;
-    }
-
-    exports.version = '1.8.0';
-    exports.Syntax = Syntax;
-    exports.traverse = traverse;
-    exports.replace = replace;
-    exports.attachComments = attachComments;
-    exports.VisitorKeys = VisitorKeys;
-    exports.VisitorOption = VisitorOption;
-    exports.Controller = Controller;
-}));
-/* vim: set sw=4 ts=4 et tw=80 : */
-
-},{}],21:[function(_dereq_,module,exports){
-/*
-  Copyright (C) 2013 Ariya Hidayat <ariya.hidayat@gmail.com>
-  Copyright (C) 2013 Thaddee Tyl <thaddee.tyl@gmail.com>
-  Copyright (C) 2013 Mathias Bynens <mathias@qiwi.be>
-  Copyright (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com>
-  Copyright (C) 2012 Mathias Bynens <mathias@qiwi.be>
-  Copyright (C) 2012 Joost-Wim Boekesteijn <joost-wim@boekesteijn.nl>
-  Copyright (C) 2012 Kris Kowal <kris.kowal@cixar.com>
-  Copyright (C) 2012 Yusuke Suzuki <utatane.tea@gmail.com>
-  Copyright (C) 2012 Arpad Borsos <arpad.borsos@googlemail.com>
-  Copyright (C) 2011 Ariya Hidayat <ariya.hidayat@gmail.com>
-
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-/*jslint bitwise:true plusplus:true */
-/*global esprima:true, define:true, exports:true, window: true,
-throwErrorTolerant: true,
-throwError: true, generateStatement: true, peek: true,
-parseAssignmentExpression: true, parseBlock: true, parseExpression: true,
-parseFunctionDeclaration: true, parseFunctionExpression: true,
-parseFunctionSourceElements: true, parseVariableIdentifier: true,
-parseLeftHandSideExpression: true,
-parseUnaryExpression: true,
-parseStatement: true, parseSourceElement: true */
-
-(function (root, factory) {
-    'use strict';
-
-    // Universal Module Definition (UMD) to support AMD, CommonJS/Node.js,
-    // Rhino, and plain browser loading.
-
-    /* istanbul ignore next */
-    if (typeof define === 'function' && define.amd) {
-        define(['exports'], factory);
-    } else if (typeof exports !== 'undefined') {
-        factory(exports);
-    } else {
-        factory((root.esprima = {}));
-    }
-}(this, function (exports) {
-    'use strict';
-
-    var Token,
-        TokenName,
-        FnExprTokens,
-        Syntax,
-        PropertyKind,
-        Messages,
-        Regex,
-        SyntaxTreeDelegate,
-        source,
-        strict,
-        index,
-        lineNumber,
-        lineStart,
-        length,
-        delegate,
-        lookahead,
-        state,
-        extra;
-
-    Token = {
-        BooleanLiteral: 1,
-        EOF: 2,
-        Identifier: 3,
-        Keyword: 4,
-        NullLiteral: 5,
-        NumericLiteral: 6,
-        Punctuator: 7,
-        StringLiteral: 8,
-        RegularExpression: 9
-    };
-
-    TokenName = {};
-    TokenName[Token.BooleanLiteral] = 'Boolean';
-    TokenName[Token.EOF] = '<end>';
-    TokenName[Token.Identifier] = 'Identifier';
-    TokenName[Token.Keyword] = 'Keyword';
-    TokenName[Token.NullLiteral] = 'Null';
-    TokenName[Token.NumericLiteral] = 'Numeric';
-    TokenName[Token.Punctuator] = 'Punctuator';
-    TokenName[Token.StringLiteral] = 'String';
-    TokenName[Token.RegularExpression] = 'RegularExpression';
-
-    // A function following one of those tokens is an expression.
-    FnExprTokens = ['(', '{', '[', 'in', 'typeof', 'instanceof', 'new',
-                    'return', 'case', 'delete', 'throw', 'void',
-                    // assignment operators
-                    '=', '+=', '-=', '*=', '/=', '%=', '<<=', '>>=', '>>>=',
-                    '&=', '|=', '^=', ',',
-                    // binary/unary operators
-                    '+', '-', '*', '/', '%', '++', '--', '<<', '>>', '>>>', '&',
-                    '|', '^', '!', '~', '&&', '||', '?', ':', '===', '==', '>=',
-                    '<=', '<', '>', '!=', '!=='];
-
-    Syntax = {
-        AssignmentExpression: 'AssignmentExpression',
-        ArrayExpression: 'ArrayExpression',
-        BlockStatement: 'BlockStatement',
-        BinaryExpression: 'BinaryExpression',
-        BreakStatement: 'BreakStatement',
-        CallExpression: 'CallExpression',
-        CatchClause: 'CatchClause',
-        ConditionalExpression: 'ConditionalExpression',
-        ContinueStatement: 'ContinueStatement',
-        DoWhileStatement: 'DoWhileStatement',
-        DebuggerStatement: 'DebuggerStatement',
-        EmptyStatement: 'EmptyStatement',
-        ExpressionStatement: 'ExpressionStatement',
-        ForStatement: 'ForStatement',
-        ForInStatement: 'ForInStatement',
-        FunctionDeclaration: 'FunctionDeclaration',
-        FunctionExpression: 'FunctionExpression',
-        Identifier: 'Identifier',
-        IfStatement: 'IfStatement',
-        Literal: 'Literal',
-        LabeledStatement: 'LabeledStatement',
-        LogicalExpression: 'LogicalExpression',
-        MemberExpression: 'MemberExpression',
-        NewExpression: 'NewExpression',
-        ObjectExpression: 'ObjectExpression',
-        Program: 'Program',
-        Property: 'Property',
-        ReturnStatement: 'ReturnStatement',
-        SequenceExpression: 'SequenceExpression',
-        SwitchStatement: 'SwitchStatement',
-        SwitchCase: 'SwitchCase',
-        ThisExpression: 'ThisExpression',
-        ThrowStatement: 'ThrowStatement',
-        TryStatement: 'TryStatement',
-        UnaryExpression: 'UnaryExpression',
-        UpdateExpression: 'UpdateExpression',
-        VariableDeclaration: 'VariableDeclaration',
-        VariableDeclarator: 'VariableDeclarator',
-        WhileStatement: 'WhileStatement',
-        WithStatement: 'WithStatement'
-    };
-
-    PropertyKind = {
-        Data: 1,
-        Get: 2,
-        Set: 4
-    };
-
-    // Error messages should be identical to V8.
-    Messages = {
-        UnexpectedToken:  'Unexpected token %0',
-        UnexpectedNumber:  'Unexpected number',
-        UnexpectedString:  'Unexpected string',
-        UnexpectedIdentifier:  'Unexpected identifier',
-        UnexpectedReserved:  'Unexpected reserved word',
-        UnexpectedEOS:  'Unexpected end of input',
-        NewlineAfterThrow:  'Illegal newline after throw',
-        InvalidRegExp: 'Invalid regular expression',
-        UnterminatedRegExp:  'Invalid regular expression: missing /',
-        InvalidLHSInAssignment:  'Invalid left-hand side in assignment',
-        InvalidLHSInForIn:  'Invalid left-hand side in for-in',
-        MultipleDefaultsInSwitch: 'More than one default clause in switch statement',
-        NoCatchOrFinally:  'Missing catch or finally after try',
-        UnknownLabel: 'Undefined label \'%0\'',
-        Redeclaration: '%0 \'%1\' has already been declared',
-        IllegalContinue: 'Illegal continue statement',
-        IllegalBreak: 'Illegal break statement',
-        IllegalReturn: 'Illegal return statement',
-        StrictModeWith:  'Strict mode code may not include a with statement',
-        StrictCatchVariable:  'Catch variable may not be eval or arguments in strict mode',
-        StrictVarName:  'Variable name may not be eval or arguments in strict mode',
-        StrictParamName:  'Parameter name eval or arguments is not allowed in strict mode',
-        StrictParamDupe: 'Strict mode function may not have duplicate parameter names',
-        StrictFunctionName:  'Function name may not be eval or arguments in strict mode',
-        StrictOctalLiteral:  'Octal literals are not allowed in strict mode.',
-        StrictDelete:  'Delete of an unqualified identifier in strict mode.',
-        StrictDuplicateProperty:  'Duplicate data property in object literal not allowed in strict mode',
-        AccessorDataProperty:  'Object literal may not have data and accessor property with the same name',
-        AccessorGetSet:  'Object literal may not have multiple get/set accessors with the same name',
-        StrictLHSAssignment:  'Assignment to eval or arguments is not allowed in strict mode',
-        StrictLHSPostfix:  'Postfix increment/decrement may not have eval or arguments operand in strict mode',
-        StrictLHSPrefix:  'Prefix increment/decrement may not have eval or arguments operand in strict mode',
-        StrictReservedWord:  'Use of future reserved word in strict mode'
-    };
-
-    // See also tools/generate-unicode-regex.py.
-    Regex = {
-        NonAsciiIdentifierStart: new RegExp('[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0\u08A2-\u08AC\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097F\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C33\u0C35-\u0C39\u0C3D\u0C58\u0C59\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D60\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F0\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191C\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19C1-\u19C7\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA697\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA793\uA7A0-\uA7AA\uA7F8-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA80-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]'),
-        NonAsciiIdentifierPart: new RegExp('[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u0527\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0\u08A2-\u08AC\u08E4-\u08FE\u0900-\u0963\u0966-\u096F\u0971-\u0977\u0979-\u097F\u0981-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C01-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C33\u0C35-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58\u0C59\u0C60-\u0C63\u0C66-\u0C6F\u0C82\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D02\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D57\u0D60-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F0\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191C\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19D9\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1CD0-\u1CD2\u1CD4-\u1CF6\u1D00-\u1DE6\u1DFC-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u2E2F\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099\u309A\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA697\uA69F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA793\uA7A0-\uA7AA\uA7F8-\uA827\uA840-\uA873\uA880-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A\uAA7B\uAA80-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uABC0-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE26\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]')
-    };
-
-    // Ensure the condition is true, otherwise throw an error.
-    // This is only to have a better contract semantic, i.e. another safety net
-    // to catch a logic error. The condition shall be fulfilled in normal case.
-    // Do NOT use this to enforce a certain condition on any user input.
-
-    function assert(condition, message) {
-        /* istanbul ignore if */
-        if (!condition) {
-            throw new Error('ASSERT: ' + message);
-        }
-    }
-
-    function isDecimalDigit(ch) {
-        return (ch >= 48 && ch <= 57);   // 0..9
-    }
-
-    function isHexDigit(ch) {
-        return '0123456789abcdefABCDEF'.indexOf(ch) >= 0;
-    }
-
-    function isOctalDigit(ch) {
-        return '01234567'.indexOf(ch) >= 0;
-    }
-
-
-    // 7.2 White Space
-
-    function isWhiteSpace(ch) {
-        return (ch === 0x20) || (ch === 0x09) || (ch === 0x0B) || (ch === 0x0C) || (ch === 0xA0) ||
-            (ch >= 0x1680 && [0x1680, 0x180E, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200A, 0x202F, 0x205F, 0x3000, 0xFEFF].indexOf(ch) >= 0);
-    }
-
-    // 7.3 Line Terminators
-
-    function isLineTerminator(ch) {
-        return (ch === 0x0A) || (ch === 0x0D) || (ch === 0x2028) || (ch === 0x2029);
-    }
-
-    // 7.6 Identifier Names and Identifiers
-
-    function isIdentifierStart(ch) {
-        return (ch === 0x24) || (ch === 0x5F) ||  // $ (dollar) and _ (underscore)
-            (ch >= 0x41 && ch <= 0x5A) ||         // A..Z
-            (ch >= 0x61 && ch <= 0x7A) ||         // a..z
-            (ch === 0x5C) ||                      // \ (backslash)
-            ((ch >= 0x80) && Regex.NonAsciiIdentifierStart.test(String.fromCharCode(ch)));
-    }
-
-    function isIdentifierPart(ch) {
-        return (ch === 0x24) || (ch === 0x5F) ||  // $ (dollar) and _ (underscore)
-            (ch >= 0x41 && ch <= 0x5A) ||         // A..Z
-            (ch >= 0x61 && ch <= 0x7A) ||         // a..z
-            (ch >= 0x30 && ch <= 0x39) ||         // 0..9
-            (ch === 0x5C) ||                      // \ (backslash)
-            ((ch >= 0x80) && Regex.NonAsciiIdentifierPart.test(String.fromCharCode(ch)));
-    }
-
-    // 7.6.1.2 Future Reserved Words
-
-    function isFutureReservedWord(id) {
-        switch (id) {
-        case 'class':
-        case 'enum':
-        case 'export':
-        case 'extends':
-        case 'import':
-        case 'super':
-            return true;
-        default:
-            return false;
-        }
-    }
-
-    function isStrictModeReservedWord(id) {
-        switch (id) {
-        case 'implements':
-        case 'interface':
-        case 'package':
-        case 'private':
-        case 'protected':
-        case 'public':
-        case 'static':
-        case 'yield':
-        case 'let':
-            return true;
-        default:
-            return false;
-        }
-    }
-
-    function isRestrictedWord(id) {
-        return id === 'eval' || id === 'arguments';
-    }
-
-    // 7.6.1.1 Keywords
-
-    function isKeyword(id) {
-        if (strict && isStrictModeReservedWord(id)) {
-            return true;
-        }
-
-        // 'const' is specialized as Keyword in V8.
-        // 'yield' and 'let' are for compatiblity with SpiderMonkey and ES.next.
-        // Some others are from future reserved words.
-
-        switch (id.length) {
-        case 2:
-            return (id === 'if') || (id === 'in') || (id === 'do');
-        case 3:
-            return (id === 'var') || (id === 'for') || (id === 'new') ||
-                (id === 'try') || (id === 'let');
-        case 4:
-            return (id === 'this') || (id === 'else') || (id === 'case') ||
-                (id === 'void') || (id === 'with') || (id === 'enum');
-        case 5:
-            return (id === 'while') || (id === 'break') || (id === 'catch') ||
-                (id === 'throw') || (id === 'const') || (id === 'yield') ||
-                (id === 'class') || (id === 'super');
-        case 6:
-            return (id === 'return') || (id === 'typeof') || (id === 'delete') ||
-                (id === 'switch') || (id === 'export') || (id === 'import');
-        case 7:
-            return (id === 'default') || (id === 'finally') || (id === 'extends');
-        case 8:
-            return (id === 'function') || (id === 'continue') || (id === 'debugger');
-        case 10:
-            return (id === 'instanceof');
-        default:
-            return false;
-        }
-    }
-
-    // 7.4 Comments
-
-    function addComment(type, value, start, end, loc) {
-        var comment, attacher;
-
-        assert(typeof start === 'number', 'Comment must have valid position');
-
-        // Because the way the actual token is scanned, often the comments
-        // (if any) are skipped twice during the lexical analysis.
-        // Thus, we need to skip adding a comment if the comment array already
-        // handled it.
-        if (state.lastCommentStart >= start) {
-            return;
-        }
-        state.lastCommentStart = start;
-
-        comment = {
-            type: type,
-            value: value
-        };
-        if (extra.range) {
-            comment.range = [start, end];
-        }
-        if (extra.loc) {
-            comment.loc = loc;
-        }
-        extra.comments.push(comment);
-        if (extra.attachComment) {
-            extra.leadingComments.push(comment);
-            extra.trailingComments.push(comment);
-        }
-    }
-
-    function skipSingleLineComment(offset) {
-        var start, loc, ch, comment;
-
-        start = index - offset;
-        loc = {
-            start: {
-                line: lineNumber,
-                column: index - lineStart - offset
-            }
-        };
-
-        while (index < length) {
-            ch = source.charCodeAt(index);
-            ++index;
-            if (isLineTerminator(ch)) {
-                if (extra.comments) {
-                    comment = source.slice(start + offset, index - 1);
-                    loc.end = {
-                        line: lineNumber,
-                        column: index - lineStart - 1
-                    };
-                    addComment('Line', comment, start, index - 1, loc);
-                }
-                if (ch === 13 && source.charCodeAt(index) === 10) {
-                    ++index;
-                }
-                ++lineNumber;
-                lineStart = index;
-                return;
-            }
-        }
-
-        if (extra.comments) {
-            comment = source.slice(start + offset, index);
-            loc.end = {
-                line: lineNumber,
-                column: index - lineStart
-            };
-            addComment('Line', comment, start, index, loc);
-        }
-    }
-
-    function skipMultiLineComment() {
-        var start, loc, ch, comment;
-
-        if (extra.comments) {
-            start = index - 2;
-            loc = {
-                start: {
-                    line: lineNumber,
-                    column: index - lineStart - 2
-                }
-            };
-        }
-
-        while (index < length) {
-            ch = source.charCodeAt(index);
-            if (isLineTerminator(ch)) {
-                if (ch === 0x0D && source.charCodeAt(index + 1) === 0x0A) {
-                    ++index;
-                }
-                ++lineNumber;
-                ++index;
-                lineStart = index;
-                if (index >= length) {
-                    throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
-                }
-            } else if (ch === 0x2A) {
-                // Block comment ends with '*/'.
-                if (source.charCodeAt(index + 1) === 0x2F) {
-                    ++index;
-                    ++index;
-                    if (extra.comments) {
-                        comment = source.slice(start + 2, index - 2);
-                        loc.end = {
-                            line: lineNumber,
-                            column: index - lineStart
-                        };
-                        addComment('Block', comment, start, index, loc);
-                    }
-                    return;
-                }
-                ++index;
-            } else {
-                ++index;
-            }
-        }
-
-        throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
-    }
-
-    function skipComment() {
-        var ch, start;
-
-        start = (index === 0);
-        while (index < length) {
-            ch = source.charCodeAt(index);
-
-            if (isWhiteSpace(ch)) {
-                ++index;
-            } else if (isLineTerminator(ch)) {
-                ++index;
-                if (ch === 0x0D && source.charCodeAt(index) === 0x0A) {
-                    ++index;
-                }
-                ++lineNumber;
-                lineStart = index;
-                start = true;
-            } else if (ch === 0x2F) { // U+002F is '/'
-                ch = source.charCodeAt(index + 1);
-                if (ch === 0x2F) {
-                    ++index;
-                    ++index;
-                    skipSingleLineComment(2);
-                    start = true;
-                } else if (ch === 0x2A) {  // U+002A is '*'
-                    ++index;
-                    ++index;
-                    skipMultiLineComment();
-                } else {
-                    break;
-                }
-            } else if (start && ch === 0x2D) { // U+002D is '-'
-                // U+003E is '>'
-                if ((source.charCodeAt(index + 1) === 0x2D) && (source.charCodeAt(index + 2) === 0x3E)) {
-                    // '-->' is a single-line comment
-                    index += 3;
-                    skipSingleLineComment(3);
-                } else {
-                    break;
-                }
-            } else if (ch === 0x3C) { // U+003C is '<'
-                if (source.slice(index + 1, index + 4) === '!--') {
-                    ++index; // `<`
-                    ++index; // `!`
-                    ++index; // `-`
-                    ++index; // `-`
-                    skipSingleLineComment(4);
-                } else {
-                    break;
-                }
-            } else {
-                break;
-            }
-        }
-    }
-
-    function scanHexEscape(prefix) {
-        var i, len, ch, code = 0;
-
-        len = (prefix === 'u') ? 4 : 2;
-        for (i = 0; i < len; ++i) {
-            if (index < length && isHexDigit(source[index])) {
-                ch = source[index++];
-                code = code * 16 + '0123456789abcdef'.indexOf(ch.toLowerCase());
-            } else {
-                return '';
-            }
-        }
-        return String.fromCharCode(code);
-    }
-
-    function getEscapedIdentifier() {
-        var ch, id;
-
-        ch = source.charCodeAt(index++);
-        id = String.fromCharCode(ch);
-
-        // '\u' (U+005C, U+0075) denotes an escaped character.
-        if (ch === 0x5C) {
-            if (source.charCodeAt(index) !== 0x75) {
-                throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
-            }
-            ++index;
-            ch = scanHexEscape('u');
-            if (!ch || ch === '\\' || !isIdentifierStart(ch.charCodeAt(0))) {
-                throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
-            }
-            id = ch;
-        }
-
-        while (index < length) {
-            ch = source.charCodeAt(index);
-            if (!isIdentifierPart(ch)) {
-                break;
-            }
-            ++index;
-            id += String.fromCharCode(ch);
-
-            // '\u' (U+005C, U+0075) denotes an escaped character.
-            if (ch === 0x5C) {
-                id = id.substr(0, id.length - 1);
-                if (source.charCodeAt(index) !== 0x75) {
-                    throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
-                }
-                ++index;
-                ch = scanHexEscape('u');
-                if (!ch || ch === '\\' || !isIdentifierPart(ch.charCodeAt(0))) {
-                    throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
-                }
-                id += ch;
-            }
-        }
-
-        return id;
-    }
-
-    function getIdentifier() {
-        var start, ch;
-
-        start = index++;
-        while (index < length) {
-            ch = source.charCodeAt(index);
-            if (ch === 0x5C) {
-                // Blackslash (U+005C) marks Unicode escape sequence.
-                index = start;
-                return getEscapedIdentifier();
-            }
-            if (isIdentifierPart(ch)) {
-                ++index;
-            } else {
-                break;
-            }
-        }
-
-        return source.slice(start, index);
-    }
-
-    function scanIdentifier() {
-        var start, id, type;
-
-        start = index;
-
-        // Backslash (U+005C) starts an escaped character.
-        id = (source.charCodeAt(index) === 0x5C) ? getEscapedIdentifier() : getIdentifier();
-
-        // There is no keyword or literal with only one character.
-        // Thus, it must be an identifier.
-        if (id.length === 1) {
-            type = Token.Identifier;
-        } else if (isKeyword(id)) {
-            type = Token.Keyword;
-        } else if (id === 'null') {
-            type = Token.NullLiteral;
-        } else if (id === 'true' || id === 'false') {
-            type = Token.BooleanLiteral;
-        } else {
-            type = Token.Identifier;
-        }
-
-        return {
-            type: type,
-            value: id,
-            lineNumber: lineNumber,
-            lineStart: lineStart,
-            start: start,
-            end: index
-        };
-    }
-
-
-    // 7.7 Punctuators
-
-    function scanPunctuator() {
-        var start = index,
-            code = source.charCodeAt(index),
-            code2,
-            ch1 = source[index],
-            ch2,
-            ch3,
-            ch4;
-
-        switch (code) {
-
-        // Check for most common single-character punctuators.
-        case 0x2E:  // . dot
-        case 0x28:  // ( open bracket
-        case 0x29:  // ) close bracket
-        case 0x3B:  // ; semicolon
-        case 0x2C:  // , comma
-        case 0x7B:  // { open curly brace
-        case 0x7D:  // } close curly brace
-        case 0x5B:  // [
-        case 0x5D:  // ]
-        case 0x3A:  // :
-        case 0x3F:  // ?
-        case 0x7E:  // ~
-            ++index;
-            if (extra.tokenize) {
-                if (code === 0x28) {
-                    extra.openParenToken = extra.tokens.length;
-                } else if (code === 0x7B) {
-                    extra.openCurlyToken = extra.tokens.length;
-                }
-            }
-            return {
-                type: Token.Punctuator,
-                value: String.fromCharCode(code),
-                lineNumber: lineNumber,
-                lineStart: lineStart,
-                start: start,
-                end: index
-            };
-
-        default:
-            code2 = source.charCodeAt(index + 1);
-
-            // '=' (U+003D) marks an assignment or comparison operator.
-            if (code2 === 0x3D) {
-                switch (code) {
-                case 0x2B:  // +
-                case 0x2D:  // -
-                case 0x2F:  // /
-                case 0x3C:  // <
-                case 0x3E:  // >
-                case 0x5E:  // ^
-                case 0x7C:  // |
-                case 0x25:  // %
-                case 0x26:  // &
-                case 0x2A:  // *
-                    index += 2;
-                    return {
-                        type: Token.Punctuator,
-                        value: String.fromCharCode(code) + String.fromCharCode(code2),
-                        lineNumber: lineNumber,
-                        lineStart: lineStart,
-                        start: start,
-                        end: index
-                    };
-
-                case 0x21: // !
-                case 0x3D: // =
-                    index += 2;
-
-                    // !== and ===
-                    if (source.charCodeAt(index) === 0x3D) {
-                        ++index;
-                    }
-                    return {
-                        type: Token.Punctuator,
-                        value: source.slice(start, index),
-                        lineNumber: lineNumber,
-                        lineStart: lineStart,
-                        start: start,
-                        end: index
-                    };
-                }
-            }
-        }
-
-        // 4-character punctuator: >>>=
-
-        ch4 = source.substr(index, 4);
-
-        if (ch4 === '>>>=') {
-            index += 4;
-            return {
-                type: Token.Punctuator,
-                value: ch4,
-                lineNumber: lineNumber,
-                lineStart: lineStart,
-                start: start,
-                end: index
-            };
-        }
-
-        // 3-character punctuators: === !== >>> <<= >>=
-
-        ch3 = ch4.substr(0, 3);
-
-        if (ch3 === '>>>' || ch3 === '<<=' || ch3 === '>>=') {
-            index += 3;
-            return {
-                type: Token.Punctuator,
-                value: ch3,
-                lineNumber: lineNumber,
-                lineStart: lineStart,
-                start: start,
-                end: index
-            };
-        }
-
-        // Other 2-character punctuators: ++ -- << >> && ||
-        ch2 = ch3.substr(0, 2);
-
-        if ((ch1 === ch2[1] && ('+-<>&|'.indexOf(ch1) >= 0)) || ch2 === '=>') {
-            index += 2;
-            return {
-                type: Token.Punctuator,
-                value: ch2,
-                lineNumber: lineNumber,
-                lineStart: lineStart,
-                start: start,
-                end: index
-            };
-        }
-
-        // 1-character punctuators: < > = ! + - * % & | ^ /
-        if ('<>=!+-*%&|^/'.indexOf(ch1) >= 0) {
-            ++index;
-            return {
-                type: Token.Punctuator,
-                value: ch1,
-                lineNumber: lineNumber,
-                lineStart: lineStart,
-                start: start,
-                end: index
-            };
-        }
-
-        throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
-    }
-
-    // 7.8.3 Numeric Literals
-
-    function scanHexLiteral(start) {
-        var number = '';
-
-        while (index < length) {
-            if (!isHexDigit(source[index])) {
-                break;
-            }
-            number += source[index++];
-        }
-
-        if (number.length === 0) {
-            throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
-        }
-
-        if (isIdentifierStart(source.charCodeAt(index))) {
-            throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
-        }
-
-        return {
-            type: Token.NumericLiteral,
-            value: parseInt('0x' + number, 16),
-            lineNumber: lineNumber,
-            lineStart: lineStart,
-            start: start,
-            end: index
-        };
-    }
-
-    function scanOctalLiteral(start) {
-        var number = '0' + source[index++];
-        while (index < length) {
-            if (!isOctalDigit(source[index])) {
-                break;
-            }
-            number += source[index++];
-        }
-
-        if (isIdentifierStart(source.charCodeAt(index)) || isDecimalDigit(source.charCodeAt(index))) {
-            throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
-        }
-
-        return {
-            type: Token.NumericLiteral,
-            value: parseInt(number, 8),
-            octal: true,
-            lineNumber: lineNumber,
-            lineStart: lineStart,
-            start: start,
-            end: index
-        };
-    }
-
-    function scanNumericLiteral() {
-        var number, start, ch;
-
-        ch = source[index];
-        assert(isDecimalDigit(ch.charCodeAt(0)) || (ch === '.'),
-            'Numeric literal must start with a decimal digit or a decimal point');
-
-        start = index;
-        number = '';
-        if (ch !== '.') {
-            number = source[index++];
-            ch = source[index];
-
-            // Hex number starts with '0x'.
-            // Octal number starts with '0'.
-            if (number === '0') {
-                if (ch === 'x' || ch === 'X') {
-                    ++index;
-                    return scanHexLiteral(start);
-                }
-                if (isOctalDigit(ch)) {
-                    return scanOctalLiteral(start);
-                }
-
-                // decimal number starts with '0' such as '09' is illegal.
-                if (ch && isDecimalDigit(ch.charCodeAt(0))) {
-                    throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
-                }
-            }
-
-            while (isDecimalDigit(source.charCodeAt(index))) {
-                number += source[index++];
-            }
-            ch = source[index];
-        }
-
-        if (ch === '.') {
-            number += source[index++];
-            while (isDecimalDigit(source.charCodeAt(index))) {
-                number += source[index++];
-            }
-            ch = source[index];
-        }
-
-        if (ch === 'e' || ch === 'E') {
-            number += source[index++];
-
-            ch = source[index];
-            if (ch === '+' || ch === '-') {
-                number += source[index++];
-            }
-            if (isDecimalDigit(source.charCodeAt(index))) {
-                while (isDecimalDigit(source.charCodeAt(index))) {
-                    number += source[index++];
-                }
-            } else {
-                throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
-            }
-        }
-
-        if (isIdentifierStart(source.charCodeAt(index))) {
-            throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
-        }
-
-        return {
-            type: Token.NumericLiteral,
-            value: parseFloat(number),
-            lineNumber: lineNumber,
-            lineStart: lineStart,
-            start: start,
-            end: index
-        };
-    }
-
-    // 7.8.4 String Literals
-
-    function scanStringLiteral() {
-        var str = '', quote, start, ch, code, unescaped, restore, octal = false, startLineNumber, startLineStart;
-        startLineNumber = lineNumber;
-        startLineStart = lineStart;
-
-        quote = source[index];
-        assert((quote === '\'' || quote === '"'),
-            'String literal must starts with a quote');
-
-        start = index;
-        ++index;
-
-        while (index < length) {
-            ch = source[index++];
-
-            if (ch === quote) {
-                quote = '';
-                break;
-            } else if (ch === '\\') {
-                ch = source[index++];
-                if (!ch || !isLineTerminator(ch.charCodeAt(0))) {
-                    switch (ch) {
-                    case 'u':
-                    case 'x':
-                        restore = index;
-                        unescaped = scanHexEscape(ch);
-                        if (unescaped) {
-                            str += unescaped;
-                        } else {
-                            index = restore;
-                            str += ch;
-                        }
-                        break;
-                    case 'n':
-                        str += '\n';
-                        break;
-                    case 'r':
-                        str += '\r';
-                        break;
-                    case 't':
-                        str += '\t';
-                        break;
-                    case 'b':
-                        str += '\b';
-                        break;
-                    case 'f':
-                        str += '\f';
-                        break;
-                    case 'v':
-                        str += '\x0B';
-                        break;
-
-                    default:
-                        if (isOctalDigit(ch)) {
-                            code = '01234567'.indexOf(ch);
-
-                            // \0 is not octal escape sequence
-                            if (code !== 0) {
-                                octal = true;
-                            }
-
-                            if (index < length && isOctalDigit(source[index])) {
-                                octal = true;
-                                code = code * 8 + '01234567'.indexOf(source[index++]);
-
-                                // 3 digits are only allowed when string starts
-                                // with 0, 1, 2, 3
-                                if ('0123'.indexOf(ch) >= 0 &&
-                                        index < length &&
-                                        isOctalDigit(source[index])) {
-                                    code = code * 8 + '01234567'.indexOf(source[index++]);
-                                }
-                            }
-                            str += String.fromCharCode(code);
-                        } else {
-                            str += ch;
-                        }
-                        break;
-                    }
-                } else {
-                    ++lineNumber;
-                    if (ch ===  '\r' && source[index] === '\n') {
-                        ++index;
-                    }
-                    lineStart = index;
-                }
-            } else if (isLineTerminator(ch.charCodeAt(0))) {
-                break;
-            } else {
-                str += ch;
-            }
-        }
-
-        if (quote !== '') {
-            throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
-        }
-
-        return {
-            type: Token.StringLiteral,
-            value: str,
-            octal: octal,
-            startLineNumber: startLineNumber,
-            startLineStart: startLineStart,
-            lineNumber: lineNumber,
-            lineStart: lineStart,
-            start: start,
-            end: index
-        };
-    }
-
-    function testRegExp(pattern, flags) {
-        var value;
-        try {
-            value = new RegExp(pattern, flags);
-        } catch (e) {
-            throwError({}, Messages.InvalidRegExp);
-        }
-        return value;
-    }
-
-    function scanRegExpBody() {
-        var ch, str, classMarker, terminated, body;
-
-        ch = source[index];
-        assert(ch === '/', 'Regular expression literal must start with a slash');
-        str = source[index++];
-
-        classMarker = false;
-        terminated = false;
-        while (index < length) {
-            ch = source[index++];
-            str += ch;
-            if (ch === '\\') {
-                ch = source[index++];
-                // ECMA-262 7.8.5
-                if (isLineTerminator(ch.charCodeAt(0))) {
-                    throwError({}, Messages.UnterminatedRegExp);
-                }
-                str += ch;
-            } else if (isLineTerminator(ch.charCodeAt(0))) {
-                throwError({}, Messages.UnterminatedRegExp);
-            } else if (classMarker) {
-                if (ch === ']') {
-                    classMarker = false;
-                }
-            } else {
-                if (ch === '/') {
-                    terminated = true;
-                    break;
-                } else if (ch === '[') {
-                    classMarker = true;
-                }
-            }
-        }
-
-        if (!terminated) {
-            throwError({}, Messages.UnterminatedRegExp);
-        }
-
-        // Exclude leading and trailing slash.
-        body = str.substr(1, str.length - 2);
-        return {
-            value: body,
-            literal: str
-        };
-    }
-
-    function scanRegExpFlags() {
-        var ch, str, flags, restore;
-
-        str = '';
-        flags = '';
-        while (index < length) {
-            ch = source[index];
-            if (!isIdentifierPart(ch.charCodeAt(0))) {
-                break;
-            }
-
-            ++index;
-            if (ch === '\\' && index < length) {
-                ch = source[index];
-                if (ch === 'u') {
-                    ++index;
-                    restore = index;
-                    ch = scanHexEscape('u');
-                    if (ch) {
-                        flags += ch;
-                        for (str += '\\u'; restore < index; ++restore) {
-                            str += source[restore];
-                        }
-                    } else {
-                        index = restore;
-                        flags += 'u';
-                        str += '\\u';
-                    }
-                    throwErrorTolerant({}, Messages.UnexpectedToken, 'ILLEGAL');
-                } else {
-                    str += '\\';
-                    throwErrorTolerant({}, Messages.UnexpectedToken, 'ILLEGAL');
-                }
-            } else {
-                flags += ch;
-                str += ch;
-            }
-        }
-
-        return {
-            value: flags,
-            literal: str
-        };
-    }
-
-    function scanRegExp() {
-        var start, body, flags, pattern, value;
-
-        lookahead = null;
-        skipComment();
-        start = index;
-
-        body = scanRegExpBody();
-        flags = scanRegExpFlags();
-        value = testRegExp(body.value, flags.value);
-
-        if (extra.tokenize) {
-            return {
-                type: Token.RegularExpression,
-                value: value,
-                lineNumber: lineNumber,
-                lineStart: lineStart,
-                start: start,
-                end: index
-            };
-        }
-
-        return {
-            literal: body.literal + flags.literal,
-            value: value,
-            start: start,
-            end: index
-        };
-    }
-
-    function collectRegex() {
-        var pos, loc, regex, token;
-
-        skipComment();
-
-        pos = index;
-        loc = {
-            start: {
-                line: lineNumber,
-                column: index - lineStart
-            }
-        };
-
-        regex = scanRegExp();
-        loc.end = {
-            line: lineNumber,
-            column: index - lineStart
-        };
-
-        /* istanbul ignore next */
-        if (!extra.tokenize) {
-            // Pop the previous token, which is likely '/' or '/='
-            if (extra.tokens.length > 0) {
-                token = extra.tokens[extra.tokens.length - 1];
-                if (token.range[0] === pos && token.type === 'Punctuator') {
-                    if (token.value === '/' || token.value === '/=') {
-                        extra.tokens.pop();
-                    }
-                }
-            }
-
-            extra.tokens.push({
-                type: 'RegularExpression',
-                value: regex.literal,
-                range: [pos, index],
-                loc: loc
-            });
-        }
-
-        return regex;
-    }
-
-    function isIdentifierName(token) {
-        return token.type === Token.Identifier ||
-            token.type === Token.Keyword ||
-            token.type === Token.BooleanLiteral ||
-            token.type === Token.NullLiteral;
-    }
-
-    function advanceSlash() {
-        var prevToken,
-            checkToken;
-        // Using the following algorithm:
-        // https://github.com/mozilla/sweet.js/wiki/design
-        prevToken = extra.tokens[extra.tokens.length - 1];
-        if (!prevToken) {
-            // Nothing before that: it cannot be a division.
-            return collectRegex();
-        }
-        if (prevToken.type === 'Punctuator') {
-            if (prevToken.value === ']') {
-                return scanPunctuator();
-            }
-            if (prevToken.value === ')') {
-                checkToken = extra.tokens[extra.openParenToken - 1];
-                if (checkToken &&
-                        checkToken.type === 'Keyword' &&
-                        (checkToken.value === 'if' ||
-                         checkToken.value === 'while' ||
-                         checkToken.value === 'for' ||
-                         checkToken.value === 'with')) {
-                    return collectRegex();
-                }
-                return scanPunctuator();
-            }
-            if (prevToken.value === '}') {
-                // Dividing a function by anything makes little sense,
-                // but we have to check for that.
-                if (extra.tokens[extra.openCurlyToken - 3] &&
-                        extra.tokens[extra.openCurlyToken - 3].type === 'Keyword') {
-                    // Anonymous function.
-                    checkToken = extra.tokens[extra.openCurlyToken - 4];
-                    if (!checkToken) {
-                        return scanPunctuator();
-                    }
-                } else if (extra.tokens[extra.openCurlyToken - 4] &&
-                        extra.tokens[extra.openCurlyToken - 4].type === 'Keyword') {
-                    // Named function.
-                    checkToken = extra.tokens[extra.openCurlyToken - 5];
-                    if (!checkToken) {
-                        return collectRegex();
-                    }
-                } else {
-                    return scanPunctuator();
-                }
-                // checkToken determines whether the function is
-                // a declaration or an expression.
-                if (FnExprTokens.indexOf(checkToken.value) >= 0) {
-                    // It is an expression.
-                    return scanPunctuator();
-                }
-                // It is a declaration.
-                return collectRegex();
-            }
-            return collectRegex();
-        }
-        if (prevToken.type === 'Keyword' && prevToken.value !== 'this') {
-            return collectRegex();
-        }
-        return scanPunctuator();
-    }
-
-    function advance() {
-        var ch;
-
-        skipComment();
-
-        if (index >= length) {
-            return {
-                type: Token.EOF,
-                lineNumber: lineNumber,
-                lineStart: lineStart,
-                start: index,
-                end: index
-            };
-        }
-
-        ch = source.charCodeAt(index);
-
-        if (isIdentifierStart(ch)) {
-            return scanIdentifier();
-        }
-
-        // Very common: ( and ) and ;
-        if (ch === 0x28 || ch === 0x29 || ch === 0x3B) {
-            return scanPunctuator();
-        }
-
-        // String literal starts with single quote (U+0027) or double quote (U+0022).
-        if (ch === 0x27 || ch === 0x22) {
-            return scanStringLiteral();
-        }
-
-
-        // Dot (.) U+002E can also start a floating-point number, hence the need
-        // to check the next character.
-        if (ch === 0x2E) {
-            if (isDecimalDigit(source.charCodeAt(index + 1))) {
-                return scanNumericLiteral();
-            }
-            return scanPunctuator();
-        }
-
-        if (isDecimalDigit(ch)) {
-            return scanNumericLiteral();
-        }
-
-        // Slash (/) U+002F can also start a regex.
-        if (extra.tokenize && ch === 0x2F) {
-            return advanceSlash();
-        }
-
-        return scanPunctuator();
-    }
-
-    function collectToken() {
-        var loc, token, range, value;
-
-        skipComment();
-        loc = {
-            start: {
-                line: lineNumber,
-                column: index - lineStart
-            }
-        };
-
-        token = advance();
-        loc.end = {
-            line: lineNumber,
-            column: index - lineStart
-        };
-
-        if (token.type !== Token.EOF) {
-            value = source.slice(token.start, token.end);
-            extra.tokens.push({
-                type: TokenName[token.type],
-                value: value,
-                range: [token.start, token.end],
-                loc: loc
-            });
-        }
-
-        return token;
-    }
-
-    function lex() {
-        var token;
-
-        token = lookahead;
-        index = token.end;
-        lineNumber = token.lineNumber;
-        lineStart = token.lineStart;
-
-        lookahead = (typeof extra.tokens !== 'undefined') ? collectToken() : advance();
-
-        index = token.end;
-        lineNumber = token.lineNumber;
-        lineStart = token.lineStart;
-
-        return token;
-    }
-
-    function peek() {
-        var pos, line, start;
-
-        pos = index;
-        line = lineNumber;
-        start = lineStart;
-        lookahead = (typeof extra.tokens !== 'undefined') ? collectToken() : advance();
-        index = pos;
-        lineNumber = line;
-        lineStart = start;
-    }
-
-    function Position(line, column) {
-        this.line = line;
-        this.column = column;
-    }
-
-    function SourceLocation(startLine, startColumn, line, column) {
-        this.start = new Position(startLine, startColumn);
-        this.end = new Position(line, column);
-    }
-
-    SyntaxTreeDelegate = {
-
-        name: 'SyntaxTree',
-
-        processComment: function (node) {
-            var lastChild, trailingComments;
-
-            if (node.type === Syntax.Program) {
-                if (node.body.length > 0) {
-                    return;
-                }
-            }
-
-            if (extra.trailingComments.length > 0) {
-                if (extra.trailingComments[0].range[0] >= node.range[1]) {
-                    trailingComments = extra.trailingComments;
-                    extra.trailingComments = [];
-                } else {
-                    extra.trailingComments.length = 0;
-                }
-            } else {
-                if (extra.bottomRightStack.length > 0 &&
-                        extra.bottomRightStack[extra.bottomRightStack.length - 1].trailingComments &&
-                        extra.bottomRightStack[extra.bottomRightStack.length - 1].trailingComments[0].range[0] >= node.range[1]) {
-                    trailingComments = extra.bottomRightStack[extra.bottomRightStack.length - 1].trailingComments;
-                    delete extra.bottomRightStack[extra.bottomRightStack.length - 1].trailingComments;
-                }
-            }
-
-            // Eating the stack.
-            while (extra.bottomRightStack.length > 0 && extra.bottomRightStack[extra.bottomRightStack.length - 1].range[0] >= node.range[0]) {
-                lastChild = extra.bottomRightStack.pop();
-            }
-
-            if (lastChild) {
-                if (lastChild.leadingComments && lastChild.leadingComments[lastChild.leadingComments.length - 1].range[1] <= node.range[0]) {
-                    node.leadingComments = lastChild.leadingComments;
-                    delete lastChild.leadingComments;
-                }
-            } else if (extra.leadingComments.length > 0 && extra.leadingComments[extra.leadingComments.length - 1].range[1] <= node.range[0]) {
-                node.leadingComments = extra.leadingComments;
-                extra.leadingComments = [];
-            }
-
-
-            if (trailingComments) {
-                node.trailingComments = trailingComments;
-            }
-
-            extra.bottomRightStack.push(node);
-        },
-
-        markEnd: function (node, startToken) {
-            if (extra.range) {
-                node.range = [startToken.start, index];
-            }
-            if (extra.loc) {
-                node.loc = new SourceLocation(
-                    startToken.startLineNumber === undefined ?  startToken.lineNumber : startToken.startLineNumber,
-                    startToken.start - (startToken.startLineStart === undefined ?  startToken.lineStart : startToken.startLineStart),
-                    lineNumber,
-                    index - lineStart
-                );
-                this.postProcess(node);
-            }
-
-            if (extra.attachComment) {
-                this.processComment(node);
-            }
-            return node;
-        },
-
-        postProcess: function (node) {
-            if (extra.source) {
-                node.loc.source = extra.source;
-            }
-            return node;
-        },
-
-        createArrayExpression: function (elements) {
-            return {
-                type: Syntax.ArrayExpression,
-                elements: elements
-            };
-        },
-
-        createAssignmentExpression: function (operator, left, right) {
-            return {
-                type: Syntax.AssignmentExpression,
-                operator: operator,
-                left: left,
-                right: right
-            };
-        },
-
-        createBinaryExpression: function (operator, left, right) {
-            var type = (operator === '||' || operator === '&&') ? Syntax.LogicalExpression :
-                        Syntax.BinaryExpression;
-            return {
-                type: type,
-                operator: operator,
-                left: left,
-                right: right
-            };
-        },
-
-        createBlockStatement: function (body) {
-            return {
-                type: Syntax.BlockStatement,
-                body: body
-            };
-        },
-
-        createBreakStatement: function (label) {
-            return {
-                type: Syntax.BreakStatement,
-                label: label
-            };
-        },
-
-        createCallExpression: function (callee, args) {
-            return {
-                type: Syntax.CallExpression,
-                callee: callee,
-                'arguments': args
-            };
-        },
-
-        createCatchClause: function (param, body) {
-            return {
-                type: Syntax.CatchClause,
-                param: param,
-                body: body
-            };
-        },
-
-        createConditionalExpression: function (test, consequent, alternate) {
-            return {
-                type: Syntax.ConditionalExpression,
-                test: test,
-                consequent: consequent,
-                alternate: alternate
-            };
-        },
-
-        createContinueStatement: function (label) {
-            return {
-                type: Syntax.ContinueStatement,
-                label: label
-            };
-        },
-
-        createDebuggerStatement: function () {
-            return {
-                type: Syntax.DebuggerStatement
-            };
-        },
-
-        createDoWhileStatement: function (body, test) {
-            return {
-                type: Syntax.DoWhileStatement,
-                body: body,
-                test: test
-            };
-        },
-
-        createEmptyStatement: function () {
-            return {
-                type: Syntax.EmptyStatement
-            };
-        },
-
-        createExpressionStatement: function (expression) {
-            return {
-                type: Syntax.ExpressionStatement,
-                expression: expression
-            };
-        },
-
-        createForStatement: function (init, test, update, body) {
-            return {
-                type: Syntax.ForStatement,
-                init: init,
-                test: test,
-                update: update,
-                body: body
-            };
-        },
-
-        createForInStatement: function (left, right, body) {
-            return {
-                type: Syntax.ForInStatement,
-                left: left,
-                right: right,
-                body: body,
-                each: false
-            };
-        },
-
-        createFunctionDeclaration: function (id, params, defaults, body) {
-            return {
-                type: Syntax.FunctionDeclaration,
-                id: id,
-                params: params,
-                defaults: defaults,
-                body: body,
-                rest: null,
-                generator: false,
-                expression: false
-            };
-        },
-
-        createFunctionExpression: function (id, params, defaults, body) {
-            return {
-                type: Syntax.FunctionExpression,
-                id: id,
-                params: params,
-                defaults: defaults,
-                body: body,
-                rest: null,
-                generator: false,
-                expression: false
-            };
-        },
-
-        createIdentifier: function (name) {
-            return {
-                type: Syntax.Identifier,
-                name: name
-            };
-        },
-
-        createIfStatement: function (test, consequent, alternate) {
-            return {
-                type: Syntax.IfStatement,
-                test: test,
-                consequent: consequent,
-                alternate: alternate
-            };
-        },
-
-        createLabeledStatement: function (label, body) {
-            return {
-                type: Syntax.LabeledStatement,
-                label: label,
-                body: body
-            };
-        },
-
-        createLiteral: function (token) {
-            return {
-                type: Syntax.Literal,
-                value: token.value,
-                raw: source.slice(token.start, token.end)
-            };
-        },
-
-        createMemberExpression: function (accessor, object, property) {
-            return {
-                type: Syntax.MemberExpression,
-                computed: accessor === '[',
-                object: object,
-                property: property
-            };
-        },
-
-        createNewExpression: function (callee, args) {
-            return {
-                type: Syntax.NewExpression,
-                callee: callee,
-                'arguments': args
-            };
-        },
-
-        createObjectExpression: function (properties) {
-            return {
-                type: Syntax.ObjectExpression,
-                properties: properties
-            };
-        },
-
-        createPostfixExpression: function (operator, argument) {
-            return {
-                type: Syntax.UpdateExpression,
-                operator: operator,
-                argument: argument,
-                prefix: false
-            };
-        },
-
-        createProgram: function (body) {
-            return {
-                type: Syntax.Program,
-                body: body
-            };
-        },
-
-        createProperty: function (kind, key, value) {
-            return {
-                type: Syntax.Property,
-                key: key,
-                value: value,
-                kind: kind
-            };
-        },
-
-        createReturnStatement: function (argument) {
-            return {
-                type: Syntax.ReturnStatement,
-                argument: argument
-            };
-        },
-
-        createSequenceExpression: function (expressions) {
-            return {
-                type: Syntax.SequenceExpression,
-                expressions: expressions
-            };
-        },
-
-        createSwitchCase: function (test, consequent) {
-            return {
-                type: Syntax.SwitchCase,
-                test: test,
-                consequent: consequent
-            };
-        },
-
-        createSwitchStatement: function (discriminant, cases) {
-            return {
-                type: Syntax.SwitchStatement,
-                discriminant: discriminant,
-                cases: cases
-            };
-        },
-
-        createThisExpression: function () {
-            return {
-                type: Syntax.ThisExpression
-            };
-        },
-
-        createThrowStatement: function (argument) {
-            return {
-                type: Syntax.ThrowStatement,
-                argument: argument
-            };
-        },
-
-        createTryStatement: function (block, guardedHandlers, handlers, finalizer) {
-            return {
-                type: Syntax.TryStatement,
-                block: block,
-                guardedHandlers: guardedHandlers,
-                handlers: handlers,
-                finalizer: finalizer
-            };
-        },
-
-        createUnaryExpression: function (operator, argument) {
-            if (operator === '++' || operator === '--') {
-                return {
-                    type: Syntax.UpdateExpression,
-                    operator: operator,
-                    argument: argument,
-                    prefix: true
-                };
-            }
-            return {
-                type: Syntax.UnaryExpression,
-                operator: operator,
-                argument: argument,
-                prefix: true
-            };
-        },
-
-        createVariableDeclaration: function (declarations, kind) {
-            return {
-                type: Syntax.VariableDeclaration,
-                declarations: declarations,
-                kind: kind
-            };
-        },
-
-        createVariableDeclarator: function (id, init) {
-            return {
-                type: Syntax.VariableDeclarator,
-                id: id,
-                init: init
-            };
-        },
-
-        createWhileStatement: function (test, body) {
-            return {
-                type: Syntax.WhileStatement,
-                test: test,
-                body: body
-            };
-        },
-
-        createWithStatement: function (object, body) {
-            return {
-                type: Syntax.WithStatement,
-                object: object,
-                body: body
-            };
-        }
-    };
-
-    // Return true if there is a line terminator before the next token.
-
-    function peekLineTerminator() {
-        var pos, line, start, found;
-
-        pos = index;
-        line = lineNumber;
-        start = lineStart;
-        skipComment();
-        found = lineNumber !== line;
-        index = pos;
-        lineNumber = line;
-        lineStart = start;
-
-        return found;
-    }
-
-    // Throw an exception
-
-    function throwError(token, messageFormat) {
-        var error,
-            args = Array.prototype.slice.call(arguments, 2),
-            msg = messageFormat.replace(
-                /%(\d)/g,
-                function (whole, index) {
-                    assert(index < args.length, 'Message reference must be in range');
-                    return args[index];
-                }
-            );
-
-        if (typeof token.lineNumber === 'number') {
-            error = new Error('Line ' + token.lineNumber + ': ' + msg);
-            error.index = token.start;
-            error.lineNumber = token.lineNumber;
-            error.column = token.start - lineStart + 1;
-        } else {
-            error = new Error('Line ' + lineNumber + ': ' + msg);
-            error.index = index;
-            error.lineNumber = lineNumber;
-            error.column = index - lineStart + 1;
-        }
-
-        error.description = msg;
-        throw error;
-    }
-
-    function throwErrorTolerant() {
-        try {
-            throwError.apply(null, arguments);
-        } catch (e) {
-            if (extra.errors) {
-                extra.errors.push(e);
-            } else {
-                throw e;
-            }
-        }
-    }
-
-
-    // Throw an exception because of the token.
-
-    function throwUnexpected(token) {
-        if (token.type === Token.EOF) {
-            throwError(token, Messages.UnexpectedEOS);
-        }
-
-        if (token.type === Token.NumericLiteral) {
-            throwError(token, Messages.UnexpectedNumber);
-        }
-
-        if (token.type === Token.StringLiteral) {
-            throwError(token, Messages.UnexpectedString);
-        }
-
-        if (token.type === Token.Identifier) {
-            throwError(token, Messages.UnexpectedIdentifier);
-        }
-
-        if (token.type === Token.Keyword) {
-            if (isFutureReservedWord(token.value)) {
-                throwError(token, Messages.UnexpectedReserved);
-            } else if (strict && isStrictModeReservedWord(token.value)) {
-                throwErrorTolerant(token, Messages.StrictReservedWord);
-                return;
-            }
-            throwError(token, Messages.UnexpectedToken, token.value);
-        }
-
-        // BooleanLiteral, NullLiteral, or Punctuator.
-        throwError(token, Messages.UnexpectedToken, token.value);
-    }
-
-    // Expect the next token to match the specified punctuator.
-    // If not, an exception will be thrown.
-
-    function expect(value) {
-        var token = lex();
-        if (token.type !== Token.Punctuator || token.value !== value) {
-            throwUnexpected(token);
-        }
-    }
-
-    // Expect the next token to match the specified keyword.
-    // If not, an exception will be thrown.
-
-    function expectKeyword(keyword) {
-        var token = lex();
-        if (token.type !== Token.Keyword || token.value !== keyword) {
-            throwUnexpected(token);
-        }
-    }
-
-    // Return true if the next token matches the specified punctuator.
-
-    function match(value) {
-        return lookahead.type === Token.Punctuator && lookahead.value === value;
-    }
-
-    // Return true if the next token matches the specified keyword
-
-    function matchKeyword(keyword) {
-        return lookahead.type === Token.Keyword && lookahead.value === keyword;
-    }
-
-    // Return true if the next token is an assignment operator
-
-    function matchAssign() {
-        var op;
-
-        if (lookahead.type !== Token.Punctuator) {
-            return false;
-        }
-        op = lookahead.value;
-        return op === '=' ||
-            op === '*=' ||
-            op === '/=' ||
-            op === '%=' ||
-            op === '+=' ||
-            op === '-=' ||
-            op === '<<=' ||
-            op === '>>=' ||
-            op === '>>>=' ||
-            op === '&=' ||
-            op === '^=' ||
-            op === '|=';
-    }
-
-    function consumeSemicolon() {
-        var line, oldIndex = index, oldLineNumber = lineNumber,
-            oldLineStart = lineStart, oldLookahead = lookahead;
-
-        // Catch the very common case first: immediately a semicolon (U+003B).
-        if (source.charCodeAt(index) === 0x3B || match(';')) {
-            lex();
-            return;
-        }
-
-        line = lineNumber;
-        skipComment();
-        if (lineNumber !== line) {
-            index = oldIndex;
-            lineNumber = oldLineNumber;
-            lineStart = oldLineStart;
-            lookahead = oldLookahead;
-            return;
-        }
-
-        if (lookahead.type !== Token.EOF && !match('}')) {
-            throwUnexpected(lookahead);
-        }
-    }
-
-    // Return true if provided expression is LeftHandSideExpression
-
-    function isLeftHandSide(expr) {
-        return expr.type === Syntax.Identifier || expr.type === Syntax.MemberExpression;
-    }
-
-    // 11.1.4 Array Initialiser
-
-    function parseArrayInitialiser() {
-        var elements = [], startToken;
-
-        startToken = lookahead;
-        expect('[');
-
-        while (!match(']')) {
-            if (match(',')) {
-                lex();
-                elements.push(null);
-            } else {
-                elements.push(parseAssignmentExpression());
-
-                if (!match(']')) {
-                    expect(',');
-                }
-            }
-        }
-
-        lex();
-
-        return delegate.markEnd(delegate.createArrayExpression(elements), startToken);
-    }
-
-    // 11.1.5 Object Initialiser
-
-    function parsePropertyFunction(param, first) {
-        var previousStrict, body, startToken;
-
-        previousStrict = strict;
-        startToken = lookahead;
-        body = parseFunctionSourceElements();
-        if (first && strict && isRestrictedWord(param[0].name)) {
-            throwErrorTolerant(first, Messages.StrictParamName);
-        }
-        strict = previousStrict;
-        return delegate.markEnd(delegate.createFunctionExpression(null, param, [], body), startToken);
-    }
-
-    function parseObjectPropertyKey() {
-        var token, startToken;
-
-        startToken = lookahead;
-        token = lex();
-
-        // Note: This function is called only from parseObjectProperty(), where
-        // EOF and Punctuator tokens are already filtered out.
-
-        if (token.type === Token.StringLiteral || token.type === Token.NumericLiteral) {
-            if (strict && token.octal) {
-                throwErrorTolerant(token, Messages.StrictOctalLiteral);
-            }
-            return delegate.markEnd(delegate.createLiteral(token), startToken);
-        }
-
-        return delegate.markEnd(delegate.createIdentifier(token.value), startToken);
-    }
-
-    function parseObjectProperty() {
-        var token, key, id, value, param, startToken;
-
-        token = lookahead;
-        startToken = lookahead;
-
-        if (token.type === Token.Identifier) {
-
-            id = parseObjectPropertyKey();
-
-            // Property Assignment: Getter and Setter.
-
-            if (token.value === 'get' && !match(':')) {
-                key = parseObjectPropertyKey();
-                expect('(');
-                expect(')');
-                value = parsePropertyFunction([]);
-                return delegate.markEnd(delegate.createProperty('get', key, value), startToken);
-            }
-            if (token.value === 'set' && !match(':')) {
-                key = parseObjectPropertyKey();
-                expect('(');
-                token = lookahead;
-                if (token.type !== Token.Identifier) {
-                    expect(')');
-                    throwErrorTolerant(token, Messages.UnexpectedToken, token.value);
-                    value = parsePropertyFunction([]);
-                } else {
-                    param = [ parseVariableIdentifier() ];
-                    expect(')');
-                    value = parsePropertyFunction(param, token);
-                }
-                return delegate.markEnd(delegate.createProperty('set', key, value), startToken);
-            }
-            expect(':');
-            value = parseAssignmentExpression();
-            return delegate.markEnd(delegate.createProperty('init', id, value), startToken);
-        }
-        if (token.type === Token.EOF || token.type === Token.Punctuator) {
-            throwUnexpected(token);
-        } else {
-            key = parseObjectPropertyKey();
-            expect(':');
-            value = parseAssignmentExpression();
-            return delegate.markEnd(delegate.createProperty('init', key, value), startToken);
-        }
-    }
-
-    function parseObjectInitialiser() {
-        var properties = [], property, name, key, kind, map = {}, toString = String, startToken;
-
-        startToken = lookahead;
-
-        expect('{');
-
-        while (!match('}')) {
-            property = parseObjectProperty();
-
-            if (property.key.type === Syntax.Identifier) {
-                name = property.key.name;
-            } else {
-                name = toString(property.key.value);
-            }
-            kind = (property.kind === 'init') ? PropertyKind.Data : (property.kind === 'get') ? PropertyKind.Get : PropertyKind.Set;
-
-            key = '$' + name;
-            if (Object.prototype.hasOwnProperty.call(map, key)) {
-                if (map[key] === PropertyKind.Data) {
-                    if (strict && kind === PropertyKind.Data) {
-                        throwErrorTolerant({}, Messages.StrictDuplicateProperty);
-                    } else if (kind !== PropertyKind.Data) {
-                        throwErrorTolerant({}, Messages.AccessorDataProperty);
-                    }
-                } else {
-                    if (kind === PropertyKind.Data) {
-                        throwErrorTolerant({}, Messages.AccessorDataProperty);
-                    } else if (map[key] & kind) {
-                        throwErrorTolerant({}, Messages.AccessorGetSet);
-                    }
-                }
-                map[key] |= kind;
-            } else {
-                map[key] = kind;
-            }
-
-            properties.push(property);
-
-            if (!match('}')) {
-                expect(',');
-            }
-        }
-
-        expect('}');
-
-        return delegate.markEnd(delegate.createObjectExpression(properties), startToken);
-    }
-
-    // 11.1.6 The Grouping Operator
-
-    function parseGroupExpression() {
-        var expr;
-
-        expect('(');
-
-        expr = parseExpression();
-
-        expect(')');
-
-        return expr;
-    }
-
-
-    // 11.1 Primary Expressions
-
-    function parsePrimaryExpression() {
-        var type, token, expr, startToken;
-
-        if (match('(')) {
-            return parseGroupExpression();
-        }
-
-        if (match('[')) {
-            return parseArrayInitialiser();
-        }
-
-        if (match('{')) {
-            return parseObjectInitialiser();
-        }
-
-        type = lookahead.type;
-        startToken = lookahead;
-
-        if (type === Token.Identifier) {
-            expr =  delegate.createIdentifier(lex().value);
-        } else if (type === Token.StringLiteral || type === Token.NumericLiteral) {
-            if (strict && lookahead.octal) {
-                throwErrorTolerant(lookahead, Messages.StrictOctalLiteral);
-            }
-            expr = delegate.createLiteral(lex());
-        } else if (type === Token.Keyword) {
-            if (matchKeyword('function')) {
-                return parseFunctionExpression();
-            }
-            if (matchKeyword('this')) {
-                lex();
-                expr = delegate.createThisExpression();
-            } else {
-                throwUnexpected(lex());
-            }
-        } else if (type === Token.BooleanLiteral) {
-            token = lex();
-            token.value = (token.value === 'true');
-            expr = delegate.createLiteral(token);
-        } else if (type === Token.NullLiteral) {
-            token = lex();
-            token.value = null;
-            expr = delegate.createLiteral(token);
-        } else if (match('/') || match('/=')) {
-            if (typeof extra.tokens !== 'undefined') {
-                expr = delegate.createLiteral(collectRegex());
-            } else {
-                expr = delegate.createLiteral(scanRegExp());
-            }
-            peek();
-        } else {
-            throwUnexpected(lex());
-        }
-
-        return delegate.markEnd(expr, startToken);
-    }
-
-    // 11.2 Left-Hand-Side Expressions
-
-    function parseArguments() {
-        var args = [];
-
-        expect('(');
-
-        if (!match(')')) {
-            while (index < length) {
-                args.push(parseAssignmentExpression());
-                if (match(')')) {
-                    break;
-                }
-                expect(',');
-            }
-        }
-
-        expect(')');
-
-        return args;
-    }
-
-    function parseNonComputedProperty() {
-        var token, startToken;
-
-        startToken = lookahead;
-        token = lex();
-
-        if (!isIdentifierName(token)) {
-            throwUnexpected(token);
-        }
-
-        return delegate.markEnd(delegate.createIdentifier(token.value), startToken);
-    }
-
-    function parseNonComputedMember() {
-        expect('.');
-
-        return parseNonComputedProperty();
-    }
-
-    function parseComputedMember() {
-        var expr;
-
-        expect('[');
-
-        expr = parseExpression();
-
-        expect(']');
-
-        return expr;
-    }
-
-    function parseNewExpression() {
-        var callee, args, startToken;
-
-        startToken = lookahead;
-        expectKeyword('new');
-        callee = parseLeftHandSideExpression();
-        args = match('(') ? parseArguments() : [];
-
-        return delegate.markEnd(delegate.createNewExpression(callee, args), startToken);
-    }
-
-    function parseLeftHandSideExpressionAllowCall() {
-        var expr, args, property, startToken, previousAllowIn = state.allowIn;
-
-        startToken = lookahead;
-        state.allowIn = true;
-        expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();
-
-        for (;;) {
-            if (match('.')) {
-                property = parseNonComputedMember();
-                expr = delegate.createMemberExpression('.', expr, property);
-            } else if (match('(')) {
-                args = parseArguments();
-                expr = delegate.createCallExpression(expr, args);
-            } else if (match('[')) {
-                property = parseComputedMember();
-                expr = delegate.createMemberExpression('[', expr, property);
-            } else {
-                break;
-            }
-            delegate.markEnd(expr, startToken);
-        }
-        state.allowIn = previousAllowIn;
-
-        return expr;
-    }
-
-    function parseLeftHandSideExpression() {
-        var expr, property, startToken;
-        assert(state.allowIn, 'callee of new expression always allow in keyword.');
-
-        startToken = lookahead;
-
-        expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();
-
-        while (match('.') || match('[')) {
-            if (match('[')) {
-                property = parseComputedMember();
-                expr = delegate.createMemberExpression('[', expr, property);
-            } else {
-                property = parseNonComputedMember();
-                expr = delegate.createMemberExpression('.', expr, property);
-            }
-            delegate.markEnd(expr, startToken);
-        }
-        return expr;
-    }
-
-    // 11.3 Postfix Expressions
-
-    function parsePostfixExpression() {
-        var expr, token, startToken = lookahead;
-
-        expr = parseLeftHandSideExpressionAllowCall();
-
-        if (lookahead.type === Token.Punctuator) {
-            if ((match('++') || match('--')) && !peekLineTerminator()) {
-                // 11.3.1, 11.3.2
-                if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {
-                    throwErrorTolerant({}, Messages.StrictLHSPostfix);
-                }
-
-                if (!isLeftHandSide(expr)) {
-                    throwErrorTolerant({}, Messages.InvalidLHSInAssignment);
-                }
-
-                token = lex();
-                expr = delegate.markEnd(delegate.createPostfixExpression(token.value, expr), startToken);
-            }
-        }
-
-        return expr;
-    }
-
-    // 11.4 Unary Operators
-
-    function parseUnaryExpression() {
-        var token, expr, startToken;
-
-        if (lookahead.type !== Token.Punctuator && lookahead.type !== Token.Keyword) {
-            expr = parsePostfixExpression();
-        } else if (match('++') || match('--')) {
-            startToken = lookahead;
-            token = lex();
-            expr = parseUnaryExpression();
-            // 11.4.4, 11.4.5
-            if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {
-                throwErrorTolerant({}, Messages.StrictLHSPrefix);
-            }
-
-            if (!isLeftHandSide(expr)) {
-                throwErrorTolerant({}, Messages.InvalidLHSInAssignment);
-            }
-
-            expr = delegate.createUnaryExpression(token.value, expr);
-            expr = delegate.markEnd(expr, startToken);
-        } else if (match('+') || match('-') || match('~') || match('!')) {
-            startToken = lookahead;
-            token = lex();
-            expr = parseUnaryExpression();
-            expr = delegate.createUnaryExpression(token.value, expr);
-            expr = delegate.markEnd(expr, startToken);
-        } else if (matchKeyword('delete') || matchKeyword('void') || matchKeyword('typeof')) {
-            startToken = lookahead;
-            token = lex();
-            expr = parseUnaryExpression();
-            expr = delegate.createUnaryExpression(token.value, expr);
-            expr = delegate.markEnd(expr, startToken);
-            if (strict && expr.operator === 'delete' && expr.argument.type === Syntax.Identifier) {
-                throwErrorTolerant({}, Messages.StrictDelete);
-            }
-        } else {
-            expr = parsePostfixExpression();
-        }
-
-        return expr;
-    }
-
-    function binaryPrecedence(token, allowIn) {
-        var prec = 0;
-
-        if (token.type !== Token.Punctuator && token.type !== Token.Keyword) {
-            return 0;
-        }
-
-        switch (token.value) {
-        case '||':
-            prec = 1;
-            break;
-
-        case '&&':
-            prec = 2;
-            break;
-
-        case '|':
-            prec = 3;
-            break;
-
-        case '^':
-            prec = 4;
-            break;
-
-        case '&':
-            prec = 5;
-            break;
-
-        case '==':
-        case '!=':
-        case '===':
-        case '!==':
-            prec = 6;
-            break;
-
-        case '<':
-        case '>':
-        case '<=':
-        case '>=':
-        case 'instanceof':
-            prec = 7;
-            break;
-
-        case 'in':
-            prec = allowIn ? 7 : 0;
-            break;
-
-        case '<<':
-        case '>>':
-        case '>>>':
-            prec = 8;
-            break;
-
-        case '+':
-        case '-':
-            prec = 9;
-            break;
-
-        case '*':
-        case '/':
-        case '%':
-            prec = 11;
-            break;
-
-        default:
-            break;
-        }
-
-        return prec;
-    }
-
-    // 11.5 Multiplicative Operators
-    // 11.6 Additive Operators
-    // 11.7 Bitwise Shift Operators
-    // 11.8 Relational Operators
-    // 11.9 Equality Operators
-    // 11.10 Binary Bitwise Operators
-    // 11.11 Binary Logical Operators
-
-    function parseBinaryExpression() {
-        var marker, markers, expr, token, prec, stack, right, operator, left, i;
-
-        marker = lookahead;
-        left = parseUnaryExpression();
-
-        token = lookahead;
-        prec = binaryPrecedence(token, state.allowIn);
-        if (prec === 0) {
-            return left;
-        }
-        token.prec = prec;
-        lex();
-
-        markers = [marker, lookahead];
-        right = parseUnaryExpression();
-
-        stack = [left, token, right];
-
-        while ((prec = binaryPrecedence(lookahead, state.allowIn)) > 0) {
-
-            // Reduce: make a binary expression from the three topmost entries.
-            while ((stack.length > 2) && (prec <= stack[stack.length - 2].prec)) {
-                right = stack.pop();
-                operator = stack.pop().value;
-                left = stack.pop();
-                expr = delegate.createBinaryExpression(operator, left, right);
-                markers.pop();
-                marker = markers[markers.length - 1];
-                delegate.markEnd(expr, marker);
-                stack.push(expr);
-            }
-
-            // Shift.
-            token = lex();
-            token.prec = prec;
-            stack.push(token);
-            markers.push(lookahead);
-            expr = parseUnaryExpression();
-            stack.push(expr);
-        }
-
-        // Final reduce to clean-up the stack.
-        i = stack.length - 1;
-        expr = stack[i];
-        markers.pop();
-        while (i > 1) {
-            expr = delegate.createBinaryExpression(stack[i - 1].value, stack[i - 2], expr);
-            i -= 2;
-            marker = markers.pop();
-            delegate.markEnd(expr, marker);
-        }
-
-        return expr;
-    }
-
-
-    // 11.12 Conditional Operator
-
-    function parseConditionalExpression() {
-        var expr, previousAllowIn, consequent, alternate, startToken;
-
-        startToken = lookahead;
-
-        expr = parseBinaryExpression();
-
-        if (match('?')) {
-            lex();
-            previousAllowIn = state.allowIn;
-            state.allowIn = true;
-            consequent = parseAssignmentExpression();
-            state.allowIn = previousAllowIn;
-            expect(':');
-            alternate = parseAssignmentExpression();
-
-            expr = delegate.createConditionalExpression(expr, consequent, alternate);
-            delegate.markEnd(expr, startToken);
-        }
-
-        return expr;
-    }
-
-    // 11.13 Assignment Operators
-
-    function parseAssignmentExpression() {
-        var token, left, right, node, startToken;
-
-        token = lookahead;
-        startToken = lookahead;
-
-        node = left = parseConditionalExpression();
-
-        if (matchAssign()) {
-            // LeftHandSideExpression
-            if (!isLeftHandSide(left)) {
-                throwErrorTolerant({}, Messages.InvalidLHSInAssignment);
-            }
-
-            // 11.13.1
-            if (strict && left.type === Syntax.Identifier && isRestrictedWord(left.name)) {
-                throwErrorTolerant(token, Messages.StrictLHSAssignment);
-            }
-
-            token = lex();
-            right = parseAssignmentExpression();
-            node = delegate.markEnd(delegate.createAssignmentExpression(token.value, left, right), startToken);
-        }
-
-        return node;
-    }
-
-    // 11.14 Comma Operator
-
-    function parseExpression() {
-        var expr, startToken = lookahead;
-
-        expr = parseAssignmentExpression();
-
-        if (match(',')) {
-            expr = delegate.createSequenceExpression([ expr ]);
-
-            while (index < length) {
-                if (!match(',')) {
-                    break;
-                }
-                lex();
-                expr.expressions.push(parseAssignmentExpression());
-            }
-
-            delegate.markEnd(expr, startToken);
-        }
-
-        return expr;
-    }
-
-    // 12.1 Block
-
-    function parseStatementList() {
-        var list = [],
-            statement;
-
-        while (index < length) {
-            if (match('}')) {
-                break;
-            }
-            statement = parseSourceElement();
-            if (typeof statement === 'undefined') {
-                break;
-            }
-            list.push(statement);
-        }
-
-        return list;
-    }
-
-    function parseBlock() {
-        var block, startToken;
-
-        startToken = lookahead;
-        expect('{');
-
-        block = parseStatementList();
-
-        expect('}');
-
-        return delegate.markEnd(delegate.createBlockStatement(block), startToken);
-    }
-
-    // 12.2 Variable Statement
-
-    function parseVariableIdentifier() {
-        var token, startToken;
-
-        startToken = lookahead;
-        token = lex();
-
-        if (token.type !== Token.Identifier) {
-            throwUnexpected(token);
-        }
-
-        return delegate.markEnd(delegate.createIdentifier(token.value), startToken);
-    }
-
-    function parseVariableDeclaration(kind) {
-        var init = null, id, startToken;
-
-        startToken = lookahead;
-        id = parseVariableIdentifier();
-
-        // 12.2.1
-        if (strict && isRestrictedWord(id.name)) {
-            throwErrorTolerant({}, Messages.StrictVarName);
-        }
-
-        if (kind === 'const') {
-            expect('=');
-            init = parseAssignmentExpression();
-        } else if (match('=')) {
-            lex();
-            init = parseAssignmentExpression();
-        }
-
-        return delegate.markEnd(delegate.createVariableDeclarator(id, init), startToken);
-    }
-
-    function parseVariableDeclarationList(kind) {
-        var list = [];
-
-        do {
-            list.push(parseVariableDeclaration(kind));
-            if (!match(',')) {
-                break;
-            }
-            lex();
-        } while (index < length);
-
-        return list;
-    }
-
-    function parseVariableStatement() {
-        var declarations;
-
-        expectKeyword('var');
-
-        declarations = parseVariableDeclarationList();
-
-        consumeSemicolon();
-
-        return delegate.createVariableDeclaration(declarations, 'var');
-    }
-
-    // kind may be `const` or `let`
-    // Both are experimental and not in the specification yet.
-    // see http://wiki.ecmascript.org/doku.php?id=harmony:const
-    // and http://wiki.ecmascript.org/doku.php?id=harmony:let
-    function parseConstLetDeclaration(kind) {
-        var declarations, startToken;
-
-        startToken = lookahead;
-
-        expectKeyword(kind);
-
-        declarations = parseVariableDeclarationList(kind);
-
-        consumeSemicolon();
-
-        return delegate.markEnd(delegate.createVariableDeclaration(declarations, kind), startToken);
-    }
-
-    // 12.3 Empty Statement
-
-    function parseEmptyStatement() {
-        expect(';');
-        return delegate.createEmptyStatement();
-    }
-
-    // 12.4 Expression Statement
-
-    function parseExpressionStatement() {
-        var expr = parseExpression();
-        consumeSemicolon();
-        return delegate.createExpressionStatement(expr);
-    }
-
-    // 12.5 If statement
-
-    function parseIfStatement() {
-        var test, consequent, alternate;
-
-        expectKeyword('if');
-
-        expect('(');
-
-        test = parseExpression();
-
-        expect(')');
-
-        consequent = parseStatement();
-
-        if (matchKeyword('else')) {
-            lex();
-            alternate = parseStatement();
-        } else {
-            alternate = null;
-        }
-
-        return delegate.createIfStatement(test, consequent, alternate);
-    }
-
-    // 12.6 Iteration Statements
-
-    function parseDoWhileStatement() {
-        var body, test, oldInIteration;
-
-        expectKeyword('do');
-
-        oldInIteration = state.inIteration;
-        state.inIteration = true;
-
-        body = parseStatement();
-
-        state.inIteration = oldInIteration;
-
-        expectKeyword('while');
-
-        expect('(');
-
-        test = parseExpression();
-
-        expect(')');
-
-        if (match(';')) {
-            lex();
-        }
-
-        return delegate.createDoWhileStatement(body, test);
-    }
-
-    function parseWhileStatement() {
-        var test, body, oldInIteration;
-
-        expectKeyword('while');
-
-        expect('(');
-
-        test = parseExpression();
-
-        expect(')');
-
-        oldInIteration = state.inIteration;
-        state.inIteration = true;
-
-        body = parseStatement();
-
-        state.inIteration = oldInIteration;
-
-        return delegate.createWhileStatement(test, body);
-    }
-
-    function parseForVariableDeclaration() {
-        var token, declarations, startToken;
-
-        startToken = lookahead;
-        token = lex();
-        declarations = parseVariableDeclarationList();
-
-        return delegate.markEnd(delegate.createVariableDeclaration(declarations, token.value), startToken);
-    }
-
-    function parseForStatement() {
-        var init, test, update, left, right, body, oldInIteration, previousAllowIn = state.allowIn;
-
-        init = test = update = null;
-
-        expectKeyword('for');
-
-        expect('(');
-
-        if (match(';')) {
-            lex();
-        } else {
-            if (matchKeyword('var') || matchKeyword('let')) {
-                state.allowIn = false;
-                init = parseForVariableDeclaration();
-                state.allowIn = previousAllowIn;
-
-                if (init.declarations.length === 1 && matchKeyword('in')) {
-                    lex();
-                    left = init;
-                    right = parseExpression();
-                    init = null;
-                }
-            } else {
-                state.allowIn = false;
-                init = parseExpression();
-                state.allowIn = previousAllowIn;
-
-                if (matchKeyword('in')) {
-                    // LeftHandSideExpression
-                    if (!isLeftHandSide(init)) {
-                        throwErrorTolerant({}, Messages.InvalidLHSInForIn);
-                    }
-
-                    lex();
-                    left = init;
-                    right = parseExpression();
-                    init = null;
-                }
-            }
-
-            if (typeof left === 'undefined') {
-                expect(';');
-            }
-        }
-
-        if (typeof left === 'undefined') {
-
-            if (!match(';')) {
-                test = parseExpression();
-            }
-            expect(';');
-
-            if (!match(')')) {
-                update = parseExpression();
-            }
-        }
-
-        expect(')');
-
-        oldInIteration = state.inIteration;
-        state.inIteration = true;
-
-        body = parseStatement();
-
-        state.inIteration = oldInIteration;
-
-        return (typeof left === 'undefined') ?
-                delegate.createForStatement(init, test, update, body) :
-                delegate.createForInStatement(left, right, body);
-    }
-
-    // 12.7 The continue statement
-
-    function parseContinueStatement() {
-        var label = null, key;
-
-        expectKeyword('continue');
-
-        // Optimize the most common form: 'continue;'.
-        if (source.charCodeAt(index) === 0x3B) {
-            lex();
-
-            if (!state.inIteration) {
-                throwError({}, Messages.IllegalContinue);
-            }
-
-            return delegate.createContinueStatement(null);
-        }
-
-        if (peekLineTerminator()) {
-            if (!state.inIteration) {
-                throwError({}, Messages.IllegalContinue);
-            }
-
-            return delegate.createContinueStatement(null);
-        }
-
-        if (lookahead.type === Token.Identifier) {
-            label = parseVariableIdentifier();
-
-            key = '$' + label.name;
-            if (!Object.prototype.hasOwnProperty.call(state.labelSet, key)) {
-                throwError({}, Messages.UnknownLabel, label.name);
-            }
-        }
-
-        consumeSemicolon();
-
-        if (label === null && !state.inIteration) {
-            throwError({}, Messages.IllegalContinue);
-        }
-
-        return delegate.createContinueStatement(label);
-    }
-
-    // 12.8 The break statement
-
-    function parseBreakStatement() {
-        var label = null, key;
-
-        expectKeyword('break');
-
-        // Catch the very common case first: immediately a semicolon (U+003B).
-        if (source.charCodeAt(index) === 0x3B) {
-            lex();
-
-            if (!(state.inIteration || state.inSwitch)) {
-                throwError({}, Messages.IllegalBreak);
-            }
-
-            return delegate.createBreakStatement(null);
-        }
-
-        if (peekLineTerminator()) {
-            if (!(state.inIteration || state.inSwitch)) {
-                throwError({}, Messages.IllegalBreak);
-            }
-
-            return delegate.createBreakStatement(null);
-        }
-
-        if (lookahead.type === Token.Identifier) {
-            label = parseVariableIdentifier();
-
-            key = '$' + label.name;
-            if (!Object.prototype.hasOwnProperty.call(state.labelSet, key)) {
-                throwError({}, Messages.UnknownLabel, label.name);
-            }
-        }
-
-        consumeSemicolon();
-
-        if (label === null && !(state.inIteration || state.inSwitch)) {
-            throwError({}, Messages.IllegalBreak);
-        }
-
-        return delegate.createBreakStatement(label);
-    }
-
-    // 12.9 The return statement
-
-    function parseReturnStatement() {
-        var argument = null;
-
-        expectKeyword('return');
-
-        if (!state.inFunctionBody) {
-            throwErrorTolerant({}, Messages.IllegalReturn);
-        }
-
-        // 'return' followed by a space and an identifier is very common.
-        if (source.charCodeAt(index) === 0x20) {
-            if (isIdentifierStart(source.charCodeAt(index + 1))) {
-                argument = parseExpression();
-                consumeSemicolon();
-                return delegate.createReturnStatement(argument);
-            }
-        }
-
-        if (peekLineTerminator()) {
-            return delegate.createReturnStatement(null);
-        }
-
-        if (!match(';')) {
-            if (!match('}') && lookahead.type !== Token.EOF) {
-                argument = parseExpression();
-            }
-        }
-
-        consumeSemicolon();
-
-        return delegate.createReturnStatement(argument);
-    }
-
-    // 12.10 The with statement
-
-    function parseWithStatement() {
-        var object, body;
-
-        if (strict) {
-            // TODO(ikarienator): Should we update the test cases instead?
-            skipComment();
-            throwErrorTolerant({}, Messages.StrictModeWith);
-        }
-
-        expectKeyword('with');
-
-        expect('(');
-
-        object = parseExpression();
-
-        expect(')');
-
-        body = parseStatement();
-
-        return delegate.createWithStatement(object, body);
-    }
-
-    // 12.10 The swith statement
-
-    function parseSwitchCase() {
-        var test, consequent = [], statement, startToken;
-
-        startToken = lookahead;
-        if (matchKeyword('default')) {
-            lex();
-            test = null;
-        } else {
-            expectKeyword('case');
-            test = parseExpression();
-        }
-        expect(':');
-
-        while (index < length) {
-            if (match('}') || matchKeyword('default') || matchKeyword('case')) {
-                break;
-            }
-            statement = parseStatement();
-            consequent.push(statement);
-        }
-
-        return delegate.markEnd(delegate.createSwitchCase(test, consequent), startToken);
-    }
-
-    function parseSwitchStatement() {
-        var discriminant, cases, clause, oldInSwitch, defaultFound;
-
-        expectKeyword('switch');
-
-        expect('(');
-
-        discriminant = parseExpression();
-
-        expect(')');
-
-        expect('{');
-
-        cases = [];
-
-        if (match('}')) {
-            lex();
-            return delegate.createSwitchStatement(discriminant, cases);
-        }
-
-        oldInSwitch = state.inSwitch;
-        state.inSwitch = true;
-        defaultFound = false;
-
-        while (index < length) {
-            if (match('}')) {
-                break;
-            }
-            clause = parseSwitchCase();
-            if (clause.test === null) {
-                if (defaultFound) {
-                    throwError({}, Messages.MultipleDefaultsInSwitch);
-                }
-                defaultFound = true;
-            }
-            cases.push(clause);
-        }
-
-        state.inSwitch = oldInSwitch;
-
-        expect('}');
-
-        return delegate.createSwitchStatement(discriminant, cases);
-    }
-
-    // 12.13 The throw statement
-
-    function parseThrowStatement() {
-        var argument;
-
-        expectKeyword('throw');
-
-        if (peekLineTerminator()) {
-            throwError({}, Messages.NewlineAfterThrow);
-        }
-
-        argument = parseExpression();
-
-        consumeSemicolon();
-
-        return delegate.createThrowStatement(argument);
-    }
-
-    // 12.14 The try statement
-
-    function parseCatchClause() {
-        var param, body, startToken;
-
-        startToken = lookahead;
-        expectKeyword('catch');
-
-        expect('(');
-        if (match(')')) {
-            throwUnexpected(lookahead);
-        }
-
-        param = parseVariableIdentifier();
-        // 12.14.1
-        if (strict && isRestrictedWord(param.name)) {
-            throwErrorTolerant({}, Messages.StrictCatchVariable);
-        }
-
-        expect(')');
-        body = parseBlock();
-        return delegate.markEnd(delegate.createCatchClause(param, body), startToken);
-    }
-
-    function parseTryStatement() {
-        var block, handlers = [], finalizer = null;
-
-        expectKeyword('try');
-
-        block = parseBlock();
-
-        if (matchKeyword('catch')) {
-            handlers.push(parseCatchClause());
-        }
-
-        if (matchKeyword('finally')) {
-            lex();
-            finalizer = parseBlock();
-        }
-
-        if (handlers.length === 0 && !finalizer) {
-            throwError({}, Messages.NoCatchOrFinally);
-        }
-
-        return delegate.createTryStatement(block, [], handlers, finalizer);
-    }
-
-    // 12.15 The debugger statement
-
-    function parseDebuggerStatement() {
-        expectKeyword('debugger');
-
-        consumeSemicolon();
-
-        return delegate.createDebuggerStatement();
-    }
-
-    // 12 Statements
-
-    function parseStatement() {
-        var type = lookahead.type,
-            expr,
-            labeledBody,
-            key,
-            startToken;
-
-        if (type === Token.EOF) {
-            throwUnexpected(lookahead);
-        }
-
-        if (type === Token.Punctuator && lookahead.value === '{') {
-            return parseBlock();
-        }
-
-        startToken = lookahead;
-
-        if (type === Token.Punctuator) {
-            switch (lookahead.value) {
-            case ';':
-                return delegate.markEnd(parseEmptyStatement(), startToken);
-            case '(':
-                return delegate.markEnd(parseExpressionStatement(), startToken);
-            default:
-                break;
-            }
-        }
-
-        if (type === Token.Keyword) {
-            switch (lookahead.value) {
-            case 'break':
-                return delegate.markEnd(parseBreakStatement(), startToken);
-            case 'continue':
-                return delegate.markEnd(parseContinueStatement(), startToken);
-            case 'debugger':
-                return delegate.markEnd(parseDebuggerStatement(), startToken);
-            case 'do':
-                return delegate.markEnd(parseDoWhileStatement(), startToken);
-            case 'for':
-                return delegate.markEnd(parseForStatement(), startToken);
-            case 'function':
-                return delegate.markEnd(parseFunctionDeclaration(), startToken);
-            case 'if':
-                return delegate.markEnd(parseIfStatement(), startToken);
-            case 'return':
-                return delegate.markEnd(parseReturnStatement(), startToken);
-            case 'switch':
-                return delegate.markEnd(parseSwitchStatement(), startToken);
-            case 'throw':
-                return delegate.markEnd(parseThrowStatement(), startToken);
-            case 'try':
-                return delegate.markEnd(parseTryStatement(), startToken);
-            case 'var':
-                return delegate.markEnd(parseVariableStatement(), startToken);
-            case 'while':
-                return delegate.markEnd(parseWhileStatement(), startToken);
-            case 'with':
-                return delegate.markEnd(parseWithStatement(), startToken);
-            default:
-                break;
-            }
-        }
-
-        expr = parseExpression();
-
-        // 12.12 Labelled Statements
-        if ((expr.type === Syntax.Identifier) && match(':')) {
-            lex();
-
-            key = '$' + expr.name;
-            if (Object.prototype.hasOwnProperty.call(state.labelSet, key)) {
-                throwError({}, Messages.Redeclaration, 'Label', expr.name);
-            }
-
-            state.labelSet[key] = true;
-            labeledBody = parseStatement();
-            delete state.labelSet[key];
-            return delegate.markEnd(delegate.createLabeledStatement(expr, labeledBody), startToken);
-        }
-
-        consumeSemicolon();
-
-        return delegate.markEnd(delegate.createExpressionStatement(expr), startToken);
-    }
-
-    // 13 Function Definition
-
-    function parseFunctionSourceElements() {
-        var sourceElement, sourceElements = [], token, directive, firstRestricted,
-            oldLabelSet, oldInIteration, oldInSwitch, oldInFunctionBody, startToken;
-
-        startToken = lookahead;
-        expect('{');
-
-        while (index < length) {
-            if (lookahead.type !== Token.StringLiteral) {
-                break;
-            }
-            token = lookahead;
-
-            sourceElement = parseSourceElement();
-            sourceElements.push(sourceElement);
-            if (sourceElement.expression.type !== Syntax.Literal) {
-                // this is not directive
-                break;
-            }
-            directive = source.slice(token.start + 1, token.end - 1);
-            if (directive === 'use strict') {
-                strict = true;
-                if (firstRestricted) {
-                    throwErrorTolerant(firstRestricted, Messages.StrictOctalLiteral);
-                }
-            } else {
-                if (!firstRestricted && token.octal) {
-                    firstRestricted = token;
-                }
-            }
-        }
-
-        oldLabelSet = state.labelSet;
-        oldInIteration = state.inIteration;
-        oldInSwitch = state.inSwitch;
-        oldInFunctionBody = state.inFunctionBody;
-
-        state.labelSet = {};
-        state.inIteration = false;
-        state.inSwitch = false;
-        state.inFunctionBody = true;
-
-        while (index < length) {
-            if (match('}')) {
-                break;
-            }
-            sourceElement = parseSourceElement();
-            if (typeof sourceElement === 'undefined') {
-                break;
-            }
-            sourceElements.push(sourceElement);
-        }
-
-        expect('}');
-
-        state.labelSet = oldLabelSet;
-        state.inIteration = oldInIteration;
-        state.inSwitch = oldInSwitch;
-        state.inFunctionBody = oldInFunctionBody;
-
-        return delegate.markEnd(delegate.createBlockStatement(sourceElements), startToken);
-    }
-
-    function parseParams(firstRestricted) {
-        var param, params = [], token, stricted, paramSet, key, message;
-        expect('(');
-
-        if (!match(')')) {
-            paramSet = {};
-            while (index < length) {
-                token = lookahead;
-                param = parseVariableIdentifier();
-                key = '$' + token.value;
-                if (strict) {
-                    if (isRestrictedWord(token.value)) {
-                        stricted = token;
-                        message = Messages.StrictParamName;
-                    }
-                    if (Object.prototype.hasOwnProperty.call(paramSet, key)) {
-                        stricted = token;
-                        message = Messages.StrictParamDupe;
-                    }
-                } else if (!firstRestricted) {
-                    if (isRestrictedWord(token.value)) {
-                        firstRestricted = token;
-                        message = Messages.StrictParamName;
-                    } else if (isStrictModeReservedWord(token.value)) {
-                        firstRestricted = token;
-                        message = Messages.StrictReservedWord;
-                    } else if (Object.prototype.hasOwnProperty.call(paramSet, key)) {
-                        firstRestricted = token;
-                        message = Messages.StrictParamDupe;
-                    }
-                }
-                params.push(param);
-                paramSet[key] = true;
-                if (match(')')) {
-                    break;
-                }
-                expect(',');
-            }
-        }
-
-        expect(')');
-
-        return {
-            params: params,
-            stricted: stricted,
-            firstRestricted: firstRestricted,
-            message: message
-        };
-    }
-
-    function parseFunctionDeclaration() {
-        var id, params = [], body, token, stricted, tmp, firstRestricted, message, previousStrict, startToken;
-
-        startToken = lookahead;
-
-        expectKeyword('function');
-        token = lookahead;
-        id = parseVariableIdentifier();
-        if (strict) {
-            if (isRestrictedWord(token.value)) {
-                throwErrorTolerant(token, Messages.StrictFunctionName);
-            }
-        } else {
-            if (isRestrictedWord(token.value)) {
-                firstRestricted = token;
-                message = Messages.StrictFunctionName;
-            } else if (isStrictModeReservedWord(token.value)) {
-                firstRestricted = token;
-                message = Messages.StrictReservedWord;
-            }
-        }
-
-        tmp = parseParams(firstRestricted);
-        params = tmp.params;
-        stricted = tmp.stricted;
-        firstRestricted = tmp.firstRestricted;
-        if (tmp.message) {
-            message = tmp.message;
-        }
-
-        previousStrict = strict;
-        body = parseFunctionSourceElements();
-        if (strict && firstRestricted) {
-            throwError(firstRestricted, message);
-        }
-        if (strict && stricted) {
-            throwErrorTolerant(stricted, message);
-        }
-        strict = previousStrict;
-
-        return delegate.markEnd(delegate.createFunctionDeclaration(id, params, [], body), startToken);
-    }
-
-    function parseFunctionExpression() {
-        var token, id = null, stricted, firstRestricted, message, tmp, params = [], body, previousStrict, startToken;
-
-        startToken = lookahead;
-        expectKeyword('function');
-
-        if (!match('(')) {
-            token = lookahead;
-            id = parseVariableIdentifier();
-            if (strict) {
-                if (isRestrictedWord(token.value)) {
-                    throwErrorTolerant(token, Messages.StrictFunctionName);
-                }
-            } else {
-                if (isRestrictedWord(token.value)) {
-                    firstRestricted = token;
-                    message = Messages.StrictFunctionName;
-                } else if (isStrictModeReservedWord(token.value)) {
-                    firstRestricted = token;
-                    message = Messages.StrictReservedWord;
-                }
-            }
-        }
-
-        tmp = parseParams(firstRestricted);
-        params = tmp.params;
-        stricted = tmp.stricted;
-        firstRestricted = tmp.firstRestricted;
-        if (tmp.message) {
-            message = tmp.message;
-        }
-
-        previousStrict = strict;
-        body = parseFunctionSourceElements();
-        if (strict && firstRestricted) {
-            throwError(firstRestricted, message);
-        }
-        if (strict && stricted) {
-            throwErrorTolerant(stricted, message);
-        }
-        strict = previousStrict;
-
-        return delegate.markEnd(delegate.createFunctionExpression(id, params, [], body), startToken);
-    }
-
-    // 14 Program
-
-    function parseSourceElement() {
-        if (lookahead.type === Token.Keyword) {
-            switch (lookahead.value) {
-            case 'const':
-            case 'let':
-                return parseConstLetDeclaration(lookahead.value);
-            case 'function':
-                return parseFunctionDeclaration();
-            default:
-                return parseStatement();
-            }
-        }
-
-        if (lookahead.type !== Token.EOF) {
-            return parseStatement();
-        }
-    }
-
-    function parseSourceElements() {
-        var sourceElement, sourceElements = [], token, directive, firstRestricted;
-
-        while (index < length) {
-            token = lookahead;
-            if (token.type !== Token.StringLiteral) {
-                break;
-            }
-
-            sourceElement = parseSourceElement();
-            sourceElements.push(sourceElement);
-            if (sourceElement.expression.type !== Syntax.Literal) {
-                // this is not directive
-                break;
-            }
-            directive = source.slice(token.start + 1, token.end - 1);
-            if (directive === 'use strict') {
-                strict = true;
-                if (firstRestricted) {
-                    throwErrorTolerant(firstRestricted, Messages.StrictOctalLiteral);
-                }
-            } else {
-                if (!firstRestricted && token.octal) {
-                    firstRestricted = token;
-                }
-            }
-        }
-
-        while (index < length) {
-            sourceElement = parseSourceElement();
-            /* istanbul ignore if */
-            if (typeof sourceElement === 'undefined') {
-                break;
-            }
-            sourceElements.push(sourceElement);
-        }
-        return sourceElements;
-    }
-
-    function parseProgram() {
-        var body, startToken;
-
-        skipComment();
-        peek();
-        startToken = lookahead;
-        strict = false;
-
-        body = parseSourceElements();
-        return delegate.markEnd(delegate.createProgram(body), startToken);
-    }
-
-    function filterTokenLocation() {
-        var i, entry, token, tokens = [];
-
-        for (i = 0; i < extra.tokens.length; ++i) {
-            entry = extra.tokens[i];
-            token = {
-                type: entry.type,
-                value: entry.value
-            };
-            if (extra.range) {
-                token.range = entry.range;
-            }
-            if (extra.loc) {
-                token.loc = entry.loc;
-            }
-            tokens.push(token);
-        }
-
-        extra.tokens = tokens;
-    }
-
-    function tokenize(code, options) {
-        var toString,
-            token,
-            tokens;
-
-        toString = String;
-        if (typeof code !== 'string' && !(code instanceof String)) {
-            code = toString(code);
-        }
-
-        delegate = SyntaxTreeDelegate;
-        source = code;
-        index = 0;
-        lineNumber = (source.length > 0) ? 1 : 0;
-        lineStart = 0;
-        length = source.length;
-        lookahead = null;
-        state = {
-            allowIn: true,
-            labelSet: {},
-            inFunctionBody: false,
-            inIteration: false,
-            inSwitch: false,
-            lastCommentStart: -1
-        };
-
-        extra = {};
-
-        // Options matching.
-        options = options || {};
-
-        // Of course we collect tokens here.
-        options.tokens = true;
-        extra.tokens = [];
-        extra.tokenize = true;
-        // The following two fields are necessary to compute the Regex tokens.
-        extra.openParenToken = -1;
-        extra.openCurlyToken = -1;
-
-        extra.range = (typeof options.range === 'boolean') && options.range;
-        extra.loc = (typeof options.loc === 'boolean') && options.loc;
-
-        if (typeof options.comment === 'boolean' && options.comment) {
-            extra.comments = [];
-        }
-        if (typeof options.tolerant === 'boolean' && options.tolerant) {
-            extra.errors = [];
-        }
-
-        try {
-            peek();
-            if (lookahead.type === Token.EOF) {
-                return extra.tokens;
-            }
-
-            token = lex();
-            while (lookahead.type !== Token.EOF) {
-                try {
-                    token = lex();
-                } catch (lexError) {
-                    token = lookahead;
-                    if (extra.errors) {
-                        extra.errors.push(lexError);
-                        // We have to break on the first error
-                        // to avoid infinite loops.
-                        break;
-                    } else {
-                        throw lexError;
-                    }
-                }
-            }
-
-            filterTokenLocation();
-            tokens = extra.tokens;
-            if (typeof extra.comments !== 'undefined') {
-                tokens.comments = extra.comments;
-            }
-            if (typeof extra.errors !== 'undefined') {
-                tokens.errors = extra.errors;
-            }
-        } catch (e) {
-            throw e;
-        } finally {
-            extra = {};
-        }
-        return tokens;
-    }
-
-    function parse(code, options) {
-        var program, toString;
-
-        toString = String;
-        if (typeof code !== 'string' && !(code instanceof String)) {
-            code = toString(code);
-        }
-
-        delegate = SyntaxTreeDelegate;
-        source = code;
-        index = 0;
-        lineNumber = (source.length > 0) ? 1 : 0;
-        lineStart = 0;
-        length = source.length;
-        lookahead = null;
-        state = {
-            allowIn: true,
-            labelSet: {},
-            inFunctionBody: false,
-            inIteration: false,
-            inSwitch: false,
-            lastCommentStart: -1
-        };
-
-        extra = {};
-        if (typeof options !== 'undefined') {
-            extra.range = (typeof options.range === 'boolean') && options.range;
-            extra.loc = (typeof options.loc === 'boolean') && options.loc;
-            extra.attachComment = (typeof options.attachComment === 'boolean') && options.attachComment;
-
-            if (extra.loc && options.source !== null && options.source !== undefined) {
-                extra.source = toString(options.source);
-            }
-
-            if (typeof options.tokens === 'boolean' && options.tokens) {
-                extra.tokens = [];
-            }
-            if (typeof options.comment === 'boolean' && options.comment) {
-                extra.comments = [];
-            }
-            if (typeof options.tolerant === 'boolean' && options.tolerant) {
-                extra.errors = [];
-            }
-            if (extra.attachComment) {
-                extra.range = true;
-                extra.comments = [];
-                extra.bottomRightStack = [];
-                extra.trailingComments = [];
-                extra.leadingComments = [];
-            }
-        }
-
-        try {
-            program = parseProgram();
-            if (typeof extra.comments !== 'undefined') {
-                program.comments = extra.comments;
-            }
-            if (typeof extra.tokens !== 'undefined') {
-                filterTokenLocation();
-                program.tokens = extra.tokens;
-            }
-            if (typeof extra.errors !== 'undefined') {
-                program.errors = extra.errors;
-            }
-        } catch (e) {
-            throw e;
-        } finally {
-            extra = {};
-        }
-
-        return program;
-    }
-
-    // Sync with *.json manifests.
-    exports.version = '1.2.4';
-
-    exports.tokenize = tokenize;
-
-    exports.parse = parse;
-
-    // Deep copy.
-   /* istanbul ignore next */
-    exports.Syntax = (function () {
-        var name, types = {};
-
-        if (typeof Object.create === 'function') {
-            types = Object.create(null);
-        }
-
-        for (name in Syntax) {
-            if (Syntax.hasOwnProperty(name)) {
-                types[name] = Syntax[name];
-            }
-        }
-
-        if (typeof Object.freeze === 'function') {
-            Object.freeze(types);
-        }
-
-        return types;
-    }());
-
-}));
-/* vim: set sw=4 ts=4 et tw=80 : */
-
-},{}],22:[function(_dereq_,module,exports){
-/**
- * power-assert-formatter.js - Power Assert output formatter
- *
- * https://github.com/twada/power-assert-formatter
- *
- * Copyright (c) 2013-2015 Takuto Wada
- * Licensed under the MIT license.
- *   https://github.com/twada/power-assert-formatter/blob/master/MIT-LICENSE.txt
- */
-'use strict';
-
-module.exports = _dereq_('./lib/create');
-
-},{"./lib/create":27}],23:[function(_dereq_,module,exports){
-'use strict';
-
-function AssertionRenderer (traversal, config) {
-    var assertionLine;
-    traversal.on('start', function (context) {
-        assertionLine = context.source.content;
-    });
-    traversal.on('render', function (writer) {
-        writer.write('');
-        writer.write(assertionLine);
-    });
-}
-module.exports = AssertionRenderer;
-
-},{}],24:[function(_dereq_,module,exports){
-'use strict';
-
-var typeName = _dereq_('type-name'),
-    keys = Object.keys || _dereq_('object-keys'),
-    syntax = _dereq_('estraverse').Syntax;
-
-
-function BinaryExpressionRenderer(traversal, config) {
-    this.config = config;
-    this.stringify = config.stringify;
-    this.diff = config.diff;
-    this.espathToPair = {};
-    var _this = this;
-    traversal.on('esnode', function (esNode) {
-        var pair;
-        if (!esNode.isCaptured()) {
-            if (isTargetBinaryExpression(esNode.getParent()) && esNode.currentNode.type === syntax.Literal) {
-                _this.espathToPair[esNode.parentEspath][esNode.currentProp] = {code: esNode.code(), value: esNode.value()};
-            }
-            return;
-        }
-        if (isTargetBinaryExpression(esNode.getParent())) {
-            _this.espathToPair[esNode.parentEspath][esNode.currentProp] = {code: esNode.code(), value: esNode.value()};
-        }
-        if (isTargetBinaryExpression(esNode)) {
-            pair = {
-                operator: esNode.currentNode.operator,
-                value: esNode.value()
-            };
-            _this.espathToPair[esNode.espath] = pair;
-        }
-    });
-    traversal.on('render', function (writer) {
-        var pairs = [];
-        keys(_this.espathToPair).forEach(function (espath) {
-            var pair = _this.espathToPair[espath];
-            if (pair.left && pair.right) {
-                pairs.push(pair);
-            }
-        });
-        pairs.forEach(function (pair) {
-            _this.compare(pair, writer);
-        });
-    });
-}
-
-BinaryExpressionRenderer.prototype.compare = function (pair, writer) {
-    if (isStringDiffTarget(pair)) {
-        this.showStringDiff(pair, writer);
-    } else {
-        this.showExpectedAndActual(pair, writer);
-    }
-};
-
-BinaryExpressionRenderer.prototype.showExpectedAndActual = function (pair, writer) {
-    writer.write('');
-    writer.write('[' + typeName(pair.right.value) + '] ' + pair.right.code);
-    writer.write('=> ' + this.stringify(pair.right.value));
-    writer.write('[' + typeName(pair.left.value)  + '] ' + pair.left.code);
-    writer.write('=> ' + this.stringify(pair.left.value));
-};
-
-BinaryExpressionRenderer.prototype.showStringDiff = function (pair, writer) {
-    writer.write('');
-    writer.write('--- [string] ' + pair.right.code);
-    writer.write('+++ [string] ' + pair.left.code);
-    writer.write(this.diff(pair.right.value, pair.left.value, this.config));
-};
-
-function isTargetBinaryExpression (esNode) {
-    return esNode &&
-        esNode.currentNode.type === syntax.BinaryExpression &&
-        (esNode.currentNode.operator === '===' || esNode.currentNode.operator === '==') &&
-        esNode.isCaptured() &&
-        !(esNode.value());
-}
-
-function isStringDiffTarget(pair) {
-    return typeof pair.left.value === 'string' && typeof pair.right.value === 'string';
-}
-
-module.exports = BinaryExpressionRenderer;
-
-},{"estraverse":36,"object-keys":39,"type-name":43}],25:[function(_dereq_,module,exports){
-'use strict';
-
-function DiagramRenderer (traversal, config) {
-    this.config = config;
-    this.events = [];
-    this.stringify = config.stringify;
-    this.widthOf = config.widthOf;
-    this.initialVertivalBarLength = 1;
-    var _this = this;
-    traversal.on('start', function (context) {
-        _this.context = context;
-        _this.assertionLine = context.source.content;
-        _this.initializeRows();
-    });
-    traversal.on('esnode', function (esNode) {
-        if (!esNode.isCaptured()) {
-            return;
-        }
-        _this.events.push({value: esNode.value(), loc: esNode.location()});
-    });
-    traversal.on('render', function (writer) {
-        _this.events.sort(rightToLeft);
-        _this.constructRows(_this.events);
-        _this.rows.forEach(function (columns) {
-            writer.write(columns.join(''));
-        });
-    });
-}
-
-DiagramRenderer.prototype.initializeRows = function () {
-    this.rows = [];
-    for (var i = 0; i <= this.initialVertivalBarLength; i += 1) {
-        this.addOneMoreRow();
-    }
-};
-
-DiagramRenderer.prototype.newRowFor = function (assertionLine) {
-    return createRow(this.widthOf(assertionLine), ' ');
-};
-
-DiagramRenderer.prototype.addOneMoreRow = function () {
-    this.rows.push(this.newRowFor(this.assertionLine));
-};
-
-DiagramRenderer.prototype.lastRow = function () {
-    return this.rows[this.rows.length - 1];
-};
-
-DiagramRenderer.prototype.renderVerticalBarAt = function (columnIndex) {
-    var i, lastRowIndex = this.rows.length - 1;
-    for (i = 0; i < lastRowIndex; i += 1) {
-        this.rows[i].splice(columnIndex, 1, '|');
-    }
-};
-
-DiagramRenderer.prototype.renderValueAt = function (columnIndex, dumpedValue) {
-    var i, width = this.widthOf(dumpedValue);
-    for (i = 0; i < width; i += 1) {
-        this.lastRow().splice(columnIndex + i, 1, dumpedValue.charAt(i));
-    }
-};
-
-DiagramRenderer.prototype.isOverlapped = function (prevCapturing, nextCaputuring, dumpedValue) {
-    return (typeof prevCapturing !== 'undefined') && this.startColumnFor(prevCapturing) <= (this.startColumnFor(nextCaputuring) + this.widthOf(dumpedValue));
-};
-
-DiagramRenderer.prototype.constructRows = function (capturedEvents) {
-    var that = this,
-        prevCaptured;
-    capturedEvents.forEach(function (captured) {
-        var dumpedValue = that.stringify(captured.value);
-        if (that.isOverlapped(prevCaptured, captured, dumpedValue)) {
-            that.addOneMoreRow();
-        }
-        that.renderVerticalBarAt(that.startColumnFor(captured));
-        that.renderValueAt(that.startColumnFor(captured), dumpedValue);
-        prevCaptured = captured;
-    });
-};
-
-DiagramRenderer.prototype.startColumnFor = function (captured) {
-    return this.widthOf(this.assertionLine.slice(0, captured.loc.start.column));
-};
-
-function createRow (numCols, initial) {
-    var row = [], i;
-    for(i = 0; i < numCols; i += 1) {
-        row[i] = initial;
-    }
-    return row;
-}
-
-function rightToLeft (a, b) {
-    return b.loc.start.column - a.loc.start.column;
-}
-
-module.exports = DiagramRenderer;
-
-},{}],26:[function(_dereq_,module,exports){
-'use strict';
-
-function FileRenderer (traversal, config) {
-    var filepath, lineNumber;
-    traversal.on('start', function (context) {
-        filepath = context.source.filepath;
-        lineNumber = context.source.line;
-    });
-    traversal.on('render', function (writer) {
-        if (filepath) {
-            writer.write('# ' + [filepath, lineNumber].join(':'));
-        } else {
-            writer.write('# at line: ' + lineNumber);
-        }
-    });
-}
-module.exports = FileRenderer;
-
-},{}],27:[function(_dereq_,module,exports){
-'use strict';
-
-var stringifier = _dereq_('stringifier'),
-    stringWidth = _dereq_('./string-width'),
-    StringWriter = _dereq_('./string-writer'),
-    ContextTraversal = _dereq_('./traverse'),
-    udiff = _dereq_('./udiff'),
-    defaultOptions = _dereq_('./default-options'),
-    typeName = _dereq_('type-name'),
-    extend = _dereq_('xtend');
-
-(function() {
-    // "Browserify can only analyze static requires. It is not in the scope of browserify to handle dynamic requires."
-    // https://github.com/substack/node-browserify/issues/377
-    _dereq_('./built-in/assertion');
-    _dereq_('./built-in/binary-expression');
-    _dereq_('./built-in/diagram');
-    _dereq_('./built-in/file');
-})();
-
-function create (options) {
-    var config = extend(defaultOptions(), options);
-    if (typeof config.widthOf !== 'function') {
-        config.widthOf = stringWidth(extend(config));
-    }
-    if (typeof config.stringify !== 'function') {
-        config.stringify = stringifier(extend(config));
-    }
-    if (typeof config.diff !== 'function') {
-        config.diff = udiff(extend(config));
-    }
-    if (!config.writerClass) {
-        config.writerClass = StringWriter;
-    }
-    return function (context) {
-        var traversal = new ContextTraversal(context);
-        var writer = new config.writerClass(extend(config));
-        var renderers = config.renderers.map(function (rendererName) {
-            var RendererClass;
-            if (typeName(rendererName) === 'function') {
-                RendererClass = rendererName;
-            } else if (typeName(rendererName) === 'string') {
-                RendererClass = _dereq_(rendererName);
-            }
-            return new RendererClass(traversal, extend(config));
-        });
-        traversal.emit('start', context);
-        traversal.traverse();
-        traversal.emit('render', writer);
-        writer.write('');
-        renderers.length = 0;
-        return writer.flush();
-    };
-}
-
-create.defaultOptions = defaultOptions;
-create.stringWidth = stringWidth;
-module.exports = create;
-
-},{"./built-in/assertion":23,"./built-in/binary-expression":24,"./built-in/diagram":25,"./built-in/file":26,"./default-options":28,"./string-width":31,"./string-writer":32,"./traverse":33,"./udiff":34,"stringifier":41,"type-name":43,"xtend":45}],28:[function(_dereq_,module,exports){
-module.exports = function defaultOptions () {
-    'use strict';
-    return {
-        lineDiffThreshold: 5,
-        maxDepth: 1,
-        outputOffset: 2,
-        anonymous: 'Object',
-        circular: '#@Circular#',
-        lineSeparator: '\n',
-        ambiguousEastAsianCharWidth: 2,
-        renderers: [
-            './built-in/file',
-            './built-in/assertion',
-            './built-in/diagram',
-            './built-in/binary-expression'
-        ]
-    };
-};
-
-},{}],29:[function(_dereq_,module,exports){
-'use strict';
-
-var syntax = _dereq_('estraverse').Syntax,
-    locationOf = _dereq_('./location');
-
-function EsNode (path, currentNode, parentNode, espathToValue, jsCode, jsAST) {
-    if (path) {
-        this.espath = path.join('/');
-        this.parentEspath = path.slice(0, path.length - 1).join('/');
-        this.currentProp = path[path.length - 1];
-    } else {
-        this.espath = '';
-        this.parentEspath = '';
-        this.currentProp = null;
-    }
-    this.currentNode = currentNode;
-    this.parentNode = parentNode;
-    this.parentEsNode = null;
-    this.espathToValue = espathToValue;
-    this.jsCode = jsCode;
-    this.jsAST = jsAST;
-}
-
-EsNode.prototype.setParent = function (parentEsNode) {
-    this.parentEsNode = parentEsNode;
-};
-
-EsNode.prototype.getParent = function () {
-    return this.parentEsNode;
-};
-
-EsNode.prototype.code = function () {
-    return this.jsCode.slice(this.currentNode.loc.start.column, this.currentNode.loc.end.column);
-};
-
-EsNode.prototype.value = function () {
-    if (this.currentNode.type === syntax.Literal) {
-        return this.currentNode.value;
-    }
-    return this.espathToValue[this.espath];
-};
-
-EsNode.prototype.isCaptured = function () {
-    return this.espathToValue.hasOwnProperty(this.espath);
-};
-
-EsNode.prototype.location = function () {
-    return locationOf(this.currentNode, this.jsAST.tokens);
-};
-
-module.exports = EsNode;
-
-},{"./location":30,"estraverse":36}],30:[function(_dereq_,module,exports){
-'use strict';
-
-var syntax = _dereq_('estraverse').Syntax;
-
-function locationOf(currentNode, tokens) {
-    switch(currentNode.type) {
-    case syntax.MemberExpression:
-        return propertyLocationOf(currentNode, tokens);
-    case syntax.CallExpression:
-        if (currentNode.callee.type === syntax.MemberExpression) {
-            return propertyLocationOf(currentNode.callee, tokens);
-        }
-        break;
-    case syntax.BinaryExpression:
-    case syntax.LogicalExpression:
-    case syntax.AssignmentExpression:
-        return infixOperatorLocationOf(currentNode, tokens);
-    default:
-        break;
-    }
-    return currentNode.loc;
-}
-
-function propertyLocationOf(memberExpression, tokens) {
-    var prop = memberExpression.property,
-        token;
-    if (!memberExpression.computed) {
-        return prop.loc;
-    }
-    token = findLeftBracketTokenOf(memberExpression, tokens);
-    return token ? token.loc : prop.loc;
-}
-
-// calculate location of infix operator for BinaryExpression, AssignmentExpression and LogicalExpression.
-function infixOperatorLocationOf (expression, tokens) {
-    var token = findOperatorTokenOf(expression, tokens);
-    return token ? token.loc : expression.left.loc;
-}
-
-function findLeftBracketTokenOf(expression, tokens) {
-    var fromLine = expression.loc.start.line,
-        toLine = expression.property.loc.start.line,
-        fromColumn = expression.property.loc.start.column;
-    return searchToken(tokens, fromLine, toLine, function (token, index) {
-        var prevToken;
-        if (token.loc.start.column === fromColumn) {
-            prevToken = tokens[index - 1];
-            if (prevToken.type === 'Punctuator' && prevToken.value === '[') {
-                return prevToken;
-            }
-        }
-        return undefined;
-    });
-}
-
-function findOperatorTokenOf(expression, tokens) {
-    var fromLine = expression.left.loc.end.line,
-        toLine = expression.right.loc.start.line,
-        fromColumn = expression.left.loc.end.column,
-        toColumn = expression.right.loc.start.column;
-    return searchToken(tokens, fromLine, toLine, function (token, index) {
-        if (fromColumn < token.loc.start.column &&
-            token.loc.end.column < toColumn &&
-            token.type === 'Punctuator' &&
-            token.value === expression.operator) {
-            return token;
-        }
-        return undefined;
-    });
-}
-
-function searchToken(tokens, fromLine, toLine, predicate) {
-    var i, token, found;
-    for(i = 0; i < tokens.length; i += 1) {
-        token = tokens[i];
-        if (token.loc.start.line < fromLine) {
-            continue;
-        }
-        if (toLine < token.loc.end.line) {
-            break;
-        }
-        found = predicate(token, i);
-        if (found) {
-            return found;
-        }
-    }
-    return undefined;
-}
-
-module.exports = locationOf;
-
-},{"estraverse":36}],31:[function(_dereq_,module,exports){
-'use strict';
-
-var eaw = _dereq_('eastasianwidth');
-
-function stringWidth (config) {
-    var ambiguousCharWidth = (config && config.ambiguousEastAsianCharWidth) || 1;
-    return function widthOf (str) {
-        var i, code, width = 0;
-        for(i = 0; i < str.length; i+=1) {
-            code = eaw.eastAsianWidth(str.charAt(i));
-            switch(code) {
-            case 'F':
-            case 'W':
-                width += 2;
-                break;
-            case 'H':
-            case 'Na':
-            case 'N':
-                width += 1;
-                break;
-            case 'A':
-                width += ambiguousCharWidth;
-                break;
-            }
-        }
-        return width;
-    };
-}
-
-module.exports = stringWidth;
-
-},{"eastasianwidth":35}],32:[function(_dereq_,module,exports){
-'use strict';
-
-function spacerStr (len) {
-    var str = '';
-    for(var i = 0; i < len; i += 1) {
-        str += ' ';
-    }
-    return str;
-}
-
-function StringWriter (config) {
-    this.lines = [];
-    this.lineSeparator = config.lineSeparator;
-    this.regex = new RegExp(this.lineSeparator, 'g');
-    this.spacer = spacerStr(config.outputOffset);
-}
-
-StringWriter.prototype.write = function (str) {
-    this.lines.push(this.spacer + str.replace(this.regex, this.lineSeparator + this.spacer));
-};
-
-StringWriter.prototype.flush = function () {
-    var str = this.lines.join(this.lineSeparator);
-    this.lines.length = 0;
-    return str;
-};
-
-module.exports = StringWriter;
-
-},{}],33:[function(_dereq_,module,exports){
-'use strict';
-
-var estraverse = _dereq_('estraverse'),
-    esprima = _dereq_('esprima'),
-    EventEmitter = _dereq_('events').EventEmitter,
-    inherits = _dereq_('util').inherits,
-    EsNode = _dereq_('./esnode');
-
-function ContextTraversal (context) {
-    this.context = context;
-    EventEmitter.call(this);
-}
-inherits(ContextTraversal, EventEmitter);
-
-ContextTraversal.prototype.traverse = function () {
-    var _this = this;
-    this.context.args.forEach(function (arg) {
-        onEachEsNode(arg, _this.context.source.content, function (esNode) {
-            _this.emit('esnode', esNode);
-        });
-    });
-};
-
-function onEachEsNode(arg, jsCode, callback) {
-    var jsAST = esprima.parse(jsCode, {tolerant: true, loc: true, tokens: true, raw: true}),
-        espathToValue = arg.events.reduce(function (accum, ev) {
-            accum[ev.espath] = ev.value;
-            return accum;
-        }, {}),
-        nodeStack = [];
-    estraverse.traverse(extractExpressionFrom(jsAST), {
-        enter: function (currentNode, parentNode) {
-            var esNode = new EsNode(this.path(), currentNode, parentNode, espathToValue, jsCode, jsAST);
-            if (1 < nodeStack.length) {
-                esNode.setParent(nodeStack[nodeStack.length - 1]);
-            }
-            nodeStack.push(esNode);
-            callback(esNode);
-        },
-        leave: function (currentNode, parentNode) {
-            nodeStack.pop();
-        }
-    });
-}
-
-function extractExpressionFrom (tree) {
-    var expressionStatement = tree.body[0],
-        expression = expressionStatement.expression;
-    return expression;
-}
-
-module.exports = ContextTraversal;
-
-},{"./esnode":29,"esprima":21,"estraverse":36,"events":2,"util":6}],34:[function(_dereq_,module,exports){
-'use strict';
-
-var DiffMatchPatch = _dereq_('googlediff'),
-    dmp = new DiffMatchPatch();
-
-function udiff (config) {
-    return function diff (text1, text2) {
-        var patch;
-        if (config && shouldUseLineLevelDiff(text1, config)) {
-            patch = udiffLines(text1, text2);
-        } else {
-            patch = udiffChars(text1, text2);
-        }
-        return decodeURIComponent(patch);
-    };
-}
-
-function shouldUseLineLevelDiff (text, config) {
-    return config.lineDiffThreshold < text.split(/\r\n|\r|\n/).length;
-}
-
-function udiffLines(text1, text2) {
-    /*jshint camelcase: false */
-    var a = dmp.diff_linesToChars_(text1, text2),
-        diffs = dmp.diff_main(a.chars1, a.chars2, false);
-    dmp.diff_charsToLines_(diffs, a.lineArray);
-    dmp.diff_cleanupSemantic(diffs);
-    return dmp.patch_toText(dmp.patch_make(text1, diffs));
-}
-
-function udiffChars (text1, text2) {
-    /*jshint camelcase: false */
-    var diffs = dmp.diff_main(text1, text2, false);
-    dmp.diff_cleanupSemantic(diffs);
-    return dmp.patch_toText(dmp.patch_make(text1, diffs));
-}
-
-module.exports = udiff;
-
-},{"googlediff":37}],35:[function(_dereq_,module,exports){
-var eaw = exports;
-
-eaw.eastAsianWidth = function(character) {
-  var x = character.charCodeAt(0);
-  var y = (character.length == 2) ? character.charCodeAt(1) : 0;
-  var codePoint = x;
-  if ((0xD800 <= x && x <= 0xDBFF) && (0xDC00 <= y && y <= 0xDFFF)) {
-    x &= 0x3FF;
-    y &= 0x3FF;
-    codePoint = (x << 10) | y;
-    codePoint += 0x10000;
-  }
-
-  if ((0x3000 == codePoint) ||
-      (0xFF01 <= codePoint && codePoint <= 0xFF60) ||
-      (0xFFE0 <= codePoint && codePoint <= 0xFFE6)) {
-    return 'F';
-  }
-  if ((0x20A9 == codePoint) ||
-      (0xFF61 <= codePoint && codePoint <= 0xFFBE) ||
-      (0xFFC2 <= codePoint && codePoint <= 0xFFC7) ||
-      (0xFFCA <= codePoint && codePoint <= 0xFFCF) ||
-      (0xFFD2 <= codePoint && codePoint <= 0xFFD7) ||
-      (0xFFDA <= codePoint && codePoint <= 0xFFDC) ||
-      (0xFFE8 <= codePoint && codePoint <= 0xFFEE)) {
-    return 'H';
-  }
-  if ((0x1100 <= codePoint && codePoint <= 0x115F) ||
-      (0x11A3 <= codePoint && codePoint <= 0x11A7) ||
-      (0x11FA <= codePoint && codePoint <= 0x11FF) ||
-      (0x2329 <= codePoint && codePoint <= 0x232A) ||
-      (0x2E80 <= codePoint && codePoint <= 0x2E99) ||
-      (0x2E9B <= codePoint && codePoint <= 0x2EF3) ||
-      (0x2F00 <= codePoint && codePoint <= 0x2FD5) ||
-      (0x2FF0 <= codePoint && codePoint <= 0x2FFB) ||
-      (0x3001 <= codePoint && codePoint <= 0x303E) ||
-      (0x3041 <= codePoint && codePoint <= 0x3096) ||
-      (0x3099 <= codePoint && codePoint <= 0x30FF) ||
-      (0x3105 <= codePoint && codePoint <= 0x312D) ||
-      (0x3131 <= codePoint && codePoint <= 0x318E) ||
-      (0x3190 <= codePoint && codePoint <= 0x31BA) ||
-      (0x31C0 <= codePoint && codePoint <= 0x31E3) ||
-      (0x31F0 <= codePoint && codePoint <= 0x321E) ||
-      (0x3220 <= codePoint && codePoint <= 0x3247) ||
-      (0x3250 <= codePoint && codePoint <= 0x32FE) ||
-      (0x3300 <= codePoint && codePoint <= 0x4DBF) ||
-      (0x4E00 <= codePoint && codePoint <= 0xA48C) ||
-      (0xA490 <= codePoint && codePoint <= 0xA4C6) ||
-      (0xA960 <= codePoint && codePoint <= 0xA97C) ||
-      (0xAC00 <= codePoint && codePoint <= 0xD7A3) ||
-      (0xD7B0 <= codePoint && codePoint <= 0xD7C6) ||
-      (0xD7CB <= codePoint && codePoint <= 0xD7FB) ||
-      (0xF900 <= codePoint && codePoint <= 0xFAFF) ||
-      (0xFE10 <= codePoint && codePoint <= 0xFE19) ||
-      (0xFE30 <= codePoint && codePoint <= 0xFE52) ||
-      (0xFE54 <= codePoint && codePoint <= 0xFE66) ||
-      (0xFE68 <= codePoint && codePoint <= 0xFE6B) ||
-      (0x1B000 <= codePoint && codePoint <= 0x1B001) ||
-      (0x1F200 <= codePoint && codePoint <= 0x1F202) ||
-      (0x1F210 <= codePoint && codePoint <= 0x1F23A) ||
-      (0x1F240 <= codePoint && codePoint <= 0x1F248) ||
-      (0x1F250 <= codePoint && codePoint <= 0x1F251) ||
-      (0x20000 <= codePoint && codePoint <= 0x2F73F) ||
-      (0x2B740 <= codePoint && codePoint <= 0x2FFFD) ||
-      (0x30000 <= codePoint && codePoint <= 0x3FFFD)) {
-    return 'W';
-  }
-  if ((0x0020 <= codePoint && codePoint <= 0x007E) ||
-      (0x00A2 <= codePoint && codePoint <= 0x00A3) ||
-      (0x00A5 <= codePoint && codePoint <= 0x00A6) ||
-      (0x00AC == codePoint) ||
-      (0x00AF == codePoint) ||
-      (0x27E6 <= codePoint && codePoint <= 0x27ED) ||
-      (0x2985 <= codePoint && codePoint <= 0x2986)) {
-    return 'Na';
-  }
-  if ((0x00A1 == codePoint) ||
-      (0x00A4 == codePoint) ||
-      (0x00A7 <= codePoint && codePoint <= 0x00A8) ||
-      (0x00AA == codePoint) ||
-      (0x00AD <= codePoint && codePoint <= 0x00AE) ||
-      (0x00B0 <= codePoint && codePoint <= 0x00B4) ||
-      (0x00B6 <= codePoint && codePoint <= 0x00BA) ||
-      (0x00BC <= codePoint && codePoint <= 0x00BF) ||
-      (0x00C6 == codePoint) ||
-      (0x00D0 == codePoint) ||
-      (0x00D7 <= codePoint && codePoint <= 0x00D8) ||
-      (0x00DE <= codePoint && codePoint <= 0x00E1) ||
-      (0x00E6 == codePoint) ||
-      (0x00E8 <= codePoint && codePoint <= 0x00EA) ||
-      (0x00EC <= codePoint && codePoint <= 0x00ED) ||
-      (0x00F0 == codePoint) ||
-      (0x00F2 <= codePoint && codePoint <= 0x00F3) ||
-      (0x00F7 <= codePoint && codePoint <= 0x00FA) ||
-      (0x00FC == codePoint) ||
-      (0x00FE == codePoint) ||
-      (0x0101 == codePoint) ||
-      (0x0111 == codePoint) ||
-      (0x0113 == codePoint) ||
-      (0x011B == codePoint) ||
-      (0x0126 <= codePoint && codePoint <= 0x0127) ||
-      (0x012B == codePoint) ||
-      (0x0131 <= codePoint && codePoint <= 0x0133) ||
-      (0x0138 == codePoint) ||
-      (0x013F <= codePoint && codePoint <= 0x0142) ||
-      (0x0144 == codePoint) ||
-      (0x0148 <= codePoint && codePoint <= 0x014B) ||
-      (0x014D == codePoint) ||
-      (0x0152 <= codePoint && codePoint <= 0x0153) ||
-      (0x0166 <= codePoint && codePoint <= 0x0167) ||
-      (0x016B == codePoint) ||
-      (0x01CE == codePoint) ||
-      (0x01D0 == codePoint) ||
-      (0x01D2 == codePoint) ||
-      (0x01D4 == codePoint) ||
-      (0x01D6 == codePoint) ||
-      (0x01D8 == codePoint) ||
-      (0x01DA == codePoint) ||
-      (0x01DC == codePoint) ||
-      (0x0251 == codePoint) ||
-      (0x0261 == codePoint) ||
-      (0x02C4 == codePoint) ||
-      (0x02C7 == codePoint) ||
-      (0x02C9 <= codePoint && codePoint <= 0x02CB) ||
-      (0x02CD == codePoint) ||
-      (0x02D0 == codePoint) ||
-      (0x02D8 <= codePoint && codePoint <= 0x02DB) ||
-      (0x02DD == codePoint) ||
-      (0x02DF == codePoint) ||
-      (0x0300 <= codePoint && codePoint <= 0x036F) ||
-      (0x0391 <= codePoint && codePoint <= 0x03A1) ||
-      (0x03A3 <= codePoint && codePoint <= 0x03A9) ||
-      (0x03B1 <= codePoint && codePoint <= 0x03C1) ||
-      (0x03C3 <= codePoint && codePoint <= 0x03C9) ||
-      (0x0401 == codePoint) ||
-      (0x0410 <= codePoint && codePoint <= 0x044F) ||
-      (0x0451 == codePoint) ||
-      (0x2010 == codePoint) ||
-      (0x2013 <= codePoint && codePoint <= 0x2016) ||
-      (0x2018 <= codePoint && codePoint <= 0x2019) ||
-      (0x201C <= codePoint && codePoint <= 0x201D) ||
-      (0x2020 <= codePoint && codePoint <= 0x2022) ||
-      (0x2024 <= codePoint && codePoint <= 0x2027) ||
-      (0x2030 == codePoint) ||
-      (0x2032 <= codePoint && codePoint <= 0x2033) ||
-      (0x2035 == codePoint) ||
-      (0x203B == codePoint) ||
-      (0x203E == codePoint) ||
-      (0x2074 == codePoint) ||
-      (0x207F == codePoint) ||
-      (0x2081 <= codePoint && codePoint <= 0x2084) ||
-      (0x20AC == codePoint) ||
-      (0x2103 == codePoint) ||
-      (0x2105 == codePoint) ||
-      (0x2109 == codePoint) ||
-      (0x2113 == codePoint) ||
-      (0x2116 == codePoint) ||
-      (0x2121 <= codePoint && codePoint <= 0x2122) ||
-      (0x2126 == codePoint) ||
-      (0x212B == codePoint) ||
-      (0x2153 <= codePoint && codePoint <= 0x2154) ||
-      (0x215B <= codePoint && codePoint <= 0x215E) ||
-      (0x2160 <= codePoint && codePoint <= 0x216B) ||
-      (0x2170 <= codePoint && codePoint <= 0x2179) ||
-      (0x2189 == codePoint) ||
-      (0x2190 <= codePoint && codePoint <= 0x2199) ||
-      (0x21B8 <= codePoint && codePoint <= 0x21B9) ||
-      (0x21D2 == codePoint) ||
-      (0x21D4 == codePoint) ||
-      (0x21E7 == codePoint) ||
-      (0x2200 == codePoint) ||
-      (0x2202 <= codePoint && codePoint <= 0x2203) ||
-      (0x2207 <= codePoint && codePoint <= 0x2208) ||
-      (0x220B == codePoint) ||
-      (0x220F == codePoint) ||
-      (0x2211 == codePoint) ||
-      (0x2215 == codePoint) ||
-      (0x221A == codePoint) ||
-      (0x221D <= codePoint && codePoint <= 0x2220) ||
-      (0x2223 == codePoint) ||
-      (0x2225 == codePoint) ||
-      (0x2227 <= codePoint && codePoint <= 0x222C) ||
-      (0x222E == codePoint) ||
-      (0x2234 <= codePoint && codePoint <= 0x2237) ||
-      (0x223C <= codePoint && codePoint <= 0x223D) ||
-      (0x2248 == codePoint) ||
-      (0x224C == codePoint) ||
-      (0x2252 == codePoint) ||
-      (0x2260 <= codePoint && codePoint <= 0x2261) ||
-      (0x2264 <= codePoint && codePoint <= 0x2267) ||
-      (0x226A <= codePoint && codePoint <= 0x226B) ||
-      (0x226E <= codePoint && codePoint <= 0x226F) ||
-      (0x2282 <= codePoint && codePoint <= 0x2283) ||
-      (0x2286 <= codePoint && codePoint <= 0x2287) ||
-      (0x2295 == codePoint) ||
-      (0x2299 == codePoint) ||
-      (0x22A5 == codePoint) ||
-      (0x22BF == codePoint) ||
-      (0x2312 == codePoint) ||
-      (0x2460 <= codePoint && codePoint <= 0x24E9) ||
-      (0x24EB <= codePoint && codePoint <= 0x254B) ||
-      (0x2550 <= codePoint && codePoint <= 0x2573) ||
-      (0x2580 <= codePoint && codePoint <= 0x258F) ||
-      (0x2592 <= codePoint && codePoint <= 0x2595) ||
-      (0x25A0 <= codePoint && codePoint <= 0x25A1) ||
-      (0x25A3 <= codePoint && codePoint <= 0x25A9) ||
-      (0x25B2 <= codePoint && codePoint <= 0x25B3) ||
-      (0x25B6 <= codePoint && codePoint <= 0x25B7) ||
-      (0x25BC <= codePoint && codePoint <= 0x25BD) ||
-      (0x25C0 <= codePoint && codePoint <= 0x25C1) ||
-      (0x25C6 <= codePoint && codePoint <= 0x25C8) ||
-      (0x25CB == codePoint) ||
-      (0x25CE <= codePoint && codePoint <= 0x25D1) ||
-      (0x25E2 <= codePoint && codePoint <= 0x25E5) ||
-      (0x25EF == codePoint) ||
-      (0x2605 <= codePoint && codePoint <= 0x2606) ||
-      (0x2609 == codePoint) ||
-      (0x260E <= codePoint && codePoint <= 0x260F) ||
-      (0x2614 <= codePoint && codePoint <= 0x2615) ||
-      (0x261C == codePoint) ||
-      (0x261E == codePoint) ||
-      (0x2640 == codePoint) ||
-      (0x2642 == codePoint) ||
-      (0x2660 <= codePoint && codePoint <= 0x2661) ||
-      (0x2663 <= codePoint && codePoint <= 0x2665) ||
-      (0x2667 <= codePoint && codePoint <= 0x266A) ||
-      (0x266C <= codePoint && codePoint <= 0x266D) ||
-      (0x266F == codePoint) ||
-      (0x269E <= codePoint && codePoint <= 0x269F) ||
-      (0x26BE <= codePoint && codePoint <= 0x26BF) ||
-      (0x26C4 <= codePoint && codePoint <= 0x26CD) ||
-      (0x26CF <= codePoint && codePoint <= 0x26E1) ||
-      (0x26E3 == codePoint) ||
-      (0x26E8 <= codePoint && codePoint <= 0x26FF) ||
-      (0x273D == codePoint) ||
-      (0x2757 == codePoint) ||
-      (0x2776 <= codePoint && codePoint <= 0x277F) ||
-      (0x2B55 <= codePoint && codePoint <= 0x2B59) ||
-      (0x3248 <= codePoint && codePoint <= 0x324F) ||
-      (0xE000 <= codePoint && codePoint <= 0xF8FF) ||
-      (0xFE00 <= codePoint && codePoint <= 0xFE0F) ||
-      (0xFFFD == codePoint) ||
-      (0x1F100 <= codePoint && codePoint <= 0x1F10A) ||
-      (0x1F110 <= codePoint && codePoint <= 0x1F12D) ||
-      (0x1F130 <= codePoint && codePoint <= 0x1F169) ||
-      (0x1F170 <= codePoint && codePoint <= 0x1F19A) ||
-      (0xE0100 <= codePoint && codePoint <= 0xE01EF) ||
-      (0xF0000 <= codePoint && codePoint <= 0xFFFFD) ||
-      (0x100000 <= codePoint && codePoint <= 0x10FFFD)) {
-    return 'A';
-  }
-
-  return 'N';
-};
-
-eaw.characterLength = function(character) {
-  var code = this.eastAsianWidth(character);
-  if (code == 'F' || code == 'W' || code == 'A') {
-    return 2;
-  } else {
-    return 1;
-  }
-};
-
-eaw.length = function(string) {
-  var len = 0;
-  for (var i = 0; i < string.length; i++) {
-    len = len + this.characterLength(string.charAt(i));
-  }
-  return len;
-};
-
-},{}],36:[function(_dereq_,module,exports){
-/*
-  Copyright (C) 2012-2013 Yusuke Suzuki <utatane.tea@gmail.com>
-  Copyright (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com>
-
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-/*jslint vars:false, bitwise:true*/
-/*jshint indent:4*/
-/*global exports:true, define:true*/
-(function (root, factory) {
-    'use strict';
-
-    // Universal Module Definition (UMD) to support AMD, CommonJS/Node.js,
-    // and plain browser loading,
-    if (typeof define === 'function' && define.amd) {
-        define(['exports'], factory);
-    } else if (typeof exports !== 'undefined') {
-        factory(exports);
-    } else {
-        factory((root.estraverse = {}));
-    }
-}(this, function (exports) {
-    'use strict';
-
-    var Syntax,
-        isArray,
-        VisitorOption,
-        VisitorKeys,
-        objectCreate,
-        objectKeys,
-        BREAK,
-        SKIP,
-        REMOVE;
-
-    function ignoreJSHintError() { }
-
-    isArray = Array.isArray;
-    if (!isArray) {
-        isArray = function isArray(array) {
-            return Object.prototype.toString.call(array) === '[object Array]';
-        };
-    }
-
-    function deepCopy(obj) {
-        var ret = {}, key, val;
-        for (key in obj) {
-            if (obj.hasOwnProperty(key)) {
-                val = obj[key];
-                if (typeof val === 'object' && val !== null) {
-                    ret[key] = deepCopy(val);
-                } else {
-                    ret[key] = val;
-                }
-            }
-        }
-        return ret;
-    }
-
-    function shallowCopy(obj) {
-        var ret = {}, key;
-        for (key in obj) {
-            if (obj.hasOwnProperty(key)) {
-                ret[key] = obj[key];
-            }
-        }
-        return ret;
-    }
-    ignoreJSHintError(shallowCopy);
-
-    // based on LLVM libc++ upper_bound / lower_bound
-    // MIT License
-
-    function upperBound(array, func) {
-        var diff, len, i, current;
-
-        len = array.length;
-        i = 0;
-
-        while (len) {
-            diff = len >>> 1;
-            current = i + diff;
-            if (func(array[current])) {
-                len = diff;
-            } else {
-                i = current + 1;
-                len -= diff + 1;
-            }
-        }
-        return i;
-    }
-
-    function lowerBound(array, func) {
-        var diff, len, i, current;
-
-        len = array.length;
-        i = 0;
-
-        while (len) {
-            diff = len >>> 1;
-            current = i + diff;
-            if (func(array[current])) {
-                i = current + 1;
-                len -= diff + 1;
-            } else {
-                len = diff;
-            }
-        }
-        return i;
-    }
-    ignoreJSHintError(lowerBound);
-
-    objectCreate = Object.create || (function () {
-        function F() { }
-
-        return function (o) {
-            F.prototype = o;
-            return new F();
-        };
-    })();
-
-    objectKeys = Object.keys || function (o) {
-        var keys = [], key;
-        for (key in o) {
-            keys.push(key);
-        }
-        return keys;
-    };
-
-    function extend(to, from) {
-        objectKeys(from).forEach(function (key) {
-            to[key] = from[key];
-        });
-        return to;
-    }
-
-    Syntax = {
-        AssignmentExpression: 'AssignmentExpression',
-        ArrayExpression: 'ArrayExpression',
-        ArrayPattern: 'ArrayPattern',
-        ArrowFunctionExpression: 'ArrowFunctionExpression',
-        BlockStatement: 'BlockStatement',
-        BinaryExpression: 'BinaryExpression',
-        BreakStatement: 'BreakStatement',
-        CallExpression: 'CallExpression',
-        CatchClause: 'CatchClause',
-        ClassBody: 'ClassBody',
-        ClassDeclaration: 'ClassDeclaration',
-        ClassExpression: 'ClassExpression',
-        ComprehensionBlock: 'ComprehensionBlock',  // CAUTION: It's deferred to ES7.
-        ComprehensionExpression: 'ComprehensionExpression',  // CAUTION: It's deferred to ES7.
-        ConditionalExpression: 'ConditionalExpression',
-        ContinueStatement: 'ContinueStatement',
-        DebuggerStatement: 'DebuggerStatement',
-        DirectiveStatement: 'DirectiveStatement',
-        DoWhileStatement: 'DoWhileStatement',
-        EmptyStatement: 'EmptyStatement',
-        ExportBatchSpecifier: 'ExportBatchSpecifier',
-        ExportDeclaration: 'ExportDeclaration',
-        ExportSpecifier: 'ExportSpecifier',
-        ExpressionStatement: 'ExpressionStatement',
-        ForStatement: 'ForStatement',
-        ForInStatement: 'ForInStatement',
-        ForOfStatement: 'ForOfStatement',
-        FunctionDeclaration: 'FunctionDeclaration',
-        FunctionExpression: 'FunctionExpression',
-        GeneratorExpression: 'GeneratorExpression',  // CAUTION: It's deferred to ES7.
-        Identifier: 'Identifier',
-        IfStatement: 'IfStatement',
-        ImportDeclaration: 'ImportDeclaration',
-        ImportDefaultSpecifier: 'ImportDefaultSpecifier',
-        ImportNamespaceSpecifier: 'ImportNamespaceSpecifier',
-        ImportSpecifier: 'ImportSpecifier',
-        Literal: 'Literal',
-        LabeledStatement: 'LabeledStatement',
-        LogicalExpression: 'LogicalExpression',
-        MemberExpression: 'MemberExpression',
-        MethodDefinition: 'MethodDefinition',
-        ModuleSpecifier: 'ModuleSpecifier',
-        NewExpression: 'NewExpression',
-        ObjectExpression: 'ObjectExpression',
-        ObjectPattern: 'ObjectPattern',
-        Program: 'Program',
-        Property: 'Property',
-        ReturnStatement: 'ReturnStatement',
-        SequenceExpression: 'SequenceExpression',
-        SpreadElement: 'SpreadElement',
-        SwitchStatement: 'SwitchStatement',
-        SwitchCase: 'SwitchCase',
-        TaggedTemplateExpression: 'TaggedTemplateExpression',
-        TemplateElement: 'TemplateElement',
-        TemplateLiteral: 'TemplateLiteral',
-        ThisExpression: 'ThisExpression',
-        ThrowStatement: 'ThrowStatement',
-        TryStatement: 'TryStatement',
-        UnaryExpression: 'UnaryExpression',
-        UpdateExpression: 'UpdateExpression',
-        VariableDeclaration: 'VariableDeclaration',
-        VariableDeclarator: 'VariableDeclarator',
-        WhileStatement: 'WhileStatement',
-        WithStatement: 'WithStatement',
-        YieldExpression: 'YieldExpression'
-    };
-
-    VisitorKeys = {
-        AssignmentExpression: ['left', 'right'],
-        ArrayExpression: ['elements'],
-        ArrayPattern: ['elements'],
-        ArrowFunctionExpression: ['params', 'defaults', 'rest', 'body'],
-        BlockStatement: ['body'],
-        BinaryExpression: ['left', 'right'],
-        BreakStatement: ['label'],
-        CallExpression: ['callee', 'arguments'],
-        CatchClause: ['param', 'body'],
-        ClassBody: ['body'],
-        ClassDeclaration: ['id', 'body', 'superClass'],
-        ClassExpression: ['id', 'body', 'superClass'],
-        ComprehensionBlock: ['left', 'right'],  // CAUTION: It's deferred to ES7.
-        ComprehensionExpression: ['blocks', 'filter', 'body'],  // CAUTION: It's deferred to ES7.
-        ConditionalExpression: ['test', 'consequent', 'alternate'],
-        ContinueStatement: ['label'],
-        DebuggerStatement: [],
-        DirectiveStatement: [],
-        DoWhileStatement: ['body', 'test'],
-        EmptyStatement: [],
-        ExportBatchSpecifier: [],
-        ExportDeclaration: ['declaration', 'specifiers', 'source'],
-        ExportSpecifier: ['id', 'name'],
-        ExpressionStatement: ['expression'],
-        ForStatement: ['init', 'test', 'update', 'body'],
-        ForInStatement: ['left', 'right', 'body'],
-        ForOfStatement: ['left', 'right', 'body'],
-        FunctionDeclaration: ['id', 'params', 'defaults', 'rest', 'body'],
-        FunctionExpression: ['id', 'params', 'defaults', 'rest', 'body'],
-        GeneratorExpression: ['blocks', 'filter', 'body'],  // CAUTION: It's deferred to ES7.
-        Identifier: [],
-        IfStatement: ['test', 'consequent', 'alternate'],
-        ImportDeclaration: ['specifiers', 'source'],
-        ImportDefaultSpecifier: ['id'],
-        ImportNamespaceSpecifier: ['id'],
-        ImportSpecifier: ['id', 'name'],
-        Literal: [],
-        LabeledStatement: ['label', 'body'],
-        LogicalExpression: ['left', 'right'],
-        MemberExpression: ['object', 'property'],
-        MethodDefinition: ['key', 'value'],
-        ModuleSpecifier: [],
-        NewExpression: ['callee', 'arguments'],
-        ObjectExpression: ['properties'],
-        ObjectPattern: ['properties'],
-        Program: ['body'],
-        Property: ['key', 'value'],
-        ReturnStatement: ['argument'],
-        SequenceExpression: ['expressions'],
-        SpreadElement: ['argument'],
-        SwitchStatement: ['discriminant', 'cases'],
-        SwitchCase: ['test', 'consequent'],
-        TaggedTemplateExpression: ['tag', 'quasi'],
-        TemplateElement: [],
-        TemplateLiteral: ['quasis', 'expressions'],
-        ThisExpression: [],
-        ThrowStatement: ['argument'],
-        TryStatement: ['block', 'handlers', 'handler', 'guardedHandlers', 'finalizer'],
-        UnaryExpression: ['argument'],
-        UpdateExpression: ['argument'],
-        VariableDeclaration: ['declarations'],
-        VariableDeclarator: ['id', 'init'],
-        WhileStatement: ['test', 'body'],
-        WithStatement: ['object', 'body'],
-        YieldExpression: ['argument']
-    };
-
-    // unique id
-    BREAK = {};
-    SKIP = {};
-    REMOVE = {};
-
-    VisitorOption = {
-        Break: BREAK,
-        Skip: SKIP,
-        Remove: REMOVE
-    };
-
-    function Reference(parent, key) {
-        this.parent = parent;
-        this.key = key;
-    }
-
-    Reference.prototype.replace = function replace(node) {
-        this.parent[this.key] = node;
-    };
-
-    Reference.prototype.remove = function remove() {
-        if (isArray(this.parent)) {
-            this.parent.splice(this.key, 1);
-            return true;
-        } else {
-            this.replace(null);
-            return false;
-        }
-    };
-
-    function Element(node, path, wrap, ref) {
-        this.node = node;
-        this.path = path;
-        this.wrap = wrap;
-        this.ref = ref;
-    }
-
-    function Controller() { }
-
-    // API:
-    // return property path array from root to current node
-    Controller.prototype.path = function path() {
-        var i, iz, j, jz, result, element;
-
-        function addToPath(result, path) {
-            if (isArray(path)) {
-                for (j = 0, jz = path.length; j < jz; ++j) {
-                    result.push(path[j]);
-                }
-            } else {
-                result.push(path);
-            }
-        }
-
-        // root node
-        if (!this.__current.path) {
-            return null;
-        }
-
-        // first node is sentinel, second node is root element
-        result = [];
-        for (i = 2, iz = this.__leavelist.length; i < iz; ++i) {
-            element = this.__leavelist[i];
-            addToPath(result, element.path);
-        }
-        addToPath(result, this.__current.path);
-        return result;
-    };
-
-    // API:
-    // return array of parent elements
-    Controller.prototype.parents = function parents() {
-        var i, iz, result;
-
-        // first node is sentinel
-        result = [];
-        for (i = 1, iz = this.__leavelist.length; i < iz; ++i) {
-            result.push(this.__leavelist[i].node);
-        }
-
-        return result;
-    };
-
-    // API:
-    // return current node
-    Controller.prototype.current = function current() {
-        return this.__current.node;
-    };
-
-    Controller.prototype.__execute = function __execute(callback, element) {
-        var previous, result;
-
-        result = undefined;
-
-        previous  = this.__current;
-        this.__current = element;
-        this.__state = null;
-        if (callback) {
-            result = callback.call(this, element.node, this.__leavelist[this.__leavelist.length - 1].node);
-        }
-        this.__current = previous;
-
-        return result;
-    };
-
-    // API:
-    // notify control skip / break
-    Controller.prototype.notify = function notify(flag) {
-        this.__state = flag;
-    };
-
-    // API:
-    // skip child nodes of current node
-    Controller.prototype.skip = function () {
-        this.notify(SKIP);
-    };
-
-    // API:
-    // break traversals
-    Controller.prototype['break'] = function () {
-        this.notify(BREAK);
-    };
-
-    // API:
-    // remove node
-    Controller.prototype.remove = function () {
-        this.notify(REMOVE);
-    };
-
-    Controller.prototype.__initialize = function(root, visitor) {
-        this.visitor = visitor;
-        this.root = root;
-        this.__worklist = [];
-        this.__leavelist = [];
-        this.__current = null;
-        this.__state = null;
-        this.__fallback = visitor.fallback === 'iteration';
-        this.__keys = VisitorKeys;
-        if (visitor.keys) {
-            this.__keys = extend(objectCreate(this.__keys), visitor.keys);
-        }
-    };
-
-    function isNode(node) {
-        if (node == null) {
-            return false;
-        }
-        return typeof node === 'object' && typeof node.type === 'string';
-    }
-
-    function isProperty(nodeType, key) {
-        return (nodeType === Syntax.ObjectExpression || nodeType === Syntax.ObjectPattern) && 'properties' === key;
-    }
-
-    Controller.prototype.traverse = function traverse(root, visitor) {
-        var worklist,
-            leavelist,
-            element,
-            node,
-            nodeType,
-            ret,
-            key,
-            current,
-            current2,
-            candidates,
-            candidate,
-            sentinel;
-
-        this.__initialize(root, visitor);
-
-        sentinel = {};
-
-        // reference
-        worklist = this.__worklist;
-        leavelist = this.__leavelist;
-
-        // initialize
-        worklist.push(new Element(root, null, null, null));
-        leavelist.push(new Element(null, null, null, null));
-
-        while (worklist.length) {
-            element = worklist.pop();
-
-            if (element === sentinel) {
-                element = leavelist.pop();
-
-                ret = this.__execute(visitor.leave, element);
-
-                if (this.__state === BREAK || ret === BREAK) {
-                    return;
-                }
-                continue;
-            }
-
-            if (element.node) {
-
-                ret = this.__execute(visitor.enter, element);
-
-                if (this.__state === BREAK || ret === BREAK) {
-                    return;
-                }
-
-                worklist.push(sentinel);
-                leavelist.push(element);
-
-                if (this.__state === SKIP || ret === SKIP) {
-                    continue;
-                }
-
-                node = element.node;
-                nodeType = element.wrap || node.type;
-                candidates = this.__keys[nodeType];
-                if (!candidates) {
-                    if (this.__fallback) {
-                        candidates = objectKeys(node);
-                    } else {
-                        throw new Error('Unknown node type ' + nodeType + '.');
-                    }
-                }
-
-                current = candidates.length;
-                while ((current -= 1) >= 0) {
-                    key = candidates[current];
-                    candidate = node[key];
-                    if (!candidate) {
-                        continue;
-                    }
-
-                    if (isArray(candidate)) {
-                        current2 = candidate.length;
-                        while ((current2 -= 1) >= 0) {
-                            if (!candidate[current2]) {
-                                continue;
-                            }
-                            if (isProperty(nodeType, candidates[current])) {
-                                element = new Element(candidate[current2], [key, current2], 'Property', null);
-                            } else if (isNode(candidate[current2])) {
-                                element = new Element(candidate[current2], [key, current2], null, null);
-                            } else {
-                                continue;
-                            }
-                            worklist.push(element);
-                        }
-                    } else if (isNode(candidate)) {
-                        worklist.push(new Element(candidate, key, null, null));
-                    }
-                }
-            }
-        }
-    };
-
-    Controller.prototype.replace = function replace(root, visitor) {
-        function removeElem(element) {
-            var i,
-                key,
-                nextElem,
-                parent;
-
-            if (element.ref.remove()) {
-                // When the reference is an element of an array.
-                key = element.ref.key;
-                parent = element.ref.parent;
-
-                // If removed from array, then decrease following items' keys.
-                i = worklist.length;
-                while (i--) {
-                    nextElem = worklist[i];
-                    if (nextElem.ref && nextElem.ref.parent === parent) {
-                        if  (nextElem.ref.key < key) {
-                            break;
-                        }
-                        --nextElem.ref.key;
-                    }
-                }
-            }
-        }
-
-        var worklist,
-            leavelist,
-            node,
-            nodeType,
-            target,
-            element,
-            current,
-            current2,
-            candidates,
-            candidate,
-            sentinel,
-            outer,
-            key;
-
-        this.__initialize(root, visitor);
-
-        sentinel = {};
-
-        // reference
-        worklist = this.__worklist;
-        leavelist = this.__leavelist;
-
-        // initialize
-        outer = {
-            root: root
-        };
-        element = new Element(root, null, null, new Reference(outer, 'root'));
-        worklist.push(element);
-        leavelist.push(element);
-
-        while (worklist.length) {
-            element = worklist.pop();
-
-            if (element === sentinel) {
-                element = leavelist.pop();
-
-                target = this.__execute(visitor.leave, element);
-
-                // node may be replaced with null,
-                // so distinguish between undefined and null in this place
-                if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
-                    // replace
-                    element.ref.replace(target);
-                }
-
-                if (this.__state === REMOVE || target === REMOVE) {
-                    removeElem(element);
-                }
-
-                if (this.__state === BREAK || target === BREAK) {
-                    return outer.root;
-                }
-                continue;
-            }
-
-            target = this.__execute(visitor.enter, element);
-
-            // node may be replaced with null,
-            // so distinguish between undefined and null in this place
-            if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
-                // replace
-                element.ref.replace(target);
-                element.node = target;
-            }
-
-            if (this.__state === REMOVE || target === REMOVE) {
-                removeElem(element);
-                element.node = null;
-            }
-
-            if (this.__state === BREAK || target === BREAK) {
-                return outer.root;
-            }
-
-            // node may be null
-            node = element.node;
-            if (!node) {
-                continue;
-            }
-
-            worklist.push(sentinel);
-            leavelist.push(element);
-
-            if (this.__state === SKIP || target === SKIP) {
-                continue;
-            }
-
-            nodeType = element.wrap || node.type;
-            candidates = this.__keys[nodeType];
-            if (!candidates) {
-                if (this.__fallback) {
-                    candidates = objectKeys(node);
-                } else {
-                    throw new Error('Unknown node type ' + nodeType + '.');
-                }
-            }
-
-            current = candidates.length;
-            while ((current -= 1) >= 0) {
-                key = candidates[current];
-                candidate = node[key];
-                if (!candidate) {
-                    continue;
-                }
-
-                if (isArray(candidate)) {
-                    current2 = candidate.length;
-                    while ((current2 -= 1) >= 0) {
-                        if (!candidate[current2]) {
-                            continue;
-                        }
-                        if (isProperty(nodeType, candidates[current])) {
-                            element = new Element(candidate[current2], [key, current2], 'Property', new Reference(candidate, current2));
-                        } else if (isNode(candidate[current2])) {
-                            element = new Element(candidate[current2], [key, current2], null, new Reference(candidate, current2));
-                        } else {
-                            continue;
-                        }
-                        worklist.push(element);
-                    }
-                } else if (isNode(candidate)) {
-                    worklist.push(new Element(candidate, key, null, new Reference(node, key)));
-                }
-            }
-        }
-
-        return outer.root;
-    };
-
-    function traverse(root, visitor) {
-        var controller = new Controller();
-        return controller.traverse(root, visitor);
-    }
-
-    function replace(root, visitor) {
-        var controller = new Controller();
-        return controller.replace(root, visitor);
-    }
-
-    function extendCommentRange(comment, tokens) {
-        var target;
-
-        target = upperBound(tokens, function search(token) {
-            return token.range[0] > comment.range[0];
-        });
-
-        comment.extendedRange = [comment.range[0], comment.range[1]];
-
-        if (target !== tokens.length) {
-            comment.extendedRange[1] = tokens[target].range[0];
-        }
-
-        target -= 1;
-        if (target >= 0) {
-            comment.extendedRange[0] = tokens[target].range[1];
-        }
-
-        return comment;
-    }
-
-    function attachComments(tree, providedComments, tokens) {
-        // At first, we should calculate extended comment ranges.
-        var comments = [], comment, len, i, cursor;
-
-        if (!tree.range) {
-            throw new Error('attachComments needs range information');
-        }
-
-        // tokens array is empty, we attach comments to tree as 'leadingComments'
-        if (!tokens.length) {
-            if (providedComments.length) {
-                for (i = 0, len = providedComments.length; i < len; i += 1) {
-                    comment = deepCopy(providedComments[i]);
-                    comment.extendedRange = [0, tree.range[0]];
-                    comments.push(comment);
-                }
-                tree.leadingComments = comments;
-            }
-            return tree;
-        }
-
-        for (i = 0, len = providedComments.length; i < len; i += 1) {
-            comments.push(extendCommentRange(deepCopy(providedComments[i]), tokens));
-        }
-
-        // This is based on John Freeman's implementation.
-        cursor = 0;
-        traverse(tree, {
-            enter: function (node) {
-                var comment;
-
-                while (cursor < comments.length) {
-                    comment = comments[cursor];
-                    if (comment.extendedRange[1] > node.range[0]) {
-                        break;
-                    }
-
-                    if (comment.extendedRange[1] === node.range[0]) {
-                        if (!node.leadingComments) {
-                            node.leadingComments = [];
-                        }
-                        node.leadingComments.push(comment);
-                        comments.splice(cursor, 1);
-                    } else {
-                        cursor += 1;
-                    }
-                }
-
-                // already out of owned node
-                if (cursor === comments.length) {
-                    return VisitorOption.Break;
-                }
-
-                if (comments[cursor].extendedRange[0] > node.range[1]) {
-                    return VisitorOption.Skip;
-                }
-            }
-        });
-
-        cursor = 0;
-        traverse(tree, {
-            leave: function (node) {
-                var comment;
-
-                while (cursor < comments.length) {
-                    comment = comments[cursor];
-                    if (node.range[1] < comment.extendedRange[0]) {
-                        break;
-                    }
-
-                    if (node.range[1] === comment.extendedRange[0]) {
-                        if (!node.trailingComments) {
-                            node.trailingComments = [];
-                        }
-                        node.trailingComments.push(comment);
-                        comments.splice(cursor, 1);
-                    } else {
-                        cursor += 1;
-                    }
-                }
-
-                // already out of owned node
-                if (cursor === comments.length) {
-                    return VisitorOption.Break;
-                }
-
-                if (comments[cursor].extendedRange[0] > node.range[1]) {
-                    return VisitorOption.Skip;
-                }
-            }
-        });
-
-        return tree;
-    }
-
-    exports.version = '1.7.1';
-    exports.Syntax = Syntax;
-    exports.traverse = traverse;
-    exports.replace = replace;
-    exports.attachComments = attachComments;
-    exports.VisitorKeys = VisitorKeys;
-    exports.VisitorOption = VisitorOption;
-    exports.Controller = Controller;
-}));
-/* vim: set sw=4 ts=4 et tw=80 : */
-
-},{}],37:[function(_dereq_,module,exports){
-module.exports = _dereq_('./javascript/diff_match_patch_uncompressed.js').diff_match_patch;
-
-},{"./javascript/diff_match_patch_uncompressed.js":38}],38:[function(_dereq_,module,exports){
-/**
- * Diff Match and Patch
- *
- * Copyright 2006 Google Inc.
- * http://code.google.com/p/google-diff-match-patch/
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * @fileoverview Computes the difference between two texts to create a patch.
- * Applies the patch onto another text, allowing for errors.
- * @author fraser@google.com (Neil Fraser)
- */
-
-/**
- * Class containing the diff, match and patch methods.
- * @constructor
- */
-function diff_match_patch() {
-
-  // Defaults.
-  // Redefine these in your program to override the defaults.
-
-  // Number of seconds to map a diff before giving up (0 for infinity).
-  this.Diff_Timeout = 1.0;
-  // Cost of an empty edit operation in terms of edit characters.
-  this.Diff_EditCost = 4;
-  // At what point is no match declared (0.0 = perfection, 1.0 = very loose).
-  this.Match_Threshold = 0.5;
-  // How far to search for a match (0 = exact location, 1000+ = broad match).
-  // A match this many characters away from the expected location will add
-  // 1.0 to the score (0.0 is a perfect match).
-  this.Match_Distance = 1000;
-  // When deleting a large block of text (over ~64 characters), how close do
-  // the contents have to be to match the expected contents. (0.0 = perfection,
-  // 1.0 = very loose).  Note that Match_Threshold controls how closely the
-  // end points of a delete need to match.
-  this.Patch_DeleteThreshold = 0.5;
-  // Chunk size for context length.
-  this.Patch_Margin = 4;
-
-  // The number of bits in an int.
-  this.Match_MaxBits = 32;
-}
-
-
-//  DIFF FUNCTIONS
-
-
-/**
- * The data structure representing a diff is an array of tuples:
- * [[DIFF_DELETE, 'Hello'], [DIFF_INSERT, 'Goodbye'], [DIFF_EQUAL, ' world.']]
- * which means: delete 'Hello', add 'Goodbye' and keep ' world.'
- */
-var DIFF_DELETE = -1;
-var DIFF_INSERT = 1;
-var DIFF_EQUAL = 0;
-
-/** @typedef {{0: number, 1: string}} */
-diff_match_patch.Diff;
-
-
-/**
- * Find the differences between two texts.  Simplifies the problem by stripping
- * any common prefix or suffix off the texts before diffing.
- * @param {string} text1 Old string to be diffed.
- * @param {string} text2 New string to be diffed.
- * @param {boolean=} opt_checklines Optional speedup flag. If present and false,
- *     then don't run a line-level diff first to identify the changed areas.
- *     Defaults to true, which does a faster, slightly less optimal diff.
- * @param {number} opt_deadline Optional time when the diff should be complete
- *     by.  Used internally for recursive calls.  Users should set DiffTimeout
- *     instead.
- * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.
- */
-diff_match_patch.prototype.diff_main = function(text1, text2, opt_checklines,
-    opt_deadline) {
-  // Set a deadline by which time the diff must be complete.
-  if (typeof opt_deadline == 'undefined') {
-    if (this.Diff_Timeout <= 0) {
-      opt_deadline = Number.MAX_VALUE;
-    } else {
-      opt_deadline = (new Date).getTime() + this.Diff_Timeout * 1000;
-    }
-  }
-  var deadline = opt_deadline;
-
-  // Check for null inputs.
-  if (text1 == null || text2 == null) {
-    throw new Error('Null input. (diff_main)');
-  }
-
-  // Check for equality (speedup).
-  if (text1 == text2) {
-    if (text1) {
-      return [[DIFF_EQUAL, text1]];
-    }
-    return [];
-  }
-
-  if (typeof opt_checklines == 'undefined') {
-    opt_checklines = true;
-  }
-  var checklines = opt_checklines;
-
-  // Trim off common prefix (speedup).
-  var commonlength = this.diff_commonPrefix(text1, text2);
-  var commonprefix = text1.substring(0, commonlength);
-  text1 = text1.substring(commonlength);
-  text2 = text2.substring(commonlength);
-
-  // Trim off common suffix (speedup).
-  commonlength = this.diff_commonSuffix(text1, text2);
-  var commonsuffix = text1.substring(text1.length - commonlength);
-  text1 = text1.substring(0, text1.length - commonlength);
-  text2 = text2.substring(0, text2.length - commonlength);
-
-  // Compute the diff on the middle block.
-  var diffs = this.diff_compute_(text1, text2, checklines, deadline);
-
-  // Restore the prefix and suffix.
-  if (commonprefix) {
-    diffs.unshift([DIFF_EQUAL, commonprefix]);
-  }
-  if (commonsuffix) {
-    diffs.push([DIFF_EQUAL, commonsuffix]);
-  }
-  this.diff_cleanupMerge(diffs);
-  return diffs;
-};
-
-
-/**
- * Find the differences between two texts.  Assumes that the texts do not
- * have any common prefix or suffix.
- * @param {string} text1 Old string to be diffed.
- * @param {string} text2 New string to be diffed.
- * @param {boolean} checklines Speedup flag.  If false, then don't run a
- *     line-level diff first to identify the changed areas.
- *     If true, then run a faster, slightly less optimal diff.
- * @param {number} deadline Time when the diff should be complete by.
- * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.
- * @private
- */
-diff_match_patch.prototype.diff_compute_ = function(text1, text2, checklines,
-    deadline) {
-  var diffs;
-
-  if (!text1) {
-    // Just add some text (speedup).
-    return [[DIFF_INSERT, text2]];
-  }
-
-  if (!text2) {
-    // Just delete some text (speedup).
-    return [[DIFF_DELETE, text1]];
-  }
-
-  var longtext = text1.length > text2.length ? text1 : text2;
-  var shorttext = text1.length > text2.length ? text2 : text1;
-  var i = longtext.indexOf(shorttext);
-  if (i != -1) {
-    // Shorter text is inside the longer text (speedup).
-    diffs = [[DIFF_INSERT, longtext.substring(0, i)],
-             [DIFF_EQUAL, shorttext],
-             [DIFF_INSERT, longtext.substring(i + shorttext.length)]];
-    // Swap insertions for deletions if diff is reversed.
-    if (text1.length > text2.length) {
-      diffs[0][0] = diffs[2][0] = DIFF_DELETE;
-    }
-    return diffs;
-  }
-
-  if (shorttext.length == 1) {
-    // Single character string.
-    // After the previous speedup, the character can't be an equality.
-    return [[DIFF_DELETE, text1], [DIFF_INSERT, text2]];
-  }
-
-  // Check to see if the problem can be split in two.
-  var hm = this.diff_halfMatch_(text1, text2);
-  if (hm) {
-    // A half-match was found, sort out the return data.
-    var text1_a = hm[0];
-    var text1_b = hm[1];
-    var text2_a = hm[2];
-    var text2_b = hm[3];
-    var mid_common = hm[4];
-    // Send both pairs off for separate processing.
-    var diffs_a = this.diff_main(text1_a, text2_a, checklines, deadline);
-    var diffs_b = this.diff_main(text1_b, text2_b, checklines, deadline);
-    // Merge the results.
-    return diffs_a.concat([[DIFF_EQUAL, mid_common]], diffs_b);
-  }
-
-  if (checklines && text1.length > 100 && text2.length > 100) {
-    return this.diff_lineMode_(text1, text2, deadline);
-  }
-
-  return this.diff_bisect_(text1, text2, deadline);
-};
-
-
-/**
- * Do a quick line-level diff on both strings, then rediff the parts for
- * greater accuracy.
- * This speedup can produce non-minimal diffs.
- * @param {string} text1 Old string to be diffed.
- * @param {string} text2 New string to be diffed.
- * @param {number} deadline Time when the diff should be complete by.
- * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.
- * @private
- */
-diff_match_patch.prototype.diff_lineMode_ = function(text1, text2, deadline) {
-  // Scan the text on a line-by-line basis first.
-  var a = this.diff_linesToChars_(text1, text2);
-  text1 = a.chars1;
-  text2 = a.chars2;
-  var linearray = a.lineArray;
-
-  var diffs = this.diff_main(text1, text2, false, deadline);
-
-  // Convert the diff back to original text.
-  this.diff_charsToLines_(diffs, linearray);
-  // Eliminate freak matches (e.g. blank lines)
-  this.diff_cleanupSemantic(diffs);
-
-  // Rediff any replacement blocks, this time character-by-character.
-  // Add a dummy entry at the end.
-  diffs.push([DIFF_EQUAL, '']);
-  var pointer = 0;
-  var count_delete = 0;
-  var count_insert = 0;
-  var text_delete = '';
-  var text_insert = '';
-  while (pointer < diffs.length) {
-    switch (diffs[pointer][0]) {
-      case DIFF_INSERT:
-        count_insert++;
-        text_insert += diffs[pointer][1];
-        break;
-      case DIFF_DELETE:
-        count_delete++;
-        text_delete += diffs[pointer][1];
-        break;
-      case DIFF_EQUAL:
-        // Upon reaching an equality, check for prior redundancies.
-        if (count_delete >= 1 && count_insert >= 1) {
-          // Delete the offending records and add the merged ones.
-          diffs.splice(pointer - count_delete - count_insert,
-                       count_delete + count_insert);
-          pointer = pointer - count_delete - count_insert;
-          var a = this.diff_main(text_delete, text_insert, false, deadline);
-          for (var j = a.length - 1; j >= 0; j--) {
-            diffs.splice(pointer, 0, a[j]);
-          }
-          pointer = pointer + a.length;
-        }
-        count_insert = 0;
-        count_delete = 0;
-        text_delete = '';
-        text_insert = '';
-        break;
-    }
-    pointer++;
-  }
-  diffs.pop();  // Remove the dummy entry at the end.
-
-  return diffs;
-};
-
-
-/**
- * Find the 'middle snake' of a diff, split the problem in two
- * and return the recursively constructed diff.
- * See Myers 1986 paper: An O(ND) Difference Algorithm and Its Variations.
- * @param {string} text1 Old string to be diffed.
- * @param {string} text2 New string to be diffed.
- * @param {number} deadline Time at which to bail if not yet complete.
- * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.
- * @private
- */
-diff_match_patch.prototype.diff_bisect_ = function(text1, text2, deadline) {
-  // Cache the text lengths to prevent multiple calls.
-  var text1_length = text1.length;
-  var text2_length = text2.length;
-  var max_d = Math.ceil((text1_length + text2_length) / 2);
-  var v_offset = max_d;
-  var v_length = 2 * max_d;
-  var v1 = new Array(v_length);
-  var v2 = new Array(v_length);
-  // Setting all elements to -1 is faster in Chrome & Firefox than mixing
-  // integers and undefined.
-  for (var x = 0; x < v_length; x++) {
-    v1[x] = -1;
-    v2[x] = -1;
-  }
-  v1[v_offset + 1] = 0;
-  v2[v_offset + 1] = 0;
-  var delta = text1_length - text2_length;
-  // If the total number of characters is odd, then the front path will collide
-  // with the reverse path.
-  var front = (delta % 2 != 0);
-  // Offsets for start and end of k loop.
-  // Prevents mapping of space beyond the grid.
-  var k1start = 0;
-  var k1end = 0;
-  var k2start = 0;
-  var k2end = 0;
-  for (var d = 0; d < max_d; d++) {
-    // Bail out if deadline is reached.
-    if ((new Date()).getTime() > deadline) {
-      break;
-    }
-
-    // Walk the front path one step.
-    for (var k1 = -d + k1start; k1 <= d - k1end; k1 += 2) {
-      var k1_offset = v_offset + k1;
-      var x1;
-      if (k1 == -d || (k1 != d && v1[k1_offset - 1] < v1[k1_offset + 1])) {
-        x1 = v1[k1_offset + 1];
-      } else {
-        x1 = v1[k1_offset - 1] + 1;
-      }
-      var y1 = x1 - k1;
-      while (x1 < text1_length && y1 < text2_length &&
-             text1.charAt(x1) == text2.charAt(y1)) {
-        x1++;
-        y1++;
-      }
-      v1[k1_offset] = x1;
-      if (x1 > text1_length) {
-        // Ran off the right of the graph.
-        k1end += 2;
-      } else if (y1 > text2_length) {
-        // Ran off the bottom of the graph.
-        k1start += 2;
-      } else if (front) {
-        var k2_offset = v_offset + delta - k1;
-        if (k2_offset >= 0 && k2_offset < v_length && v2[k2_offset] != -1) {
-          // Mirror x2 onto top-left coordinate system.
-          var x2 = text1_length - v2[k2_offset];
-          if (x1 >= x2) {
-            // Overlap detected.
-            return this.diff_bisectSplit_(text1, text2, x1, y1, deadline);
-          }
-        }
-      }
-    }
-
-    // Walk the reverse path one step.
-    for (var k2 = -d + k2start; k2 <= d - k2end; k2 += 2) {
-      var k2_offset = v_offset + k2;
-      var x2;
-      if (k2 == -d || (k2 != d && v2[k2_offset - 1] < v2[k2_offset + 1])) {
-        x2 = v2[k2_offset + 1];
-      } else {
-        x2 = v2[k2_offset - 1] + 1;
-      }
-      var y2 = x2 - k2;
-      while (x2 < text1_length && y2 < text2_length &&
-             text1.charAt(text1_length - x2 - 1) ==
-             text2.charAt(text2_length - y2 - 1)) {
-        x2++;
-        y2++;
-      }
-      v2[k2_offset] = x2;
-      if (x2 > text1_length) {
-        // Ran off the left of the graph.
-        k2end += 2;
-      } else if (y2 > text2_length) {
-        // Ran off the top of the graph.
-        k2start += 2;
-      } else if (!front) {
-        var k1_offset = v_offset + delta - k2;
-        if (k1_offset >= 0 && k1_offset < v_length && v1[k1_offset] != -1) {
-          var x1 = v1[k1_offset];
-          var y1 = v_offset + x1 - k1_offset;
-          // Mirror x2 onto top-left coordinate system.
-          x2 = text1_length - x2;
-          if (x1 >= x2) {
-            // Overlap detected.
-            return this.diff_bisectSplit_(text1, text2, x1, y1, deadline);
-          }
-        }
-      }
-    }
-  }
-  // Diff took too long and hit the deadline or
-  // number of diffs equals number of characters, no commonality at all.
-  return [[DIFF_DELETE, text1], [DIFF_INSERT, text2]];
-};
-
-
-/**
- * Given the location of the 'middle snake', split the diff in two parts
- * and recurse.
- * @param {string} text1 Old string to be diffed.
- * @param {string} text2 New string to be diffed.
- * @param {number} x Index of split point in text1.
- * @param {number} y Index of split point in text2.
- * @param {number} deadline Time at which to bail if not yet complete.
- * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.
- * @private
- */
-diff_match_patch.prototype.diff_bisectSplit_ = function(text1, text2, x, y,
-    deadline) {
-  var text1a = text1.substring(0, x);
-  var text2a = text2.substring(0, y);
-  var text1b = text1.substring(x);
-  var text2b = text2.substring(y);
-
-  // Compute both diffs serially.
-  var diffs = this.diff_main(text1a, text2a, false, deadline);
-  var diffsb = this.diff_main(text1b, text2b, false, deadline);
-
-  return diffs.concat(diffsb);
-};
-
-
-/**
- * Split two texts into an array of strings.  Reduce the texts to a string of
- * hashes where each Unicode character represents one line.
- * @param {string} text1 First string.
- * @param {string} text2 Second string.
- * @return {{chars1: string, chars2: string, lineArray: !Array.<string>}}
- *     An object containing the encoded text1, the encoded text2 and
- *     the array of unique strings.
- *     The zeroth element of the array of unique strings is intentionally blank.
- * @private
- */
-diff_match_patch.prototype.diff_linesToChars_ = function(text1, text2) {
-  var lineArray = [];  // e.g. lineArray[4] == 'Hello\n'
-  var lineHash = {};   // e.g. lineHash['Hello\n'] == 4
-
-  // '\x00' is a valid character, but various debuggers don't like it.
-  // So we'll insert a junk entry to avoid generating a null character.
-  lineArray[0] = '';
-
-  /**
-   * Split a text into an array of strings.  Reduce the texts to a string of
-   * hashes where each Unicode character represents one line.
-   * Modifies linearray and linehash through being a closure.
-   * @param {string} text String to encode.
-   * @return {string} Encoded string.
-   * @private
-   */
-  function diff_linesToCharsMunge_(text) {
-    var chars = '';
-    // Walk the text, pulling out a substring for each line.
-    // text.split('\n') would would temporarily double our memory footprint.
-    // Modifying text would create many large strings to garbage collect.
-    var lineStart = 0;
-    var lineEnd = -1;
-    // Keeping our own length variable is faster than looking it up.
-    var lineArrayLength = lineArray.length;
-    while (lineEnd < text.length - 1) {
-      lineEnd = text.indexOf('\n', lineStart);
-      if (lineEnd == -1) {
-        lineEnd = text.length - 1;
-      }
-      var line = text.substring(lineStart, lineEnd + 1);
-      lineStart = lineEnd + 1;
-
-      if (lineHash.hasOwnProperty ? lineHash.hasOwnProperty(line) :
-          (lineHash[line] !== undefined)) {
-        chars += String.fromCharCode(lineHash[line]);
-      } else {
-        chars += String.fromCharCode(lineArrayLength);
-        lineHash[line] = lineArrayLength;
-        lineArray[lineArrayLength++] = line;
-      }
-    }
-    return chars;
-  }
-
-  var chars1 = diff_linesToCharsMunge_(text1);
-  var chars2 = diff_linesToCharsMunge_(text2);
-  return {chars1: chars1, chars2: chars2, lineArray: lineArray};
-};
-
-
-/**
- * Rehydrate the text in a diff from a string of line hashes to real lines of
- * text.
- * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
- * @param {!Array.<string>} lineArray Array of unique strings.
- * @private
- */
-diff_match_patch.prototype.diff_charsToLines_ = function(diffs, lineArray) {
-  for (var x = 0; x < diffs.length; x++) {
-    var chars = diffs[x][1];
-    var text = [];
-    for (var y = 0; y < chars.length; y++) {
-      text[y] = lineArray[chars.charCodeAt(y)];
-    }
-    diffs[x][1] = text.join('');
-  }
-};
-
-
-/**
- * Determine the common prefix of two strings.
- * @param {string} text1 First string.
- * @param {string} text2 Second string.
- * @return {number} The number of characters common to the start of each
- *     string.
- */
-diff_match_patch.prototype.diff_commonPrefix = function(text1, text2) {
-  // Quick check for common null cases.
-  if (!text1 || !text2 || text1.charAt(0) != text2.charAt(0)) {
-    return 0;
-  }
-  // Binary search.
-  // Performance analysis: http://neil.fraser.name/news/2007/10/09/
-  var pointermin = 0;
-  var pointermax = Math.min(text1.length, text2.length);
-  var pointermid = pointermax;
-  var pointerstart = 0;
-  while (pointermin < pointermid) {
-    if (text1.substring(pointerstart, pointermid) ==
-        text2.substring(pointerstart, pointermid)) {
-      pointermin = pointermid;
-      pointerstart = pointermin;
-    } else {
-      pointermax = pointermid;
-    }
-    pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);
-  }
-  return pointermid;
-};
-
-
-/**
- * Determine the common suffix of two strings.
- * @param {string} text1 First string.
- * @param {string} text2 Second string.
- * @return {number} The number of characters common to the end of each string.
- */
-diff_match_patch.prototype.diff_commonSuffix = function(text1, text2) {
-  // Quick check for common null cases.
-  if (!text1 || !text2 ||
-      text1.charAt(text1.length - 1) != text2.charAt(text2.length - 1)) {
-    return 0;
-  }
-  // Binary search.
-  // Performance analysis: http://neil.fraser.name/news/2007/10/09/
-  var pointermin = 0;
-  var pointermax = Math.min(text1.length, text2.length);
-  var pointermid = pointermax;
-  var pointerend = 0;
-  while (pointermin < pointermid) {
-    if (text1.substring(text1.length - pointermid, text1.length - pointerend) ==
-        text2.substring(text2.length - pointermid, text2.length - pointerend)) {
-      pointermin = pointermid;
-      pointerend = pointermin;
-    } else {
-      pointermax = pointermid;
-    }
-    pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);
-  }
-  return pointermid;
-};
-
-
-/**
- * Determine if the suffix of one string is the prefix of another.
- * @param {string} text1 First string.
- * @param {string} text2 Second string.
- * @return {number} The number of characters common to the end of the first
- *     string and the start of the second string.
- * @private
- */
-diff_match_patch.prototype.diff_commonOverlap_ = function(text1, text2) {
-  // Cache the text lengths to prevent multiple calls.
-  var text1_length = text1.length;
-  var text2_length = text2.length;
-  // Eliminate the null case.
-  if (text1_length == 0 || text2_length == 0) {
-    return 0;
-  }
-  // Truncate the longer string.
-  if (text1_length > text2_length) {
-    text1 = text1.substring(text1_length - text2_length);
-  } else if (text1_length < text2_length) {
-    text2 = text2.substring(0, text1_length);
-  }
-  var text_length = Math.min(text1_length, text2_length);
-  // Quick check for the worst case.
-  if (text1 == text2) {
-    return text_length;
-  }
-
-  // Start by looking for a single character match
-  // and increase length until no match is found.
-  // Performance analysis: http://neil.fraser.name/news/2010/11/04/
-  var best = 0;
-  var length = 1;
-  while (true) {
-    var pattern = text1.substring(text_length - length);
-    var found = text2.indexOf(pattern);
-    if (found == -1) {
-      return best;
-    }
-    length += found;
-    if (found == 0 || text1.substring(text_length - length) ==
-        text2.substring(0, length)) {
-      best = length;
-      length++;
-    }
-  }
-};
-
-
-/**
- * Do the two texts share a substring which is at least half the length of the
- * longer text?
- * This speedup can produce non-minimal diffs.
- * @param {string} text1 First string.
- * @param {string} text2 Second string.
- * @return {Array.<string>} Five element Array, containing the prefix of
- *     text1, the suffix of text1, the prefix of text2, the suffix of
- *     text2 and the common middle.  Or null if there was no match.
- * @private
- */
-diff_match_patch.prototype.diff_halfMatch_ = function(text1, text2) {
-  if (this.Diff_Timeout <= 0) {
-    // Don't risk returning a non-optimal diff if we have unlimited time.
-    return null;
-  }
-  var longtext = text1.length > text2.length ? text1 : text2;
-  var shorttext = text1.length > text2.length ? text2 : text1;
-  if (longtext.length < 4 || shorttext.length * 2 < longtext.length) {
-    return null;  // Pointless.
-  }
-  var dmp = this;  // 'this' becomes 'window' in a closure.
-
-  /**
-   * Does a substring of shorttext exist within longtext such that the substring
-   * is at least half the length of longtext?
-   * Closure, but does not reference any external variables.
-   * @param {string} longtext Longer string.
-   * @param {string} shorttext Shorter string.
-   * @param {number} i Start index of quarter length substring within longtext.
-   * @return {Array.<string>} Five element Array, containing the prefix of
-   *     longtext, the suffix of longtext, the prefix of shorttext, the suffix
-   *     of shorttext and the common middle.  Or null if there was no match.
-   * @private
-   */
-  function diff_halfMatchI_(longtext, shorttext, i) {
-    // Start with a 1/4 length substring at position i as a seed.
-    var seed = longtext.substring(i, i + Math.floor(longtext.length / 4));
-    var j = -1;
-    var best_common = '';
-    var best_longtext_a, best_longtext_b, best_shorttext_a, best_shorttext_b;
-    while ((j = shorttext.indexOf(seed, j + 1)) != -1) {
-      var prefixLength = dmp.diff_commonPrefix(longtext.substring(i),
-                                               shorttext.substring(j));
-      var suffixLength = dmp.diff_commonSuffix(longtext.substring(0, i),
-                                               shorttext.substring(0, j));
-      if (best_common.length < suffixLength + prefixLength) {
-        best_common = shorttext.substring(j - suffixLength, j) +
-            shorttext.substring(j, j + prefixLength);
-        best_longtext_a = longtext.substring(0, i - suffixLength);
-        best_longtext_b = longtext.substring(i + prefixLength);
-        best_shorttext_a = shorttext.substring(0, j - suffixLength);
-        best_shorttext_b = shorttext.substring(j + prefixLength);
-      }
-    }
-    if (best_common.length * 2 >= longtext.length) {
-      return [best_longtext_a, best_longtext_b,
-              best_shorttext_a, best_shorttext_b, best_common];
-    } else {
-      return null;
-    }
-  }
-
-  // First check if the second quarter is the seed for a half-match.
-  var hm1 = diff_halfMatchI_(longtext, shorttext,
-                             Math.ceil(longtext.length / 4));
-  // Check again based on the third quarter.
-  var hm2 = diff_halfMatchI_(longtext, shorttext,
-                             Math.ceil(longtext.length / 2));
-  var hm;
-  if (!hm1 && !hm2) {
-    return null;
-  } else if (!hm2) {
-    hm = hm1;
-  } else if (!hm1) {
-    hm = hm2;
-  } else {
-    // Both matched.  Select the longest.
-    hm = hm1[4].length > hm2[4].length ? hm1 : hm2;
-  }
-
-  // A half-match was found, sort out the return data.
-  var text1_a, text1_b, text2_a, text2_b;
-  if (text1.length > text2.length) {
-    text1_a = hm[0];
-    text1_b = hm[1];
-    text2_a = hm[2];
-    text2_b = hm[3];
-  } else {
-    text2_a = hm[0];
-    text2_b = hm[1];
-    text1_a = hm[2];
-    text1_b = hm[3];
-  }
-  var mid_common = hm[4];
-  return [text1_a, text1_b, text2_a, text2_b, mid_common];
-};
-
-
-/**
- * Reduce the number of edits by eliminating semantically trivial equalities.
- * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
- */
-diff_match_patch.prototype.diff_cleanupSemantic = function(diffs) {
-  var changes = false;
-  var equalities = [];  // Stack of indices where equalities are found.
-  var equalitiesLength = 0;  // Keeping our own length var is faster in JS.
-  /** @type {?string} */
-  var lastequality = null;
-  // Always equal to diffs[equalities[equalitiesLength - 1]][1]
-  var pointer = 0;  // Index of current position.
-  // Number of characters that changed prior to the equality.
-  var length_insertions1 = 0;
-  var length_deletions1 = 0;
-  // Number of characters that changed after the equality.
-  var length_insertions2 = 0;
-  var length_deletions2 = 0;
-  while (pointer < diffs.length) {
-    if (diffs[pointer][0] == DIFF_EQUAL) {  // Equality found.
-      equalities[equalitiesLength++] = pointer;
-      length_insertions1 = length_insertions2;
-      length_deletions1 = length_deletions2;
-      length_insertions2 = 0;
-      length_deletions2 = 0;
-      lastequality = diffs[pointer][1];
-    } else {  // An insertion or deletion.
-      if (diffs[pointer][0] == DIFF_INSERT) {
-        length_insertions2 += diffs[pointer][1].length;
-      } else {
-        length_deletions2 += diffs[pointer][1].length;
-      }
-      // Eliminate an equality that is smaller or equal to the edits on both
-      // sides of it.
-      if (lastequality && (lastequality.length <=
-          Math.max(length_insertions1, length_deletions1)) &&
-          (lastequality.length <= Math.max(length_insertions2,
-                                           length_deletions2))) {
-        // Duplicate record.
-        diffs.splice(equalities[equalitiesLength - 1], 0,
-                     [DIFF_DELETE, lastequality]);
-        // Change second copy to insert.
-        diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT;
-        // Throw away the equality we just deleted.
-        equalitiesLength--;
-        // Throw away the previous equality (it needs to be reevaluated).
-        equalitiesLength--;
-        pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1;
-        length_insertions1 = 0;  // Reset the counters.
-        length_deletions1 = 0;
-        length_insertions2 = 0;
-        length_deletions2 = 0;
-        lastequality = null;
-        changes = true;
-      }
-    }
-    pointer++;
-  }
-
-  // Normalize the diff.
-  if (changes) {
-    this.diff_cleanupMerge(diffs);
-  }
-  this.diff_cleanupSemanticLossless(diffs);
-
-  // Find any overlaps between deletions and insertions.
-  // e.g: <del>abcxxx</del><ins>xxxdef</ins>
-  //   -> <del>abc</del>xxx<ins>def</ins>
-  // e.g: <del>xxxabc</del><ins>defxxx</ins>
-  //   -> <ins>def</ins>xxx<del>abc</del>
-  // Only extract an overlap if it is as big as the edit ahead or behind it.
-  pointer = 1;
-  while (pointer < diffs.length) {
-    if (diffs[pointer - 1][0] == DIFF_DELETE &&
-        diffs[pointer][0] == DIFF_INSERT) {
-      var deletion = diffs[pointer - 1][1];
-      var insertion = diffs[pointer][1];
-      var overlap_length1 = this.diff_commonOverlap_(deletion, insertion);
-      var overlap_length2 = this.diff_commonOverlap_(insertion, deletion);
-      if (overlap_length1 >= overlap_length2) {
-        if (overlap_length1 >= deletion.length / 2 ||
-            overlap_length1 >= insertion.length / 2) {
-          // Overlap found.  Insert an equality and trim the surrounding edits.
-          diffs.splice(pointer, 0,
-              [DIFF_EQUAL, insertion.substring(0, overlap_length1)]);
-          diffs[pointer - 1][1] =
-              deletion.substring(0, deletion.length - overlap_length1);
-          diffs[pointer + 1][1] = insertion.substring(overlap_length1);
-          pointer++;
-        }
-      } else {
-        if (overlap_length2 >= deletion.length / 2 ||
-            overlap_length2 >= insertion.length / 2) {
-          // Reverse overlap found.
-          // Insert an equality and swap and trim the surrounding edits.
-          diffs.splice(pointer, 0,
-              [DIFF_EQUAL, deletion.substring(0, overlap_length2)]);
-          diffs[pointer - 1][0] = DIFF_INSERT;
-          diffs[pointer - 1][1] =
-              insertion.substring(0, insertion.length - overlap_length2);
-          diffs[pointer + 1][0] = DIFF_DELETE;
-          diffs[pointer + 1][1] =
-              deletion.substring(overlap_length2);
-          pointer++;
-        }
-      }
-      pointer++;
-    }
-    pointer++;
-  }
-};
-
-
-/**
- * Look for single edits surrounded on both sides by equalities
- * which can be shifted sideways to align the edit to a word boundary.
- * e.g: The c<ins>at c</ins>ame. -> The <ins>cat </ins>came.
- * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
- */
-diff_match_patch.prototype.diff_cleanupSemanticLossless = function(diffs) {
-  /**
-   * Given two strings, compute a score representing whether the internal
-   * boundary falls on logical boundaries.
-   * Scores range from 6 (best) to 0 (worst).
-   * Closure, but does not reference any external variables.
-   * @param {string} one First string.
-   * @param {string} two Second string.
-   * @return {number} The score.
-   * @private
-   */
-  function diff_cleanupSemanticScore_(one, two) {
-    if (!one || !two) {
-      // Edges are the best.
-      return 6;
-    }
-
-    // Each port of this function behaves slightly differently due to
-    // subtle differences in each language's definition of things like
-    // 'whitespace'.  Since this function's purpose is largely cosmetic,
-    // the choice has been made to use each language's native features
-    // rather than force total conformity.
-    var char1 = one.charAt(one.length - 1);
-    var char2 = two.charAt(0);
-    var nonAlphaNumeric1 = char1.match(diff_match_patch.nonAlphaNumericRegex_);
-    var nonAlphaNumeric2 = char2.match(diff_match_patch.nonAlphaNumericRegex_);
-    var whitespace1 = nonAlphaNumeric1 &&
-        char1.match(diff_match_patch.whitespaceRegex_);
-    var whitespace2 = nonAlphaNumeric2 &&
-        char2.match(diff_match_patch.whitespaceRegex_);
-    var lineBreak1 = whitespace1 &&
-        char1.match(diff_match_patch.linebreakRegex_);
-    var lineBreak2 = whitespace2 &&
-        char2.match(diff_match_patch.linebreakRegex_);
-    var blankLine1 = lineBreak1 &&
-        one.match(diff_match_patch.blanklineEndRegex_);
-    var blankLine2 = lineBreak2 &&
-        two.match(diff_match_patch.blanklineStartRegex_);
-
-    if (blankLine1 || blankLine2) {
-      // Five points for blank lines.
-      return 5;
-    } else if (lineBreak1 || lineBreak2) {
-      // Four points for line breaks.
-      return 4;
-    } else if (nonAlphaNumeric1 && !whitespace1 && whitespace2) {
-      // Three points for end of sentences.
-      return 3;
-    } else if (whitespace1 || whitespace2) {
-      // Two points for whitespace.
-      return 2;
-    } else if (nonAlphaNumeric1 || nonAlphaNumeric2) {
-      // One point for non-alphanumeric.
-      return 1;
-    }
-    return 0;
-  }
-
-  var pointer = 1;
-  // Intentionally ignore the first and last element (don't need checking).
-  while (pointer < diffs.length - 1) {
-    if (diffs[pointer - 1][0] == DIFF_EQUAL &&
-        diffs[pointer + 1][0] == DIFF_EQUAL) {
-      // This is a single edit surrounded by equalities.
-      var equality1 = diffs[pointer - 1][1];
-      var edit = diffs[pointer][1];
-      var equality2 = diffs[pointer + 1][1];
-
-      // First, shift the edit as far left as possible.
-      var commonOffset = this.diff_commonSuffix(equality1, edit);
-      if (commonOffset) {
-        var commonString = edit.substring(edit.length - commonOffset);
-        equality1 = equality1.substring(0, equality1.length - commonOffset);
-        edit = commonString + edit.substring(0, edit.length - commonOffset);
-        equality2 = commonString + equality2;
-      }
-
-      // Second, step character by character right, looking for the best fit.
-      var bestEquality1 = equality1;
-      var bestEdit = edit;
-      var bestEquality2 = equality2;
-      var bestScore = diff_cleanupSemanticScore_(equality1, edit) +
-          diff_cleanupSemanticScore_(edit, equality2);
-      while (edit.charAt(0) === equality2.charAt(0)) {
-        equality1 += edit.charAt(0);
-        edit = edit.substring(1) + equality2.charAt(0);
-        equality2 = equality2.substring(1);
-        var score = diff_cleanupSemanticScore_(equality1, edit) +
-            diff_cleanupSemanticScore_(edit, equality2);
-        // The >= encourages trailing rather than leading whitespace on edits.
-        if (score >= bestScore) {
-          bestScore = score;
-          bestEquality1 = equality1;
-          bestEdit = edit;
-          bestEquality2 = equality2;
-        }
-      }
-
-      if (diffs[pointer - 1][1] != bestEquality1) {
-        // We have an improvement, save it back to the diff.
-        if (bestEquality1) {
-          diffs[pointer - 1][1] = bestEquality1;
-        } else {
-          diffs.splice(pointer - 1, 1);
-          pointer--;
-        }
-        diffs[pointer][1] = bestEdit;
-        if (bestEquality2) {
-          diffs[pointer + 1][1] = bestEquality2;
-        } else {
-          diffs.splice(pointer + 1, 1);
-          pointer--;
-        }
-      }
-    }
-    pointer++;
-  }
-};
-
-// Define some regex patterns for matching boundaries.
-diff_match_patch.nonAlphaNumericRegex_ = /[^a-zA-Z0-9]/;
-diff_match_patch.whitespaceRegex_ = /\s/;
-diff_match_patch.linebreakRegex_ = /[\r\n]/;
-diff_match_patch.blanklineEndRegex_ = /\n\r?\n$/;
-diff_match_patch.blanklineStartRegex_ = /^\r?\n\r?\n/;
-
-/**
- * Reduce the number of edits by eliminating operationally trivial equalities.
- * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
- */
-diff_match_patch.prototype.diff_cleanupEfficiency = function(diffs) {
-  var changes = false;
-  var equalities = [];  // Stack of indices where equalities are found.
-  var equalitiesLength = 0;  // Keeping our own length var is faster in JS.
-  /** @type {?string} */
-  var lastequality = null;
-  // Always equal to diffs[equalities[equalitiesLength - 1]][1]
-  var pointer = 0;  // Index of current position.
-  // Is there an insertion operation before the last equality.
-  var pre_ins = false;
-  // Is there a deletion operation before the last equality.
-  var pre_del = false;
-  // Is there an insertion operation after the last equality.
-  var post_ins = false;
-  // Is there a deletion operation after the last equality.
-  var post_del = false;
-  while (pointer < diffs.length) {
-    if (diffs[pointer][0] == DIFF_EQUAL) {  // Equality found.
-      if (diffs[pointer][1].length < this.Diff_EditCost &&
-          (post_ins || post_del)) {
-        // Candidate found.
-        equalities[equalitiesLength++] = pointer;
-        pre_ins = post_ins;
-        pre_del = post_del;
-        lastequality = diffs[pointer][1];
-      } else {
-        // Not a candidate, and can never become one.
-        equalitiesLength = 0;
-        lastequality = null;
-      }
-      post_ins = post_del = false;
-    } else {  // An insertion or deletion.
-      if (diffs[pointer][0] == DIFF_DELETE) {
-        post_del = true;
-      } else {
-        post_ins = true;
-      }
-      /*
-       * Five types to be split:
-       * <ins>A</ins><del>B</del>XY<ins>C</ins><del>D</del>
-       * <ins>A</ins>X<ins>C</ins><del>D</del>
-       * <ins>A</ins><del>B</del>X<ins>C</ins>
-       * <ins>A</del>X<ins>C</ins><del>D</del>
-       * <ins>A</ins><del>B</del>X<del>C</del>
-       */
-      if (lastequality && ((pre_ins && pre_del && post_ins && post_del) ||
-                           ((lastequality.length < this.Diff_EditCost / 2) &&
-                            (pre_ins + pre_del + post_ins + post_del) == 3))) {
-        // Duplicate record.
-        diffs.splice(equalities[equalitiesLength - 1], 0,
-                     [DIFF_DELETE, lastequality]);
-        // Change second copy to insert.
-        diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT;
-        equalitiesLength--;  // Throw away the equality we just deleted;
-        lastequality = null;
-        if (pre_ins && pre_del) {
-          // No changes made which could affect previous entry, keep going.
-          post_ins = post_del = true;
-          equalitiesLength = 0;
-        } else {
-          equalitiesLength--;  // Throw away the previous equality.
-          pointer = equalitiesLength > 0 ?
-              equalities[equalitiesLength - 1] : -1;
-          post_ins = post_del = false;
-        }
-        changes = true;
-      }
-    }
-    pointer++;
-  }
-
-  if (changes) {
-    this.diff_cleanupMerge(diffs);
-  }
-};
-
-
-/**
- * Reorder and merge like edit sections.  Merge equalities.
- * Any edit section can move as long as it doesn't cross an equality.
- * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
- */
-diff_match_patch.prototype.diff_cleanupMerge = function(diffs) {
-  diffs.push([DIFF_EQUAL, '']);  // Add a dummy entry at the end.
-  var pointer = 0;
-  var count_delete = 0;
-  var count_insert = 0;
-  var text_delete = '';
-  var text_insert = '';
-  var commonlength;
-  while (pointer < diffs.length) {
-    switch (diffs[pointer][0]) {
-      case DIFF_INSERT:
-        count_insert++;
-        text_insert += diffs[pointer][1];
-        pointer++;
-        break;
-      case DIFF_DELETE:
-        count_delete++;
-        text_delete += diffs[pointer][1];
-        pointer++;
-        break;
-      case DIFF_EQUAL:
-        // Upon reaching an equality, check for prior redundancies.
-        if (count_delete + count_insert > 1) {
-          if (count_delete !== 0 && count_insert !== 0) {
-            // Factor out any common prefixies.
-            commonlength = this.diff_commonPrefix(text_insert, text_delete);
-            if (commonlength !== 0) {
-              if ((pointer - count_delete - count_insert) > 0 &&
-                  diffs[pointer - count_delete - count_insert - 1][0] ==
-                  DIFF_EQUAL) {
-                diffs[pointer - count_delete - count_insert - 1][1] +=
-                    text_insert.substring(0, commonlength);
-              } else {
-                diffs.splice(0, 0, [DIFF_EQUAL,
-                                    text_insert.substring(0, commonlength)]);
-                pointer++;
-              }
-              text_insert = text_insert.substring(commonlength);
-              text_delete = text_delete.substring(commonlength);
-            }
-            // Factor out any common suffixies.
-            commonlength = this.diff_commonSuffix(text_insert, text_delete);
-            if (commonlength !== 0) {
-              diffs[pointer][1] = text_insert.substring(text_insert.length -
-                  commonlength) + diffs[pointer][1];
-              text_insert = text_insert.substring(0, text_insert.length -
-                  commonlength);
-              text_delete = text_delete.substring(0, text_delete.length -
-                  commonlength);
-            }
-          }
-          // Delete the offending records and add the merged ones.
-          if (count_delete === 0) {
-            diffs.splice(pointer - count_insert,
-                count_delete + count_insert, [DIFF_INSERT, text_insert]);
-          } else if (count_insert === 0) {
-            diffs.splice(pointer - count_delete,
-                count_delete + count_insert, [DIFF_DELETE, text_delete]);
-          } else {
-            diffs.splice(pointer - count_delete - count_insert,
-                count_delete + count_insert, [DIFF_DELETE, text_delete],
-                [DIFF_INSERT, text_insert]);
-          }
-          pointer = pointer - count_delete - count_insert +
-                    (count_delete ? 1 : 0) + (count_insert ? 1 : 0) + 1;
-        } else if (pointer !== 0 && diffs[pointer - 1][0] == DIFF_EQUAL) {
-          // Merge this equality with the previous one.
-          diffs[pointer - 1][1] += diffs[pointer][1];
-          diffs.splice(pointer, 1);
-        } else {
-          pointer++;
-        }
-        count_insert = 0;
-        count_delete = 0;
-        text_delete = '';
-        text_insert = '';
-        break;
-    }
-  }
-  if (diffs[diffs.length - 1][1] === '') {
-    diffs.pop();  // Remove the dummy entry at the end.
-  }
-
-  // Second pass: look for single edits surrounded on both sides by equalities
-  // which can be shifted sideways to eliminate an equality.
-  // e.g: A<ins>BA</ins>C -> <ins>AB</ins>AC
-  var changes = false;
-  pointer = 1;
-  // Intentionally ignore the first and last element (don't need checking).
-  while (pointer < diffs.length - 1) {
-    if (diffs[pointer - 1][0] == DIFF_EQUAL &&
-        diffs[pointer + 1][0] == DIFF_EQUAL) {
-      // This is a single edit surrounded by equalities.
-      if (diffs[pointer][1].substring(diffs[pointer][1].length -
-          diffs[pointer - 1][1].length) == diffs[pointer - 1][1]) {
-        // Shift the edit over the previous equality.
-        diffs[pointer][1] = diffs[pointer - 1][1] +
-            diffs[pointer][1].substring(0, diffs[pointer][1].length -
-                                        diffs[pointer - 1][1].length);
-        diffs[pointer + 1][1] = diffs[pointer - 1][1] + diffs[pointer + 1][1];
-        diffs.splice(pointer - 1, 1);
-        changes = true;
-      } else if (diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) ==
-          diffs[pointer + 1][1]) {
-        // Shift the edit over the next equality.
-        diffs[pointer - 1][1] += diffs[pointer + 1][1];
-        diffs[pointer][1] =
-            diffs[pointer][1].substring(diffs[pointer + 1][1].length) +
-            diffs[pointer + 1][1];
-        diffs.splice(pointer + 1, 1);
-        changes = true;
-      }
-    }
-    pointer++;
-  }
-  // If shifts were made, the diff needs reordering and another shift sweep.
-  if (changes) {
-    this.diff_cleanupMerge(diffs);
-  }
-};
-
-
-/**
- * loc is a location in text1, compute and return the equivalent location in
- * text2.
- * e.g. 'The cat' vs 'The big cat', 1->1, 5->8
- * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
- * @param {number} loc Location within text1.
- * @return {number} Location within text2.
- */
-diff_match_patch.prototype.diff_xIndex = function(diffs, loc) {
-  var chars1 = 0;
-  var chars2 = 0;
-  var last_chars1 = 0;
-  var last_chars2 = 0;
-  var x;
-  for (x = 0; x < diffs.length; x++) {
-    if (diffs[x][0] !== DIFF_INSERT) {  // Equality or deletion.
-      chars1 += diffs[x][1].length;
-    }
-    if (diffs[x][0] !== DIFF_DELETE) {  // Equality or insertion.
-      chars2 += diffs[x][1].length;
-    }
-    if (chars1 > loc) {  // Overshot the location.
-      break;
-    }
-    last_chars1 = chars1;
-    last_chars2 = chars2;
-  }
-  // Was the location was deleted?
-  if (diffs.length != x && diffs[x][0] === DIFF_DELETE) {
-    return last_chars2;
-  }
-  // Add the remaining character length.
-  return last_chars2 + (loc - last_chars1);
-};
-
-
-/**
- * Convert a diff array into a pretty HTML report.
- * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
- * @return {string} HTML representation.
- */
-diff_match_patch.prototype.diff_prettyHtml = function(diffs) {
-  var html = [];
-  var pattern_amp = /&/g;
-  var pattern_lt = /</g;
-  var pattern_gt = />/g;
-  var pattern_para = /\n/g;
-  for (var x = 0; x < diffs.length; x++) {
-    var op = diffs[x][0];    // Operation (insert, delete, equal)
-    var data = diffs[x][1];  // Text of change.
-    var text = data.replace(pattern_amp, '&amp;').replace(pattern_lt, '&lt;')
-        .replace(pattern_gt, '&gt;').replace(pattern_para, '&para;<br>');
-    switch (op) {
-      case DIFF_INSERT:
-        html[x] = '<ins style="background:#e6ffe6;">' + text + '</ins>';
-        break;
-      case DIFF_DELETE:
-        html[x] = '<del style="background:#ffe6e6;">' + text + '</del>';
-        break;
-      case DIFF_EQUAL:
-        html[x] = '<span>' + text + '</span>';
-        break;
-    }
-  }
-  return html.join('');
-};
-
-
-/**
- * Compute and return the source text (all equalities and deletions).
- * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
- * @return {string} Source text.
- */
-diff_match_patch.prototype.diff_text1 = function(diffs) {
-  var text = [];
-  for (var x = 0; x < diffs.length; x++) {
-    if (diffs[x][0] !== DIFF_INSERT) {
-      text[x] = diffs[x][1];
-    }
-  }
-  return text.join('');
-};
-
-
-/**
- * Compute and return the destination text (all equalities and insertions).
- * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
- * @return {string} Destination text.
- */
-diff_match_patch.prototype.diff_text2 = function(diffs) {
-  var text = [];
-  for (var x = 0; x < diffs.length; x++) {
-    if (diffs[x][0] !== DIFF_DELETE) {
-      text[x] = diffs[x][1];
-    }
-  }
-  return text.join('');
-};
-
-
-/**
- * Compute the Levenshtein distance; the number of inserted, deleted or
- * substituted characters.
- * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
- * @return {number} Number of changes.
- */
-diff_match_patch.prototype.diff_levenshtein = function(diffs) {
-  var levenshtein = 0;
-  var insertions = 0;
-  var deletions = 0;
-  for (var x = 0; x < diffs.length; x++) {
-    var op = diffs[x][0];
-    var data = diffs[x][1];
-    switch (op) {
-      case DIFF_INSERT:
-        insertions += data.length;
-        break;
-      case DIFF_DELETE:
-        deletions += data.length;
-        break;
-      case DIFF_EQUAL:
-        // A deletion and an insertion is one substitution.
-        levenshtein += Math.max(insertions, deletions);
-        insertions = 0;
-        deletions = 0;
-        break;
-    }
-  }
-  levenshtein += Math.max(insertions, deletions);
-  return levenshtein;
-};
-
-
-/**
- * Crush the diff into an encoded string which describes the operations
- * required to transform text1 into text2.
- * E.g. =3\t-2\t+ing  -> Keep 3 chars, delete 2 chars, insert 'ing'.
- * Operations are tab-separated.  Inserted text is escaped using %xx notation.
- * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
- * @return {string} Delta text.
- */
-diff_match_patch.prototype.diff_toDelta = function(diffs) {
-  var text = [];
-  for (var x = 0; x < diffs.length; x++) {
-    switch (diffs[x][0]) {
-      case DIFF_INSERT:
-        text[x] = '+' + encodeURI(diffs[x][1]);
-        break;
-      case DIFF_DELETE:
-        text[x] = '-' + diffs[x][1].length;
-        break;
-      case DIFF_EQUAL:
-        text[x] = '=' + diffs[x][1].length;
-        break;
-    }
-  }
-  return text.join('\t').replace(/%20/g, ' ');
-};
-
-
-/**
- * Given the original text1, and an encoded string which describes the
- * operations required to transform text1 into text2, compute the full diff.
- * @param {string} text1 Source string for the diff.
- * @param {string} delta Delta text.
- * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.
- * @throws {!Error} If invalid input.
- */
-diff_match_patch.prototype.diff_fromDelta = function(text1, delta) {
-  var diffs = [];
-  var diffsLength = 0;  // Keeping our own length var is faster in JS.
-  var pointer = 0;  // Cursor in text1
-  var tokens = delta.split(/\t/g);
-  for (var x = 0; x < tokens.length; x++) {
-    // Each token begins with a one character parameter which specifies the
-    // operation of this token (delete, insert, equality).
-    var param = tokens[x].substring(1);
-    switch (tokens[x].charAt(0)) {
-      case '+':
-        try {
-          diffs[diffsLength++] = [DIFF_INSERT, decodeURI(param)];
-        } catch (ex) {
-          // Malformed URI sequence.
-          throw new Error('Illegal escape in diff_fromDelta: ' + param);
-        }
-        break;
-      case '-':
-        // Fall through.
-      case '=':
-        var n = parseInt(param, 10);
-        if (isNaN(n) || n < 0) {
-          throw new Error('Invalid number in diff_fromDelta: ' + param);
-        }
-        var text = text1.substring(pointer, pointer += n);
-        if (tokens[x].charAt(0) == '=') {
-          diffs[diffsLength++] = [DIFF_EQUAL, text];
-        } else {
-          diffs[diffsLength++] = [DIFF_DELETE, text];
-        }
-        break;
-      default:
-        // Blank tokens are ok (from a trailing \t).
-        // Anything else is an error.
-        if (tokens[x]) {
-          throw new Error('Invalid diff operation in diff_fromDelta: ' +
-                          tokens[x]);
-        }
-    }
-  }
-  if (pointer != text1.length) {
-    throw new Error('Delta length (' + pointer +
-        ') does not equal source text length (' + text1.length + ').');
-  }
-  return diffs;
-};
-
-
-//  MATCH FUNCTIONS
-
-
-/**
- * Locate the best instance of 'pattern' in 'text' near 'loc'.
- * @param {string} text The text to search.
- * @param {string} pattern The pattern to search for.
- * @param {number} loc The location to search around.
- * @return {number} Best match index or -1.
- */
-diff_match_patch.prototype.match_main = function(text, pattern, loc) {
-  // Check for null inputs.
-  if (text == null || pattern == null || loc == null) {
-    throw new Error('Null input. (match_main)');
-  }
-
-  loc = Math.max(0, Math.min(loc, text.length));
-  if (text == pattern) {
-    // Shortcut (potentially not guaranteed by the algorithm)
-    return 0;
-  } else if (!text.length) {
-    // Nothing to match.
-    return -1;
-  } else if (text.substring(loc, loc + pattern.length) == pattern) {
-    // Perfect match at the perfect spot!  (Includes case of null pattern)
-    return loc;
-  } else {
-    // Do a fuzzy compare.
-    return this.match_bitap_(text, pattern, loc);
-  }
-};
-
-
-/**
- * Locate the best instance of 'pattern' in 'text' near 'loc' using the
- * Bitap algorithm.
- * @param {string} text The text to search.
- * @param {string} pattern The pattern to search for.
- * @param {number} loc The location to search around.
- * @return {number} Best match index or -1.
- * @private
- */
-diff_match_patch.prototype.match_bitap_ = function(text, pattern, loc) {
-  if (pattern.length > this.Match_MaxBits) {
-    throw new Error('Pattern too long for this browser.');
-  }
-
-  // Initialise the alphabet.
-  var s = this.match_alphabet_(pattern);
-
-  var dmp = this;  // 'this' becomes 'window' in a closure.
-
-  /**
-   * Compute and return the score for a match with e errors and x location.
-   * Accesses loc and pattern through being a closure.
-   * @param {number} e Number of errors in match.
-   * @param {number} x Location of match.
-   * @return {number} Overall score for match (0.0 = good, 1.0 = bad).
-   * @private
-   */
-  function match_bitapScore_(e, x) {
-    var accuracy = e / pattern.length;
-    var proximity = Math.abs(loc - x);
-    if (!dmp.Match_Distance) {
-      // Dodge divide by zero error.
-      return proximity ? 1.0 : accuracy;
-    }
-    return accuracy + (proximity / dmp.Match_Distance);
-  }
-
-  // Highest score beyond which we give up.
-  var score_threshold = this.Match_Threshold;
-  // Is there a nearby exact match? (speedup)
-  var best_loc = text.indexOf(pattern, loc);
-  if (best_loc != -1) {
-    score_threshold = Math.min(match_bitapScore_(0, best_loc), score_threshold);
-    // What about in the other direction? (speedup)
-    best_loc = text.lastIndexOf(pattern, loc + pattern.length);
-    if (best_loc != -1) {
-      score_threshold =
-          Math.min(match_bitapScore_(0, best_loc), score_threshold);
-    }
-  }
-
-  // Initialise the bit arrays.
-  var matchmask = 1 << (pattern.length - 1);
-  best_loc = -1;
-
-  var bin_min, bin_mid;
-  var bin_max = pattern.length + text.length;
-  var last_rd;
-  for (var d = 0; d < pattern.length; d++) {
-    // Scan for the best match; each iteration allows for one more error.
-    // Run a binary search to determine how far from 'loc' we can stray at this
-    // error level.
-    bin_min = 0;
-    bin_mid = bin_max;
-    while (bin_min < bin_mid) {
-      if (match_bitapScore_(d, loc + bin_mid) <= score_threshold) {
-        bin_min = bin_mid;
-      } else {
-        bin_max = bin_mid;
-      }
-      bin_mid = Math.floor((bin_max - bin_min) / 2 + bin_min);
-    }
-    // Use the result from this iteration as the maximum for the next.
-    bin_max = bin_mid;
-    var start = Math.max(1, loc - bin_mid + 1);
-    var finish = Math.min(loc + bin_mid, text.length) + pattern.length;
-
-    var rd = Array(finish + 2);
-    rd[finish + 1] = (1 << d) - 1;
-    for (var j = finish; j >= start; j--) {
-      // The alphabet (s) is a sparse hash, so the following line generates
-      // warnings.
-      var charMatch = s[text.charAt(j - 1)];
-      if (d === 0) {  // First pass: exact match.
-        rd[j] = ((rd[j + 1] << 1) | 1) & charMatch;
-      } else {  // Subsequent passes: fuzzy match.
-        rd[j] = (((rd[j + 1] << 1) | 1) & charMatch) |
-                (((last_rd[j + 1] | last_rd[j]) << 1) | 1) |
-                last_rd[j + 1];
-      }
-      if (rd[j] & matchmask) {
-        var score = match_bitapScore_(d, j - 1);
-        // This match will almost certainly be better than any existing match.
-        // But check anyway.
-        if (score <= score_threshold) {
-          // Told you so.
-          score_threshold = score;
-          best_loc = j - 1;
-          if (best_loc > loc) {
-            // When passing loc, don't exceed our current distance from loc.
-            start = Math.max(1, 2 * loc - best_loc);
-          } else {
-            // Already passed loc, downhill from here on in.
-            break;
-          }
-        }
-      }
-    }
-    // No hope for a (better) match at greater error levels.
-    if (match_bitapScore_(d + 1, loc) > score_threshold) {
-      break;
-    }
-    last_rd = rd;
-  }
-  return best_loc;
-};
-
-
-/**
- * Initialise the alphabet for the Bitap algorithm.
- * @param {string} pattern The text to encode.
- * @return {!Object} Hash of character locations.
- * @private
- */
-diff_match_patch.prototype.match_alphabet_ = function(pattern) {
-  var s = {};
-  for (var i = 0; i < pattern.length; i++) {
-    s[pattern.charAt(i)] = 0;
-  }
-  for (var i = 0; i < pattern.length; i++) {
-    s[pattern.charAt(i)] |= 1 << (pattern.length - i - 1);
-  }
-  return s;
-};
-
-
-//  PATCH FUNCTIONS
-
-
-/**
- * Increase the context until it is unique,
- * but don't let the pattern expand beyond Match_MaxBits.
- * @param {!diff_match_patch.patch_obj} patch The patch to grow.
- * @param {string} text Source text.
- * @private
- */
-diff_match_patch.prototype.patch_addContext_ = function(patch, text) {
-  if (text.length == 0) {
-    return;
-  }
-  var pattern = text.substring(patch.start2, patch.start2 + patch.length1);
-  var padding = 0;
-
-  // Look for the first and last matches of pattern in text.  If two different
-  // matches are found, increase the pattern length.
-  while (text.indexOf(pattern) != text.lastIndexOf(pattern) &&
-         pattern.length < this.Match_MaxBits - this.Patch_Margin -
-         this.Patch_Margin) {
-    padding += this.Patch_Margin;
-    pattern = text.substring(patch.start2 - padding,
-                             patch.start2 + patch.length1 + padding);
-  }
-  // Add one chunk for good luck.
-  padding += this.Patch_Margin;
-
-  // Add the prefix.
-  var prefix = text.substring(patch.start2 - padding, patch.start2);
-  if (prefix) {
-    patch.diffs.unshift([DIFF_EQUAL, prefix]);
-  }
-  // Add the suffix.
-  var suffix = text.substring(patch.start2 + patch.length1,
-                              patch.start2 + patch.length1 + padding);
-  if (suffix) {
-    patch.diffs.push([DIFF_EQUAL, suffix]);
-  }
-
-  // Roll back the start points.
-  patch.start1 -= prefix.length;
-  patch.start2 -= prefix.length;
-  // Extend the lengths.
-  patch.length1 += prefix.length + suffix.length;
-  patch.length2 += prefix.length + suffix.length;
-};
-
-
-/**
- * Compute a list of patches to turn text1 into text2.
- * Use diffs if provided, otherwise compute it ourselves.
- * There are four ways to call this function, depending on what data is
- * available to the caller:
- * Method 1:
- * a = text1, b = text2
- * Method 2:
- * a = diffs
- * Method 3 (optimal):
- * a = text1, b = diffs
- * Method 4 (deprecated, use method 3):
- * a = text1, b = text2, c = diffs
- *
- * @param {string|!Array.<!diff_match_patch.Diff>} a text1 (methods 1,3,4) or
- * Array of diff tuples for text1 to text2 (method 2).
- * @param {string|!Array.<!diff_match_patch.Diff>} opt_b text2 (methods 1,4) or
- * Array of diff tuples for text1 to text2 (method 3) or undefined (method 2).
- * @param {string|!Array.<!diff_match_patch.Diff>} opt_c Array of diff tuples
- * for text1 to text2 (method 4) or undefined (methods 1,2,3).
- * @return {!Array.<!diff_match_patch.patch_obj>} Array of Patch objects.
- */
-diff_match_patch.prototype.patch_make = function(a, opt_b, opt_c) {
-  var text1, diffs;
-  if (typeof a == 'string' && typeof opt_b == 'string' &&
-      typeof opt_c == 'undefined') {
-    // Method 1: text1, text2
-    // Compute diffs from text1 and text2.
-    text1 = /** @type {string} */(a);
-    diffs = this.diff_main(text1, /** @type {string} */(opt_b), true);
-    if (diffs.length > 2) {
-      this.diff_cleanupSemantic(diffs);
-      this.diff_cleanupEfficiency(diffs);
-    }
-  } else if (a && typeof a == 'object' && typeof opt_b == 'undefined' &&
-      typeof opt_c == 'undefined') {
-    // Method 2: diffs
-    // Compute text1 from diffs.
-    diffs = /** @type {!Array.<!diff_match_patch.Diff>} */(a);
-    text1 = this.diff_text1(diffs);
-  } else if (typeof a == 'string' && opt_b && typeof opt_b == 'object' &&
-      typeof opt_c == 'undefined') {
-    // Method 3: text1, diffs
-    text1 = /** @type {string} */(a);
-    diffs = /** @type {!Array.<!diff_match_patch.Diff>} */(opt_b);
-  } else if (typeof a == 'string' && typeof opt_b == 'string' &&
-      opt_c && typeof opt_c == 'object') {
-    // Method 4: text1, text2, diffs
-    // text2 is not used.
-    text1 = /** @type {string} */(a);
-    diffs = /** @type {!Array.<!diff_match_patch.Diff>} */(opt_c);
-  } else {
-    throw new Error('Unknown call format to patch_make.');
-  }
-
-  if (diffs.length === 0) {
-    return [];  // Get rid of the null case.
-  }
-  var patches = [];
-  var patch = new diff_match_patch.patch_obj();
-  var patchDiffLength = 0;  // Keeping our own length var is faster in JS.
-  var char_count1 = 0;  // Number of characters into the text1 string.
-  var char_count2 = 0;  // Number of characters into the text2 string.
-  // Start with text1 (prepatch_text) and apply the diffs until we arrive at
-  // text2 (postpatch_text).  We recreate the patches one by one to determine
-  // context info.
-  var prepatch_text = text1;
-  var postpatch_text = text1;
-  for (var x = 0; x < diffs.length; x++) {
-    var diff_type = diffs[x][0];
-    var diff_text = diffs[x][1];
-
-    if (!patchDiffLength && diff_type !== DIFF_EQUAL) {
-      // A new patch starts here.
-      patch.start1 = char_count1;
-      patch.start2 = char_count2;
-    }
-
-    switch (diff_type) {
-      case DIFF_INSERT:
-        patch.diffs[patchDiffLength++] = diffs[x];
-        patch.length2 += diff_text.length;
-        postpatch_text = postpatch_text.substring(0, char_count2) + diff_text +
-                         postpatch_text.substring(char_count2);
-        break;
-      case DIFF_DELETE:
-        patch.length1 += diff_text.length;
-        patch.diffs[patchDiffLength++] = diffs[x];
-        postpatch_text = postpatch_text.substring(0, char_count2) +
-                         postpatch_text.substring(char_count2 +
-                             diff_text.length);
-        break;
-      case DIFF_EQUAL:
-        if (diff_text.length <= 2 * this.Patch_Margin &&
-            patchDiffLength && diffs.length != x + 1) {
-          // Small equality inside a patch.
-          patch.diffs[patchDiffLength++] = diffs[x];
-          patch.length1 += diff_text.length;
-          patch.length2 += diff_text.length;
-        } else if (diff_text.length >= 2 * this.Patch_Margin) {
-          // Time for a new patch.
-          if (patchDiffLength) {
-            this.patch_addContext_(patch, prepatch_text);
-            patches.push(patch);
-            patch = new diff_match_patch.patch_obj();
-            patchDiffLength = 0;
-            // Unlike Unidiff, our patch lists have a rolling context.
-            // http://code.google.com/p/google-diff-match-patch/wiki/Unidiff
-            // Update prepatch text & pos to reflect the application of the
-            // just completed patch.
-            prepatch_text = postpatch_text;
-            char_count1 = char_count2;
-          }
-        }
-        break;
-    }
-
-    // Update the current character count.
-    if (diff_type !== DIFF_INSERT) {
-      char_count1 += diff_text.length;
-    }
-    if (diff_type !== DIFF_DELETE) {
-      char_count2 += diff_text.length;
-    }
-  }
-  // Pick up the leftover patch if not empty.
-  if (patchDiffLength) {
-    this.patch_addContext_(patch, prepatch_text);
-    patches.push(patch);
-  }
-
-  return patches;
-};
-
-
-/**
- * Given an array of patches, return another array that is identical.
- * @param {!Array.<!diff_match_patch.patch_obj>} patches Array of Patch objects.
- * @return {!Array.<!diff_match_patch.patch_obj>} Array of Patch objects.
- */
-diff_match_patch.prototype.patch_deepCopy = function(patches) {
-  // Making deep copies is hard in JavaScript.
-  var patchesCopy = [];
-  for (var x = 0; x < patches.length; x++) {
-    var patch = patches[x];
-    var patchCopy = new diff_match_patch.patch_obj();
-    patchCopy.diffs = [];
-    for (var y = 0; y < patch.diffs.length; y++) {
-      patchCopy.diffs[y] = patch.diffs[y].slice();
-    }
-    patchCopy.start1 = patch.start1;
-    patchCopy.start2 = patch.start2;
-    patchCopy.length1 = patch.length1;
-    patchCopy.length2 = patch.length2;
-    patchesCopy[x] = patchCopy;
-  }
-  return patchesCopy;
-};
-
-
-/**
- * Merge a set of patches onto the text.  Return a patched text, as well
- * as a list of true/false values indicating which patches were applied.
- * @param {!Array.<!diff_match_patch.patch_obj>} patches Array of Patch objects.
- * @param {string} text Old text.
- * @return {!Array.<string|!Array.<boolean>>} Two element Array, containing the
- *      new text and an array of boolean values.
- */
-diff_match_patch.prototype.patch_apply = function(patches, text) {
-  if (patches.length == 0) {
-    return [text, []];
-  }
-
-  // Deep copy the patches so that no changes are made to originals.
-  patches = this.patch_deepCopy(patches);
-
-  var nullPadding = this.patch_addPadding(patches);
-  text = nullPadding + text + nullPadding;
-
-  this.patch_splitMax(patches);
-  // delta keeps track of the offset between the expected and actual location
-  // of the previous patch.  If there are patches expected at positions 10 and
-  // 20, but the first patch was found at 12, delta is 2 and the second patch
-  // has an effective expected position of 22.
-  var delta = 0;
-  var results = [];
-  for (var x = 0; x < patches.length; x++) {
-    var expected_loc = patches[x].start2 + delta;
-    var text1 = this.diff_text1(patches[x].diffs);
-    var start_loc;
-    var end_loc = -1;
-    if (text1.length > this.Match_MaxBits) {
-      // patch_splitMax will only provide an oversized pattern in the case of
-      // a monster delete.
-      start_loc = this.match_main(text, text1.substring(0, this.Match_MaxBits),
-                                  expected_loc);
-      if (start_loc != -1) {
-        end_loc = this.match_main(text,
-            text1.substring(text1.length - this.Match_MaxBits),
-            expected_loc + text1.length - this.Match_MaxBits);
-        if (end_loc == -1 || start_loc >= end_loc) {
-          // Can't find valid trailing context.  Drop this patch.
-          start_loc = -1;
-        }
-      }
-    } else {
-      start_loc = this.match_main(text, text1, expected_loc);
-    }
-    if (start_loc == -1) {
-      // No match found.  :(
-      results[x] = false;
-      // Subtract the delta for this failed patch from subsequent patches.
-      delta -= patches[x].length2 - patches[x].length1;
-    } else {
-      // Found a match.  :)
-      results[x] = true;
-      delta = start_loc - expected_loc;
-      var text2;
-      if (end_loc == -1) {
-        text2 = text.substring(start_loc, start_loc + text1.length);
-      } else {
-        text2 = text.substring(start_loc, end_loc + this.Match_MaxBits);
-      }
-      if (text1 == text2) {
-        // Perfect match, just shove the replacement text in.
-        text = text.substring(0, start_loc) +
-               this.diff_text2(patches[x].diffs) +
-               text.substring(start_loc + text1.length);
-      } else {
-        // Imperfect match.  Run a diff to get a framework of equivalent
-        // indices.
-        var diffs = this.diff_main(text1, text2, false);
-        if (text1.length > this.Match_MaxBits &&
-            this.diff_levenshtein(diffs) / text1.length >
-            this.Patch_DeleteThreshold) {
-          // The end points match, but the content is unacceptably bad.
-          results[x] = false;
-        } else {
-          this.diff_cleanupSemanticLossless(diffs);
-          var index1 = 0;
-          var index2;
-          for (var y = 0; y < patches[x].diffs.length; y++) {
-            var mod = patches[x].diffs[y];
-            if (mod[0] !== DIFF_EQUAL) {
-              index2 = this.diff_xIndex(diffs, index1);
-            }
-            if (mod[0] === DIFF_INSERT) {  // Insertion
-              text = text.substring(0, start_loc + index2) + mod[1] +
-                     text.substring(start_loc + index2);
-            } else if (mod[0] === DIFF_DELETE) {  // Deletion
-              text = text.substring(0, start_loc + index2) +
-                     text.substring(start_loc + this.diff_xIndex(diffs,
-                         index1 + mod[1].length));
-            }
-            if (mod[0] !== DIFF_DELETE) {
-              index1 += mod[1].length;
-            }
-          }
-        }
-      }
-    }
-  }
-  // Strip the padding off.
-  text = text.substring(nullPadding.length, text.length - nullPadding.length);
-  return [text, results];
-};
-
-
-/**
- * Add some padding on text start and end so that edges can match something.
- * Intended to be called only from within patch_apply.
- * @param {!Array.<!diff_match_patch.patch_obj>} patches Array of Patch objects.
- * @return {string} The padding string added to each side.
- */
-diff_match_patch.prototype.patch_addPadding = function(patches) {
-  var paddingLength = this.Patch_Margin;
-  var nullPadding = '';
-  for (var x = 1; x <= paddingLength; x++) {
-    nullPadding += String.fromCharCode(x);
-  }
-
-  // Bump all the patches forward.
-  for (var x = 0; x < patches.length; x++) {
-    patches[x].start1 += paddingLength;
-    patches[x].start2 += paddingLength;
-  }
-
-  // Add some padding on start of first diff.
-  var patch = patches[0];
-  var diffs = patch.diffs;
-  if (diffs.length == 0 || diffs[0][0] != DIFF_EQUAL) {
-    // Add nullPadding equality.
-    diffs.unshift([DIFF_EQUAL, nullPadding]);
-    patch.start1 -= paddingLength;  // Should be 0.
-    patch.start2 -= paddingLength;  // Should be 0.
-    patch.length1 += paddingLength;
-    patch.length2 += paddingLength;
-  } else if (paddingLength > diffs[0][1].length) {
-    // Grow first equality.
-    var extraLength = paddingLength - diffs[0][1].length;
-    diffs[0][1] = nullPadding.substring(diffs[0][1].length) + diffs[0][1];
-    patch.start1 -= extraLength;
-    patch.start2 -= extraLength;
-    patch.length1 += extraLength;
-    patch.length2 += extraLength;
-  }
-
-  // Add some padding on end of last diff.
-  patch = patches[patches.length - 1];
-  diffs = patch.diffs;
-  if (diffs.length == 0 || diffs[diffs.length - 1][0] != DIFF_EQUAL) {
-    // Add nullPadding equality.
-    diffs.push([DIFF_EQUAL, nullPadding]);
-    patch.length1 += paddingLength;
-    patch.length2 += paddingLength;
-  } else if (paddingLength > diffs[diffs.length - 1][1].length) {
-    // Grow last equality.
-    var extraLength = paddingLength - diffs[diffs.length - 1][1].length;
-    diffs[diffs.length - 1][1] += nullPadding.substring(0, extraLength);
-    patch.length1 += extraLength;
-    patch.length2 += extraLength;
-  }
-
-  return nullPadding;
-};
-
-
-/**
- * Look through the patches and break up any which are longer than the maximum
- * limit of the match algorithm.
- * Intended to be called only from within patch_apply.
- * @param {!Array.<!diff_match_patch.patch_obj>} patches Array of Patch objects.
- */
-diff_match_patch.prototype.patch_splitMax = function(patches) {
-  var patch_size = this.Match_MaxBits;
-  for (var x = 0; x < patches.length; x++) {
-    if (patches[x].length1 <= patch_size) {
-      continue;
-    }
-    var bigpatch = patches[x];
-    // Remove the big old patch.
-    patches.splice(x--, 1);
-    var start1 = bigpatch.start1;
-    var start2 = bigpatch.start2;
-    var precontext = '';
-    while (bigpatch.diffs.length !== 0) {
-      // Create one of several smaller patches.
-      var patch = new diff_match_patch.patch_obj();
-      var empty = true;
-      patch.start1 = start1 - precontext.length;
-      patch.start2 = start2 - precontext.length;
-      if (precontext !== '') {
-        patch.length1 = patch.length2 = precontext.length;
-        patch.diffs.push([DIFF_EQUAL, precontext]);
-      }
-      while (bigpatch.diffs.length !== 0 &&
-             patch.length1 < patch_size - this.Patch_Margin) {
-        var diff_type = bigpatch.diffs[0][0];
-        var diff_text = bigpatch.diffs[0][1];
-        if (diff_type === DIFF_INSERT) {
-          // Insertions are harmless.
-          patch.length2 += diff_text.length;
-          start2 += diff_text.length;
-          patch.diffs.push(bigpatch.diffs.shift());
-          empty = false;
-        } else if (diff_type === DIFF_DELETE && patch.diffs.length == 1 &&
-                   patch.diffs[0][0] == DIFF_EQUAL &&
-                   diff_text.length > 2 * patch_size) {
-          // This is a large deletion.  Let it pass in one chunk.
-          patch.length1 += diff_text.length;
-          start1 += diff_text.length;
-          empty = false;
-          patch.diffs.push([diff_type, diff_text]);
-          bigpatch.diffs.shift();
-        } else {
-          // Deletion or equality.  Only take as much as we can stomach.
-          diff_text = diff_text.substring(0,
-              patch_size - patch.length1 - this.Patch_Margin);
-          patch.length1 += diff_text.length;
-          start1 += diff_text.length;
-          if (diff_type === DIFF_EQUAL) {
-            patch.length2 += diff_text.length;
-            start2 += diff_text.length;
-          } else {
-            empty = false;
-          }
-          patch.diffs.push([diff_type, diff_text]);
-          if (diff_text == bigpatch.diffs[0][1]) {
-            bigpatch.diffs.shift();
-          } else {
-            bigpatch.diffs[0][1] =
-                bigpatch.diffs[0][1].substring(diff_text.length);
-          }
-        }
-      }
-      // Compute the head context for the next patch.
-      precontext = this.diff_text2(patch.diffs);
-      precontext =
-          precontext.substring(precontext.length - this.Patch_Margin);
-      // Append the end context for this patch.
-      var postcontext = this.diff_text1(bigpatch.diffs)
-                            .substring(0, this.Patch_Margin);
-      if (postcontext !== '') {
-        patch.length1 += postcontext.length;
-        patch.length2 += postcontext.length;
-        if (patch.diffs.length !== 0 &&
-            patch.diffs[patch.diffs.length - 1][0] === DIFF_EQUAL) {
-          patch.diffs[patch.diffs.length - 1][1] += postcontext;
-        } else {
-          patch.diffs.push([DIFF_EQUAL, postcontext]);
-        }
-      }
-      if (!empty) {
-        patches.splice(++x, 0, patch);
-      }
-    }
-  }
-};
-
-
-/**
- * Take a list of patches and return a textual representation.
- * @param {!Array.<!diff_match_patch.patch_obj>} patches Array of Patch objects.
- * @return {string} Text representation of patches.
- */
-diff_match_patch.prototype.patch_toText = function(patches) {
-  var text = [];
-  for (var x = 0; x < patches.length; x++) {
-    text[x] = patches[x];
-  }
-  return text.join('');
-};
-
-
-/**
- * Parse a textual representation of patches and return a list of Patch objects.
- * @param {string} textline Text representation of patches.
- * @return {!Array.<!diff_match_patch.patch_obj>} Array of Patch objects.
- * @throws {!Error} If invalid input.
- */
-diff_match_patch.prototype.patch_fromText = function(textline) {
-  var patches = [];
-  if (!textline) {
-    return patches;
-  }
-  var text = textline.split('\n');
-  var textPointer = 0;
-  var patchHeader = /^@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@$/;
-  while (textPointer < text.length) {
-    var m = text[textPointer].match(patchHeader);
-    if (!m) {
-      throw new Error('Invalid patch string: ' + text[textPointer]);
-    }
-    var patch = new diff_match_patch.patch_obj();
-    patches.push(patch);
-    patch.start1 = parseInt(m[1], 10);
-    if (m[2] === '') {
-      patch.start1--;
-      patch.length1 = 1;
-    } else if (m[2] == '0') {
-      patch.length1 = 0;
-    } else {
-      patch.start1--;
-      patch.length1 = parseInt(m[2], 10);
-    }
-
-    patch.start2 = parseInt(m[3], 10);
-    if (m[4] === '') {
-      patch.start2--;
-      patch.length2 = 1;
-    } else if (m[4] == '0') {
-      patch.length2 = 0;
-    } else {
-      patch.start2--;
-      patch.length2 = parseInt(m[4], 10);
-    }
-    textPointer++;
-
-    while (textPointer < text.length) {
-      var sign = text[textPointer].charAt(0);
-      try {
-        var line = decodeURI(text[textPointer].substring(1));
-      } catch (ex) {
-        // Malformed URI sequence.
-        throw new Error('Illegal escape in patch_fromText: ' + line);
-      }
-      if (sign == '-') {
-        // Deletion.
-        patch.diffs.push([DIFF_DELETE, line]);
-      } else if (sign == '+') {
-        // Insertion.
-        patch.diffs.push([DIFF_INSERT, line]);
-      } else if (sign == ' ') {
-        // Minor equality.
-        patch.diffs.push([DIFF_EQUAL, line]);
-      } else if (sign == '@') {
-        // Start of next patch.
-        break;
-      } else if (sign === '') {
-        // Blank line?  Whatever.
-      } else {
-        // WTF?
-        throw new Error('Invalid patch mode "' + sign + '" in: ' + line);
-      }
-      textPointer++;
-    }
-  }
-  return patches;
-};
-
-
-/**
- * Class representing one patch operation.
- * @constructor
- */
-diff_match_patch.patch_obj = function() {
-  /** @type {!Array.<!diff_match_patch.Diff>} */
-  this.diffs = [];
-  /** @type {?number} */
-  this.start1 = null;
-  /** @type {?number} */
-  this.start2 = null;
-  /** @type {number} */
-  this.length1 = 0;
-  /** @type {number} */
-  this.length2 = 0;
-};
-
-
-/**
- * Emmulate GNU diff's format.
- * Header: @@ -382,8 +481,9 @@
- * Indicies are printed as 1-based, not 0-based.
- * @return {string} The GNU diff string.
- */
-diff_match_patch.patch_obj.prototype.toString = function() {
-  var coords1, coords2;
-  if (this.length1 === 0) {
-    coords1 = this.start1 + ',0';
-  } else if (this.length1 == 1) {
-    coords1 = this.start1 + 1;
-  } else {
-    coords1 = (this.start1 + 1) + ',' + this.length1;
-  }
-  if (this.length2 === 0) {
-    coords2 = this.start2 + ',0';
-  } else if (this.length2 == 1) {
-    coords2 = this.start2 + 1;
-  } else {
-    coords2 = (this.start2 + 1) + ',' + this.length2;
-  }
-  var text = ['@@ -' + coords1 + ' +' + coords2 + ' @@\n'];
-  var op;
-  // Escape the body of the patch with %xx notation.
-  for (var x = 0; x < this.diffs.length; x++) {
-    switch (this.diffs[x][0]) {
-      case DIFF_INSERT:
-        op = '+';
-        break;
-      case DIFF_DELETE:
-        op = '-';
-        break;
-      case DIFF_EQUAL:
-        op = ' ';
-        break;
-    }
-    text[x + 1] = op + encodeURI(this.diffs[x][1]) + '\n';
-  }
-  return text.join('').replace(/%20/g, ' ');
-};
-
-
-// Export these global variables so that they survive Google's JS compiler.
-// In a browser, 'this' will be 'window'.
-// Users of node.js should 'require' the uncompressed version since Google's
-// JS compiler may break the following exports for non-browser environments.
-this['diff_match_patch'] = diff_match_patch;
-this['DIFF_DELETE'] = DIFF_DELETE;
-this['DIFF_INSERT'] = DIFF_INSERT;
-this['DIFF_EQUAL'] = DIFF_EQUAL;
-
-},{}],39:[function(_dereq_,module,exports){
-'use strict';
-
-// modified from https://github.com/es-shims/es5-shim
-var has = Object.prototype.hasOwnProperty;
-var toStr = Object.prototype.toString;
-var isArgs = _dereq_('./isArguments');
-var hasDontEnumBug = !({ 'toString': null }).propertyIsEnumerable('toString');
-var hasProtoEnumBug = function () {}.propertyIsEnumerable('prototype');
-var dontEnums = [
-	'toString',
-	'toLocaleString',
-	'valueOf',
-	'hasOwnProperty',
-	'isPrototypeOf',
-	'propertyIsEnumerable',
-	'constructor'
-];
-
-var keysShim = function keys(object) {
-	var isObject = object !== null && typeof object === 'object';
-	var isFunction = toStr.call(object) === '[object Function]';
-	var isArguments = isArgs(object);
-	var isString = isObject && toStr.call(object) === '[object String]';
-	var theKeys = [];
-
-	if (!isObject && !isFunction && !isArguments) {
-		throw new TypeError('Object.keys called on a non-object');
-	}
-
-	var skipProto = hasProtoEnumBug && isFunction;
-	if (isString && object.length > 0 && !has.call(object, 0)) {
-		for (var i = 0; i < object.length; ++i) {
-			theKeys.push(String(i));
-		}
-	}
-
-	if (isArguments && object.length > 0) {
-		for (var j = 0; j < object.length; ++j) {
-			theKeys.push(String(j));
-		}
-	} else {
-		for (var name in object) {
-			if (!(skipProto && name === 'prototype') && has.call(object, name)) {
-				theKeys.push(String(name));
-			}
-		}
-	}
-
-	if (hasDontEnumBug) {
-		var ctor = object.constructor;
-		var skipConstructor = ctor && ctor.prototype === object;
-
-		for (var k = 0; k < dontEnums.length; ++k) {
-			if (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) {
-				theKeys.push(dontEnums[k]);
-			}
-		}
-	}
-	return theKeys;
-};
-
-keysShim.shim = function shimObjectKeys() {
-	if (!Object.keys) {
-		Object.keys = keysShim;
-	}
-	return Object.keys || keysShim;
-};
-
-module.exports = keysShim;
-
-},{"./isArguments":40}],40:[function(_dereq_,module,exports){
-'use strict';
-
-var toStr = Object.prototype.toString;
-
-module.exports = function isArguments(value) {
-	var str = toStr.call(value);
-	var isArgs = str === '[object Arguments]';
-	if (!isArgs) {
-		isArgs = str !== '[object Array]'
-			&& value !== null
-			&& typeof value === 'object'
-			&& typeof value.length === 'number'
-			&& value.length >= 0
-			&& toStr.call(value.callee) === '[object Function]';
-	}
-	return isArgs;
-};
-
-},{}],41:[function(_dereq_,module,exports){
-/**
- * stringifier
- * 
- * https://github.com/twada/stringifier
- *
- * Copyright (c) 2014-2015 Takuto Wada
- * Licensed under the MIT license.
- *   http://twada.mit-license.org/2014-2015
- */
-'use strict';
-
-var traverse = _dereq_('traverse'),
-    typeName = _dereq_('type-name'),
-    extend = _dereq_('xtend'),
-    s = _dereq_('./strategies');
-
-function defaultHandlers () {
-    return {
-        'null': s.always('null'),
-        'undefined': s.always('undefined'),
-        'function': s.prune(),
-        'string': s.json(),
-        'boolean': s.json(),
-        'number': s.number(),
-        'RegExp': s.toStr(),
-        'String': s.newLike(),
-        'Boolean': s.newLike(),
-        'Number': s.newLike(),
-        'Date': s.newLike(),
-        'Array': s.array(),
-        'Object': s.object(),
-        '@default': s.object()
-    };
-}
-
-function defaultOptions () {
-    return {
-        maxDepth: null,
-        indent: null,
-        anonymous: '@Anonymous',
-        circular: '#@Circular#',
-        snip: '..(snip)',
-        lineSeparator: '\n',
-        typeFun: typeName
-    };
-}
-
-function createStringifier (customOptions) {
-    var options = extend(defaultOptions(), customOptions),
-        handlers = extend(defaultHandlers(), options.handlers);
-    return function stringifyAny (push, x) {
-        var context = this,
-            handler = handlerFor(context.node, options, handlers),
-            currentPath = '/' + context.path.join('/'),
-            customization = handlers[currentPath],
-            acc = {
-                context: context,
-                options: options,
-                handlers: handlers,
-                push: push
-            };
-        if (typeName(customization) === 'function') {
-            handler = customization;
-        } else if (typeName(customization) === 'number') {
-            handler = s.flow.compose(s.filters.truncate(customization),handler);
-        }
-        handler(acc, x);
-        return push;
-    };
-}
-
-function handlerFor (val, options, handlers) {
-    var tname = options.typeFun(val);
-    if (typeName(handlers[tname]) === 'function') {
-        return handlers[tname];
-    }
-    return handlers['@default'];
-}
-
-function walk (val, reducer) {
-    var buffer = [],
-        push = function (str) {
-            buffer.push(str);
-        };
-    traverse(val).reduce(reducer, push);
-    return buffer.join('');
-}
-
-function stringify (val, options) {
-    return walk(val, createStringifier(options));
-}
-
-function stringifier (options) {
-    return function (val) {
-        return walk(val, createStringifier(options));
-    };
-}
-
-stringifier.stringify = stringify;
-stringifier.strategies = s;
-stringifier.defaultOptions = defaultOptions;
-stringifier.defaultHandlers = defaultHandlers;
-module.exports = stringifier;
-
-},{"./strategies":42,"traverse":44,"type-name":43,"xtend":45}],42:[function(_dereq_,module,exports){
-'use strict';
-
-var typeName = _dereq_('type-name'),
-    slice = Array.prototype.slice,
-    END = {},
-    ITERATE = {};
-
-// arguments should end with end or iterate
-function compose () {
-    var filters = slice.apply(arguments);
-    return filters.reduceRight(function(right, left) {
-        return left(right);
-    });
-}
-
-// skip children
-function end () {
-    return function (acc, x) {
-        acc.context.keys = [];
-        return END;
-    };
-}
-
-// iterate children
-function iterate () {
-    return function (acc, x) {
-        return ITERATE;
-    };
-}
-
-function filter (predicate) {
-    return function (next) {
-        return function (acc, x) {
-            var toBeIterated,
-                isIteratingArray = (typeName(x) === 'Array');
-            if (typeName(predicate) === 'function') {
-                toBeIterated = [];
-                acc.context.keys.forEach(function (key) {
-                    var indexOrKey = isIteratingArray ? parseInt(key, 10) : key,
-                        kvp = {
-                            key: indexOrKey,
-                            value: x[key]
-                        },
-                        decision = predicate(kvp);
-                    if (decision) {
-                        toBeIterated.push(key);
-                    }
-                    if (typeName(decision) === 'number') {
-                        truncateByKey(decision, key, acc);
-                    }
-                    if (typeName(decision) === 'function') {
-                        customizeStrategyForKey(decision, key, acc);
-                    }
-                });
-                acc.context.keys = toBeIterated;
-            }
-            return next(acc, x);
-        };
-    };
-}
-
-function customizeStrategyForKey (strategy, key, acc) {
-    acc.handlers[currentPath(key, acc)] = strategy;
-}
-
-function truncateByKey (size, key, acc) {
-    acc.handlers[currentPath(key, acc)] = size;
-}
-
-function currentPath (key, acc) {
-    var pathToCurrentNode = [''].concat(acc.context.path);
-    if (typeName(key) !== 'undefined') {
-        pathToCurrentNode.push(key);
-    }
-    return pathToCurrentNode.join('/');
-}
-
-function allowedKeys (orderedWhiteList) {
-    return function (next) {
-        return function (acc, x) {
-            var isIteratingArray = (typeName(x) === 'Array');
-            if (!isIteratingArray && typeName(orderedWhiteList) === 'Array') {
-                acc.context.keys = orderedWhiteList.filter(function (propKey) {
-                    return acc.context.keys.indexOf(propKey) !== -1;
-                });
-            }
-            return next(acc, x);
-        };
-    };
-}
-
-function safeKeys () {
-    return function (next) {
-        return function (acc, x) {
-            if (typeName(x) !== 'Array') {
-                acc.context.keys = acc.context.keys.filter(function (propKey) {
-                    // Error handling for unsafe property access.
-                    // For example, on PhantomJS,
-                    // accessing HTMLInputElement.selectionEnd causes TypeError
-                    try {
-                        var val = x[propKey];
-                        return true;
-                    } catch (e) {
-                        // skip unsafe key
-                        return false;
-                    }
-                });
-            }
-            return next(acc, x);
-        };
-    };
-}
-
-function when (guard, then) {
-    return function (next) {
-        return function (acc, x) {
-            var kvp = {
-                key: acc.context.key,
-                value: x
-            };
-            if (guard(kvp, acc)) {
-                return then(acc, x);
-            }
-            return next(acc, x);
-        };
-    };
-}
-
-function truncate (size) {
-    return function (next) {
-        return function (acc, x) {
-            var orig = acc.push, ret;
-            acc.push = function (str) {
-                var savings = str.length - size,
-                    truncated;
-                if (savings <= size) {
-                    orig.call(acc, str);
-                } else {
-                    truncated = str.substring(0, size);
-                    orig.call(acc, truncated + acc.options.snip);
-                }
-            };
-            ret = next(acc, x);
-            acc.push = orig;
-            return ret;
-        };
-    };
-}
-
-function constructorName () {
-    return function (next) {
-        return function (acc, x) {
-            var name = acc.options.typeFun(x);
-            if (name === '') {
-                name = acc.options.anonymous;
-            }
-            acc.push(name);
-            return next(acc, x);
-        };
-    };
-}
-
-function always (str) {
-    return function (next) {
-        return function (acc, x) {
-            acc.push(str);
-            return next(acc, x);
-        };
-    };
-}
-
-function optionValue (key) {
-    return function (next) {
-        return function (acc, x) {
-            acc.push(acc.options[key]);
-            return next(acc, x);
-        };
-    };
-}
-
-function json (replacer) {
-    return function (next) {
-        return function (acc, x) {
-            acc.push(JSON.stringify(x, replacer));
-            return next(acc, x);
-        };
-    };
-}
-
-function toStr () {
-    return function (next) {
-        return function (acc, x) {
-            acc.push(x.toString());
-            return next(acc, x);
-        };
-    };
-}
-
-function decorateArray () {
-    return function (next) {
-        return function (acc, x) {
-            acc.context.before(function (node) {
-                acc.push('[');
-            });
-            acc.context.after(function (node) {
-                afterAllChildren(this, acc.push, acc.options);
-                acc.push(']');
-            });
-            acc.context.pre(function (val, key) {
-                beforeEachChild(this, acc.push, acc.options);
-            });
-            acc.context.post(function (childContext) {
-                afterEachChild(childContext, acc.push);
-            });
-            return next(acc, x);
-        };
-    };
-}
-
-function decorateObject () {
-    return function (next) {
-        return function (acc, x) {
-            acc.context.before(function (node) {
-                acc.push('{');
-            });
-            acc.context.after(function (node) {
-                afterAllChildren(this, acc.push, acc.options);
-                acc.push('}');
-            });
-            acc.context.pre(function (val, key) {
-                beforeEachChild(this, acc.push, acc.options);
-                acc.push(sanitizeKey(key) + (acc.options.indent ? ': ' : ':'));
-            });
-            acc.context.post(function (childContext) {
-                afterEachChild(childContext, acc.push);
-            });
-            return next(acc, x);
-        };
-    };
-}
-
-function sanitizeKey (key) {
-    return /^[A-Za-z_]+$/.test(key) ? key : JSON.stringify(key);
-}
-
-function afterAllChildren (context, push, options) {
-    if (options.indent && 0 < context.keys.length) {
-        push(options.lineSeparator);
-        for(var i = 0; i < context.level; i += 1) { // indent level - 1
-            push(options.indent);
-        }
-    }
-}
-
-function beforeEachChild (context, push, options) {
-    if (options.indent) {
-        push(options.lineSeparator);
-        for(var i = 0; i <= context.level; i += 1) {
-            push(options.indent);
-        }
-    }
-}
-
-function afterEachChild (childContext, push) {
-    if (!childContext.isLast) {
-        push(',');
-    }
-}
-
-function nan (kvp, acc) {
-    return kvp.value !== kvp.value;
-}
-
-function positiveInfinity (kvp, acc) {
-    return !isFinite(kvp.value) && kvp.value === Infinity;
-}
-
-function negativeInfinity (kvp, acc) {
-    return !isFinite(kvp.value) && kvp.value !== Infinity;
-}
-
-function circular (kvp, acc) {
-    return acc.context.circular;
-}
-
-function maxDepth (kvp, acc) {
-    return (acc.options.maxDepth && acc.options.maxDepth <= acc.context.level);
-}
-
-var prune = compose(
-    always('#'),
-    constructorName(),
-    always('#'),
-    end()
-);
-var omitNaN = when(nan, compose(
-    always('NaN'),
-    end()
-));
-var omitPositiveInfinity = when(positiveInfinity, compose(
-    always('Infinity'),
-    end()
-));
-var omitNegativeInfinity = when(negativeInfinity, compose(
-    always('-Infinity'),
-    end()
-));
-var omitCircular = when(circular, compose(
-    optionValue('circular'),
-    end()
-));
-var omitMaxDepth = when(maxDepth, prune);
-
-module.exports = {
-    filters: {
-        always: always,
-        constructorName: constructorName,
-        json: json,
-        toStr: toStr,
-        prune: prune,
-        truncate: truncate,
-        decorateArray: decorateArray,
-        decorateObject: decorateObject
-    },
-    flow: {
-        compose: compose,
-        when: when,
-        allowedKeys: allowedKeys,
-        safeKeys: safeKeys,
-        filter: filter,
-        iterate: iterate,
-        end: end
-    },
-    symbols: {
-        END: END,
-        ITERATE: ITERATE
-    },
-    always: function (str) {
-        return compose(always(str), end());
-    },
-    json: function () {
-        return compose(json(), end());
-    },
-    toStr: function () {
-        return compose(toStr(), end());
-    },
-    prune: function () {
-        return prune;
-    },
-    number: function () {
-        return compose(
-            omitNaN,
-            omitPositiveInfinity,
-            omitNegativeInfinity,
-            json(),
-            end()
-        );
-    },
-    newLike: function () {
-        return compose(
-            always('new '),
-            constructorName(),
-            always('('),
-            json(),
-            always(')'),
-            end()
-        );
-    },
-    array: function (predicate) {
-        return compose(
-            omitCircular,
-            omitMaxDepth,
-            decorateArray(),
-            filter(predicate),
-            iterate()
-        );
-    },
-    object: function (predicate, orderedWhiteList) {
-        return compose(
-            omitCircular,
-            omitMaxDepth,
-            constructorName(),
-            decorateObject(),
-            allowedKeys(orderedWhiteList),
-            safeKeys(),
-            filter(predicate),
-            iterate()
-        );
-    }
-};
-
-},{"type-name":43}],43:[function(_dereq_,module,exports){
-/**
- * type-name - Just a reasonable typeof
- * 
- * https://github.com/twada/type-name
- *
- * Copyright (c) 2014 Takuto Wada
- * Licensed under the MIT license.
- *   http://twada.mit-license.org/
- */
-'use strict';
-
-var toStr = Object.prototype.toString;
-
-function funcName (f) {
-    return f.name ? f.name : /^\s*function\s*([^\(]*)/im.exec(f.toString())[1];
-}
-
-function ctorName (obj) {
-    var strName = toStr.call(obj).slice(8, -1);
-    if (strName === 'Object' && obj.constructor) {
-        return funcName(obj.constructor);
-    }
-    return strName;
-}
-
-function typeName (val) {
-    var type;
-    if (val === null) {
-        return 'null';
-    }
-    type = typeof(val);
-    if (type === 'object') {
-        return ctorName(val);
-    }
-    return type;
-}
-
-module.exports = typeName;
-
-},{}],44:[function(_dereq_,module,exports){
-var traverse = module.exports = function (obj) {
-    return new Traverse(obj);
-};
-
-function Traverse (obj) {
-    this.value = obj;
-}
-
-Traverse.prototype.get = function (ps) {
-    var node = this.value;
-    for (var i = 0; i < ps.length; i ++) {
-        var key = ps[i];
-        if (!node || !hasOwnProperty.call(node, key)) {
-            node = undefined;
-            break;
-        }
-        node = node[key];
-    }
-    return node;
-};
-
-Traverse.prototype.has = function (ps) {
-    var node = this.value;
-    for (var i = 0; i < ps.length; i ++) {
-        var key = ps[i];
-        if (!node || !hasOwnProperty.call(node, key)) {
-            return false;
-        }
-        node = node[key];
-    }
-    return true;
-};
-
-Traverse.prototype.set = function (ps, value) {
-    var node = this.value;
-    for (var i = 0; i < ps.length - 1; i ++) {
-        var key = ps[i];
-        if (!hasOwnProperty.call(node, key)) node[key] = {};
-        node = node[key];
-    }
-    node[ps[i]] = value;
-    return value;
-};
-
-Traverse.prototype.map = function (cb) {
-    return walk(this.value, cb, true);
-};
-
-Traverse.prototype.forEach = function (cb) {
-    this.value = walk(this.value, cb, false);
-    return this.value;
-};
-
-Traverse.prototype.reduce = function (cb, init) {
-    var skip = arguments.length === 1;
-    var acc = skip ? this.value : init;
-    this.forEach(function (x) {
-        if (!this.isRoot || !skip) {
-            acc = cb.call(this, acc, x);
-        }
-    });
-    return acc;
-};
-
-Traverse.prototype.paths = function () {
-    var acc = [];
-    this.forEach(function (x) {
-        acc.push(this.path); 
-    });
-    return acc;
-};
-
-Traverse.prototype.nodes = function () {
-    var acc = [];
-    this.forEach(function (x) {
-        acc.push(this.node);
-    });
-    return acc;
-};
-
-Traverse.prototype.clone = function () {
-    var parents = [], nodes = [];
-    
-    return (function clone (src) {
-        for (var i = 0; i < parents.length; i++) {
-            if (parents[i] === src) {
-                return nodes[i];
-            }
-        }
-        
-        if (typeof src === 'object' && src !== null) {
-            var dst = copy(src);
-            
-            parents.push(src);
-            nodes.push(dst);
-            
-            forEach(objectKeys(src), function (key) {
-                dst[key] = clone(src[key]);
-            });
-            
-            parents.pop();
-            nodes.pop();
-            return dst;
-        }
-        else {
-            return src;
-        }
-    })(this.value);
-};
-
-function walk (root, cb, immutable) {
-    var path = [];
-    var parents = [];
-    var alive = true;
-    
-    return (function walker (node_) {
-        var node = immutable ? copy(node_) : node_;
-        var modifiers = {};
-        
-        var keepGoing = true;
-        
-        var state = {
-            node : node,
-            node_ : node_,
-            path : [].concat(path),
-            parent : parents[parents.length - 1],
-            parents : parents,
-            key : path.slice(-1)[0],
-            isRoot : path.length === 0,
-            level : path.length,
-            circular : null,
-            update : function (x, stopHere) {
-                if (!state.isRoot) {
-                    state.parent.node[state.key] = x;
-                }
-                state.node = x;
-                if (stopHere) keepGoing = false;
-            },
-            'delete' : function (stopHere) {
-                delete state.parent.node[state.key];
-                if (stopHere) keepGoing = false;
-            },
-            remove : function (stopHere) {
-                if (isArray(state.parent.node)) {
-                    state.parent.node.splice(state.key, 1);
-                }
-                else {
-                    delete state.parent.node[state.key];
-                }
-                if (stopHere) keepGoing = false;
-            },
-            keys : null,
-            before : function (f) { modifiers.before = f },
-            after : function (f) { modifiers.after = f },
-            pre : function (f) { modifiers.pre = f },
-            post : function (f) { modifiers.post = f },
-            stop : function () { alive = false },
-            block : function () { keepGoing = false }
-        };
-        
-        if (!alive) return state;
-        
-        function updateState() {
-            if (typeof state.node === 'object' && state.node !== null) {
-                if (!state.keys || state.node_ !== state.node) {
-                    state.keys = objectKeys(state.node)
-                }
-                
-                state.isLeaf = state.keys.length == 0;
-                
-                for (var i = 0; i < parents.length; i++) {
-                    if (parents[i].node_ === node_) {
-                        state.circular = parents[i];
-                        break;
-                    }
-                }
-            }
-            else {
-                state.isLeaf = true;
-                state.keys = null;
-            }
-            
-            state.notLeaf = !state.isLeaf;
-            state.notRoot = !state.isRoot;
-        }
-        
-        updateState();
-        
-        // use return values to update if defined
-        var ret = cb.call(state, state.node);
-        if (ret !== undefined && state.update) state.update(ret);
-        
-        if (modifiers.before) modifiers.before.call(state, state.node);
-        
-        if (!keepGoing) return state;
-        
-        if (typeof state.node == 'object'
-        && state.node !== null && !state.circular) {
-            parents.push(state);
-            
-            updateState();
-            
-            forEach(state.keys, function (key, i) {
-                path.push(key);
-                
-                if (modifiers.pre) modifiers.pre.call(state, state.node[key], key);
-                
-                var child = walker(state.node[key]);
-                if (immutable && hasOwnProperty.call(state.node, key)) {
-                    state.node[key] = child.node;
-                }
-                
-                child.isLast = i == state.keys.length - 1;
-                child.isFirst = i == 0;
-                
-                if (modifiers.post) modifiers.post.call(state, child);
-                
-                path.pop();
-            });
-            parents.pop();
-        }
-        
-        if (modifiers.after) modifiers.after.call(state, state.node);
-        
-        return state;
-    })(root).node;
-}
-
-function copy (src) {
-    if (typeof src === 'object' && src !== null) {
-        var dst;
-        
-        if (isArray(src)) {
-            dst = [];
-        }
-        else if (isDate(src)) {
-            dst = new Date(src.getTime ? src.getTime() : src);
-        }
-        else if (isRegExp(src)) {
-            dst = new RegExp(src);
-        }
-        else if (isError(src)) {
-            dst = { message: src.message };
-        }
-        else if (isBoolean(src)) {
-            dst = new Boolean(src);
-        }
-        else if (isNumber(src)) {
-            dst = new Number(src);
-        }
-        else if (isString(src)) {
-            dst = new String(src);
-        }
-        else if (Object.create && Object.getPrototypeOf) {
-            dst = Object.create(Object.getPrototypeOf(src));
-        }
-        else if (src.constructor === Object) {
-            dst = {};
-        }
-        else {
-            var proto =
-                (src.constructor && src.constructor.prototype)
-                || src.__proto__
-                || {}
-            ;
-            var T = function () {};
-            T.prototype = proto;
-            dst = new T;
-        }
-        
-        forEach(objectKeys(src), function (key) {
-            dst[key] = src[key];
-        });
-        return dst;
-    }
-    else return src;
-}
-
-var objectKeys = Object.keys || function keys (obj) {
-    var res = [];
-    for (var key in obj) res.push(key)
-    return res;
-};
-
-function toS (obj) { return Object.prototype.toString.call(obj) }
-function isDate (obj) { return toS(obj) === '[object Date]' }
-function isRegExp (obj) { return toS(obj) === '[object RegExp]' }
-function isError (obj) { return toS(obj) === '[object Error]' }
-function isBoolean (obj) { return toS(obj) === '[object Boolean]' }
-function isNumber (obj) { return toS(obj) === '[object Number]' }
-function isString (obj) { return toS(obj) === '[object String]' }
-
-var isArray = Array.isArray || function isArray (xs) {
-    return Object.prototype.toString.call(xs) === '[object Array]';
-};
-
-var forEach = function (xs, fn) {
-    if (xs.forEach) return xs.forEach(fn)
-    else for (var i = 0; i < xs.length; i++) {
-        fn(xs[i], i, xs);
-    }
-};
-
-forEach(objectKeys(Traverse.prototype), function (key) {
-    traverse[key] = function (obj) {
-        var args = [].slice.call(arguments, 1);
-        var t = new Traverse(obj);
-        return t[key].apply(t, args);
-    };
-});
-
-var hasOwnProperty = Object.hasOwnProperty || function (obj, key) {
-    return key in obj;
-};
-
-},{}],45:[function(_dereq_,module,exports){
-module.exports = extend
-
-function extend() {
-    var target = {}
-
-    for (var i = 0; i < arguments.length; i++) {
-        var source = arguments[i]
-
-        for (var key in source) {
-            if (source.hasOwnProperty(key)) {
-                target[key] = source[key]
-            }
-        }
-    }
-
-    return target
-}
-
-},{}],46:[function(_dereq_,module,exports){
-module.exports = extend
-
-function extend(target) {
-    for (var i = 1; i < arguments.length; i++) {
-        var source = arguments[i]
-
-        for (var key in source) {
-            if (source.hasOwnProperty(key)) {
-                target[key] = source[key]
-            }
-        }
-    }
-
-    return target
-}
-
-},{}]},{},[7])(7)
-});
-
diff --git a/packages/planner/node_modules/deepcopy/deepcopy.js b/packages/planner/node_modules/deepcopy/deepcopy.js
deleted file mode 100644
index cb66bc6a..00000000
--- a/packages/planner/node_modules/deepcopy/deepcopy.js
+++ /dev/null
@@ -1,229 +0,0 @@
-/*!
- * @license deepcopy.js Copyright(c) 2013 sasa+1
- * https://github.com/sasaplus1/deepcopy.js
- * Released under the MIT license.
- */
-
-
-/**
- * export to AMD/CommonJS/global.
- *
- * @param {Object} global global object.
- * @param {Function} factory factory method.
- */
-(function(global, factory) {
-  'use strict';
-
-  if (typeof define === 'function' && !!define.amd) {
-    define(factory);
-  } else if (typeof exports === 'object') {
-    module.exports = factory();
-  } else {
-    global.deepcopy = factory();
-  }
-}(this, function() {
-  'use strict';
-
-  var isNode, util, isBuffer, getKeys, getSymbols, indexOfArray;
-
-  // is node.js/io.js?
-  isNode = (typeof process !== 'undefined' && typeof require !== 'undefined');
-
-  // fallback util module for browser.
-  util = (isNode) ? require('util') : (function() {
-    function isArray(value) {
-      return (typeof value === 'object' &&
-          Object.prototype.toString.call(value) === '[object Array]');
-    }
-
-    function isDate(value) {
-      return (typeof value === 'object' &&
-          Object.prototype.toString.call(value) === '[object Date]');
-    }
-
-    function isRegExp(value) {
-      return (typeof value === 'object' &&
-          Object.prototype.toString.call(value) === '[object RegExp]');
-    }
-
-    function isSymbol(value) {
-      return (typeof value === 'symbol');
-    }
-
-    return {
-      isArray: (typeof Array.isArray === 'function') ?
-          function(obj) {
-            return Array.isArray(obj);
-          } : isArray,
-      isDate: isDate,
-      isRegExp: isRegExp,
-      isSymbol: (typeof Symbol === 'function') ?
-          isSymbol :
-          function() {
-            // always return false when Symbol is not supported.
-            return false;
-          }
-    };
-  }());
-
-  // fallback Buffer.isBuffer
-  isBuffer = (isNode) ?
-      function(obj) {
-        return Buffer.isBuffer(obj);
-      } :
-      function() {
-        // if browser, always return false
-        return false;
-      };
-
-  // fallback Object.keys for old browsers.
-  getKeys = (typeof Object.keys === 'function') ?
-      function(obj) {
-        return Object.keys(obj);
-      } :
-      function(obj) {
-        var keys = [],
-            key;
-
-        if (obj === null || typeof obj !== 'object') {
-          throw new TypeError('obj is not an Object');
-        }
-
-        for (key in obj) {
-          obj.hasOwnProperty(key) && keys.push(key);
-        }
-
-        return keys;
-      };
-
-  // get symbols in object.
-  getSymbols = (typeof Symbol === 'function') ?
-      function(obj) {
-        return Object.getOwnPropertySymbols(obj);
-      } :
-      function() {
-        // always return empty array when Symbol is not supported.
-        return [];
-      };
-
-  // fallback Array#indexOf for old browsers.
-  indexOfArray = (typeof Array.prototype.indexOf === 'function') ?
-      function(array, searchElement) {
-        return array.indexOf(searchElement);
-      } :
-      function(array, searchElement) {
-        var i, len;
-
-        if (!util.isArray(array)) {
-          throw new TypeError('array is not an Array');
-        }
-
-        for (i = 0, len = array.length; i < len; ++i) {
-          if (array[i] === searchElement) {
-            return i;
-          }
-        }
-
-        return -1;
-      };
-
-  /**
-   * recursive deep copy for value.
-   *
-   * @private
-   * @param {*} value copy target.
-   * @param {*} clone
-   * @param {Array} visited
-   * @param {Array} reference
-   * @return {*} copied value.
-   */
-  function copyValue_(value, clone, visited, reference) {
-    var str, pos, buf, keys, i, len, key, val, idx, obj, ref;
-
-    // number, string, boolean, null, undefined, function and symbol.
-    if (value === null || typeof value !== 'object') {
-      return value;
-    }
-
-    // Date.
-    if (util.isDate(value)) {
-      // Firefox need to convert to Number
-      //
-      // Firefox:
-      //   var date = new Date;
-      //   +date;            // 1420909365967
-      //   +new Date(date);  // 1420909365000
-      //   +new Date(+date); // 1420909365967
-      // Chrome:
-      //   var date = new Date;
-      //   +date;            // 1420909757913
-      //   +new Date(date);  // 1420909757913
-      //   +new Date(+date); // 1420909757913
-      return new Date(+value);
-    }
-
-    // RegExp.
-    if (util.isRegExp(value)) {
-      // Chrome, Safari:
-      //   (new RegExp).source => "(?:)"
-      // Firefox:
-      //   (new RegExp).source => ""
-      // Chrome, Safari, Firefox
-      //   String(new RegExp) => "/(?:)/"
-      str = String(value);
-      pos = str.lastIndexOf('/');
-
-      return new RegExp(str.slice(1, pos), str.slice(pos + 1));
-    }
-
-    // Buffer, node.js only.
-    if (isBuffer(value)) {
-      buf = new Buffer(value.length);
-      value.copy(buf);
-
-      return buf;
-    }
-
-    // Object or Array.
-    keys = getKeys(value).concat(getSymbols(value));
-
-    for (i = 0, len = keys.length; i < len; ++i) {
-      key = keys[i];
-      val = value[key];
-
-      if (val !== null && typeof val === 'object') {
-        idx = indexOfArray(visited, val);
-
-        if (idx === -1) {
-          // not circular reference
-          obj = (util.isArray(val)) ? [] : {};
-
-          visited.push(val);
-          reference.push(obj);
-        } else {
-          // circular reference
-          ref = reference[idx];
-        }
-      }
-
-      clone[key] = ref || copyValue_(val, obj, visited, reference);
-    }
-
-    return clone;
-  }
-
-  /**
-   * deep copy for value.
-   *
-   * @param {*} value copy target.
-   */
-  function deepcopy(value) {
-    var clone = (util.isArray(value)) ? [] : {},
-        visited = [value],
-        reference = [clone];
-
-    return copyValue_(value, clone, visited, reference);
-  }
-
-  return deepcopy;
-}));
diff --git a/packages/planner/node_modules/deepcopy/package.json b/packages/planner/node_modules/deepcopy/package.json
deleted file mode 100644
index 17cbb745..00000000
--- a/packages/planner/node_modules/deepcopy/package.json
+++ /dev/null
@@ -1,69 +0,0 @@
-{
-  "name": "deepcopy",
-  "version": "0.5.0",
-  "author": {
-    "name": "sasa+1",
-    "email": "sasaplus1@gmail.com"
-  },
-  "contributors": [
-    {
-      "name": "kjirou",
-      "email": "kjirou.web@gmail.com"
-    }
-  ],
-  "description": "deep copy for any data",
-  "main": "./deepcopy.js",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/sasaplus1/deepcopy.js.git"
-  },
-  "directories": {
-    "test": "test/"
-  },
-  "scripts": {
-    "bower": "bower install",
-    "fix": "fixjsstyle --flagfile .closurelinter -r .",
-    "lint": "gjslint --flagfile .closurelinter -r .",
-    "minify": "uglifyjs ./deepcopy.js --comments '@license' -cm -r deepcopy -o ./deepcopy.min.js",
-    "power": "espower ./test/test.js > ./test/test.pwr.js",
-    "test": "mocha ./test/test.js",
-    "testem": "testem",
-    "travis": "testem ci --launch Firefox,PhantomJS"
-  },
-  "devDependencies": {
-    "bower": "~1.4",
-    "espower-cli": "~0.2",
-    "intelli-espower-loader": "~0.6",
-    "mocha": "~2.2",
-    "power-assert": "~0.10",
-    "testem": "~0.7",
-    "uglify-js": "~2.4"
-  },
-  "gitHead": "6fffac0b35e82d5ae67b756f6955f28d10f0fac1",
-  "bugs": {
-    "url": "https://github.com/sasaplus1/deepcopy.js/issues"
-  },
-  "homepage": "https://github.com/sasaplus1/deepcopy.js",
-  "_id": "deepcopy@0.5.0",
-  "_shasum": "d2ca34335c2d31f54c1b4f13745e001977d491a2",
-  "_from": "deepcopy@*",
-  "_npmVersion": "2.7.5",
-  "_nodeVersion": "1.6.4",
-  "_npmUser": {
-    "name": "sasaplus1",
-    "email": "sasaplus1@gmail.com"
-  },
-  "maintainers": [
-    {
-      "name": "sasaplus1",
-      "email": "sasaplus1@gmail.com"
-    }
-  ],
-  "dist": {
-    "shasum": "d2ca34335c2d31f54c1b4f13745e001977d491a2",
-    "tarball": "http://registry.npmjs.org/deepcopy/-/deepcopy-0.5.0.tgz"
-  },
-  "_resolved": "https://registry.npmjs.org/deepcopy/-/deepcopy-0.5.0.tgz",
-  "readme": "ERROR: No README data found!"
-}
diff --git a/packages/planner/node_modules/deepcopy/testem.json b/packages/planner/node_modules/deepcopy/testem.json
deleted file mode 100644
index d49cd811..00000000
--- a/packages/planner/node_modules/deepcopy/testem.json
+++ /dev/null
@@ -1,5 +0,0 @@
-{
-  "before_tests": "npm run power",
-  "on_exit": "rm ./test/test.pwr.js",
-  "test_page": "./test/index.html"
-}
diff --git a/packages/planner/package.js b/packages/planner/package.js
index 6f8b1b61..e8731b52 100644
--- a/packages/planner/package.js
+++ b/packages/planner/package.js
@@ -7,15 +7,17 @@ Package.describe({
 	git: '',
 	// By default, Meteor will default to using README.md for documentation.
 	// To avoid submitting documentation, set this field to null.
-	documentation: 'README.md'
+	documentation: 'README.md',
 });
 
 Package.onUse(function(api) {
 	api.versionsFrom('1.1.0.2');
+	api.use('erasaur:meteor-lodash');
+
 	api.addFiles('planner.js');
 
-	api.export("HomeworkDescription");
-	api.export("Planner");
+	api.export('HomeworkDescription');
+	api.export('Planner');
 });
 
 Package.onTest(function(api) {
diff --git a/packages/planner/package.json b/packages/planner/package.json
new file mode 100644
index 00000000..ca6f6bf2
--- /dev/null
+++ b/packages/planner/package.json
@@ -0,0 +1,14 @@
+{
+  "name": "planner",
+  "version": "0.0.1",
+  "description": "The plan algorithm of simplyHomework.",
+  "main": "planner.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "simply <hello@simplyApps.nl> (http://www.simplyApps.nl/)",
+  "license": "UNLICENSED",
+  "dependencies": {
+    "lodash": "^3.10.1"
+  }
+}
diff --git a/packages/planner/planner.js b/packages/planner/planner.js
index 0da3e518..143d2458 100644
--- a/packages/planner/planner.js
+++ b/packages/planner/planner.js
@@ -4,7 +4,7 @@
  * @module planner
  */
 
-var deepcopy=require("deepcopy");
+var _ = _ || require('lodash');
 
 var assert = function (val) {
 	if (!val) throw new Error("AssertionError: false == true");
@@ -102,12 +102,12 @@ Planner=function(){
 	};
 
 	this.persistable=function(){
-		return deepcopy(subjects);
+		return _.cloneDeep(subjects);
 	};
 	this.frompersistable=function(subj){
 		if(subj.isPlannerObject===true) //they persisted the whole object ._.
 			subjects=subj.persistable();
-		else subjects=deepcopy(subj);
+		else subjects=_.cloneDeep(subj);
 	};
 
 	this.availableTimeConvert=function(code){
@@ -120,7 +120,7 @@ Planner=function(){
 	//  on that day of the plan region.
 	//`today` is a Date which the planner uses as "today"
 	this.plan=function(items,available,today){
-		items=deepcopy(items); //we'll modify them for our own needs
+		items=_.cloneDeep(items); //we'll modify them for our own needs
 		var ndays=available.length;
 		var needed=new Array(ndays);
 		var i;
@@ -178,7 +178,7 @@ Planner=function(){
 
 
 
-	if(arguments.length==1)subjects=deepcopy(arguments[0]); //from a persist source
+	if(arguments.length==1)subjects=_.cloneDeep(arguments[0]); //from a persist source
 };
 
 

From 8adfb6a9a9342b43eb4b46984aa81d3705da8bde Mon Sep 17 00:00:00 2001
From: tomsmeding <hallo@tomsmeding.nl>
Date: Fri, 28 Aug 2015 14:28:22 +0200
Subject: [PATCH 10/18] Working planner algorithm with fixing capability in
 case of non-fitting stuff

The test case in testtest.js is quite an aggressive one; stuff doesn't fit AT ALL.
Put the [1,9] testcase at 4 days for some relief, or the [1,2] case at 3 days, for example.
---
 packages/planner/planner.js  | 81 +++++++++++++++++++++++++++---------
 packages/planner/testtest.js | 22 ++++++----
 2 files changed, 77 insertions(+), 26 deletions(-)

diff --git a/packages/planner/planner.js b/packages/planner/planner.js
index 143d2458..71a262af 100644
--- a/packages/planner/planner.js
+++ b/packages/planner/planner.js
@@ -4,7 +4,8 @@
  * @module planner
  */
 
-var _ = _ || require('lodash');
+require("js-object-clone");
+var util=require("util");
 
 var assert = function (val) {
 	if (!val) throw new Error("AssertionError: false == true");
@@ -95,19 +96,19 @@ Planner=function(){
 
 	this.estimate=function(hwdesc){
 		var subj,loc;
-		//assert(hwdesc instanceof HomeworkDescription);
+		assert(hwdesc instanceof HomeworkDescription);
 		return sum(hwdesc.location.map(function(loc){
 			return estimateSingle(HomeworkDescription(hwdesc.subject,[loc]));
 		}));
 	};
 
 	this.persistable=function(){
-		return _.cloneDeep(subjects);
+		return Object.clone(subjects,true);
 	};
 	this.frompersistable=function(subj){
 		if(subj.isPlannerObject===true) //they persisted the whole object ._.
 			subjects=subj.persistable();
-		else subjects=_.cloneDeep(subj);
+		else subjects=Object.clone(subj,true);
 	};
 
 	this.availableTimeConvert=function(code){
@@ -118,14 +119,12 @@ Planner=function(){
 	//`items` is an Array of HomeworkDescriptions
 	//`available` is an Array of ints, specifying how much time (in the time unit) there is available
 	//  on that day of the plan region.
-	//`today` is a Date which the planner uses as "today"
+	//`today` is a Date which the planner uses as "today"; will be rounded to start of day
 	this.plan=function(items,available,today){
-		items=_.cloneDeep(items); //we'll modify them for our own needs
-		var ndays=available.length;
-		var needed=new Array(ndays);
+		items=Object.clone(items,true); //we'll modify them for our own needs
+		var needed=new Array(items.length);
 		var i;
-		for(i=0;i<ndays;i++){
-			available[i]=this.availableTimeConvert(available[i]);
+		for(i=0;i<items.length;i++){
 			needed[i]=this.estimate(items[i]);
 		}
 		console.log("available =",available," needed =",needed);
@@ -143,7 +142,7 @@ Planner=function(){
 			dueInDays[items[i].duediff].push({item:items[i],needed:needed[i]});
 		}
 		for(i=0;i<dueInDays.length;i++){
-			dueInDays[i].sort(function(a,b){return a.needed<b.needed;}); //descending sort on needed time
+			dueInDays[i].sort(function(a,b){return a.needed<b.needed;}); //descending sort on needed time, per day
 		}
 		var schedule=new Array(maxdiff);
 		var daylength=new Array(maxdiff);
@@ -152,22 +151,66 @@ Planner=function(){
 			daylength[i]=0;
 		}
 		var workingForDay;
-		var day,it;
+		var day,it,total,itemcopy,fractions,firstUsedDay,lastUsedDay,firstDayItem,lastDayItem;
 		workingForDay=0;
 		while(true){
 			while(workingForDay<dueInDays.length&&dueInDays[workingForDay].length==0)workingForDay++;
 			if(workingForDay>=dueInDays.length)break; //done!
-			console.log("day:",dueInDays[workingForDay]);
 			it=dueInDays[workingForDay].shift();
-			console.log("it =",it);
-			console.log("daylength[0]="+daylength[0]+" it.needed="+it.needed+" available[0]="+available[0]);
+			console.log("daylength="+util.inspect(daylength)+" item={\""+it.item.subject+"\" - "+util.inspect(it.item.location)+" - due in "+it.item.duediff+" day"+(it.item.duediff==1?"":"s")+"} it.needed="+it.needed);
 			for(day=0;day<it.item.duediff;day++){
 				if(daylength[day]+it.needed<=available[day])break;
 			}
-			if(day==it.item.duediff)assert(false); //TODO FIX STUFF THAT DOESN'T FIT
-			schedule[day].push(it.item);
-			daylength[day]+=it.needed;
+			if(day<it.item.duediff){
+				console.log(" -> planned on day "+day);
+				schedule[day].push(it.item);
+				daylength[day]+=it.needed;
+			} else { //the item didn't fit anywhere
+				console.log(" -> no fit found; distributing");
+				total=0;
+				fractions=[];
+				firstUsedDay=-1;
+				for(day=0;day<it.item.duediff;day++){
+					itemcopy=Object.clone(it.item,true);
+					itemcopy.timepart=Math.min(available[day]-daylength[day],it.needed-total);
+					if(itemcopy.timepart<=0)continue;
+					itemcopy.timefraction=itemcopy.timepart/it.needed;
+					if(firstUsedDay==-1)firstUsedDay=day;
+					lastUsedDay=day;
+					schedule[day].push(itemcopy);
+					daylength[day]+=itemcopy.timepart;
+					total+=itemcopy.timepart;
+					fractions.push({timepart:itemcopy.timepart,day:day});
+					if(total>=it.needed)break;
+				}
+				if(total<it.needed){
+					console.log(" -> distributing left "+(it.needed-total)+" excess; putting on first used day");
+					if(firstUsedDay==-1){ //HELP we didn't plan ANYTHING yet at all
+						console.log(" -> NO FIRST USED DAY, so just plugging everything on day 0");
+						schedule[0].push(it.item);
+						daylength[0]+=it.needed;
+						continue; //skip all the fraction stuff
+					} else {
+						firstDayItem=schedule[firstUsedDay][schedule[firstUsedDay].length-1];
+						firstDayItem.timepart+=it.needed-total;
+						firstDayItem.timefraction=firstDayItem.timepart/it.needed;
+					}
+					total=it.needed;
+				}
+				//NOT REACHED IF SHIT WAS JUST THROWN ON DAY 0 DUE TO continue ABOVE
+				fractions.sort(function(a,b){a.timepart>b.timepart;}); //descending sort on timepart
+				lastDayItem=schedule[lastUsedDay][schedule[lastUsedDay].length-1];
+				while(fractions[0].timepart<available[lastUsedDay]-daylength[lastUsedDay]){
+					schedule[fractions[0].day].pop();
+					daylength[fractions[0].day]-=fractions[0].timepart;
+					lastDayItem.timepart+=fractions[0].timepart;
+					lastDayItem.timefraction=lastDayItem.timepart/it.needed;
+					daylength[lastUsedDay]+=fractions[0].timepart;
+					fractions.shift();
+				}
+			}
 		}
+		console.log("daylength="+util.inspect(daylength));
 		var ret={};
 		for(i=0;i<schedule.length;i++){
 			if(schedule[i].length==0)continue;
@@ -178,7 +221,7 @@ Planner=function(){
 
 
 
-	if(arguments.length==1)subjects=_.cloneDeep(arguments[0]); //from a persist source
+	if(arguments.length==1)subjects=Object.clone(arguments[0],true); //from a persist source
 };
 
 
diff --git a/packages/planner/testtest.js b/packages/planner/testtest.js
index 7bc3e88f..9f429cf9 100755
--- a/packages/planner/testtest.js
+++ b/packages/planner/testtest.js
@@ -4,15 +4,23 @@ var util=require("util");
 REQ=require("./planner")
 H=REQ.HomeworkDescription
 P=REQ.Planner
-function hh(s,l){var h=new H;h.subject=s;h.location=l;return h;}
 function inspect(o){console.log(util.inspect(o,{depth:8}));}
 function startOfDay(date){return new Date(date.getFullYear(),date.getMonth(),date.getDate());}
 function addDays(date,ndays){return new Date(date.getTime()+ndays*24*3600*1000);}
 p=new P
-p.learn(hh("ne",[[1,1],[1,2]]),100)
-p.learn(hh("ne",[[1,5]]),40)
+p.learn(H("ne",[[1,1],[1,2]]),1500)
+p.learn(H("ne",[[1,5]]),900)
+p.learn(H("ne",[[1,9]]),2000)
 inspect(p.persistable())
-p.estimate(hh("ne",[[1,5]]))
-p.estimate(hh("ne",[[1,4]]))
-var schedule=p.plan([H("ne",[[1,2]],addDays(startOfDay(new Date),2)),H("ne",[[1,1],[1,5]],addDays(startOfDay(new Date),1))],[1,1],new Date)
-console.log(schedule)
+p.estimate(H("ne",[[1,5]]))
+p.estimate(H("ne",[[1,4]]))
+var schedule=p.plan(
+	[
+		H("ne",[[1,2]],addDays(startOfDay(new Date),2)),
+		H("ne",[[1,1],[1,5]],addDays(startOfDay(new Date),1)),
+		H("ne",[[1,9]],addDays(startOfDay(new Date),2))
+	],
+	[1,1,1,1].map(p.availableTimeConvert),
+	new Date
+)
+inspect(schedule)

From 806baddff1ba8613caac377c615d5f2661d9c7fe Mon Sep 17 00:00:00 2001
From: tomsmeding <hallo@tomsmeding.nl>
Date: Fri, 28 Aug 2015 20:25:18 +0200
Subject: [PATCH 11/18] time{part,fraction}, HD.id, (new) HD, min time/day

---
 packages/planner/planner.js  | 29 ++++++++++++++++++++++++-----
 packages/planner/testtest.js |  7 ++++---
 2 files changed, 28 insertions(+), 8 deletions(-)

diff --git a/packages/planner/planner.js b/packages/planner/planner.js
index 71a262af..39fda883 100644
--- a/packages/planner/planner.js
+++ b/packages/planner/planner.js
@@ -7,6 +7,10 @@
 require("js-object-clone");
 var util=require("util");
 
+
+var MIN_TIME_TASK_DAY=450; //minimum of 7.5 minutes for one task on a day (except if expected time is <7.5 min)
+
+
 var assert = function (val) {
 	if (!val) throw new Error("AssertionError: false == true");
 };
@@ -16,7 +20,12 @@ function subjectGrade(subjid){
 }
 
 HomeworkDescription=function(){
-	if(!(this instanceof HomeworkDescription))return new HomeworkDescription(arguments[0],arguments[1],arguments[2]);
+	if(!(this instanceof HomeworkDescription)){
+		return new (Function.prototype.bind.apply(
+			HomeworkDescription,
+			[null].concat(Array.prototype.slice.call(arguments))
+		));
+	}
 
 	//A unique identifier for a subject. Can be pretty much anything, lest it's a primitive type
 	//  and unique and fixed, i.e. there is only one identifier per subject and only one subject per identifier.
@@ -30,11 +39,14 @@ HomeworkDescription=function(){
 	//In general, anything that can be expressed in a sequence of integers that specifies the location.
 	//  (Actually, they should be index paths — think NSIndexPath)
 	//The `location` property contains an array of those, because homework can be multiple exercises, for example.
-	//Please make the array contiguous, though; don't mix indexing conventions! (!) (!!)
+	//Per subject, please use just one index convention. If you need to, add ones where you don't have entries.
 	this.location=arguments.length>1?arguments[1]:[];
 
 	//A Date indicating when this homework is due
 	this.duedate=arguments.length>2?arguments[2]:null;
+
+	//Some id that the outside world can decide on
+	this.id=arguments.length>3?arguments[3]:null;
 };
 
 Planner=function(){
@@ -163,7 +175,10 @@ Planner=function(){
 			}
 			if(day<it.item.duediff){
 				console.log(" -> planned on day "+day);
-				schedule[day].push(it.item);
+				itemcopy=Object.clone(it.item,true);
+				itemcopy.timepart=it.needed;
+				itemcopy.timefraction=1;
+				schedule[day].push(itemcopy);
 				daylength[day]+=it.needed;
 			} else { //the item didn't fit anywhere
 				console.log(" -> no fit found; distributing");
@@ -173,6 +188,7 @@ Planner=function(){
 				for(day=0;day<it.item.duediff;day++){
 					itemcopy=Object.clone(it.item,true);
 					itemcopy.timepart=Math.min(available[day]-daylength[day],it.needed-total);
+					if(itemcopy.timepart<it.needed-total&&itemcopy.timepart<MIN_TIME_TASK_DAY)continue; //almost no time left
 					if(itemcopy.timepart<=0)continue;
 					itemcopy.timefraction=itemcopy.timepart/it.needed;
 					if(firstUsedDay==-1)firstUsedDay=day;
@@ -187,7 +203,10 @@ Planner=function(){
 					console.log(" -> distributing left "+(it.needed-total)+" excess; putting on first used day");
 					if(firstUsedDay==-1){ //HELP we didn't plan ANYTHING yet at all
 						console.log(" -> NO FIRST USED DAY, so just plugging everything on day 0");
-						schedule[0].push(it.item);
+						itemcopy=Object.clone(it.item,true);
+						itemcopy.timepart=it.needed;
+						itemcopy.timefraction=1;
+						schedule[0].push(itemcopy);
 						daylength[0]+=it.needed;
 						continue; //skip all the fraction stuff
 					} else {
@@ -214,7 +233,7 @@ Planner=function(){
 		var ret={};
 		for(i=0;i<schedule.length;i++){
 			if(schedule[i].length==0)continue;
-			ret[addDays(today,i)]=schedule[i];
+			ret[addDays(today,i).getTime()]=schedule[i];
 		}
 		return ret;
 	};
diff --git a/packages/planner/testtest.js b/packages/planner/testtest.js
index 9f429cf9..7779f302 100755
--- a/packages/planner/testtest.js
+++ b/packages/planner/testtest.js
@@ -16,11 +16,12 @@ p.estimate(H("ne",[[1,5]]))
 p.estimate(H("ne",[[1,4]]))
 var schedule=p.plan(
 	[
-		H("ne",[[1,2]],addDays(startOfDay(new Date),2)),
-		H("ne",[[1,1],[1,5]],addDays(startOfDay(new Date),1)),
-		H("ne",[[1,9]],addDays(startOfDay(new Date),2))
+		H("ne",[[1,2]],addDays(startOfDay(new Date),2),"id 1"),
+		H("ne",[[1,1],[1,5]],addDays(startOfDay(new Date),1),"id 2"),
+		H("ne",[[1,9]],addDays(startOfDay(new Date),2),"id 3")
 	],
 	[1,1,1,1].map(p.availableTimeConvert),
 	new Date
 )
 inspect(schedule)
+console.log(JSON.stringify(schedule))

From c5ddda742b7f52be92acf70a771195407d0fc7ce Mon Sep 17 00:00:00 2001
From: tomsmeding <hallo@tomsmeding.nl>
Date: Sat, 29 Aug 2015 10:57:33 +0200
Subject: [PATCH 12/18] Better input interface to Planner::plan

---
 packages/planner/planner.js  | 28 ++++++++++++++++++++--------
 packages/planner/testtest.js | 12 +++++++-----
 2 files changed, 27 insertions(+), 13 deletions(-)

diff --git a/packages/planner/planner.js b/packages/planner/planner.js
index 39fda883..78e6af4c 100644
--- a/packages/planner/planner.js
+++ b/packages/planner/planner.js
@@ -129,18 +129,28 @@ Planner=function(){
 	};
 
 	//`items` is an Array of HomeworkDescriptions
-	//`available` is an Array of ints, specifying how much time (in the time unit) there is available
-	//  on that day of the plan region.
+	//`availableFn` is a Function(Date) returning int, specifying the code for how much time (in the
+	//  time unit) there is available on the given day
 	//`today` is a Date which the planner uses as "today"; will be rounded to start of day
-	this.plan=function(items,available,today){
+	this.plan=function(items,availableFn,today){
+		today=startOfDay(today);
+		var availableCache=[];
+		var available=(function(day){
+			var targetday;
+			if(day<0)assert(false);
+			while(day>=availableCache.length){
+				targetday=addDays(today,availableCache.length);
+				availableCache.push(this.availableTimeConvert(availableFn(targetday)));
+			}
+			return availableCache[day];
+		}).bind(this);
 		items=Object.clone(items,true); //we'll modify them for our own needs
 		var needed=new Array(items.length);
 		var i;
 		for(i=0;i<items.length;i++){
 			needed[i]=this.estimate(items[i]);
 		}
-		console.log("available =",available," needed =",needed);
-		today=startOfDay(today);
+		console.log(" needed =",needed);
 		var maxdiff=0;
 		for(i=0;i<items.length;i++){
 			items[i].duedate=startOfDay(items[i].duedate);
@@ -149,6 +159,8 @@ Planner=function(){
 			maxdiff=Math.max(maxdiff,items[i].duediff);
 		}
 		var dueInDays=new Array(maxdiff+1);
+		for(i=0;i<=maxdiff;i++)available(i);
+		console.log("available =",availableCache);
 		for(i=0;i<=maxdiff;i++)dueInDays[i]=[];
 		for(i=0;i<items.length;i++){
 			dueInDays[items[i].duediff].push({item:items[i],needed:needed[i]});
@@ -171,7 +183,7 @@ Planner=function(){
 			it=dueInDays[workingForDay].shift();
 			console.log("daylength="+util.inspect(daylength)+" item={\""+it.item.subject+"\" - "+util.inspect(it.item.location)+" - due in "+it.item.duediff+" day"+(it.item.duediff==1?"":"s")+"} it.needed="+it.needed);
 			for(day=0;day<it.item.duediff;day++){
-				if(daylength[day]+it.needed<=available[day])break;
+				if(daylength[day]+it.needed<=available(day))break;
 			}
 			if(day<it.item.duediff){
 				console.log(" -> planned on day "+day);
@@ -187,7 +199,7 @@ Planner=function(){
 				firstUsedDay=-1;
 				for(day=0;day<it.item.duediff;day++){
 					itemcopy=Object.clone(it.item,true);
-					itemcopy.timepart=Math.min(available[day]-daylength[day],it.needed-total);
+					itemcopy.timepart=Math.min(available(day)-daylength[day],it.needed-total);
 					if(itemcopy.timepart<it.needed-total&&itemcopy.timepart<MIN_TIME_TASK_DAY)continue; //almost no time left
 					if(itemcopy.timepart<=0)continue;
 					itemcopy.timefraction=itemcopy.timepart/it.needed;
@@ -219,7 +231,7 @@ Planner=function(){
 				//NOT REACHED IF SHIT WAS JUST THROWN ON DAY 0 DUE TO continue ABOVE
 				fractions.sort(function(a,b){a.timepart>b.timepart;}); //descending sort on timepart
 				lastDayItem=schedule[lastUsedDay][schedule[lastUsedDay].length-1];
-				while(fractions[0].timepart<available[lastUsedDay]-daylength[lastUsedDay]){
+				while(fractions[0].timepart<available(lastUsedDay)-daylength[lastUsedDay]){
 					schedule[fractions[0].day].pop();
 					daylength[fractions[0].day]-=fractions[0].timepart;
 					lastDayItem.timepart+=fractions[0].timepart;
diff --git a/packages/planner/testtest.js b/packages/planner/testtest.js
index 7779f302..7f08da87 100755
--- a/packages/planner/testtest.js
+++ b/packages/planner/testtest.js
@@ -7,6 +7,7 @@ P=REQ.Planner
 function inspect(o){console.log(util.inspect(o,{depth:8}));}
 function startOfDay(date){return new Date(date.getFullYear(),date.getMonth(),date.getDate());}
 function addDays(date,ndays){return new Date(date.getTime()+ndays*24*3600*1000);}
+function diffDays(d1,d2){return ~~((d2.getTime()-d1.getTime())/(24*3600*1000));}
 p=new P
 p.learn(H("ne",[[1,1],[1,2]]),1500)
 p.learn(H("ne",[[1,5]]),900)
@@ -14,14 +15,15 @@ p.learn(H("ne",[[1,9]]),2000)
 inspect(p.persistable())
 p.estimate(H("ne",[[1,5]]))
 p.estimate(H("ne",[[1,4]]))
+var now=new Date,today=startOfDay(now)
 var schedule=p.plan(
 	[
-		H("ne",[[1,2]],addDays(startOfDay(new Date),2),"id 1"),
-		H("ne",[[1,1],[1,5]],addDays(startOfDay(new Date),1),"id 2"),
-		H("ne",[[1,9]],addDays(startOfDay(new Date),2),"id 3")
+		H("ne",[[1,2]],addDays(today,2),"id 1"),
+		H("ne",[[1,1],[1,5]],addDays(today,1),"id 2"),
+		H("ne",[[1,9]],addDays(today,2),"id 3")
 	],
-	[1,1,1,1].map(p.availableTimeConvert),
-	new Date
+	function(day){return [1,1,1,1,1,1,1,1,1,1,1,1,1,1][diffDays(today,day)];},
+	now //any date on this day; `plan` applies startOfDay
 )
 inspect(schedule)
 console.log(JSON.stringify(schedule))

From cdd2686d222bb6e6a020606bb4d92c0402ab8d1b Mon Sep 17 00:00:00 2001
From: Lieuwe Rooijakkers <lieuwerooijakkers@gmail.com>
Date: Sat, 29 Aug 2015 15:51:06 +0200
Subject: [PATCH 13/18] planner: fix meteor stuff and npm dependencies

---
 packages/planner/package.js   | 11 +++++++----
 packages/planner/package.json |  2 +-
 packages/planner/planner.js   | 12 ++++--------
 3 files changed, 12 insertions(+), 13 deletions(-)

diff --git a/packages/planner/package.js b/packages/planner/package.js
index e8731b52..5c7e76ed 100644
--- a/packages/planner/package.js
+++ b/packages/planner/package.js
@@ -10,14 +10,17 @@ Package.describe({
 	documentation: 'README.md',
 });
 
+Npm.depends({
+	'js-object-clone': '0.4.2',
+});
+
 Package.onUse(function(api) {
 	api.versionsFrom('1.1.0.2');
-	api.use('erasaur:meteor-lodash');
 
-	api.addFiles('planner.js');
+	api.addFiles('planner.js', 'server');
 
-	api.export('HomeworkDescription');
-	api.export('Planner');
+	api.export('HomeworkDescription', 'server');
+	api.export('Planner', 'server');
 });
 
 Package.onTest(function(api) {
diff --git a/packages/planner/package.json b/packages/planner/package.json
index ca6f6bf2..a9f54aee 100644
--- a/packages/planner/package.json
+++ b/packages/planner/package.json
@@ -9,6 +9,6 @@
   "author": "simply <hello@simplyApps.nl> (http://www.simplyApps.nl/)",
   "license": "UNLICENSED",
   "dependencies": {
-    "lodash": "^3.10.1"
+    "js-object-clone": "^0.4.2"
   }
 }
diff --git a/packages/planner/planner.js b/packages/planner/planner.js
index 78e6af4c..c926888c 100644
--- a/packages/planner/planner.js
+++ b/packages/planner/planner.js
@@ -4,16 +4,12 @@
  * @module planner
  */
 
+var require = require || Npm.require;
 require("js-object-clone");
-var util=require("util");
+var util = require("util");
+var assert = require('assert');
 
-
-var MIN_TIME_TASK_DAY=450; //minimum of 7.5 minutes for one task on a day (except if expected time is <7.5 min)
-
-
-var assert = function (val) {
-	if (!val) throw new Error("AssertionError: false == true");
-};
+var MIN_TIME_TASK_DAY = 450; // minimum of 7.5 minutes for one task on a day (except if expected time is <7.5 min)
 
 function subjectGrade(subjid){
 	return Math.random()*9+1; //TODO:: Get average grade of student for this subject

From 9abf7c82f1553c66af1207ef33330250ad941635 Mon Sep 17 00:00:00 2001
From: tomsmeding <hallo@tomsmeding.nl>
Date: Sat, 29 Aug 2015 21:17:33 +0200
Subject: [PATCH 14/18] Fix estimation and planning for unknown subjects

When we haven't learnt anything about a subject, the
engine falls back to average grade. This didn't work.
This works now.
---
 packages/planner/planner.js  | 29 +++++++++++++----------------
 packages/planner/testtest.js |  3 ++-
 2 files changed, 15 insertions(+), 17 deletions(-)

diff --git a/packages/planner/planner.js b/packages/planner/planner.js
index c926888c..5337789c 100644
--- a/packages/planner/planner.js
+++ b/packages/planner/planner.js
@@ -11,10 +11,6 @@ var assert = require('assert');
 
 var MIN_TIME_TASK_DAY = 450; // minimum of 7.5 minutes for one task on a day (except if expected time is <7.5 min)
 
-function subjectGrade(subjid){
-	return Math.random()*9+1; //TODO:: Get average grade of student for this subject
-}
-
 HomeworkDescription=function(){
 	if(!(this instanceof HomeworkDescription)){
 		return new (Function.prototype.bind.apply(
@@ -78,16 +74,16 @@ Planner=function(){
 		}
 	};
 
-	this.generalSubjectEstimate=function(subjid){
-		var grade=subjectGrade(subjid);
-		return 3600*3/2-3600*grade;
+	this.generalSubjectEstimate=function(subjid,gradeFn){
+		var grade=gradeFn(subjid);
+		return 3600*3/2-3600*grade/10;
 	};
 
-	function estimateSingle(hwdesc){
+	this.estimateSingle=function(hwdesc,gradeFn){
 		assert(hwdesc instanceof HomeworkDescription);
 		assert(hwdesc.location.length==1);
 		if(!subjects[hwdesc.subject]){
-			return this.generalSubjectEstimate(hwdesc.subject);
+			return this.generalSubjectEstimate(hwdesc.subject,gradeFn);
 		}
 		var i,itemref=subjects[hwdesc.subject];
 		for(i=0;i<hwdesc.location[0].length;i++){
@@ -100,14 +96,14 @@ Planner=function(){
 			timearr.push(itemref[key]);
 		}
 		return rms(timearr);
-	}
+	};
 
-	this.estimate=function(hwdesc){
+	this.estimate=function(hwdesc,gradeFn){
 		var subj,loc;
 		assert(hwdesc instanceof HomeworkDescription);
 		return sum(hwdesc.location.map(function(loc){
-			return estimateSingle(HomeworkDescription(hwdesc.subject,[loc]));
-		}));
+			return this.estimateSingle(HomeworkDescription(hwdesc.subject,[loc]),gradeFn);
+		}.bind(this)));
 	};
 
 	this.persistable=function(){
@@ -128,7 +124,8 @@ Planner=function(){
 	//`availableFn` is a Function(Date) returning int, specifying the code for how much time (in the
 	//  time unit) there is available on the given day
 	//`today` is a Date which the planner uses as "today"; will be rounded to start of day
-	this.plan=function(items,availableFn,today){
+	//`gradeFn` is a Function(String) taking a subject identifier and returning the average grade of the student for that subject
+	this.plan=function(items,availableFn,today,gradeFn){
 		today=startOfDay(today);
 		var availableCache=[];
 		var available=(function(day){
@@ -136,7 +133,7 @@ Planner=function(){
 			if(day<0)assert(false);
 			while(day>=availableCache.length){
 				targetday=addDays(today,availableCache.length);
-				availableCache.push(this.availableTimeConvert(availableFn(targetday)));
+				availableCache.push(availableFn(targetday));
 			}
 			return availableCache[day];
 		}).bind(this);
@@ -144,7 +141,7 @@ Planner=function(){
 		var needed=new Array(items.length);
 		var i;
 		for(i=0;i<items.length;i++){
-			needed[i]=this.estimate(items[i]);
+			needed[i]=this.estimate(items[i],gradeFn);
 		}
 		console.log(" needed =",needed);
 		var maxdiff=0;
diff --git a/packages/planner/testtest.js b/packages/planner/testtest.js
index 7f08da87..dd4b995f 100755
--- a/packages/planner/testtest.js
+++ b/packages/planner/testtest.js
@@ -23,7 +23,8 @@ var schedule=p.plan(
 		H("ne",[[1,9]],addDays(today,2),"id 3")
 	],
 	function(day){return [1,1,1,1,1,1,1,1,1,1,1,1,1,1][diffDays(today,day)];},
-	now //any date on this day; `plan` applies startOfDay
+	now, //any date on this day; `plan` applies startOfDay
+	function(subjid){return 7;} //this student has averages of 7 for each subject.
 )
 inspect(schedule)
 console.log(JSON.stringify(schedule))

From be156225e692e516a9f4bd1e4a27ca95495600d2 Mon Sep 17 00:00:00 2001
From: Lieuwe Rooijakkers <lieuwerooijakkers@gmail.com>
Date: Tue, 1 Sep 2015 15:12:45 +0200
Subject: [PATCH 15/18] small code cleanup

---
 packages/planner/planner.js | 25 ++++---------------------
 1 file changed, 4 insertions(+), 21 deletions(-)

diff --git a/packages/planner/planner.js b/packages/planner/planner.js
index 5337789c..6fdf10db 100644
--- a/packages/planner/planner.js
+++ b/packages/planner/planner.js
@@ -274,26 +274,9 @@ function sum(arr){
 	return sum;
 }
 
-if(typeof Meteor=="undefined"){
-	module.exports={
-		HomeworkDescription:HomeworkDescription,
-		Planner:Planner
+if (module !== undefined) {
+	module.exports= {
+		HomeworkDescription: HomeworkDescription,
+		Planner: Planner,
 	};
 }
-
-/*
-REQ=require("./planner")
-H=REQ.HomeworkDescription
-P=REQ.Planner
-function hh(s,l){var h=new H;h.subject=s;h.location=l;return h;}
-function inspect(o){console.log(util.inspect(o,{depth:8}));}
-function startOfDay(date){return new Date(date.getFullYear(),date.getMonth(),date.getDate());}
-function addDays(date,ndays){return new Date(date.getTime()+ndays*24*3600*1000);}
-p=new P
-p.learn(hh("ne",[[1,1],[1,2]]),100)
-p.learn(hh("ne",[[1,5]]),40)
-inspect(p.persistable())
-p.estimate(hh("ne",[[1,5]]))
-p.estimate(hh("ne",[[1,4]]))
-p.plan([H("ne",[[1,2]],addDays(startOfDay(new Date),2)),H("ne",[[1,1],[1,5]],addDays(startOfDay(new Date),1))],[1,1],new Date)
-*/

From 324ac671e6f28406d50e302778d8a0bc2da3673e Mon Sep 17 00:00:00 2001
From: Lieuwe Rooijakkers <lieuwerooijakkers@gmail.com>
Date: Tue, 1 Sep 2015 22:32:39 +0200
Subject: [PATCH 16/18] jsdoc all the stuff

---
 packages/planner/planner.js | 128 ++++++++++++++++++++++++++++++------
 1 file changed, 107 insertions(+), 21 deletions(-)

diff --git a/packages/planner/planner.js b/packages/planner/planner.js
index 6fdf10db..b43a9d0c 100644
--- a/packages/planner/planner.js
+++ b/packages/planner/planner.js
@@ -11,6 +11,14 @@ var assert = require('assert');
 
 var MIN_TIME_TASK_DAY = 450; // minimum of 7.5 minutes for one task on a day (except if expected time is <7.5 min)
 
+/**
+ * @class HomeworkDescription
+ * @constructor
+ * @param {any} subject Must be primitive, unique and fixed
+ * @param {int[][]} locations
+ * @param {Date} duedate
+ * @param {any} id
+ */
 HomeworkDescription=function(){
 	if(!(this instanceof HomeworkDescription)){
 		return new (Function.prototype.bind.apply(
@@ -19,38 +27,76 @@ HomeworkDescription=function(){
 		));
 	}
 
-	//A unique identifier for a subject. Can be pretty much anything, lest it's a primitive type
-	//  and unique and fixed, i.e. there is only one identifier per subject and only one subject per identifier.
+	/**
+	 * A unique identifier for a subject. Can be pretty much anything, lest it's
+	 * a primitive type and unique and fixed, i.e. there is only one identifier
+	 * per subject and only one subject per identifier.
+	 *
+	 * @property subject
+	 * @type any
+	 */
 	this.subject=arguments.length>0?arguments[0]:null;
 
-	//Items in `location` can be multiple things, e.g.
-	//- [chapter,paragraph,exercise]
-	//- [bookid,page,exercise]
-	//- [chapter,exercise]
-	//- [bookid,page]
-	//In general, anything that can be expressed in a sequence of integers that specifies the location.
-	//  (Actually, they should be index paths — think NSIndexPath)
-	//The `location` property contains an array of those, because homework can be multiple exercises, for example.
-	//Per subject, please use just one index convention. If you need to, add ones where you don't have entries.
+	/**
+	 * Items in `location` can be multiple things, e.g.
+	 *   - [chapter,paragraph,exercise]
+	 *   - [bookid,page,exercise]
+	 *   - [chapter,exercise]
+	 *   - [bookid,page]
+	 *
+	 * In general, anything that can be expressed in a sequence of integers that
+	 * specifies the location.  (Actually, they should be index paths — think
+	 * NSIndexPath) The `location` property contains an array of those, because
+	 * homework can be multiple exercises, for example.  Per subject, please use
+	 * just one index convention. If you need to, add ones where you don't have
+	 * entries.
+	 *
+	 * @property location
+	 * @type int[][]
+	 */
 	this.location=arguments.length>1?arguments[1]:[];
 
-	//A Date indicating when this homework is due
+	/**
+	 * A Date indicating when this homework is due
+	 * @prototype duedate
+	 * @type Date
+	 */
 	this.duedate=arguments.length>2?arguments[2]:null;
 
-	//Some id that the outside world can decide on
+	/**
+	 * Some id that the outside world can decide on
+	 * @property id
+	 * @type any
+	 */
 	this.id=arguments.length>3?arguments[3]:null;
 };
 
+/**
+ * @class Planner
+ * @constructor
+ * @param {Object} [persisted] Result from `Planner::persistable`.
+ */
 Planner=function(){
 	if(!(this instanceof Planner))return new Planner(arguments[0]);
 
+	/**
+	 * @property isPlannerObject
+	 * @type Boolean
+	 * @final
+	 * @default true
+	 */
 	this.isPlannerObject=true;
 
 	//PREV: Object[subject id][location index path item][value of the loc. idxp. item][samples of time taken]
 	//Object[subject id][loc item 0][loc item 1]...[loc item n] = time taken for that index path
 	var subjects={}; //The Cache
 
-	//`timetaken` in any unit you find convenient; but please be consistent. Suggestion: seconds.
+	/**
+	 * Learn.
+	 * @method learn
+	 * @param {HomeworkDescription} hwdesc The `HomeworkDescription` that was done.
+	 * @param {Number} timetaken Number in time unit that specifies how long the given description took.
+	 */
 	this.learn=function(hwdesc,timetaken){
 		var i,j,idx,subj,loc;
 		assert(hwdesc instanceof HomeworkDescription);
@@ -74,12 +120,26 @@ Planner=function(){
 		}
 	};
 
+	/**
+	 * @method generalSubjectEstimate
+	 * @param {any} subjid
+	 * @param {Function} gradeFn
+	 * @return {Number}
+	 */
 	this.generalSubjectEstimate=function(subjid,gradeFn){
 		var grade=gradeFn(subjid);
 		return 3600*3/2-3600*grade/10;
 	};
 
-	this.estimateSingle=function(hwdesc,gradeFn){
+	/**
+	 * Guesses the time needed for the given `hwdesc` with a single location.
+	 * @private
+	 * @method _estimateSingle
+	 * @param {HomeworkDescription} hwdesc
+	 * @param {Function} gradeFn
+	 * @return {Number}
+	 */
+	this._estimateSingle=function(hwdesc,gradeFn){
 		assert(hwdesc instanceof HomeworkDescription);
 		assert(hwdesc.location.length==1);
 		if(!subjects[hwdesc.subject]){
@@ -98,33 +158,59 @@ Planner=function(){
 		return rms(timearr);
 	};
 
+	/**
+	 * Guesses the time needed for the given `hwdesc`.
+	 * @method estimate
+	 * @param {HomeworkDescription} hwdesc
+	 * @param {Function} gradeFn
+	 * @return {Number}
+	 */
 	this.estimate=function(hwdesc,gradeFn){
 		var subj,loc;
 		assert(hwdesc instanceof HomeworkDescription);
 		return sum(hwdesc.location.map(function(loc){
-			return this.estimateSingle(HomeworkDescription(hwdesc.subject,[loc]),gradeFn);
+			return this._estimateSingle(HomeworkDescription(hwdesc.subject,[loc]),gradeFn);
 		}.bind(this)));
 	};
 
+	/**
+	 * Converts the current Planner to a persistable object.
+	 * @method persistable
+	 * @return {Object}
+	 */
 	this.persistable=function(){
 		return Object.clone(subjects,true);
 	};
+
+	/**
+	 * Loads in an object created by `Planner::persistable`.
+	 * @method frompersistable
+	 * @param {Object} subj The object created by `Planner:persistable` to load.
+	 */
 	this.frompersistable=function(subj){
 		if(subj.isPlannerObject===true) //they persisted the whole object ._.
 			subjects=subj.persistable();
 		else subjects=Object.clone(subj,true);
 	};
 
+	/**
+	 * @method availableTimeConvert
+	 * @param {Number} code
+	 * @return Number
+	 */
 	this.availableTimeConvert=function(code){
 		// return [0,30*60,90*60,180*60][code];
 		return (15*code*code+15*code)*60;
 	};
 
-	//`items` is an Array of HomeworkDescriptions
-	//`availableFn` is a Function(Date) returning int, specifying the code for how much time (in the
-	//  time unit) there is available on the given day
-	//`today` is a Date which the planner uses as "today"; will be rounded to start of day
-	//`gradeFn` is a Function(String) taking a subject identifier and returning the average grade of the student for that subject
+	/**
+	 * @method plan
+	 * @param {HomeworkDescription[]} items
+	 * @param {Function(Date) Number} availableFn Specifies the code for how much time (in time unit) there is available for the given day.
+	 * @param {Date} today The date which the planner uses as "today"; will be rounded to start of day.
+	 * @param {Function(String) Number} gradeFn Gets a subject identifier and must return the average grade of the student for that subject.
+	 * @return {Object} The schedule.
+	 */
 	this.plan=function(items,availableFn,today,gradeFn){
 		today=startOfDay(today);
 		var availableCache=[];

From 3a8cd9c77a3b8afd46c6e0a2fe31371983b486b9 Mon Sep 17 00:00:00 2001
From: Lieuwe Rooijakkers <lieuwerooijakkers@gmail.com>
Date: Tue, 1 Sep 2015 22:37:37 +0200
Subject: [PATCH 17/18] :bomb: console.log

---
 packages/planner/planner.js | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/packages/planner/planner.js b/packages/planner/planner.js
index b43a9d0c..3e37f79c 100644
--- a/packages/planner/planner.js
+++ b/packages/planner/planner.js
@@ -11,6 +11,10 @@ var assert = require('assert');
 
 var MIN_TIME_TASK_DAY = 450; // minimum of 7.5 minutes for one task on a day (except if expected time is <7.5 min)
 
+var log = function () {
+	//console.log.apply(console, arguments);
+};
+
 /**
  * @class HomeworkDescription
  * @constructor
@@ -229,7 +233,7 @@ Planner=function(){
 		for(i=0;i<items.length;i++){
 			needed[i]=this.estimate(items[i],gradeFn);
 		}
-		console.log(" needed =",needed);
+		log(" needed =",needed);
 		var maxdiff=0;
 		for(i=0;i<items.length;i++){
 			items[i].duedate=startOfDay(items[i].duedate);
@@ -239,7 +243,7 @@ Planner=function(){
 		}
 		var dueInDays=new Array(maxdiff+1);
 		for(i=0;i<=maxdiff;i++)available(i);
-		console.log("available =",availableCache);
+		log("available =",availableCache);
 		for(i=0;i<=maxdiff;i++)dueInDays[i]=[];
 		for(i=0;i<items.length;i++){
 			dueInDays[items[i].duediff].push({item:items[i],needed:needed[i]});
@@ -260,19 +264,19 @@ Planner=function(){
 			while(workingForDay<dueInDays.length&&dueInDays[workingForDay].length==0)workingForDay++;
 			if(workingForDay>=dueInDays.length)break; //done!
 			it=dueInDays[workingForDay].shift();
-			console.log("daylength="+util.inspect(daylength)+" item={\""+it.item.subject+"\" - "+util.inspect(it.item.location)+" - due in "+it.item.duediff+" day"+(it.item.duediff==1?"":"s")+"} it.needed="+it.needed);
+			log("daylength="+util.inspect(daylength)+" item={\""+it.item.subject+"\" - "+util.inspect(it.item.location)+" - due in "+it.item.duediff+" day"+(it.item.duediff==1?"":"s")+"} it.needed="+it.needed);
 			for(day=0;day<it.item.duediff;day++){
 				if(daylength[day]+it.needed<=available(day))break;
 			}
 			if(day<it.item.duediff){
-				console.log(" -> planned on day "+day);
+				log(" -> planned on day "+day);
 				itemcopy=Object.clone(it.item,true);
 				itemcopy.timepart=it.needed;
 				itemcopy.timefraction=1;
 				schedule[day].push(itemcopy);
 				daylength[day]+=it.needed;
 			} else { //the item didn't fit anywhere
-				console.log(" -> no fit found; distributing");
+				log(" -> no fit found; distributing");
 				total=0;
 				fractions=[];
 				firstUsedDay=-1;
@@ -291,9 +295,9 @@ Planner=function(){
 					if(total>=it.needed)break;
 				}
 				if(total<it.needed){
-					console.log(" -> distributing left "+(it.needed-total)+" excess; putting on first used day");
+					log(" -> distributing left "+(it.needed-total)+" excess; putting on first used day");
 					if(firstUsedDay==-1){ //HELP we didn't plan ANYTHING yet at all
-						console.log(" -> NO FIRST USED DAY, so just plugging everything on day 0");
+						log(" -> NO FIRST USED DAY, so just plugging everything on day 0");
 						itemcopy=Object.clone(it.item,true);
 						itemcopy.timepart=it.needed;
 						itemcopy.timefraction=1;
@@ -320,7 +324,7 @@ Planner=function(){
 				}
 			}
 		}
-		console.log("daylength="+util.inspect(daylength));
+		log("daylength="+util.inspect(daylength));
 		var ret={};
 		for(i=0;i<schedule.length;i++){
 			if(schedule[i].length==0)continue;

From 2d6cb350ff960cc857af348c2f748af84f5af94e Mon Sep 17 00:00:00 2001
From: Lieuwe Rooijakkers <lieuwerooijakkers@gmail.com>
Date: Sun, 20 Sep 2015 01:06:53 +0200
Subject: [PATCH 18/18] don't try to use `undefined` or `null` as Planner::ctor
 argument as persistable.

This doesn't break anything, right, @tomsmeding?
---
 packages/planner/planner.js | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/packages/planner/planner.js b/packages/planner/planner.js
index 3e37f79c..46ea2b00 100644
--- a/packages/planner/planner.js
+++ b/packages/planner/planner.js
@@ -80,8 +80,10 @@ HomeworkDescription=function(){
  * @constructor
  * @param {Object} [persisted] Result from `Planner::persistable`.
  */
-Planner=function(){
-	if(!(this instanceof Planner))return new Planner(arguments[0]);
+Planner = function (persisted) {
+	if (!(this instanceof Planner)) {
+		return new Planner(persisted);
+	}
 
 	/**
 	 * @property isPlannerObject
@@ -333,9 +335,10 @@ Planner=function(){
 		return ret;
 	};
 
-
-
-	if(arguments.length==1)subjects=Object.clone(arguments[0],true); //from a persist source
+	if (persisted != null) {
+		// from a persist source
+		subjects = Object.clone(persistable, true);
+	}
 };